1. js中并不是所有值都是对象

基本数据类型不是对象，没有方法和属性
  方法:是某个特定对象才能调用的函数
  属性:是隶属于某个特定对象的变量
  对象:是一种字包含的数据类型
ECMAScript和JavaScript的关系是，前者是后者的规格，后者是前者的一种实现。在日常场合，这两个词是可以互换的。

2. 语法

2.1基本语法

等号右边是表达式，每一行用;分开的代码都是一个语句，
语句和表达式的区别在于，前者主要为了进行某种操作，一般情况下不需要返回值，语句的值就是是undefined；后者则是为了得到返回值，一定会返回一个值
变量提升：就是所有的变量的声明语句，都会被提升到代码的头部
for循环和while循环相同
三元运算符(条件) ? 表达式1 : 表达式2可视为if...else的简写
do...while循环不管条件是否为true至少执行一次
continue语句用于立即终止本轮循环，返回循环结构的头部，开始下一轮循环
break用于直接跳出循环或代码块

2.2数据类型

typeof null返回object
if语句中undefined和null都会转为false
null是一个表示“空”的对象，转为数值时为0；
undefined是一个表示”此处无定义”的原始值，转为数值时为NaN。
转换规则是除了下面六个值被转为false，其他值都视为true。 undefined null false 0 NaN "或''（空字符串）

2.3数值

2.3.1 js中所有数字都是64位双精度浮点数

第1位：符号位，0表示正数，1表示负数
第2位到第12位（共11位）：指数部分
第13位到第64位（共52位）：小数部分（即有效数字）

绝对值小于等于2的53次方的整数，即2^-53到2^53，都可以精确表示。

2.3.2 数值的进制

十进制：没有前导0的数值。八进制：有前缀0o或0O的数值，或者有前导0、且只用到0-7的八个阿拉伯数字的数值。十六进制：有前缀0x或0X的数值。二进制：有前缀0b或0B的数值。

2.3.3 parseInt方法用于将字符串转为整数。

如果parseInt的参数不是字符串，则会先转为字符串再转换。
字符串转为整数的时候，是一个个字符依次转换，如果遇到不能转为数字的字符，就不再进行下去，返回已经转好的部分。 3.如果以0x开头会照16进制解析 4如果以0开头会以10进制解析
parseInt方法还可以接受第二个参数（2到36之间），表示被解析的值的进制
如果第一个参数不是字符串，"0x11"写成0x11则会先转换为10进制，在进行第二个参数的转换 -isNaN()

2.3.4 isNaN()可以用来判断一个值是否为NaN。

isNaN只对数值有效，如果传入其他值，会被先转成数值。相当于isNaN(Number('xxx'))

2.4字符串

1. 字符串只能写在一行内，如果要分成多行，每一行末尾加上\和换行符

2. 反斜杠（\）在字符串内有特殊含义，用来表示一些特殊字符，所以又称为转义符。

3. 字符串可视为字符数组可以使用[]运算符返回某个位置的字符

反斜杠\有3种特殊的用法：

\HHH 反斜杠后面紧跟三个八进制数（000到377），代表一个字符。HHH对应该字符的 Unicode 码点，比如\251表示版权符号。显然，这种方法只能输出256种字符。
\xHH \x后面紧跟两个十六进制数（00到FF），代表一个字符。HH对应该字符的 Unicode 码点，比如\xA9表示版权符号。这种方法也只能输出256种字符。
\uXXXX \u后面紧跟四个十六进制数（0000到FFFF），代表一个字符。HHHH对应该字符的 Unicode 码点，比如\u00A9表示版权符号。

4. 字符集：

每个字符在javascript中都以16位（2个字节）的utf-16格式储存
JavaScript 使用 Unicode 字符集。JavaScript 引擎内部，所有字符都用 Unicode 表示。
由于历史原因，对于码点在U+10000到U+10FFFF之间的字符，JavaScript 总是认为它们是两个字符

5. Base64 转码

