笔记5 - 标准库 面向对象编程

一、标准库

1. Object 对象

• Object对象的原生方法分成两类
  • Object本身的方法
  • Object的实例方法

// Object对象本身的方法
Object.print = function (o) { console.log(o) };
// Object的实例方法
Object.prototype.print = function () {
  console.log(this);
};
var obj = new Object();
obj.print() // Object

Object()

• Object本身是一个函数，可以当作工具方法使用，将任意值转为对象
• 这个方法常用于保证某个值一定是对象

var obj = Object();
// 等同于
var obj = Object(undefined);
var obj = Object(null);
obj instanceof Object // true
// instanceof运算符用来验证，一个对象是否为指定的构造函数的实例
// 参数为各种原始类型的值
var obj = Object(1);
obj instanceof Object // true
obj instanceof Number // true
var obj = Object('foo');
obj instanceof Object // true
obj instanceof String // true
var obj = Object(true);
obj instanceof Object // true
obj instanceof Boolean // true
// 参数为一个对象
var arr = [];
var obj = Object(arr); // 返回原数组
obj === arr // true
var value = {};
var obj = Object(value) // 返回原对象
obj === value // true
var fn = function () {};
var obj = Object(fn); // 返回原函数
obj === fn // true
// 写一个判断变量是否为对象的函数
function isObject(value) {
  return value === Object(value);
}
isObject([]) // true
isObject(true) // false

Object 构造函数

• Object不仅可以当作工具函数使用，还可以当作构造函数使用
• 即前面可以使用new命令

var obj = new Object();
// var obj = new Object()的写法与 var obj = {}是等价的
var o1 = {a: 1};
var o2 = new Object(o1);
o1 === o2 // true
var obj = new Object(123);
obj instanceof Number // true
// Object(value)与new Object(value)两者的语义是不同的
// Object(value)表示将value转成一个对象
// new Object(value)则表示新生成一个对象，它的值是value

Object.keys()，Object.getOwnPropertyNames()

var obj = {
  p1: 123,
  p2: 456
};
Object.keys(obj) // ["p1", "p2"]
var obj = {
  p1: 123,
  p2: 456
};
Object.getOwnPropertyNames(obj) // ["p1", "p2"]
// 对于一般的对象来说，Object.keys()和Object.getOwnPropertyNames()返回的结果是一样的
// 只有涉及不可枚举属性时，才会有不一样的结果
var a = ['Hello', 'World'];
Object.keys(a) // ["0", "1"]
Object.getOwnPropertyNames(a) // ["0", "1", "length"]
// 数组的length属性是不可枚举的属性
// 由于 JavaScript 没有提供计算对象属性个数的方法，所以可以用这两个方法代替
var obj = {
  p1: 123,
  p2: 456
};
Object.keys(obj).length // 2
Object.getOwnPropertyNames(obj).length // 2
// 一般情况下，几乎总是使用Object.keys方法，遍历对象的属性

Object 本身的其他方法

• 对象属性模型的相关方法
  • Object.getOwnPropertyDescriptor()：获取某个属性的描述对象
  • Object.defineProperty()：通过描述对象，定义某个属性
  • Object.defineProperties()：通过描述对象，定义多个属性
• 控制对象状态的方法
  • Object.preventExtensions()：防止对象扩展
  • Object.isExtensible()：判断对象是否可扩展
  • Object.seal()：禁止对象配置
  • Object.isSealed()：判断一个对象是否可配置
  • Object.freeze()：冻结一个对象
  • Object.isFrozen()：判断一个对象是否被冻结。
• 原型链相关方法
• Object.create()：该方法可以指定原型对象和属性，返回一个新的对象
• Object.getPrototypeOf()：获取对象的Prototype对象

Object 的实例方法

• 主要有以下六个
• Object.prototype.valueOf()：返回当前对象对应的值
• Object.prototype.toString()：返回当前对象对应的字符串形式
• Object.prototype.toLocaleString()：返回当前对象对应的本地字符串形式
• Object.prototype.hasOwnProperty()：判断某个属性是否为当前对象自身的属性，还是继承自原型对象的属性
• Object.prototype.isPrototypeOf()：判断当前对象是否为另一个对象的原型
• Object.prototype.propertyIsEnumerable()：判断某个属性是否可枚举。

