观阮一峰老师js教程笔记

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. 第1位：符号位，0表示正数，1表示负数
2. 第2位到第12位（共11位）：指数部分
3. 第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方法用于将字符串转为整数。

1. 若是parseInt的参数不是字符串，则会先转为字符串再转换。
2. 字符串转为整数的时候，是一个个字符依次转换，若是遇到不能转为数字的字符，就再也不进行下去，返回已经转好的部分。 3.若是以0x开头会照16进制解析 4若是以0开头会以10进制解析
3. parseInt方法还能够接受第二个参数（2到36之间），表示被解析的值的进制
4. 若是第一个参数不是字符串，"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前面添加addElement一、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"
复制代码