《JavaScript 教程》学习补遗（三）

数据类型

函数

（1） 该函数名只在函数体内部有效，在函数体外部无效，所以下面的声明是正确的。

var f = function f() {};

（2） Function 构造函数可以不使用new命令，返回结果完全一样。

var foo = new Function(
  'return "hello world";'
);
// 这是正确的
var foo = Function(
  'return "hello world";'
);

（3） 如果同一个函数被多次声明，后面的声明就会覆盖前面的声明。而且，由于函数名的提升，前一次声明在任何时候都是无效的，这一点要特别注意。

（4） return语句不是必需的，如果没有的话，该函数就不返回任何值，或者说返回undefined。

（5） 函数只是一个可以执行的值，此外并无特殊之处。与其它值（数值、字符串、布尔值等等）地位相同。

（6）JavaScript 引擎将函数名视同变量名，所以采用 function 命令声明函数时，整个函数会像变量声明一样，被提升到代码头部。

var f = function () {
  console.log('1');
}

function f() {
  console.log('2');
}

f() // 1

（7） name 属性返回函数的名字，如果函数未命名，返回的是赋值变量的名字；但真正的函数名，还是变量的名字。

var myFunc = function () {};

function test(f) {
  console.log(f.name);
}

test(myFunc) // myFunc

（8） length 属性返回函数定义之中的参数个数
（9） 自定义 toString() 方法返回一个字符串，内容是函数的源码；原生函数 toString() 方法返回 function (){[native code]}

(10） 变向实现返回多行字符串

var multiline = function (fn) {
  var arr = fn.toString().split('n');
  return arr.slice(1, arr.length - 1).join('n');
};

function f() {/*
  这是一个
  多行注释
*/}

multiline(f);

" 这是一个
  多行注释"

（11）调用函数时，省略的参数的值就变为 undefined，但是，没有办法只省略靠前的参数，而保留靠后的参数。如果一定要省略靠前的参数，只有显式传入undefined。

function f(a, b) {
  return a;
}

f( , 1) // SyntaxError: Unexpected token ,(…)
f(undefined, 1) // undefined

（12）如果函数内部修改的，不是参数对象的某个属性，而是替换掉整个参数，这时不会影响到原始值。

var obj = [1, 2, 3];

function f(o) {
  o = [2, 3, 4];
}
f(obj);

obj // [1, 2, 3]

（13）如果有同名的参数，则取最后出现的那个值

function f(a, a) {
  console.log(a);
}

f(1, 2) // 2

function f(a, a) {
  console.log(a);
}

f(1) // undefined

function f(a, a) {
  console.log(arguments[0]); // 使用arguments[0]来提取值
}

f(1) // 1

（14）通过arguments对象的length属性，可以判断函数调用时到底带几个参数。

function f() {
  return arguments.length;
}

f(1, 2, 3) // 3
f(1) // 1
f() // 0

（15）

var f = function(a, b) {
  arguments[0] = 3; //正确模式下，可以修改arguments
  arguments[1] = 2;
  return a + b;
}

f(1, 1) // 5

var f = function(a, b) {
 'use strict'; 
  arguments[0] = 3;// 开启严格模式，修改不生效
  arguments[1] = 2;
  return a + b;
}

f(1, 1) // 2

（16）arguments是一个对象。方法（比如slice和forEach），不能在arguments对象上直接使用。如果非要调用，先转换成数组。

var args = Array.prototype.slice.call(arguments);

// 或者
var args = [];
for (var i = 0; i < arguments.length; i++) {
  args.push(arguments[i]);
}

（17）callee属性，返回它所对应的原函数。严格模式下无效，不建议使用。

var f = function () {
  console.log(arguments.callee === f);
}

f() // true

（18）闭包的最大用处有两个，一个是可以读取函数内部的变量，另一个就是让这些变量始终保持在内存中，使得内部变量记住上一次调用时的运算结果。

function createIncrementor(start) {
  return function () {
    return start++;
  };
}

var inc = createIncrementor(5);

inc() // 5
inc() // 6
inc() // 7

（19）闭包的另一个用处，是封装对象的私有属性和私有方法。

function Person(name) {
  var _age;
  function setAge(n) {
    _age = n;
  }
  function getAge() {
    return _age;
  }

  return {
    name: name,
    getAge: getAge,
    setAge: setAge
  };
}

var p1 = Person('张三');
p1.setAge(25);
p1.getAge() // 25

（20）外层函数每次运行，都会生成一个新的闭包，而这个闭包又会保留外层函数的内部变量，所以内存消耗很大。因此不能滥用闭包，否则会造成网页的性能问题。

（21）function 只有作为表达式时，引擎才会把函数定义当作一个值。

function(){ /* code */ }();
// SyntaxError: Unexpected token (

产生这个错误的原因是，function这个关键字即可以当作语句，也可以当作表达式。

// 语句
function f() {}

// 表达式
var f = function f() {}

当作表达式时，函数可以定义后直接加圆括号调用。

var f = function f(){ return 1}();
f // 1

（22）JavaScript 规定，如果function关键字出现在行首，一律解释成语句。

// 可以如下解决
(function(){ /* code */ }());
// 或者
(function(){ /* code */ })();

（23）通常情况下，只对匿名函数使用这种“立即执行的函数表达式”。它的目的有两个：一是不必为函数命名，避免了污染全局变量；二是 IIFE 内部形成了一个单独的作用域，可以封装一些外部无法读取的私有变量。

// 写法一
var tmp = newData;
processData(tmp);
storeData(tmp);

// 写法二
(function () {
  var tmp = newData;
  processData(tmp);
  storeData(tmp);
}());

（24）eval 命令接受一个字符串作为参数，并将这个字符串当作语句执行

eval('var a = 1;');
a // 1

eval('3x') // Uncaught SyntaxError: Invalid or unexpected token

如果参数字符串无法当作语句运行，那么就会报错。

（25）放在 eval 中的字符串，应该有独自存在的意义，不能用来与eval以外的命令配合使用。

eval('return;'); // Uncaught SyntaxError: Illegal return statement

（26）如果 eval 的参数不是字符串，那么会原样返回。

eval(123) // 123

（27）eval没有自己的作用域，都在当前作用域内执行，因此可能会修改当前作用域的变量的值，造成安全问题。

var a = 1;
eval('a = 2');

a // 2

（28）JavaScript 规定，如果使用严格模式，eval内部声明的变量，不会影响到外部作用域。

(function f() {
 'use strict';
  eval('var foo = 123');
  console.log(foo);  // ReferenceError: foo is not defined
})()

（29）不过，即使在严格模式下，eval依然可以读写当前作用域的变量。所以一般不推荐使用。

(function f() {
 'use strict';
  var foo = 1;
  eval('foo = 2');
  console.log(foo);  // 2
})()

（30）凡是使用别名执行eval，eval内部一律是全局作用域。

var a = 1;

function f() {
  var a = 2;
  var e = eval;
  e('console.log(a)');
}

f() // 1

（31）eval 的别名调用的形式五花八门，只要不是直接调用，都属于别名调用，因为引擎只能分辨eval()这一种形式是直接调用。

// 作用域都是全局作用域
eval.call(null, '...')
window.eval('...')
(1, eval)('...')
(eval, eval)('...')