// valueOf方法的作用是返回一个对象的“值”，默认情况下返回对象本身
var obj = new Object();
obj.valueOf() === obj // true
var obj = new Object();
1 + obj // "1[object Object]"
var obj = new Object();
obj.valueOf = function () {
  return 2;
};
1 + obj // 3
// toString方法的作用是返回一个对象的字符串形式，默认情况下返回类型字符串
var o1 = new Object();
o1.toString() // "[object Object]"
var o2 = {a:1};
o2.toString() // "[object Object]"
var obj = new Object();
obj.toString = function () {
  return 'hello';
};
obj + ' ' + 'world' // "hello world"
// 数组、字符串、函数、Date 对象都分别部署了自定义的toString方法
// 覆盖了Object.prototype.toString方法
[1, 2, 3].toString() // "1,2,3"
'123'.toString() // "123"
(function () {
  return 123;
}).toString()
// "function () {
//   return 123;
// }"
(new Date()).toString()
// "Tue May 10 2016 09:11:31 GMT+0800 (CST)"
// 上面代码中，数组、字符串、函数、Date 对象调用toString方法
// 并不会返回[object Object]，因为它们都自定义了toString方法，覆盖原始方法
// toString() 的应用：判断数据类型
var obj = {};
obj.toString() // "[object Object]"
// 其中第二个Object表示该值的构造函数。这是一个十分有用的判断数据类型的方法
// 由于实例对象可能会自定义toString方法，覆盖掉Object.prototype.toString方法
// 所以为了得到类型字符串，最好直接使用Object.prototype.toString方法
// Object.prototype.toString.call(value)
// 不同数据类型的Object.prototype.toString方法返回值如下
数值：返回[object Number]
字符串：返回[object String]
布尔值：返回[object Boolean]
undefined：返回[object Undefined]
null：返回[object Null]
数组：返回[object Array]
arguments 对象：返回[object Arguments]
函数：返回[object Function]
Error 对象：返回[object Error]
Date 对象：返回[object Date]
RegExp 对象：返回[object RegExp]
其他对象：返回[object Object]
Object.prototype.toString.call(2) // "[object Number]"
Object.prototype.toString.call('') // "[object String]"
Object.prototype.toString.call(true) // "[object Boolean]"
Object.prototype.toString.call(undefined) // "[object Undefined]"
Object.prototype.toString.call(null) // "[object Null]"
Object.prototype.toString.call(Math) // "[object Math]"
Object.prototype.toString.call({}) // "[object Object]"
Object.prototype.toString.call([]) // "[object Array]"
// 利用这个特性，可以写出一个比typeof运算符更准确的类型判断函数
var type = function (o){
  var s = Object.prototype.toString.call(o);
  return s.match(/\[object (.*?)\]/)[1].toLowerCase();
};
type({}); // "object"
type([]); // "array"
type(5); // "number"
type(null); // "null"
type(); // "undefined"
type(/abcd/); // "regex"
type(new Date()); // "date"
// 在上面这个type函数的基础上，还可以加上专门判断某种类型数据的方法
var type = function (o){
  var s = Object.prototype.toString.call(o);
  return s.match(/\[object (.*?)\]/)[1].toLowerCase();
};
['Null',
 'Undefined',
 'Object',
 'Array',
 'String',
 'Number',
 'Boolean',
 'Function',
 'RegExp'
].forEach(function (t) {
  type['is' + t] = function (o) {
    return type(o) === t.toLowerCase();
  };
});
type.isObject({}) // true
type.isNumber(NaN) // true
type.isRegExp(/abc/) // true
// Object.prototype.toLocaleString方法与toString的返回结果相同，也是返回一个值的字符串形式
var obj = {};
obj.toString(obj) // "[object Object]"
obj.toLocaleString(obj) // "[object Object]"
// 这个方法的主要作用是留出一个接口，让各种不同的对象实现自己版本的toLocaleString
// 用来返回针对某些地域的特定的值
var person = {
  toString: function () {
    return 'Henry Norman Bethune';
  },
  toLocaleString: function () {
    return '白求恩';
  }
};
person.toString() // Henry Norman Bethune
person.toLocaleString() // 白求恩
// 目前，主要有三个对象自定义了toLocaleString方法
Array.prototype.toLocaleString()
Number.prototype.toLocaleString()
Date.prototype.toLocaleString()
// 举例来说，日期的实例对象的toString和toLocaleString返回值就不一样
// 而且toLocaleString的返回值跟用户设定的所在地域相关
var date = new Date();
date.toString() // "Tue Jan 01 2018 12:01:33 GMT+0800 (CST)"
date.toLocaleString() // "1/01/2018, 12:01:33 PM"
// Object.prototype.hasOwnProperty方法接受一个字符串作为参数，返回一个布尔值
// 表示该实例对象自身是否具有该属性
var obj = {
  p: 123
};
obj.hasOwnProperty('p') // true
obj.hasOwnProperty('toString') // false
// 上面代码中，对象obj自身具有p属性，所以返回true
toString属性是继承的，所以返回false

2. 属性描述对象

• JavaScript 提供了一个内部数据结构，用来描述对象的属性，控制它的行为
• 比如该属性是否可写、可遍历等等
• 这个内部数据结构称为“属性描述对象”（attributes object）
• 每个属性都有自己对应的属性描述对象，保存该属性的一些元信息

// 属性描述对象的一个例子
{
  value: 123,  // 该属性的属性值，默认为undefined
  writable: false, // 表示属性值（value）是否可改变（即是否可写），默认为true
  enumerable: true,  // 表示该属性是否可遍历
  configurable: false,  // 表示可配置性，默认为true
  get: undefined,  // get是一个函数，表示该属性的取值函数（getter），默认为undefined
  set: undefined  // set是一个函数，表示该属性的存值函数（setter），默认为undefined
}

Object.getOwnPropertyDescriptor()，Object.getOwnPropertyNames

// Object.getOwnPropertyDescriptor()方法可以获取属性描述对象
// 它的第一个参数是目标对象，第二个参数是一个字符串，对应目标对象的某个属性名
var obj = { p: 'a' };
Object.getOwnPropertyDescriptor(obj, 'p')
// Object { value: "a",
//   writable: true,
//   enumerable: true,
//   configurable: true
// }
// 注意，Object.getOwnPropertyDescriptor()方法只能用于对象自身的属性，不能用于继承的属性
var obj = { p: 'a' };
Object.getOwnPropertyDescriptor(obj, 'toString')
// undefined
// Object.getOwnPropertyNames方法返回一个数组，成员是参数对象自身的全部属性的属性名
// 不管该属性是否可遍历
var obj = Object.defineProperties({}, {
  p1: { value: 1, enumerable: true },
  p2: { value: 2, enumerable: false }
});
Object.getOwnPropertyNames(obj)
// ["p1", "p2"]
Object.keys([]) // []
Object.getOwnPropertyNames([]) // [ 'length' ]
// 这跟Object.keys的行为不同，Object.keys只返回对象自身的可遍历属性的全部属性名
Object.keys(Object.prototype) // []
Object.getOwnPropertyNames(Object.prototype)
// ['hasOwnProperty',
//  'valueOf',
//  'constructor',
//  'toLocaleString',
//  'isPrototypeOf',
//  'propertyIsEnumerable',
//  'toString']

