摘要：有點尷尬，返回一個布爾值，表示判斷數組成員是否符合某種條件。該方法的參數為小數位數，有效范圍為，超出這范圍將會拋出錯誤。調用結束后，該對象自動銷毀。

這是ES5的入門篇教程的筆記，網址在上一篇文章中，以下內容中黑體表示大標題，還有一些重點；斜體表示對于自身，還需要下功夫學習的內容。這里面有一些自己的見解，所以若是發現問題，歡迎指出~

繼續標準庫
Array對象
Array構造函數有一個很大的缺陷，就是不同的參數，會導致它的行為不一樣（這我知道，所以我都直接賦值的，就是怕出現意想不到的結果，推薦直接賦值呀，哈哈哈）。

// 無參數時，返回一個空數組
new Array() // []

// 單個正整數參數，表示返回的新數組的長度
new Array(1) // [empty]
new Array(2) // [empty * 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"]

使用Array.isArray()方法可以返回一個布爾值，表示參數是否為數組，它可以彌補typeof運算符的不足（一般會用在從后端接收數據時，防止被挖坑，如果想要接收的是數組，可以先預判斷防止報錯）。

push()和pop()是一對。push方法用于在數組的末端添加一個或多個元素（原來還可以添加多個，一直以來都以為是一個），并返回添加新元素后的數組長度;pop方法用于刪除數組的最后一個元素，并返回該元素，兩種方法都會改變原數組。
shift()和unshift()是一對。shift()用于刪除數組的第一個元素，并返回該元素；unshift()方法用于在數組的第一個位置添加一個或多個元素，并返回添加新元素后的數組長度，這兩種方法也會改變原數組。
push和pop結合使用，就構成了“后進先出”的棧結構（stack）；push和shift結合使用，就構成了“先進先出”的隊列結構（queue）。

let arr = [];
arr.push(1) // 1
arr.push("a") // 2
arr.push(true, {}) // 4
arr // [1, "a", true, {}]
arr.pop() // {}
arr // [1, "a", true]

let a = ["a", "b", "c"];
a.shift() // "a"
a // ["b", "c"]

a = ["c", "d"];
a.unshift("a", "b") // 4
a // ["a", "b", "c", "d"]

join()方法以指定參數作為分隔符，將所有數組成員連接為一個字符串返回，如果不提供參數，默認用逗號分隔。（這個方法不怎么用，差點都忘了還有這個方法）
通過call方法，可以用于字符串或類似數組的對象。

let a = [1, 2, 3, 4];
a.join(" ") // "1 2 3 4"
a.join(" | ") // "1 | 2 | 3 | 4"
a.join() // "1,2,3,4"

Array.prototype.join.call("hello", "-") // "h-e-l-l-o"
let obj = { 0: "a", 1: "b", ; length: 2 };
Array.prototype.join.call(obj, "-") // "a-b"

concat方法用于多個數組的合并。它將新數組的成員，添加到原數組成員的后部，然后返回一個新的數組，原數組不變。
除了數組作為參數，concat也接受其他類型的值作為參數，添加到目標數組尾部。
如果數組成員包括對象，concat方法返回當前數組的一個淺拷貝。所謂“淺拷貝”，指的是新數組拷貝的是對象的引用。

[].concat({a: 1}, {b: 2}) // [{a: 1}, {b: 2}]
[2].concat({a: 1}) // [2, {a: 1}]

[1, 2, 3].concat(4, 5, 6) // [1, 2, 3, 4, 5, 6]

let obj = {a: 1};
let oldArray = [obj];
let newArray = oldArray.concat();
obj.a = 2;
newArray[0].a // 2

reverse方法用于顛倒排列數組元素，返回改變后的數組，該方法將改變原數組。

let a = ["a", "b", "c"];
a.reverse() // ["c", "b", "a"]
a // ["c", "b", "a"]

