javascript 权威指南

1、对象

1.1、序列话对象

JSON.stringify() 和 JSON.parse() 用来序列化和还原 javascript 对象。

var o = {x:1, y:{z:[false,null,""]}};　　// 定义对象
var s = JSON.stringify(o);　　　　　　　　 // s是 "{"x":1,"y":{"z":[false,null,""]}}"
var p = JSON.parse(s);　　　　　　　　　　　// p 是 o 的深拷贝

2、数组

2.1、push() 和 pop()

push() 方法在数组的尾部添加一个或多个元素，并返回数组新的长度。

pop() 方法刚相反，它删除数组的最后一个元素，减少数组长度并返回它删除的值。

注意：两个方法都修改并替换原始数组而非生成一个修改版的新数组

var arr = [];           // arr: []
arr.push( 1, 2 );       // arr: [1, 2]    　　返回：2
arr.pop();              // arr: [1]       　　返回：2
arr.push( [4, 5] );     // arr: [1, [4,5]]　　返回：2
arr.pop();              // arr: [1]　　　　　　返回：[4, 5]
arr.pop();              // arr: []           返回：1

2.2、map()

map() 方法将调用的数组的每个元素传递给指定的函数，并返回一个数组，它包含该函数的返回值。

var arrA = [1, 2, 3];
var arrB = a.map( function( x ) {
return x * x;        // arrB = [1, 4, 9]
});

2.3、filter()

filter() 方法返回的数组元素是调用的数组的一个子集。传递是函数是用来逻辑判定的：该函数返回 true 或 false。

var arrA = [5, 4, 3, 2, 1];
var arrB = arrA.filter( function( x ) {
return x < 3;    // [2, 1]
});
var arrC = arrA.filter( function( x, i ) {
return i % 2 === 0;        // [5, 3, 1]
});

2.4、every() 和 some()

every() 和 some() 方法是数组的逻辑判定：它们对数组元素应用指定的函数进行判定，返回 true 或 false。

3、函数

3.1、函数的调用

作为函数

作为方法

作为构造函数

通过它们的 call() 和 apply() 方法间接调用

3.2、作为值的函数

函数可以定义，也可以调用，也是值，可以将函数赋值给变量。

function square( x ) {
return x * x;
}

var s = square;        // 现在 s 和 square 指向同一个函数
square( 4 );        　  // 16
s( 4 );                // 16

3.3、闭包

函数的执行依赖于变量作用域，这个作用域是在函数定义时决定的，而不是函数调用时决定的。为了实现这种词法的作用域，JavaScript 函数对象是内部状态不仅包含函数的代码逻辑，还必须引用当前的作用域。函数对象可以通过作用域链相互关联起来，函数体内的变量都可以保存在作用域内，这种特性被称为“闭包”。

注：闭包是指函数变量可以被隐藏于作用域链之内，因此看起来是函数将变量“包裹”了起来。

例1：

var integer = (function() {
var count = 0;
return function() {
return count ++;
}
}());

定义了一个立即调用的函数，因此是这个函数返回值赋值给变量 integer。嵌套的函数是可以访问作用域内的变量的，而且可以访问外部函数中定义的 count 变量。当外部函数返回之后，其他任何代码都无法访问 count 变量，只有内部的函数才能访问它。

例2：

function counter() {
var n = 0;
return {
count: function() {
return n++;
},
reset: function() {
return n = 0;
}
}
}
var c = counter(), d = counter();
c.count();        // => 0
d.count();        // => 0
c.reset();        // count() 和 reset() 共享状态
c.count();        // => 0
d.count();        // => 1