Object.defineProperty()，Object.defineProperties()，Object.prototype.propertyIsEnumerable()

// Object.defineProperty()方法允许通过属性描述对象，定义或修改一个属性
// 然后返回修改后的对象，它的用法如下
Object.defineProperty(object, propertyName, attributesObject)
var obj = Object.defineProperty({}, 'p', {
  value: 123,
  writable: false,
  enumerable: true,
  configurable: false
});
obj.p // 123
obj.p = 246;
obj.p // 123
// 一次性定义或修改多个属性
var obj = Object.defineProperties({}, {
  p1: { value: 123, enumerable: true },
  p2: { value: 'abc', enumerable: true },
  p3: { get: function () { return this.p1 + this.p2 },
    enumerable:true,
    configurable:true
  }
});
obj.p1 // 123
obj.p2 // "abc"
obj.p3 // "123abc"
// 其中，p3属性定义了取值函数get，即每次读取该属性，都会调用这个取值函数
// 注意，一旦定义了取值函数get（或存值函数set）
// 就不能将writable属性设为true，或者同时定义value属性，否则会报错
var obj = {};
Object.defineProperty(obj, 'p', {
  value: 123,
  get: function() { return 456; }
});
// TypeError: Invalid property.
// A property cannot both have accessors and be writable or have a value
Object.defineProperty(obj, 'p', {
  writable: true,
  get: function() { return 456; }
});
// TypeError: Invalid property descriptor.
// Cannot both specify accessors and a value or writable attribute
// 上面代码中，同时定义了get属性和value属性，以及将writable属性设为true，就会报错。
// Object.defineProperty()和Object.defineProperties()参数里面的属性描述对象中，
// writable、configurable、enumerable这三个属性的默认值都为false
var obj = {};
Object.defineProperty(obj, 'foo', {});
Object.getOwnPropertyDescriptor(obj, 'foo')
// {
//   value: undefined,
//   writable: false,
//   enumerable: false,
//   configurable: false
// }
// 实例对象的propertyIsEnumerable()方法返回一个布尔值，用来判断某个属性是否可遍历
// 注意，这个方法只能用于判断对象自身的属性，对于继承的属性一律返回false
var obj = {};
obj.p = 123;
obj.propertyIsEnumerable('p') // true
obj.propertyIsEnumerable('toString') // false
// 上面代码中，obj.p是可遍历的，而obj.toString是继承的属性

元属性

• 属性描述对象的各个属性称为“元属性”，因为它们可以看作是控制属性的属性

// value属性是目标属性的值
var obj = {};
obj.p = 123;
Object.getOwnPropertyDescriptor(obj, 'p').value
// 123
Object.defineProperty(obj, 'p', { value: 246 });
obj.p // 246
// 上面代码是通过value属性，读取或改写obj.p的例子
// writable属性是一个布尔值，决定了目标属性的值（value）是否可以被改变
var obj = {};
Object.defineProperty(obj, 'a', {
  value: 37,
  writable: false
});
obj.a // 37
obj.a = 25;
obj.a // 37
// obj.a的writable属性是false。然后，改变obj.a的值，不会有任何效果
// enumerable（可遍历性）返回一个布尔值，表示目标属性是否可遍历
var obj = {};
'toString' in obj // true
// 上面代码中，toString不是obj对象自身的属性，但是in运算符也返回true
// 这导致了toString属性也会被for...in循环遍历
// 这显然不太合理，后来就引入了“可遍历性”这个概念
// 只有可遍历的属性，才会被for...in循环遍历
// 同时还规定toString这一类实例对象继承的原生属性，都是不可遍历的
// 这样就保证了for...in循环的可用性
// 具体来说，如果一个属性的enumerable为false，下面三个操作不会取到该属性
for..in循环
Object.keys方法
JSON.stringify方法
var obj = {};
Object.defineProperty(obj, 'x', {
  value: 123,
  enumerable: false
});
obj.x // 123
for (var key in obj) {
  console.log(key);
}
// undefined
Object.keys(obj)  // []
JSON.stringify(obj) // "{}"
// 注意，for...in循环包括继承的属性，Object.keys方法不包括继承的属性
// 如果需要获取对象自身的所有属性，不管是否可遍历，可以使用Object.getOwnPropertyNames方法
// configurable(可配置性）返回一个布尔值，决定了是否可以修改属性描述对象
// 也就是说，configurable为false时，value、writable、enumerable和configurable都不能被修改了
var obj = Object.defineProperty({}, 'p', {
  value: 1,
  writable: false,
  enumerable: false,
  configurable: false
});
Object.defineProperty(obj, 'p', {value: 2})
// TypeError: Cannot redefine property: p
Object.defineProperty(obj, 'p', {writable: true})
// TypeError: Cannot redefine property: p
Object.defineProperty(obj, 'p', {enumerable: true})
// TypeError: Cannot redefine property: p
Object.defineProperty(obj, 'p', {configurable: true})
// TypeError: Cannot redefine property: p
// 注意，writable只有在false改为true会报错，true改为false是允许的
// 至于value，只要writable和configurable有一个为true，就允许改动

存取器

• 除了直接定义以外，属性还可以用存取器（accessor）定义
  • 存值函数称为setter，使用属性描述对象的set属性
  • 取值函数称为getter，使用属性描述对象的get属性