slice方法用于提取目標數組的一部分，返回一個新數組，原數組不變。
第一個參數為起始位置（從0開始），第二個參數為終止位置（但該位置的元素本身不包括在內）。如果省略第二個參數，則一直返回到原數組的最后一個成員。
slice方法的一個重要應用，是將類似數組的對象轉為真正的數組。（并沒有用到過，也沒有適用場景）

arr.slice(start, end);
a.slice(0) // ["a", "b", "c"]
a.slice(1) // ["b", "c"]
a.slice(1, 2) // ["b"]
a.slice() // ["a", "b", "c"]

Array.prototype.slice.call({ 0: "a", 1: "b", length: 2}) // ["a", "b"]
Array.prototype.slice.call(arguments);

splice方法用于刪除原數組的一部分成員，并可以在刪除的位置添加新的數組成員，返回值是被刪除的元素。該方法回改變原數組。（splice和slice，split一直都是傻傻分不清楚，每次要拆分數組或是刪除數組元素的時候，都要百度，感受到了無力感。。。slice中文意思是切片，不改變原數組；splice表示的是拼接，改變原數組；split表示的是分裂。）
第一個參數是刪除的起始位置（從0開始），第二個參數是被刪除的元素的個數。如果后面還有更多的參數，則表示這些就是要被插入數組的新元素。

arr.splice(start, count, addElement1, addElement2, …);

let a = ["a", "b", "c", "d", "e", "f"];
a.splice(4, 2, 1, 2) // ["e", "f"]
a // ["a", "b", "c", "d", 1, 2]

sort方法對數組成員進行排序，默認是按照字典順序排序。排序后，原數組將改變。
sort方法不是按照大小排序，而是按照字段順序，也就是說，數值會被先轉成字符串，再按照字典順序進行比較，所以101排在11的前面。
sort方法也可以按照自定義方式排序，可以傳入一個函數作為參數。
sort的參數函數本身可以接受兩個參數，表示進行比較的兩個數組成員。如果該函數的返回值大于0，表示第一個成員排在第二個成員后面；其他情況下（小于等于0），都是第一個元素排在第二個元素前面。

["d", "c", "b", "a"].sort() // ["a", "b", "c", "d"]
[4, 3, 2, 1].sort() // [1, 2, 3, 4]
[11, 101].sort() // [101, 11]