文本有不可打印的符号可以使用base64转码
btoa()：任意值转为 Base64 编码 atob()：Base64 编码转为原来的值
必须是ASCII 码的字符

2.5对象

对象就是hash，就是一组“键值对”（key-value）的集合，是一种无序的复合数据集合。
对象中所有的key(键名)的都是字符串,如果是数值会自动转换为字符串
如果key不符合标识符的条件，（比如第一个字符为数字，或者含有空格或运算符且也不是数字），必须加上引号
key也叫属性，如果value为函数，那么通常把这个属性称为“方法”，如果属性的值还是一个对象，就形成了链式引用。
如果只采用大括号。JavaScript 规定，如果行首是大括号，一律解释为语句（即代码块），如果想表达对象则要咋在外加上圆括号({a:123})
读取属性obj.p或者obj['p'] 如果不加引号则指向一个变量
查看对象的所有属性Object.keys -delete命令可以删除对象的属性，删除不存在的属性也会返回true，不能删除继承的属性
in运算符检查某个对象是否包含某个属性(key) （不能识别是否为继承的，都会返回true）
for（...in...）｛｝用于遍历对象的全部属性
with 语句用来批量操作同一个对象的多个属性（如果with区块内部有变量的赋值操作，必须是当前对象已经存在的属性，否则会生成一个全局变量）

2.6数组

数组其实是固定key的对象(hash)，key['0'],['1'],['2'].['3'],['4']...都是字符串
数组的length是其中最大key+1，不是其中的个数
当数组的某个元素是空元素，即2个逗号之间没有任何值，我们称改数组存在空位
空位不会影响length属性，空位是可读取的，返回undefined，delete命令删除某个属性，这个位置就形成了空位
空位就是数组没有这个元素，所以不会被遍历到，而undefined则表示数组有这个元素，值是undefined，所以遍历不会跳过。
类似数组的对象，特征是具有lenght属性，length不是动态的
可以使用var arr = Array.prototype.slice.call(arrayLike)把对象变成真正的数组

2.7函数

函数名也会提升，如果同时采用function命令和赋值语句声明同一个函数，最后总是采用赋值语句的定义。
根据es5规范，不得在条件语句中声明函数，由于存在函数名提升，所以可能不报错，如果非要在条件语句中定义函数，请使用变量声明函数
构造函数：return一个对象的函数
函数也是对象，他的原型中有个call方法来通过eval执行函数体
函数的toString返回函数的源码
函数内部定义的变量会在该作用于内覆盖同名全局变量
函数执行时所在的作用域，是定义时的作用域，而不是调用时所在的作用域
参数可以省略，如果要省略靠前的参数，则传入undefined 比如→ f(undefined,b)
arguments对象包含了函数运行时的所有参数，arguments[0]就是第一个参数，普通模式下，arguments对象可以修改，严格模式不行，arguments是一个伪数组
把arguments变成真数组:var args = Array.prototype.slice.call(arguments);
闭包看我写的函数文章
立即执行函数(IIFE):一般情况下只对匿名函数使用立即执行函数,不污染全局变量，内部形成单独作用域，可封装私有变量
1. (function()){}
2. (function(){})
3. !function(){}
eval命令:把字符串当作语句来执行，eval没有单独的作用域，可以修改当前作用域中变量的值，有安全风险

2.8运算符

2.8.1重载

加法在相加的时候决定，是执行相加还是相连，导致不同的语法行为，这种现象叫重载。
减法、除法和乘法运算符，都是将字符串自动转为数值，然后再运算。
```
'3' + 4 + 5 // "345"
3 + 4 + '5' // "75"
```

2.8.2 对象转成原始类型的值，规则如下

x.valueOf().toString()

valueOf方法最适合该对象类型的原始值，这时再自动调用对象的toString方法，将其转为字符串。
在数值运算里，会优先调用valueOf()，如a + b；在字符串运算里，会优先调用toString()，如alert(c)。

2.8.3自增和自减