var obj = Object.defineProperty({}, 'p', {
  get: function () {
    return 'getter';
  },
  set: function (value) {
    console.log('setter: ' + value);
  }
});
obj.p // "getter"
obj.p = 123 // "setter: 123"
// obj.p定义了get和set属性。obj.p取值时，就会调用get；赋值时，就会调用set
// 写法二
var obj = {
  get p() {
    return 'getter';
  },
  set p(value) {
    console.log('setter: ' + value);
  }
};
// 上面两种写法，虽然属性p的读取和赋值行为是一样的，但是有一些细微的区别
// 一种写法，属性p的configurable和enumerable都为false
// 第二种写法，属性p的configurable和enumerable都为true，因此属性 p 是可遍历的
// 因此属性p是可遍历的。实际开发中，写法二更常用
// 存取器往往用于，属性的值依赖对象内部数据的场合
var obj ={
  $n : 5,
  get next() { return this.$n++ },
  set next(n) {
    if (n >= this.$n) this.$n = n;
    else throw new Error('新的值必须大于当前值');
  }
};
obj.next // 5
obj.next = 10;
obj.next // 10
obj.next = 5;
// Uncaught Error: 新的值必须大于当前值
// 上面代码中，next属性的存值函数和取值函数，都依赖于内部属性$n

对象的拷贝

// 将一个对象的所有属性，拷贝到另一个对象，可以用下面的方法实现
var extend = function (to, from) {
  for (var property in from) {
    to[property] = from[property];
  }
  return to;
}
extend({}, {
  a: 1
})
// {a: 1}
// 上面这个方法的问题在于，如果遇到存取器定义的属性，会只拷贝值
extend({}, {
  get a() { return 1 }
})
// {a: 1}
// 为了解决这个问题，我们可以通过Object.defineProperty方法来拷贝属性
var extend = function (to, from) {
  for (var property in from) {
    if (!from.hasOwnProperty(property)) continue;
    Object.defineProperty(
      to,
      property,
      Object.getOwnPropertyDescriptor(from, property)
    );
  }
  return to;
}
extend({}, { get a(){ return 1 } })
// { get a(){ return 1 } })

冻结对象的读写状态，防止对象被改变，有三种冻结方式

• 最弱的一种是Object.preventExtensions
• 其次是Object.seal
• 最强的是Object.freeze

// Object.preventExtensions方法可以使得一个对象无法再添加新的属性
var obj = new Object();
Object.preventExtensions(obj);
Object.defineProperty(obj, 'p', {
  value: 'hello'
});
// TypeError: Cannot define property:p, object is not extensible.
obj.p = 1;
obj.p // undefined
// Object.isExtensible方法用于检查一个对象是否使用了Object.preventExtensions方法
// 也就是说，检查是否可以为一个对象添加属性
var obj = new Object();
Object.isExtensible(obj) // true
Object.preventExtensions(obj);
Object.isExtensible(obj) // false
// Object.seal方法使得一个对象既无法添加新属性，也无法删除旧属性
var obj = { p: 'hello' };
Object.seal(obj);
delete obj.p;
obj.p // "hello"
obj.x = 'world';
obj.x // undefined
// Object.seal实质是把属性描述对象的configurable属性设为false，因此属性描述对象不再能改变了
// Object.seal只是禁止新增或删除属性，并不影响修改某个属性的值
// Object.isSealed方法用于检查一个对象是否使用了Object.seal方法
var obj = { p: 'a' };
Object.seal(obj);
Object.isSealed(obj) // true
// 这时，Object.isExtensible方法也返回false
var obj = { p: 'a' };
Object.seal(obj);
Object.isExtensible(obj) // false
// Object.freeze方法可以使得一个对象无法添加新属性、无法删除旧属性
// 也无法改变属性的值，使得这个对象实际上变成了常量
var obj = {
  p: 'hello'
};
Object.freeze(obj);
obj.p = 'world';
obj.p // "hello"
obj.t = 'hello';
obj.t // undefined
delete obj.p // false
obj.p // "hello"
// 上面代码中，对obj对象进行Object.freeze()以后，修改属性、新增属性、删除属性都无效了
// 这些操作并不报错，只是默默地失败，如果在严格模式下，则会报错
// Object.isFrozen方法用于检查一个对象是否使用了Object.freeze方法
var obj = {
  p: 'hello'
};
Object.freeze(obj);
Object.isFrozen(obj) // true
// 使用Object.freeze方法以后，Object.isSealed将会返回true，Object.isExtensible返回false
var obj = {
  p: 'hello'
};
Object.freeze(obj);
Object.isSealed(obj) // true
Object.isExtensible(obj) // false
// Object.isFrozen的一个用途是，确认某个对象没有被冻结后，再对它的属性赋值
var obj = {
  p: 'hello'
};
Object.freeze(obj);
if (!Object.isFrozen(obj)) {
  obj.p = 'world';
}
// 局限性
// 上面的三个方法锁定对象的可写性有一个漏洞：可以通过改变原型对象，来为对象增加属性
var obj = new Object();
Object.preventExtensions(obj);
var proto = Object.getPrototypeOf(obj);
proto.t = 'hello';
obj.t
// hello
// 对象obj本身不能新增属性，但是可以在它的原型对象上新增属性，就依然能够在obj上读到
// 另外一个局限是，如果属性值是对象
// 上面这些方法只能冻结属性指向的对象，而不能冻结对象本身的内容
var obj = {
  foo: 1,
  bar: ['a', 'b']
};
Object.freeze(obj);
obj.bar.push('c');
obj.bar // ["a", "b", "c"]
// 上面代码中，obj.bar属性指向一个数组，obj对象被冻结以后
// 这个指向无法改变，即无法指向其他值，但是所指向的数组是可以改变的

3. Array 对象

var arr = new Array(2);
arr.length // 2
arr // [ empty x 2 ]
// 生成一个两个成员的数组，每个位置都是空值
var arr = new Array(2);
// 等同于
var arr = Array(2);
// 考虑到语义性，以及与其他构造函数用户保持一致，建议总是加上new
// rray()作为构造函数，行为很不一致
因此，不建议使用它生成新数组，直接使用数组字面量是更好的做法
// bad
var arr = new Array(1, 2);
// good
var arr = [1, 2];
var a = new Array(3);
var b = [undefined, undefined, undefined];
a.length // 3
b.length // 3
a[0] // undefined
b[0] // undefined
0 in a // false
0 in b // true

