关于javascript: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)('...')