下面代码中，x是先返回当前值，然后自增，所以得到1；y是先自增，然后返回新的值，所以得到2。

var x = 1;
var y = 1;
x++ // 1
++y // 2

+也是数值运算符，可以把任何值转换为number

2.8.3比较运算符

字符串比较

JavaScript 引擎内部首先比较首字符的 Unicode 码点。如果相等，再比较第二个字符的 Unicode 码点，以此类推。

非字符串比较

true > false // true
// 等同于 Number(true) > Number(false)
// 即 1 > 0

先转换为数值在进行比较

对象比较

对象转换成原始类型的值，算法是先调用valueOf方法；如果返回的还是对象，再接着调用toString方法

x.valueOf().toString() >y.valueOf().toString()

2.8.4严格相等运算符

两个复合类型（对象、数组、函数）的数据比较时，不是比较它们的值是否相等，而是比较它们是否指向同一个地址。

{} === {} // false
[] === [] // false
(function () {} === function () {}) // false

如果两个变量引用同一个对象，则它们相等。

var a = {}
var b = a
a === b//true

2.8.5 &&且运算符

它的运算规则是：如果第一个运算子的布尔值为true，则返回第二个运算子的值（注意是值，不是布尔值）；如果第一个运算子的布尔值为false，则直接返回第一个运算子的值，且不再对第二个运算子求值。
返回值就是遇到的第一个falsy值,如果全为真,则返回最后一个值

1 && 0 //0
1 && 0 && 2 && 3 && 4 //0
1 && 2 && 3 && 4 && 5 //5

if (i) {
  doSomething();
}

// 等价于

i && doSomething();

2.8.6 或运算符（||）

它的运算规则是：如果第一个运算子的布尔值为true，则返回第一个运算子的值，且不再对第二个运算子求值；如果第一个运算子的布尔值为false，则返回第二个运算子的值。
返回值就是遇到的第一个truthy值,如果全为假,则返回最后一个值

0 || 1 //1
0 || null || undefined || NaN || 1 //1
0 || null || undefined || NaN || "" //""

2.8.7 位运算符

二进制或运算符（or）：符号为|，表示若两个二进制位都为0，则结果为0，否则为1。
二进制与运算符（and）：符号为&，表示若两个二进制位都为1，则结果为1，否则为0。
二进制否运算符（not）：符号为~，表示对一个二进制位取反。
异或运算符（xor）：符号为^，表示若两个二进制位不相同，则结果为1，否则为0。
左移运算符（left shift）：符号为<<，详见下文解释。
右移运算符（right shift）：符号为>>，详见下文解释。
带符号位的右移运算符（zero filled right shift）：符号为>>>，详见下文解释。

有一点需要特别注意，位运算符只对整数起作用，如果一个运算子不是整数，会自动转为整数后再执行。另外，虽然在 JavaScript 内部，数值都是以64位浮点数的形式储存，但是做位运算的时候，是以32位带符号的整数进行运算的，并且返回值也是一个32位带符号的整数。

2.8.8 void运算符

void运算符的作用是执行一个表达式，然后不返回任何值，或者说返回undefined。
这个运算符的主要用途是浏览器的书签工具（bookmarklet），以及在超级链接中插入代码防止网页跳转。

<a href="javascript: void(f())">文字</a>

2.8.9逗号运算符

逗号运算符用于对两个表达式求值，并返回后一个表达式的值。

'a', 'b' // "b"

var x = 0;
var y = (x++, 10);
x // 1
y // 10

2.8.10 优先级

圆括号的作用

圆括号()可以用来提高运算的优先级，因为它的优先级是最高的，即圆括号中的表达式会第一个运算。

左结合与右结合

对于优先级别相同的运算符，大多数情况，计算顺序总是从左到右。

x + y + z

但是少数运算符的计算顺序是从右到左，即从右边开始计算。
其中，最主要的是赋值运算符（=）和三元条件运算符（?:）。

w = x = y = z;
q = a ? b : c ? d : e ? f : g;