Array.isArray()

• Array.isArray方法返回一个布尔值，表示参数是否为数组。它可以弥补typeof运算符的不足

var arr = [1, 2, 3];
typeof arr // "object"
Array.isArray(arr) // true
// typeof运算符只能显示数组的类型是Object，而Array.isArray方法可以识别数组

valueOf()，toString()

// 数组的valueOf方法返回数组本身
var arr = [1, 2, 3];
arr.valueOf() // [1, 2, 3]
// 数组的toString方法返回数组的字符串形式
var arr = [1, 2, 3];
arr.toString() // "1,2,3"
var arr = [1, 2, 3, [4, 5, 6]];
arr.toString() // "1,2,3,4,5,6"

push()，pop()

// push方法用于在数组的末端添加一个或多个元素，并返回添加新元素后的数组长度
// 注意，该方法会改变原数组
var arr = [];
arr.push(1) // 1
arr.push('a') // 2
arr.push(true, {}) // 4
arr // [1, 'a', true, {}]
// pop方法用于删除数组的最后一个元素，并返回该元素
// 注意，该方法会改变原数组
var arr = ['a', 'b', 'c'];
arr.pop() // 'c'
arr // ['a', 'b']
// 对空数组使用pop方法，不会报错，而是返回undefined
[].pop() // undefined
// push和pop结合使用，就构成了“后进先出”的栈结构（stack）
var arr = [];
arr.push(1, 2);
arr.push(3);
arr.pop();
arr // [1, 2]

shift()，unshift()

// shift()方法用于删除数组的第一个元素，并返回该元素
// 注意，该方法会改变原数组
var a = ['a', 'b', 'c'];
a.shift() // 'a'
a // ['b', 'c']
// shift()方法可以遍历并清空一个数组
var list = [1, 2, 3, 4];
var item;
while (item = list.shift()) {
  console.log(item);
}
list // []
// 它的前提是数组元素不能是0或任何布尔值等于false的元素
// 因此这样的遍历不是很可靠
// push()和shift()结合使用，就构成了“先进先出”的队列结构（queue）
// unshift()方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度
注意，该方法会改变原数组
var a = ['a', 'b', 'c'];
a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']
// unshift()方法可以接受多个参数，这些参数都会添加到目标数组头部
var arr = [ 'c', 'd' ];
arr.unshift('a', 'b') // 4
arr // [ 'a', 'b', 'c', 'd' ]

join()

// join()方法以指定参数作为分隔符，将所有数组成员连接为一个字符串返回
如果不提供参数，默认用逗号分隔
var a = [1, 2, 3, 4];
a.join(' ') // '1 2 3 4'
a.join(' | ') // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"
// 如果数组成员是undefined或null或空位，会被转成空字符串
[undefined, null].join('#')
// '#'
['a',, 'b'].join('-')
// 'a--b'
// 通过call方法，这个方法也可以用于字符串或类似数组的对象
Array.prototype.join.call('hello', '-')
// "h-e-l-l-o"
var obj = { 0: 'a', 1: 'b', length: 2 };
Array.prototype.join.call(obj, '-')
// 'a-b'

concat()

// concat方法用于多个数组的合并
// 它将新数组的成员，添加到原数组成员的后部，然后返回一个新数组，原数组不变
['hello'].concat(['world'])
// ["hello", "world"]
['hello'].concat(['world'], ['!'])
// ["hello", "world", "!"]
[].concat({a: 1}, {b: 2})
// [{ a: 1 }, { b: 2 }]
[2].concat({a: 1})
// [2, {a: 1}]
// 除了数组作为参数，concat也接受其他类型的值作为参数，添加到目标数组尾部。
[1, 2, 3].concat(4, 5, 6)
// [1, 2, 3, 4, 5, 6]
// 如果数组成员包括对象，concat方法返回当前数组的一个浅拷贝
var obj = { a: 1 };
var oldArray = [obj];
var newArray = oldArray.concat();
obj.a = 2;
newArray[0].a // 2

reverse()

// reverse方法用于颠倒排列数组元素，返回改变后的数组。注意，该方法将改变原数组
var a = ['a', 'b', 'c'];
a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]

slice()

// slice()方法用于提取目标数组的一部分，返回一个新数组，原数组不变
arr.slice(start, end);
var a = ['a', 'b', 'c'];
a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice(2, 6) // ["c"]
a.slice() // ["a", "b", "c"]
// 最后一个例子slice()没有参数，实际上等于返回一个原数组的拷贝
// 如果slice()方法的参数是负数，则表示倒数计算的位置
var a = ['a', 'b', 'c'];
a.slice(-2) // ["b", "c"]
a.slice(-2, -1) // ["b"]
// 如果第一个参数大于等于数组长度，或者第二个参数小于第一个参数，则返回空数组
var a = ['a', 'b', 'c'];
a.slice(4) // []
a.slice(2, 1) // []
// slice()方法的一个重要应用，是将类似数组的对象转为真正的数组
Array.prototype.slice.call({ 0: 'a', 1: 'b', length: 2 })
// ['a', 'b']
Array.prototype.slice.call(document.querySelectorAll("div"));
Array.prototype.slice.call(arguments);

splice()