[{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 }
// ]

map方法將數組的所有成員一次傳入參數函數，然后把每一次的執行結果組成一個新數組返回。
map方法接受一個函數作為參數，調用該函數時，map方法向它傳入三個參數：當前成員、當前位置和數組本身。
map方法還可以接受第二個參數，用來綁定回調函數內部的this變量。

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

let arr = ["a", "b", "c"];
[1, 2].map(function (e) {
    return this(e);
}, arr) // ["b", "c"] 第二個參數，將回調函數內部的this對象，指向arr數組

forEach方法與map方法很相似，也是對數組的所有成員依次執行參數函數，但是forEach方法不返回值，只用來操作數據。=》如果數組遍歷的目的是為了得到返回值，那么使用map方法，否則使用forEach方法。
forEach方法無法終端執行，總是會將所有成員遍歷完，如果希望符合某種條件時，就中斷遍歷，要使用for循環，這也是for和forEach最明顯的區別。
filter方法用于過濾數組成員，滿足條件的成員組成一個新數組返回，原數組不會改變。
some()、every()，這兩個方法類似“斷言”（assert, 沒聽說，只聽說過斷點。。。。。有點尷尬），返回一個布爾值，表示判斷數組成員是否符合某種條件。
some方法是只要一個成員的返回值是true，則整個some方法的返回值就是true，否則返回false。
every方法是所有成員的返回值都是true，整個every方法才返回true，否則返回false。
對于空數組，some方法返回false，every方法返回true，回調函數都不會執行。（這個真奇怪）

let arr = [1, 2, 3, 4, 5];
arr.some(function (elem, index, arr) {
    return elem >= 3;
}); // true

arr.every(function (elem, index, arr) {
    return elem >= 3;
)}; // false

function isEven(x) { return x % 2 === 0 }

[].some(isEven) // false
[].every(isEven) // true

indexOf方法返回給定元素在數組中第一次出現的位置，如果沒有出現則返回-1.
indexOf方法還可以接受第二個參數，表示搜索的開始位置。
lastIndexOf方法返回給定元素在數組中最后一次出現的位置，如果沒有出現則返回-1.
這兩個方法不能用來搜索NaN的位置，也就說它們無法確定數組成員是否包含NaN。

let a = ["a", "b", "c"];
a.indexOf("b") // 1
a.indexOf("y") // -1
a.indexOf("a", 1) // -1

a = [2, 5, 9, 2];
a.lastIndexOf(2) // 3
a.lastIndexOf(7) // -1

這些數組方法之中，有不少返回的還是數組，所以可以鏈式使用。

包裝對象
對象是JavaScript語言最主要的數據類型，三種原始類型的值——數值、字符串、布爾值——在一定條件下，也會自動轉為對象，也就是原始類型的“包裝對象”（wrapper）。
所謂的“包裝對象”，指的是與數字、字符串、布爾值分別相對應的Number、String、Boolean三個原生對象。這三個原生對象可以把原始類型的值變成（包裝成）對象。
包裝對象設計的目的在于，首先使得“對象”這種類型可以覆蓋JavaScript所有的值，整門語言有一個通用的數據模型，其次是使得原始類型的值也有辦法調用自己的方法。

let v1 = new Number(123);
let v2 = new String("abc");
let v3 = new Boolean(true);

typeof v1 // "object"
typeof v2 // "object"
typeof v3 // "object"

v1 === 123 // false
v2 === "abc" // false
v3 === true // false

原始類型與實例對象的自動轉換
某些場合，原始類型的值會自動當作包裝對象調用，即調用包裝對象的屬性和方法。這時，JavaScript引擎會自動將原始類型的值轉為包裝對象實例，并在使用后立刻銷毀實例。自動轉換生成的對象是只讀的，無法修改，也就是說，字符串無法添加新屬性。

let str = "abc";
str.length // 3 abc是一個字符串，本身不是對象，不能調用length屬性，引擎自動將其轉為包裝對象，在這個對象上調用length屬性。調用結束后，這個臨時對象就會被銷毀，這就是原始類型與實例對象的自動轉換。
// 等同于
let strObj = new String(str);
// String {
//     0: "a", 1: "b", 2: "c", length: 3, [[PrimitiveValue]]: "abc"
// }
strObj.length // 3

str.x = 123;
str.x // undefined  自動轉換生成的包裝對象是只讀的

let newStr = new String("new");
newStr.x = 123;
newStr // 123

Boolean對象
對于一些特殊值，Boolean對象前面加不加new，會得到完全相反的結果！可以用!!可以將任意值轉為對應的布爾值。

if (Boolean(false)) {
    console.log("true");
} // 無輸出 這里沒有new，表示的是將任意值轉為布爾值
if (new Boolean(false)) {
    console.log("true");
} // true 前面加了new，表示生成了一個Boolean對象的實例，只要是對象，返回都為true
if (Boolean(null)) {
    console.log("true");
} // 無輸出
if (new Boolean(null)) {
    console.log("true");
} // true

Number
Number.prototype.toFixed()方法先將一個數轉為指定位數的小數，然后返回這個小數對應的字符串。
該方法的參數為小數位數，有效范圍為0~20，超出這范圍將會拋出RangeError錯誤。
由于浮點數不是精確儲存的原因，小數5的四舍五入是不確定的（上次使用的時候，就發現了這個問題，終于知道原因了，當時因為這個原因，都是先把值放大到n10倍，用Math.round取整，再除以（n10）。因為整數取整沒有這個問題），使用的時候必須小心。
Number.prototype.toExponential()方法用于將一個數轉為科學計數法形式。
該方法的參數是小數位數，有效范圍為0~20.

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

// 理由同上一個
let n = 1;
n.x = 1;
n.x // undefined 自動轉為Number的實例對象。調用結束后，該對象自動銷毀。

n = new Number(1);
n.x = 1;
n.x // 1

String對象
字符串對象是一個類似數組的對象（很想數組，但不是數組，其他地方又稱為“類數組”。）需要注意的是只有字符串對象才是，原生字符串不是，因為字符串對象中有過一個length屬性，而類數組最顯著的特征就是length屬性。

new String("abc")
// String {0: "a", 1: "b", 2: "c", length: 3}

原來字符串也有concat實例方法，用于連接兩個字符串，返回一個新字符串，不改變原字符串。
emmm字符串也有slice方法，又要開始暈頭了
slice方法用來從原字符串取出子字符串并返回，不改變原字符串，最多參數為兩個。
toLowerCase(),toUpperCase()分別用于將一個字符串全部轉為小寫、大寫，返回的都是一個新字符串，不改變原字符串。
match方法用于確定源字符串是否匹配某個子字符串，返回一個數組，成員為匹配的第一個字符串，否則，返回null。match方法還可以匹配正則表達式。

"cat, bat, sat".match("at") // ["at"]
"cat, bat, sat".match("xt") // null

replace方法用于替換匹配的子字符串，一般情況下只替換第一個匹配（除非使用帶有g"修飾符的正則表達式）。
split方法按照給定規則分割字符串，返回一個由分割出來的子字符串組成的數組。split方法還可以接受第二個參數，限定返回數組的最大成員數。

"a|b|c".split("|") // ["a", "b", "c"]
"a|b|c".split("") // ["a", "|", "b", "|", "c"]
"a|b|c".split("|", 3) // ["a", "b", "c"]

Math對象
這些方法都比較常用，就沒仔細看了。

Math.abs()：絕對值
Math.ceil()：向上取整
Math.floor()：向下取整
Math.max()：最大值
Math.min()：最小值
Math.pow()：指數運算
Math.sqrt()：平方根
Math.log()：自然對數
Math.exp()：e的指數
Math.round()：四舍五入
Math.random()：隨機數

// 還有三角函數，平時不怎么用到
Math.sing(0) // 0
Math.cos(0) // 1
Math.tan(0) // 0
Math.sin(Math.PI / 2) // 1
Math.asin(1) // 1.5707963267948966
Math.acos(1) // 0
Math.atan(1) // 0.7853981633974483

// round
Math.round(1.5) // 2
Math.round(-1.5) // -1

RegExp對象
終于到了正則表達式內容了，激動人心的時刻到了，在這之前還沒好好梳理過正則表達式呢！
正則表達式（regular expression）是一種表達文本模式（即字符串結構）的方法，有點像字符串的模板，常常用來按照“給定模式”匹配文本。
新建正則表達式有兩種方法，一種是使用字面量，以斜桿表示開始和結束；另一種使用RegExp構造函數。
第一種方法在引擎編譯代碼時，就會新建正則表達式；第二種方法在運行時新建正則表達式。第一種的效率較高，且比較便利和直觀，所以實際應用中，基本上都采用字面量定義正則表達式。
正則實例對象的test方法返回一個布爾值，表示當前模式是否能匹配參數字符串。

let regex = /xyz/;
let regex = new RegExp("xyz"); // 這兩種寫法都是等價的，都新建了一個內容為xyz的正則表達式對象。
/cat/.test("cats and dogs") // true

與正則表達式有關的字符串實例方法：
String.prototype.match():返回一個數組，成員是所有匹配的子字符串。（跟test的區別在于，test是正則實例對象的方法，返回是布爾值；match是字符串實例對象的方法，返回的是數組。）
String.prototype.search():按照給定的正則表達式進行搜索，返回一個整數，表示匹配開始的位置。
String.prototype.replace():按照給定的正則表達式進行替換，返回替換后的字符串。
String.prototype.split():按照給定規則進行字符串分割，返回一個數組，包含分割后的各個成員。

let s = "_x_x";
let r1 = /x/;
let r2 = /y/;
s.match(r1); // ["x"]
s.match(r2); // null

"_x_x".search(/x/) // 1

// 字符串對象的replace方法可以替換匹配的值。可以接受兩個參數，第一個是正則表達式，表示搜索模式，第二個是替換的內容。 str.replace(search, replacement)。正則表達式如果不加g修飾符，就替換第一個匹配成功的值，否則替換所有匹配成功的值。
"aaa".replace("a", "b") // "baa"
"aaa".replace(/a/, "b") // "baa"
"aaa".replace(/a/g, "b") // "bbb"

// split可以接受兩個參數，第一個參數是正則表達式，表示分割規則，第二個參數是返回數組的最大成員數
"a, b,c, d".split(",") // ["a", " b", "c", " d"]
"a, b,c, d".split(/, */) / ["a", "b", "c", "d"] 去除多余的空格

"aaa**a*".split(/a*/) // ["", "*", "*", "*"] 分割規則是0次或多次的a，由于正則默認是貪婪匹配，第一個分隔符是aaa，第二個分隔符是0個a（即空字符），第三個分隔符是a，所以將字符串分成四個部分。

// 如果正則表達式帶有括號，則括號匹配的部分也會作為數組成員返回。
"aaa*a*".split(/(a*)/)// [ "", "aaa", "*", "a", "*" ] 代碼的正則表達式使用了括號，第一個組匹配是aaa，第二個組匹配是a，它們都作為數組成員返 回。

正則表達式中的字面量字符和元字符
大部分字符在正則表達式中，就是字面的含義，比如/a/匹配a，/b/匹配b。
如果在正則表達式中，某個字符只表示它字面的含義（比如/a/匹配a），那么他們就叫做“字面量字符”。
除了字面量字符以外，還有一部分字符有特殊含義，不代表字面的意思，它們叫做“元字符”。

/dog/.test("old dog") // true

// **元字符**主要有以下幾個

// 1、點字符. 匹配除回車
、換行
、行分隔符u2028和段分隔符u2029以外的所有字符。需要注意的是，對于碼點大于0xFFFF字符，點字符不能正確匹配，會認為這是兩個字符。
/c.t/ // c.t匹配c和t之間包含任意一個字符的情況，只要這三個字符在同一行，比如cat、c2t、c-t等等，但是不匹配coot。

// 2、位置字符 用來提示字符所處的位置，主要有兩個字符。 ^表示字符串的開始位置；$表字符串的結束位置。
/^test/.test("test123") // true 表示test必須出現在開始位置
/test$/.test("new test") // true 表示test必須出現在結束位置
/^test$/.test("test") // true 表示從開始位置到結束位置**只有test**
/^test$/.test("test test") // false 

// 3.選擇符 |  在正則表達式中表示“或關系”（OR），即cat|dog表示匹配cat或dog。
/11|22/.test("911") // true 正則表達式指定必須匹配11或22，選擇會包括它前后的多個字符，比如/11|22/指的是匹配11或22，而不是指匹配1或2，如果先要修改這個行為，可以使用圓括號。
/a( |	)b/.test("a	b") // true 表示的是a和b之間有一個空格或者一個制表符

// 4.轉義符  正則表達式中那些特殊含義的元字符，如果要匹配它們本身，就需要在它們前面加上反斜杠
/1+1/.test("1+1") // false 加號是元字符，不代表自身
/1+1/.test("11") // true
/1+1/.test("1+1") // true
// 如果使用RegExp方法生成正則對象，轉義需要使用兩個斜桿，因為RegExp作為構造函數，參數是一個字符串，但是在字符串內部，反斜杠也是轉義字符，所以它會先被反斜杠轉義一次，然后再被正則表達式轉義一次，因此需要兩個反斜杠轉義。

字符類表示有一系列字符可供選擇，只要匹配其中一個就可以了，所有可供選擇的字符都放在方括號內，比如[xyz]表示x、y、z之中任選一個匹配。
脫字符 ^ 表示除了字符表之中的字符，其他字符都可以匹配。
連字符 - 用來提供簡寫形式，表示字符的連續范圍，比如[123456789]可以寫成[0-9]。連字符只有在方括號之中，才表示連續的字符序列，不出現在方括號之中，就不具備簡寫的作用。

/[abc]/.test("hello world") // false
/[abc]/.test("apple") // true  該字符串包含字母a，所以返回true

/[^abc]/.test("hello world") // true 表示除了a、b、c之外都可以匹配。
/[^abc]/.test("bbc") // false

// [^] 表示匹配一切字符，其中包括換行符。相比之下，點字符(.)是不包括換行符的
// 脫字符只有在字符類的第一個位置才有特殊含義，否則就是字面含義。

/a-z/.test("b") // false
/[a-z]/.test("b") // true

[a-z0-9]
[1-31] // 不代表1到31，只代表1到3
/[1-31]/.test(17) // true 1到3或者1，17匹配到了1，所以返回true，所以/[1-31]/.test(17777)也是true 

記住，正則表達式遇到換行符(n)就會停止匹配。
一些簡寫方式：

d 匹配0-9之間的任一數字，相當于[0-9]
D 匹配所有0-9以外的字符，相當于[^0-9]
w 匹配任意的字母、數字和下劃線，相當于[A-Za-z0-9]
W 除字母、數字和下劃線以外的字符，相當于[^A-Za-z0-9]
s 匹配空格（包括換行符、制表符、空格符等），相當于[	
vf]
S 匹配非空格的字符，相當于[^	
vf]
 匹配詞的邊界
B 匹配非詞邊界，即在詞的內部

重復類 模式的精確匹配次數，使用大括號({})表示。{n}表示恰好重復n次， {n,}表示至少重復n次， {n,m}表示重復不少于n次，不多于m次。

/lo{2}k/.test("look") // true
/lo{2,5}k/.test("looook") // true 注意逗號","后面不要加空格

量詞符 用來設定某個模式出現的次數。

? 問號表示某個模式出現0次或1次，等同于{0,1}
* 星號表示某個模式出現0次或多次，等同于{0,}
+ 加號表示某個模式出現1次或多次，等同于{1,}
// 上面的是貪婪模式的，就是最大可能匹配，直到下一個字符不滿足匹配規則為止，默認是貪婪模式
// 下面的是非貪婪模式
+? 表示某個模式出現1次或多次，匹配是采用非貪婪模式（也就是出現1次）
*? 表示某個模式出現0次或多次，匹配時采用非貪婪模式（也就是出現0次）
?? 表示某個模式出現0次或1次，匹配時采用非貪婪模式（也就是出現0次）

修飾符 表示模式的附加規則，放在這種正則模式的最尾部。
g修飾符 表示全局匹配（global）
i修飾符 表示忽略大小寫（ignoreCase）默認正則對象是區分字母的大小寫
m修飾符 表示多行模式，用于識別換行符

JSON對象
json對值得類型和格式的規定：

1、復合類型的值只能是數組或對象，不能是函數、正則表達式對象、日期對象；
2、原始類型的值只有四種：字符串、數值（必須以十進制表示）、布爾值和null（不**能使用NaN， Infinity， -Infinity和undefined**）；（null、空數組和空對象都是合法的JSON值）
3、字符串必須使用**雙引號**表示，不能使用單引號；
4、**對象的鍵名必須放在雙引號里面**；
5、數組或對象最后一個成員的后面，**不能加逗號**。

JSON對象的兩個靜態方法
JSON.stringify方法用于將一個值轉為JSON字符串.該字符串符合JSON格式，并且可以被JSON.parse方法還原。
JSON.parse方法用于將JSON字符串轉換成對應的值。