--------------------------------
w = (x = (y = z));
q = a ? b : (c ? d : (e ? f : g));

2.8数据类型转换

强制转换

2.8.1 Number()

使用Number函数，可以将任意类型的值转化成数值。
下面分成两种情况讨论，一种是参数是原始类型的值，另一种是参数是对象。

Number()
ture会变为1，false变为0
null变成0
undefined变为NaN
""变为0 
parseInt('1',进制) 会忽略掉前面的空格,知道找到第一个非数字就停止
parseFloat() 浮点数

老司机采用-0 such as:"1"-0===1
老司机采用+ such as:+"1"===1

对象

简单的规则是，Number方法的参数是对象时，将返回NaN，除非是包含单个数值的数组。

Number({a: 1})                  // NaN
Number([1, 2, 3])               // NaN
Number([5])                     // 5

2.8.2 String()

String函数可以将任意类型的值转化成字符串,强制转换,null会变成'null',undefined变成'undefined'

String(null)                   //'null'

tostring()
√：number，boolean
×(报错：null，undefined
obj.tostring()会得到"{object:Object}" 不是你想要的

√：number,boolean null undefinded
obj+''还是会得到"{object:Object}"
tips:因为+会把两边的类型趋向2个string相加，1+"1"=(1).tostring+"1"="11" 
window.string()

老司机采用+' '方法转为字符串`

对象

String方法的参数如果是对象，返回一个类型字符串；如果是数组，返回该数组的字符串形式。

String({a: 1})                  // "[object Object]"
String([1, 2, 3])               // "1,2,3"

2.8.3 Boolean()

Boolean函数可以将任意类型的值转为布尔值。它的转换规则相对简单：除了以下五个值的转换结果为false，其他的值全部为true。

undefined
null
-0或+0
NaN
''（空字符串）

2.8编程风格

2.8.1区块

总是使用大括号

2.8.2圆括号

表示函数调用时，函数名与左括号之间没有空格。

表示函数定义时，函数名与左括号之间没有空格。

其他情况时，前面位置的语法元素与左括号之间，都有一个空格。

// 圆括号表示函数的调用
console.log('abc');

// 圆括号表示表达式的组合
(1 + 2) * 3

2.8.3全局变量

JavaScript 最大的语法缺点，可能就是全局变量对于任何一个代码块，都是可读可写。这对代码的模块化和重复使用，非常不利。

因此，建议避免使用全局变量。如果不得不使用，可以考虑用大写字母表示变量名，这样更容易看出这是全局变量，比如UPPER_CASE。

2.8.4相等和严格相等

建议不要使用相等运算符（==），只使用严格相等运算符（===）

2.8.5自增和自减运算符

自增（++）和自减（--）运算符，放在变量的前面或后面，返回的值不一样，很容易发生错误。事实上，所有的++运算符都可以用+= 1代替。

2.8.6分号

建议在行尾添加分号，在有些情况下，不添加分好可能出现错误

x = y
(function () {
  // ...
})();

// 等同于
x = y(function () {...})();

3. 标准库

3.1 Object对象

Object本身是一个函数，可以当作工具方法使用，将任意值转为对象。这个方法常用于保证某个值一定是对象。
如果参数为空（或者为undefined和null），Object()返回一个空对象。 instanceof运算符用来验证，一个对象是否为指定的构造函数的实例。obj instanceof Object返回true，就表示obj对象是Object的实例。

3.1.2 Object 构造函数

虽然用法相似，但是Object(value)与new Object(value)两者的语义是不同的，Object(value)表示将value转成一个对象，new Object(value)则表示新生成一个对象，它的值是value。

3.1.3 Object 的静态方法

所谓“静态方法”，是指部署在Object对象自身的方法

3.1.3.1 Object.keys()，Object.getOwnPropertyNames()

Object.keys方法和Object.getOwnPropertyNames方法都用来遍历对象的属性。

var obj = {
  p1: 123,
  p2: 456
};

Object.keys(obj) // ["p1", "p2"]
Object.getOwnPropertyNames(obj) // ["p1", "p2"]

Object.keys()和Object.getOwnPropertyNames()返回的结果是一样的。只有涉及不可枚举属性时，才会有不一样的结果。Object.keys方法只返回可枚举的属性，Object.getOwnPropertyNames方法还返回不可枚举的属性名。

3.1.3.2 Object 的实例方法

还有不少方法定义在Object.prototype对象。它们称为实例方法，所有Object的实例对象都继承了这些方法。

Object.prototype.valueOf()：返回当前对象对应的值。              //valueOf方法的主要用途是，JavaScript 自动类型转换时会默认调用这个方法
Object.prototype.toString()：返回当前对象对应的字符串形式。
Object.prototype.toLocaleString()：返回当前对象对应的本地字符串形式。
Object.prototype.hasOwnProperty()：判断某个属性是否为当前对象自身的属性，还是继承自原型对象的属性。
Object.prototype.isPrototypeOf()：判断当前对象是否为另一个对象的原型。
Object.prototype.propertyIsEnumerable()：判断某个属性是否可枚举。

3.1.3.2 Object.prototype.isPrototypeOf()和object instanceof 构造函数

A.isPrototypeOf(B) 判断的是A对象是否存在于B对象的原型链之中
A instanceof B 判断的是B.prototype是否存在与A的原型链之中

A.isPrototypeOf(B)  返回true 则B instanceof A 一定返回true
//A是B的原型，B在由A构造，B.prototype指向A   对象instanceof 构造函数

3.1.3.3 Object.prototype.toString()

上面代码表示，对于一个对象调用toString方法，会返回字符串[object Object]，该字符串说明对象的类型。字符串[object Object]本身没有太大的用处
数组、字符串、函数、Date 对象都分别部署了自定义的toString方法，覆盖了Object.prototype.toString方法

3.1.3.4 toString() 的应用：判断数据类型

空对象调用toString()结果返回一个字符串object Object，其中第二个Object表示该值的构造函数。这是一个十分有用的判断数据类型的方法。
由于实例对象可能会自定义toString方法，覆盖掉Object.prototype.toString方法，所以为了得到类型字符串，最好直接使用Object.prototype.toString方法。通过函数的call方法，可以在任意值上调用这个方法，帮助我们判断这个值的类型。

Object.prototype.toString.call(value)
数值：返回[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]。

3.1.3.5 Object.prototype.toLocaleString()

Object.prototype.toLocaleString方法与toString的返回结果相同，也是返回一个值的字符串形式。
这个方法的主要作用是留出一个接口，让各种不同的对象实现自己版本的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"

3.1.3.6 Object.prototype.hasOwnProperty()

Object.prototype.hasOwnProperty方法接受一个字符串作为参数，返回一个布尔值，表示该实例对象自身是否具有该属性。(可枚举属性)

var obj = {
  p: 123
};

obj.hasOwnProperty('p') // true
obj.hasOwnProperty('toString') // false

3.2 Array对象

3.2.1 构造函数

Array是 JavaScript 的原生对象，同时也是一个构造函数，可以用它生成新的数组。
Array构造函数有一个很大的缺陷，就是不同的参数，会导致它的行为不一致。辣鸡js

// 无参数时，返回一个空数组
new Array() // []

// 单个正整数参数，表示返回的新数组的长度
new Array(1) // [ empty ]
new Array(2) // [ empty x 2 ]

// 非正整数的数值作为参数，会报错
new Array(3.2) // RangeError: Invalid array length
new Array(-3) // RangeError: Invalid array length

// 单个非数值（比如字符串、布尔值、对象等）作为参数，
// 则该参数是返回的新数组的成员
new Array('abc') // ['abc']
new Array([1]) // [Array[1]]

// 多参数时，所有参数都是返回的新数组的成员
new Array(1, 2) // [1, 2]
new Array('a', 'b', 'c') // ['a', 'b', 'c']

不要用我估计你也不会用，

// bad 辣鸡
var arr = new Array(1, 2);

// good nice马飞
var arr = [1, 2];

3.2.2 静态方法

3.2.2.1 Array.isArray()

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

var arr = [1, 2, 3];

typeof arr // "object"
Array.isArray(arr) // true

3.2.3 实例方法

3.2.3.1 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]

3.2.3.2 shift()，unshift()

shift方法用于删除数组的第一个元素，并返回该元素。注意，该方法会改变原数组。

var a = ['a', 'b', 'c'];

a.shift() // 'a'
a // ['b', 'c']

shift方法可以遍历并清空一个数组。
push和shift结合使用，就构成了“先进先出”的队列结构（queue）

unshift方法用于在数组的第一个位置添加元素，并返回添加新元素后的数组长度。注意，该方法会改变原数组。

var a = ['a', 'b', 'c'];

a.unshift('x'); // 4
a // ['x', 'a', 'b', 'c']

3.2.3.3 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'

3.2.3.4 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方法返回当前数组的一个浅拷贝。所谓“浅拷贝”，指的是新数组拷贝的是对象的引用。

var obj = { a: 1 };
var array = [obj];

var newArray = array.concat();

obj.a = 2;
newArray[0].a
// 2

3.2.3.5 reverse()

reverse方法用于颠倒排列数组元素，返回改变后的数组。注意，该方法将改变原数组。

3.2.3.6 slice()

slice() 方法返回一个从开始到结束（不包括结束）选择的数组的一部分浅拷贝到一个新数组对象。且原始数组不会被修改。。

arr.slice(start, end);

3.2.3.7 splice()

splice方法用于删除原数组的一部分成员，并可以在删除的位置添加新的数组成员，返回值是被删除的元素。注意，该方法会改变原数组。

arr.splice(start, count, addElement1, addElement2, ...);
// 从start开始包括strat删除count个，在strat前面添加addElement1、addElement2

如果只提供第一个参数，等同于将原数组在指定位置拆分成两个数组。

var a = [1, 2, 3, 4];
a.splice(2) // [3, 4]
a // [1, 2]

3.2.3.8 sort()

sort方法对数组成员进行排序，默认是按照unicode顺序排序。排序后，原数组将被改变。
如果想让sort方法按照自定义方式排序，可以传入一个函数作为参数。

[10111, 1101, 111].sort(function (a, b) {
  return a - b;
})
// [111, 1101, 10111]

上面代码中，sort的参数函数本身接受两个参数，表示进行比较的两个数组成员。如果该函数的返回值大于0，表示第一个成员排在第二个成员后面；其他情况下，都是第一个元素排在第二个元素前面。

3.2.3.9 map()

map方法将数组的所有成员依次传入参数函数，然后把每一次的执行结果组成一个新数组返回。

var numbers = [1, 2, 3];

numbers.map(function (n) {
  return n + 1;
});
// [2, 3, 4]

numbers
// [1, 2, 3]

3.2.3.10 forEach()

forEach() 方法对数组的每个元素执行一次提供的函数,没有返回值

array.forEach(callback(value, key, arr){
    //do something
}, this)
//arr,this可选
-----------------------------------------------------------------
array.forEach( function(value,key){
    //do some thing
})

forEach用this传参给里面的函数调用 ,所以array.forEach(function(value,key){//do something})能够遍历array
a.forEacj中的函数接受3个参数 arr.value,arr.key,arr自己，第三个可以省略，下面2行代码相等

array.forEach(function(value,key){})
array.forEach.call(this,function(value,key ){})

我们可以自己手写一个forEach

let foo={0:'a',1:'b',length:2}
foo.forEach=function(fn){
    for(let i = 0;i < foo.length; i++){
        fn(this[i],i)       //foo的每一项都调用一下fn
    }
}

3.2.3.11 filter()

过滤器：filter() 方法创建一个新数组, 其包含通过所提供函数实现的测试的所有元素

array.filter(function(currentValue,index,arr){
    
}, thisValue)
//thisValue可选。对象作为该执行回调时使用，传递给函数，用作 this 的值。如果省略了 thisValue ，this 的值为"undefined

let array=[1,2,3,4,5,6,7,8,9,10]
array.fillter(function(value,key){
    return value >= 5
})
//[5,6,7,8,9,10]

3.2.3.12 reduce()

reduce() 方法对累加器和数组中的每个元素（从左到右）应用一个函数，最后返回单个值。

arr.reduce(function(a, b, c, d){},e)

a:累加器的返回值,上一次的结果
b:当前处理的元素,现在
c:当前处理的元素的索引，第一次处理时，如果提供了初始值，则为0，没有提供则为1,可选
d:d:arr自己本身，可选
e:初始值，如果没有指定，则arr中的第一个值为初始值,可选

let arr=[1,2,3,4]
arr.reduce((prev, curr) => prev + curr )
//10

reduce可以表示map

a = [1,2,3]
a.reduce(function(arr,n){
    arr.push(n*2)
    return arr
},[])
//[2,4,6]
//每一项平方

reduce可以表示filter

a = [1,2,3,4,5,6,7,8,9,10]
a.reduce(function(arr,n){
    if(n % 2 === 0){
        arr.push(n)
    }
    return arr
},[])
//[2,4,6,8,10]

3.2.3.13 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

3.3包装对象

对象是 JavaScript 语言最主要的数据类型，三种原始类型的值——数值、字符串、布尔值——在一定条件下，也会自动转为对象，也就是原始类型的“包装对象”。

所谓“包装对象”，就是分别与数值、字符串、布尔值相对应的Number、String、Boolean三个原生对象。这三个原生对象可以把原始类型的值变成（包装成）对象。

var v1 = new Number(123);
var v2 = new String('abc');
var v3 = new Boolean(true);

包装对象的最大目的，首先是使得 JavaScript 的对象涵盖所有的值，其次使得原始类型的值可以方便地调用某些方法。
Number、String和Boolean如果不作为构造函数调用（即调用时不加new），常常用于将任意类型的值转为数值、字符串和布尔值

Number(123) // 123
String('abc') // "abc"
Boolean(true) // true

3.3.1实例方法

3.3.1.1 valueOf()

valueOf方法返回包装对象实例对应的原始类型的值。

new Number(123).valueOf()  // 123
new String('abc').valueOf() // "abc"
new Boolean(true).valueOf() // true

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

原始类型的值，可以自动当作对象调用，即调用各种对象的方法和参数。这时，JavaScript 引擎会自动将原始类型的值转为包装对象实例，在使用后立刻销毁实例。

比如，字符串可以调用length属性，返回字符串的长度。

'abc'.length // 3

上面代码中，abc是一个字符串，本身不是对象，不能调用length属性。JavaScript 引擎自动将其转为包装对象，在这个对象上调用length属性。调用结束后，这个临时对象就会被销毁。这就叫原始类型与实例对象的自动转换。

3.4Number对象

Number对象是数值对应的包装对象，可以作为构造函数使用，也可以作为工具函数使用。
作为构造函数时，它用于生成值为数值的对象。

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

作为工具函数时，它可以将任何类型的值转为数值。

Number(true) // 1

3.4.1属性

Number对象拥有以下一些属性

Number.POSITIVE_INFINITY：正的无限，指向Infinity。
Number.NEGATIVE_INFINITY：负的无限，指向-Infinity。
Number.NaN：表示非数值，指向NaN。
Number.MAX_VALUE：表示最大的正数，相应的，最小的负数为-Number.MAX_VALUE。
Number.MIN_VALUE：表示最小的正数（即最接近0的正数，在64位浮点数体系中为5e-324），相应的，最接近0的负数为-Number.MIN_VALUE。
Number.MAX_SAFE_INTEGER：表示能够精确表示的最大整数，即9007199254740991。
Number.MIN_SAFE_INTEGER：表示能够精确表示的最小整数，即-9007199254740991。

3.4.2实例方法

3.4.2.1 Number.prototype.toString()

toString方法可以接受一个参数，表示输出的进制。如果省略这个参数，默认将数值先转为十进制，再输出字符串；否则，就根据参数指定的进制，将一个数字转化成某个进制的字符串

10).toString() // "10"
(10).toString(2) // "1010"
(10).toString(8) // "12"
(10).toString(16) // "a"

上面代码中，10一定要放在括号里，这样表明后面的点表示调用对象属性。如果不加括号，这个点会被 JavaScript 引擎解释成小数点，从而报错
toString方法只能将十进制的数，转为其他进制的字符串。如果要将其他进制的数，转回十进制，需要使用parseInt方法。

3.4.2.2 Number.prototype.toFixed()

toFixed方法先将一个数转为指定位数的小数，然后返回这个小数对应的字符串。

(10).toFixed(2) // "10.00"
10.005.toFixed(2) // "10.01"

3.4.2.3 Number.prototype.toExponential()

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"

3.4.2.4 Number.prototype.toPrecision()

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"

3.5 String对象

String对象是 JavaScript 原生提供的三个包装对象之一，用来生成字符串对象。除了用作构造函数，String对象还可以当作工具方法使用，将任意类型的值转为字符串

var s1 = 'abc';
var s2 = new String('abc');

typeof s1 // "string"
typeof s2 // "object"

s2.valueOf() // "abc"

字符串对象是一个伪数组

3.5.1 静态方法

3.5.1.1 String.fromCharCode()

String对象提供的静态方法（即定义在对象本身，而不是定义在对象实例的方法），主要是String.fromCharCode()。该方法的参数是一个或多个数值，代表 Unicode 码点，返回值是这些码点组成的字符串。

String.fromCharCode() // ""
String.fromCharCode(97) // "a"
String.fromCharCode(104, 101, 108, 108, 111)
// "hello"

3.5.2 实例属性

3.5.2.1 String.prototype.length

字符串实例的length属性返回字符串的长度。

'abc'.length // 3

3.5.2 实例方法

3.5.2.1 String.prototype.charAt()

charAt返回指定位置的字符，参数从0开始

'abc'.charAt(1) // "b"
'abc'[1] // "b"

3.5.2.2 String.prototype.concat()

concat用于连接两个字符串，返回一个新字符串，不改变原字符串

var s1 = 'abc';
var s2 = 'def';
'a'.concat('b', 'c') // "abc"
s1.concat(s2) // "abcdef"
s1 // "abc"

3.5.2.3 String.prototype.slice()

slice方法用于从原字符串取出子字符串并返回，不改变原字符串。它的第一个参数是子字符串的开始位置，第二个参数是子字符串的结束位置（不含该位置）。

'JavaScript'.slice(0, 4) // "Java"
'JavaScript'.slice(4) // "Script"
'JavaScript'.slice(2, 1) // "" 如果第一个参数大于第二个参数，slice方法返回一个空字符串

3.5.2.4 String.prototype.substring()

substring方法用于从原字符串取出子字符串并返回，不改变原字符串，跟slice方法很相像。它的第一个参数表示子字符串的开始位置，第二个位置表示结束位置（返回结果不含该位置）。不建议使用substring

'JavaScript'.substring(10, 4) // "Script"  
// 等同于  //如果第二个参数大于第一个参数，substring方法会自动更换两个参数的位置
'JavaScript'.substring(4, 10) // "Script"

'Javascript'.substring(-3) // "JavaScript"
'JavaScript'.substring(4, -3) // "Java"
//如果参数是负数，substring方法会自动将负数转为0。

3.5.2.5 String.prototype.substr()

substr方法用于从原字符串取出子字符串并返回，不改变原字符串，跟slice和substring方法的作用相同。
substr方法的第一个参数是子字符串的开始位置（从0开始计算），第二个参数是子字符串的长度

'JavaScript'.substr(4, 6) // "Script"