// splice()方法用于删除原数组的一部分成员
// 并可以在删除的位置添加新的数组成员,返回值是被删除的元素
// 注意，该方法会改变原数组
arr.splice(start, count, addElement1, addElement2, ...);
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(4, 2) // ["e", "f"]
a // ["a", "b", "c", "d"]
// 起始位置如果是负数，就表示从倒数位置开始删除
var a = ['a', 'b', 'c', 'd', 'e', 'f'];
a.splice(-4, 2) // ["c", "d"]
// 如果只是单纯地插入元素，splice方法的第二个参数可以设为0
var a = [1, 1, 1];
a.splice(1, 0, 2) // []
a // [1, 2, 1, 1]
// 如果只提供第一个参数，等同于将原数组在指定位置拆分成两个数组
var a = [1, 2, 3, 4];
a.splice(2) // [3, 4]
a // [1, 2]

sort()

// sort方法对数组成员进行排序，默认是按照字典顺序排序
// 排序后，原数组将被改变
['d', 'c', 'b', 'a'].sort()
// ['a', 'b', 'c', 'd']
[4, 3, 2, 1].sort()
// [1, 2, 3, 4]
[11, 101].sort()
// [101, 11]
[10111, 1101, 111].sort()
// [10111, 1101, 111]
// 上面代码的最后两个例子，需要特殊注意
// sort()方法不是按照大小排序，而是按照字典顺序
// 也就是说，数值会被先转成字符串，再按照字典顺序进行比较，所以101排在11的前面
// 如果想让sort方法按照自定义方式排序，可以传入一个函数作为参数
[10111, 1101, 111].sort(function (a, b) {
  return a - b;
})
// [111, 1101, 10111]
// 上面代码中，sort的参数函数本身接受两个参数，表示进行比较的两个数组成员
[
  { name: "张三", age: 30 },
  { name: "李四", age: 24 },
  { name: "王五", age: 28  }
].sort(function (o1, o2) {
  return o1.age - o2.age;
})
// [
//   { name: "李四", age: 24 },
//   { name: "王五", age: 28  },
//   { name: "张三", age: 30 }
// ]
// bad
[1, 4, 2, 6, 0, 6, 2, 6].sort((a, b) => a > b)
// good
[1, 4, 2, 6, 0, 6, 2, 6].sort((a, b) => a - b)
// 前一种排序算法返回的是布尔值，这是不推荐使用的。后一种是数值，才是更好的写法

map()

// map方法将数组的所有成员依次传入参数函数
// 然后把每一次的执行结果组成一个新数组返回
var numbers = [1, 2, 3];
numbers.map(function (n) {
  return n + 1;
});
// [2, 3, 4]
numbers
// [1, 2, 3]
// map方法接受一个函数作为参数
// 该函数调用时，map方法向它传入三个参数：当前成员、当前位置和数组本身
[1, 2, 3].map(function(elem, index, arr) {
  return elem * index;
});
// [0, 2, 6]
// map方法还可以接受第二个参数，用来绑定回调函数内部的this变量
var arr = ['a', 'b', 'c'];
[1, 2].map(function (e) {
  return this[e];
}, arr)
// ['b', 'c']
// 如果数组有空位，map方法的回调函数在这个位置不会执行，会跳过数组的空位
var f = function (n) { return 'a' };
[1, undefined, 2].map(f) // ["a", "a", "a"]
[1, null, 2].map(f) // ["a", "a", "a"]
[1, , 2].map(f) // ["a", , "a"]

forEach()

// forEach方法与map方法很相似，也是对数组的所有成员依次执行参数函数
// 但是，forEach方法不返回值，只用来操作数据
function log(element, index, array) {
  console.log('[' + index + '] = ' + element);
}
[2, 5, 9].forEach(log);
// [0] = 2
// [1] = 5
// [2] = 9
// forEach方法也可以接受第二个参数，绑定参数函数的this变量
var out = [];
[1, 2, 3].forEach(function(elem) {
  this.push(elem * elem);
}, out);
out // [1, 4, 9]
// 注意，forEach方法无法中断执行，总是会将所有成员遍历完
// 如果希望符合某种条件时，就中断遍历，要使用for循环
var arr = [1, 2, 3];
for (var i = 0; i < arr.length; i++) {
  if (arr[i] === 2) break;
  console.log(arr[i]);
}
// 1
// forEach方法也会跳过数组的空位
var log = function (n) {
  console.log(n + 1);
};
[1, undefined, 2].forEach(log)
// 2
// NaN
// 3
[1, null, 2].forEach(log)
// 2
// 1
// 3
[1, , 2].forEach(log)
// 2
// 3

filter()

// filter方法用于过滤数组成员，满足条件的成员组成一个新数组返回
[1, 2, 3, 4, 5].filter(function (elem) {
  return (elem > 3);
})
// [4, 5]
var arr = [0, 1, 'a', false];
arr.filter(Boolean)
// [1, "a"]
// filter方法的参数函数可以接受三个参数：当前成员，当前位置和整个数组
[1, 2, 3, 4, 5].filter(function (elem, index, arr) {
  return index % 2 === 0;
});
// [1, 3, 5]
// filter方法还可以接受第二个参数，用来绑定参数函数内部的this变量
var obj = { MAX: 3 };
var myFilter = function (item) {
  if (item > this.MAX) return true;
};
var arr = [2, 8, 3, 4, 1, 3, 2, 9];
arr.filter(myFilter, obj) // [8, 4, 9]

some()，every()

//这两个方法类似“断言”（assert），返回一个布尔值
// 表示判断数组成员是否符合某种条件
// 它们接受一个函数作为参数，所有数组成员依次执行该函数
// 该函数接受三个参数：当前成员、当前位置和整个数组，然后返回一个布尔值
// some方法是只要一个成员的返回值是true，则整个some方法的返回值就是true
// 否则返回false
var arr = [1, 2, 3, 4, 5];
arr.some(function (elem, index, arr) {
  return elem >= 3;
});
// true
// every方法是所有成员的返回值都是true，整个every方法才返回true
// 否则返回false
var arr = [1, 2, 3, 4, 5];
arr.every(function (elem, index, arr) {
  return elem >= 3;
});
// false
// 注意，对于空数组，some方法返回false
// every方法返回true
// 回调函数都不会执行
function isEven(x) { return x % 2 === 0 }
[].some(isEven) // false
[].every(isEven) // true
// some和every方法还可以接受第二个参数，用来绑定参数函数内部的this变量

reduce()，reduceRight()

// reduce方法和reduceRight方法依次处理数组的每个成员，最终累计为一个值
// 它们的差别是，reduce是从左到右处理（从第一个成员到最后一个成员）
// reduceRight则是从右到左（从最后一个成员到第一个成员），其他完全一样
[1, 2, 3, 4, 5].reduce(function (a, b) {
  console.log(a, b);
  return a + b;
})
// 1 2
// 3 3
// 6 4
// 10 5
//最后结果：15
// reduce方法和reduceRight方法的第一个参数都是一个函数
// 该函数接受以下四个参数。
累积变量，默认为数组的第一个成员
当前变量，默认为数组的第二个成员
当前位置（从0开始）
原数组
// 这四个参数之中，只有前两个是必须的，后两个则是可选的
// 如果要对累积变量指定初值，可以把它放在reduce方法和reduceRight方法的第二个参数
[1, 2, 3, 4, 5].reduce(function (a, b) {
  return a + b;
}, 10);
// 25
// 上面的第二个参数相当于设定了默认值，处理空数组时尤其有用
function add(prev, cur) {
  return prev + cur;
}
[].reduce(add)
// TypeError: Reduce of empty array with no initial value
[].reduce(add, 1)
// 1
// reduceRight方法的例子
function subtract(prev, cur) {
  return prev - cur;
}
[3, 2, 1].reduce(subtract) // 0
[3, 2, 1].reduceRight(subtract) // -4
// 上面代码中，reduce方法相当于3减去2再减去1
// reduceRight方法相当于1减去2再减去3
// 由于这两个方法会遍历数组，所以实际上还可以用来做一些遍历相关的操作
// 比如，找出字符长度最长的数组成员
function findLongest(entries) {
  return entries.reduce(function (longest, entry) {
    return entry.length > longest.length ? entry : longest;
  }, '');
}
findLongest(['aaa', 'bb', 'c']) // "aaa"
// reduce的参数函数会将字符长度较长的那个数组成员，作为累积值
// 这导致遍历所有成员之后，累积值就是字符长度最长的那个成员

indexOf()，lastIndexOf()

// indexOf方法返回给定元素在数组中第一次出现的位置，如果没有出现则返回-1
var a = ['a', 'b', 'c'];
a.indexOf('b') // 1
a.indexOf('y') // -1
// indexOf方法还可以接受第二个参数，表示搜索的开始位置
['a', 'b', 'c'].indexOf('a', 1) // -1
// lastIndexOf方法返回给定元素在数组中最后一次出现的位置，如果没有出现则返回-1
var a = [2, 5, 9, 2];
a.lastIndexOf(2) // 3
a.lastIndexOf(7) // -1
// 注意，这两个方法不能用来搜索NaN的位置，即它们无法确定数组成员是否包含NaN
[NaN].indexOf(NaN) // -1
[NaN].lastIndexOf(NaN) // -1
// 这是因为这两个方法内部，使用严格相等运算符（===）进行比较
// 而NaN是唯一一个不等于自身的值

链式使用

var users = [
  {name: 'tom', email: 'tom@example.com'},
  {name: 'peter', email: 'peter@example.com'}
];
users
.map(function (user) {
  return user.email;
})
.filter(function (email) {
  return /^t/.test(email);
})
.forEach(function (email) {
  console.log(email);
});
// "tom@example.com"

4. 包装对象

• 所谓“包装对象”，指的是与数值、字符串、布尔值分别相对应的Number、String、Boolean三个原生对象
• 这三个原生对象可以把原始类型的值变成（包装成）对象
• 包装对象的设计目的
  • 首先是使得“对象”这种类型可以覆盖 JavaScript 所有的值，整门语言有一个通用的数据模型
  • 其次是使得原始类型的值也有办法调用自己的方法

var v1 = new Number(123);
var v2 = new String('abc');
var v3 = new Boolean(true);
typeof v1 // "object"
typeof v2 // "object"
typeof v3 // "object"
v1 === 123 // false
v2 === 'abc' // false
v3 === true // false
// Number、String和Boolean这三个原生对象
// 如果不作为构造函数调用（即调用时不加new），而是作为普通函数调用
// 常常用于将任意类型的值转为数值、字符串和布尔值
// 字符串转为数值
Number('123') // 123
// 数值转为字符串
String(123) // "123"
// 数值转为布尔值
Boolean(123) // true
// 实例方法
valueOf()方法返回包装对象实例对应的原始类型的值
new Number(123).valueOf()  // 123
new String('abc').valueOf() // "abc"
new Boolean(true).valueOf() // true
// toString()方法返回对应的字符串形式
new Number(123).toString() // "123"
new String('abc').toString() // "abc"
new Boolean(true).toString() // "true"

原始类型与实例对象的自动转换

• 某些场合，原始类型的值会自动当作包装对象调用，即调用包装对象的属性和方法
• 这时，JavaScript 引擎会自动将原始类型的值转为包装对象实例，并在使用后立刻销毁实例

'abc'.length // 3
var str = 'abc';
str.length // 3
// 等同于
var strObj = new String(str)
// String {
//   0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"
// }
strObj.length // 3
// 上面代码中，字符串abc的包装对象提供了多个属性，length只是其中之一
// 自动转换生成的包装对象是只读的，无法修改。所以，字符串无法添加新属性
var s = 'Hello World';
s.x = 123;
s.x // undefined

自定义方法

String.prototype.double = function () {
  return this.valueOf() + this.valueOf();
};
'abc'.double()
// abcabc
Number.prototype.double = function () {
  return this.valueOf() + this.valueOf();
};
(123).double() // 246
// 注意，最后一行的123外面必须要加上圆括号
// 否则后面的点运算符（.）会被解释成小数点

5. Boolean 对象

• Boolean对象是 JavaScript 的三个包装对象之一
• 作为构造函数，它主要用于生成布尔值的包装对象实例

var b = new Boolean(true);
typeof b // "object"
b.valueOf() // true
// 注意，false对应的包装对象实例，布尔运算结果也是true
if (new Boolean(false)) {
  console.log('true');
} // true
if (new Boolean(false).valueOf()) {
  console.log('true');
} // 无输出

Boolean 函数的类型转换作用

Boolean(undefined) // false
Boolean(null) // false
Boolean(0) // false
Boolean('') // false
Boolean(NaN) // false
Boolean(1) // true
Boolean('false') // true
Boolean([]) // true
Boolean({}) // true
Boolean(function () {}) // true
Boolean(/foo/) // true
// 使用双重的否运算符（!）也可以将任意值转为对应的布尔值
!!undefined // false
!!null // false
!!0 // false
!!'' // false
!!NaN // false
!!1 // true
!!'false' // true
!![] // true
!!{} // true
!!function(){} // true
!!/foo/ // true
// 对于一些特殊值，Boolean对象前面加不加new，会得到完全相反的结果，必须小心
if (Boolean(false)) {
  console.log('true');
} // 无输出
if (new Boolean(false)) {
  console.log('true');
} // true
if (Boolean(null)) {
  console.log('true');
} // 无输出
if (new Boolean(null)) {
  console.log('true');
} // true

6. Number 对象

• Number对象是数值对应的包装对象
  • 可以作为构造函数使用
  • 也可以作为工具函数使用

var n = new Number(1);
typeof n // "object"
Number(true) // 1

静态属性

Number.POSITIVE_INFINITY // Infinity
Number.NEGATIVE_INFINITY // -Infinity
Number.NaN // NaN
Number.MAX_VALUE
// 1.7976931348623157e+308
Number.MAX_VALUE < Infinity
// true
Number.MIN_VALUE
// 5e-324
Number.MIN_VALUE > 0
// true
Number.MAX_SAFE_INTEGER // 9007199254740991
Number.MIN_SAFE_INTEGER // -9007199254740991

实例方法

// Number.prototype.toString()
// Number对象部署了自己的toString方法，用来将一个数值转为字符串形式
(10).toString() // "10"
// toString方法可以接受一个参数，表示输出的进制
// 如果省略这个参数，默认将数值先转为十进制
(10).toString(2) // "1010"
(10).toString(8) // "12"
(10).toString(16) // "a"
// toString方法只能将十进制的数，转为其他进制的字符串
// 如果要将其他进制的数，转回十进制，需要使用parseInt方法
// Number.prototype.toFixed()
// toFixed()方法先将一个数转为指定位数的小数，然后返回这个小数对应的字符串
(10).toFixed(2) // "10.00"
10.005.toFixed(2) // "10.01"
// 由于浮点数的原因，小数5的四舍五入是不确定的，使用的时候必须小心
// Number.prototype.toExponential()
// toExponential方法用于将一个数转为科学计数法形式
(10).toExponential()  // "1e+1"
(10).toExponential(1) // "1.0e+1"
(10).toExponential(2) // "1.00e+1"
(1234).toExponential()  // "1.234e+3"
(1234).toExponential(1) // "1.2e+3"
(1234).toExponential(2) // "1.23e+3"
// toExponential方法的参数是小数点后有效数字的位数，范围为0到100
// 超出这个范围，会抛出一个 RangeError 错误
// Number.prototype.toPrecision()
// Number.prototype.toPrecision()方法用于将一个数转为指定位数的有效数字
(12.34).toPrecision(1) // "1e+1"
(12.34).toPrecision(2) // "12"
(12.34).toPrecision(3) // "12.3"
(12.34).toPrecision(4) // "12.34"
(12.34).toPrecision(5) // "12.340"
// 该方法用于四舍五入时不太可靠，跟浮点数不是精确储存有
(12.35).toPrecision(3) // "12.3"
(12.25).toPrecision(3) // "12.3"
(12.15).toPrecision(3) // "12.2"
(12.45).toPrecision(3) // "12.4"
// Number.prototype.toLocaleString()
// Number.prototype.toLocaleString()方法接受一个地区码作为参数，返回一个字符串
// 表示当前数字在该地区的当地书写形式
(123).toLocaleString('zh-Hans-CN-u-nu-hanidec')
// "一二三"
// 该方法还可以接受第二个参数配置对象，用来定制指定用途的返回字符串
// 该对象的style属性指定输出样式，默认值是decimal，表示输出十进制形式
// 如果值为percent，表示输出百分数
(123).toLocaleString('zh-Hans-CN', { style: 'percent' })
// "12,300%"
// 如果style属性的值为currency，则可以搭配currency属性，输出指定格式的货币字符串形式
(123).toLocaleString('zh-Hans-CN', { style: 'currency', currency: 'CNY' })
// "￥123.00"
(123).toLocaleString('de-DE', { style: 'currency', currency: 'EUR' })
// "123,00 €"
(123).toLocaleString('en-US', { style: 'currency', currency: 'USD' })
// "$123.00"
// 如果Number.prototype.toLocaleString()省略了参数，则由浏览器自行决定如何处理
// 注意，该方法如果使用浏览器不认识的地区码，会抛出一个错误
(123).toLocaleString('123') // 出错