前端點滴（JS基礎）（二）----傾盡所有
- JavaScript 內置對象（一）
- 內置對象公有屬性
- Array 對象
- 1. Array 對象實例
- 2. Array 對象的方法
- （1）Array 對象的增、刪、改、查、填充、截取
- （2）Array 對象的排序、分隔、連接、轉換
- （3）Array 對象的判斷、過濾、循環、累加
- 1. every() 檢測數值元素的每個元素是否==都==符合條件。
- 2. some() 檢測數組元素中是否==有==元素符合指定條件。
- 3. find() 返回符合傳入測試（函數）條件的數組元素。
- 4. findIndex() 返回符合傳入測試（函數）條件的數組元素索引。
- 5. includes() 判斷一個數組是否包含一個指定的值。
- 6. isArray() 判斷對象是否爲數組。
- 7. filter() 檢測數值元素，並返回符合條件所有元素的數組。（重點）
- 8. forEach() 數組每個元素都執行一次回調函數。（重點）
- 9. map() 通過指定函數處理數組的每個元素，並返回處理後的數組。（重點）
- 10. reduce() 將數組元素計算爲一個值（累加器）。
- 3. 總結
JavaScript 內置對象（一）
內置對象公有屬性
涉及面向對象編程（重點）！！！
1. constructor 返回對象的構造函數。
說明：在 JavaScript 中, constructor 屬性返回對象的構造函數。js內置對象中都存在constructor屬性，Match除外。用於返回創建對象的構造函數，還可用作類型的判別。
語法：
內置對象實例.constructor
實例：
/* Array */
var arr = new Array(1,2,3);
console.log(arr.constructor); //=> function Array() { [native code] }
var arr1 = new Array('chenjianer','yaodao','chen');
console.log(arr1.constructor); //=> function Array() { [native code] }
var arr2 = new Array({name:"chenjianer",age:20},{name:"yaodao",age:20},{name:"chen",age:20});
console.log(arr2.constructor); //=> function Array() { [native code] }
/* Object */
var obj = new Object({name:"chenjianer",age:20});
console.log(obj.constructor); //=> function Object() { [native code] }
/* String */
var str = new String('chenjianer');
console.log(str.constructor); //=> function String() { [native code] }
/* Number */
var num = new Number(1);
console.log(num.constructor); //=> function Number() { [native code] }
/* Boolean */
var bool = new Boolean(1/true);
console.log(bool.constructor); //=> function Boolean() { [native code] }
/* undefined */
var test;
console.log(test.constructor); //=> TypeError: Cannot read property 'constructor' of undefined
/* null */
var test2 = null;
console.log(test2.constructor); //=> TypeError: Cannot read property 'constructor' of null
/* Function */
function test3(){
}
var fn = new Function(test3());
console.log(fn.constructor); //=> function Function() { [native code] }
/* Date */
var test4 = new Date();
console.log(test4.constructor); //=> function Date() { [native code] }
2. prototype、__ proto __ 允許你向原型對象添加屬性或方法。
說明：
prototype、__ proto __ 屬性使您有能力向原型對象添加屬性和方法。
語法：
構造函數.prototype.name=value
實例化對象.__proto__.name=value
上述的name可以是屬性名、函數名；value可以是屬性值、函數。
當構建一個屬性，所有該類型的實例對象將被設置屬性，它是默認值。
在構建一個方法時，所有該類型的實例對象都可以使用該方法。
因此：在JavaScript對象中，Prototype是一個全局屬性。
/* Array原型對象添加方法 */
var arr = new Array(1,2,3);
arr.__proto__.test=function(){
this.push(4);
return this;
}
/**
*Array.prototype.test=function(){
*this.push(4);
*return this;
*}
console.log(arr.test()); //=> [1, 2, 3, 4]
/* Object原型對象添加屬性*/
Object.prototype.name='chenjianer';
var obj = {age:20,sex:'male'};
console.log(obj); //=> {age: 20,name: "chenjianer",sex: "male"}
var obj1 = {age:25,sex:'female'};
console.log(obj1); //=> {age: 25,name: "chenjianer",sex: "female"}
/* 構造函數原型對象添加屬性與方法 */
function fn(){
};
fn.prototype.name = 'chenjianer';
fn.prototype.say = function(){
console.log('向原型對象添加屬性和方法');
}
var fn1 = new fn();
console.log(fn1); //=>{name:"chenjianer",say: fn()}
console.log(fn1.name); //=> "chenjianer"
fn1.say(); //=> "向原型對象添加屬性和方法"
/* Number原型對象添加方法 */
Number.prototype.test1=function(){
return this+2;
}
var num = 0;
console.log(num.test1()); //=> 2
/* String原型對象添加方法 */
/* 此處說明在JavaScript對象中，Prototype是一個全局屬性，誰需要誰就來調用 */
String.prototype.test2 = function(){
return this+"=yaodao";
}
var str = 'chenjianer';
console.log(str.test2()); //=> "chenjianer=yaodao"
var str2 = 'chenjianer2';
console.log(str2.test2()); //=> "chenjianer=yaodao"
3. length 僅用於設置或返回數組元素的個數。
語法：
array.length //=> 用於查詢
array.length = number; //=> 用於設置個數
array.length = 0; //=> 用於清空數組
Array 對象
1. Array 對象實例
Array 對象（數組對象）用於在變量中存儲多個值（可以是Num類型，String類型，Object類型的值），千萬不要以爲數組就是純數字。
var arr = [1,2,3];
var arr = ['1','2','3'];
var arr = ["jack", "yaodao", "chen"];
var arr = [{name:"jack",age:20},{name:"yaodao",age:20},{name:"chen",age:20}];
var arr = new Array(1,2,3);
var arr = new Array('1','2','3');
....
第一個數組元素的索引值爲 0，第二個索引值爲 1，以此類推。
2. Array 對象的方法
（1）Array 對象的增、刪、改、查、填充、截取
1. push() 向數組的末尾添加一個或更多元素，並返回新的長度。
語法：array.push(item1, item2, ..., itemX)
定義：
push() 方法可向數組的末尾添加一個或多個元素，並返回新的長度。
注意： 新元素將添加在數組的末尾。
注意： 此方法改變數組的長度。
注意： 其中的 item 可以爲不同的類型。
實例：
/* push() 會改變原有的數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.push("Kiwi");
console.log(fruits) //=> ["Banana", "Orange", "Apple", "Mango", "Kiwi"]
2. unshift() 向數組的開頭添加一個或更多元素，並返回新的長度。
語法：array.unshift(item1, item2, ..., itemX)
定義：
unshift() 方法可向數組的開頭添加一個或更多元素，並返回新的長度。
注意： 新元素將添加在數組的開頭。
注意： 此方法改變數組的長度。
注意： 其中的 item 可以爲不同的類型。
實例：
/* unshift() 會改變原有的數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.unshift("Kiwi");
console.log(fruits) //=> ["Kiwi", "Banana", "Orange", "Apple", "Mango"]
3. splice() 從數組中添加或刪除元素。
語法：array.splice(index(下標),howmany(刪除數量),item1,.....,itemX(添加元素))
定義：
splice() 方法用於添加或刪除數組中的元素。
注意： 這種方法會改變原始數組。
注意： 有添加元素就是添加（添加位置在索引前），無添加元素就是刪除，howmany爲刪除數量，index爲位置的索引（表示從哪開始）
實例：
/* splice() 會改變原有的數組 */
/* 刪除元素 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,1); //=> 返回的是被刪除的元素數組["Apple"]，如果 howmany 爲 0 返回 []
console.log(fruits); //=> ["Banana", "Orange", "Mango"]
/* 添加元素 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi"); // 表示從下標 2 的前邊開始添加
console.log(fruits); //=> ["Banana", "Orange", "Lemon", "Kiwi", "Apple", "Mango"]
4. pop() 刪除數組的最後一個元素並返回刪除的元素。
語法：array.pop()
定義：
pop() 方法用於刪除數組的最後一個元素並返回刪除的元素。
注意： 這種方法會改變原始數組。
注意： 此方法改變數組的長度！
注意： 刪除數組最後的元素。
實例：
/* pop() 會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.pop();
console.log(fruits); //=> ["Banana", "Orange", "Apple"]
5. shift() 刪除並返回數組的第一個元素。
語法：array.shift()
定義：
shift() 方法用於把數組的第一個元素從其中刪除，並返回第一個元素的值。
注意： 這種方法會改變原始數組。
注意： 此方法改變數組的長度！
注意： 刪除數組開頭（下標爲 0）的元素。
實例：
/* shift() 會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.shift()
console.log(fruits); //=> ["Orange", "Apple", "Mango"]
6. 索引法修改數組元素
語法：array[index] = XXX;
定義：
注意： 這種方法會改變原始數組。
注意： index爲元素的下標。
實例：
/* 此方法會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits[0] = 'chestnut'
console.log(fruits); //=> ["chestnut", "Orange", "Apple", "Mango"]
7. indexOf() 搜索數組中的元素，並返回它所在的位置。
語法：array.indexOf(item,start)
定義：
indexOf() 方法可返回數組中某個指定的元素位置。
該方法將從頭到尾地檢索數組，看它是否含有對應的元素。開始檢索的位置在數組 start 處或數組的開頭（沒有指定 start 參數時，start = 0）。如果找到一個 item，則返回 item 的第一次出現的位置。開始位置的索引爲 0。
注意： 搜索到就立即返回，並且只返回最先符合搜索內容元素的索引。
注意： 如果在數組中沒找到指定元素則返回 -1。
實例：
/* indexOf()僅用於搜索，不會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango","Apple"];
var a = fruits.indexOf("Apple");
console.log(a); //=> 2
var b = fruits.indexOf("chestnut");
console.log(b); //=> -1
8. lastIndexOf() 搜索數組中的元素，並返回它最後出現的位置。
語法：array.lastIndexOf(item,start)
定義：
lastIndexOf() 方法可返回數組中某個指定的元素位置。
該方法將從頭到尾地檢索數組，看它是否含有對應的元素。開始檢索的位置在數組 start 處或數組的開頭（沒有指定 start 參數時，start = 0）。如果找到一個 item，則返回 item 的第一次出現的位置。開始位置的索引爲 0。
注意： 搜索到就立即返回，並且只返回最後符合搜索內容元素的索引。
注意： 如果在數組中沒找到指定元素則返回 -1。
實例：
/* lastIndexOf()僅用於搜索，不會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango","Apple"];
var a = fruits.lastIndexOf("Apple");
console.log(a); //=> 4
var b = fruits.lastIndexOf("chestnut");
console.log(b); //=> -1
9. fill() 使用一個固定值來填充數組。
語法：array.fill(value, start, end)
定義：
fill() 方法用於將一個固定值替換數組的元素。
注意： 參數value 必需。填充的值。
注意： 參數start 可選/不填（默認0）。開始填充位置。
注意： 參數end 可選/不填（默認數組長度）。停止填充位置 (默認爲 array.length)
實例：
/* fill()會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.fill("Runoob", 2, 4);
console.log(fruits); //=> ["Banana", "Orange", "Runoob", "Runoob"]
fruits.fill("Runoob");
console.log(fruits); //=> ["Runoob", "Runoob", "Runoob", "Runoob"]
10. slice() 選取數組的的一部分，並返回一個新數組。
語法：array.slice(start, end)
定義：
slice() 方法可從已有的數組中返回選定的元素。
slice()方法可提取字符串的某個部分，並以新的字符串返回被提取的部分。
注意： slice() 方法不會改變原始數組。
注意： start 可選。規定從何處開始選取。如果是負數，那麼它規定從數組尾部開始算起的位置。也就是說，-1 指最後一個元素，-2 指倒數第二個元素，以此類推。
注意： end 可選。規定從何處結束選取。該參數是數組片斷結束處的數組下標。如果沒有指定該參數，那麼切分的數組包含從 start 到數組結束的所有元素。如果這個參數是負數，那麼它規定的是從數組尾部開始算起的元素。
個人習慣： 從第 n 個開始截取：start = n-1
實例:
/* slice() 方法不會改變原始數組 */
/* 截取第數組第二、三個元素 */
var fruits = ["Banana", "Orange", "Lemon", "Apple", "Mango"];
var citrus = fruits.slice(1,3);
console.log(citrus); //=> ["Orange", "Lemon"]
/* 從第五個字符開始截取到最後 */
var str = "www.chenjianer.com!";
var res = str.slice(4);
console.log(res); //=> "chenjianer.com!"
（2）Array 對象的排序、分隔、連接、轉換
1. sort() 對數組的元素進行排序。
語法：array.sort(sortfunction)
定義：
sort() 方法用於對數組的元素進行排序。
排序順序可以是字母或數字，並按升序或降序。
默認排序順序爲按字母升序。
注意： 這種方法會改變原始數組。
注意： 當數字是按字母順序排列時"40"將排在"5"前面。
注意： 使用數字排序，你必須通過一個函數作爲參數來調用（升序或降序）。
實例：
/* sort()會改變原始數組 */
/* 數字按照字母排序 */
var points = [40,100,1,5,25,10,60,30];
points.sort();
console.log(points); //=> [1, 10, 100, 25, 30, 40, 5, 60]
/* 數字排序（數字和升序）*/
var points = [40,100,1,5,25,10,60,30];
points.sort(function(a,b){return a-b});
console.log(points); //=> [1, 5, 10, 25, 30, 40, 60, 100]
/* 數字排序（數字和降序）*/
var points = [40,100,1,5,25,10,60,30];
points.sort(function(a,b){return b-a});
console.log(points); //=> [100, 60, 40, 30, 25, 10, 5, 1]
/* 字符串首字母，字母順序 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
console.log(fruits); //=> ["Apple", "Banana", "Mango", "Orange"]
/* 字符串首字母，字母倒序 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.sort();
fruits.reverse();
console.log(fruits); //=> ["Orange", "Mango", "Banana", "Apple"]
2. reverse() 反轉數組的元素順序。
語法：array.reverse()
定義：
reverse() 方法用於顛倒數組中元素的順序。
注意： 這種方法會改變原始數組。
實例：
/* reverse()會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.reverse();
console.log(fruits); //=> ["Mango", "Apple", "Orange", "Banana"]
3. join() 把數組的所有元素放入一個字符串。
語法：array.join(separator)
定義：
join() 方法用於把數組中的所有元素轉換一個字符串。
元素是通過指定的分隔符進行分隔的。
注意： 這種方法不會改變原始數組。
注意： separator規定分隔符號。
實例：
/* join()不會改變元素數組 */
/* 使用and對數組元素進行分隔 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var res = fruits.join(" and ");
console.log(res); //=> "Banana and Orange and Apple and Mango"
/* 簡單使用join() 進行分隔 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var res = fruits.join();
console.log(res); //=> "Banana,Orange,Apple,Mango"
4. concat() 連接兩個或更多的數組，並返回結果。
語法：array1.concat(array2,array3,...,arrayX)
定義：
concat() 方法用於連接兩個或多個數組。會返回被連接數組的一個副本。
注意： 這種方法不會改變原始數組。
實例：
/* concat() 不會改變原始數組 */
var arr1 = ["Cecilie", "Lone"];
var arr2 = ["Emil", "Tobias", "Linus"];
var arr3 = ["Robin"];
var arr4 = hege.concat(stale,kai);
console.log(arr4) //=> ["Cecilie", "Lone", "Emil", "Tobias", "Linus", "Robin"]
實例二：
傳遞兩個參數m，n，返回長度爲m，所有元素都爲n的數組，要求不能用循環。
利用函數的遞歸和 concat() 方法可以實現：
function fn(m, n) {
return m ? fn(m - 1, n).concat(n) : [];
}
console.log(fn(8,2)); //=> [2, 2, 2, 2, 2, 2, 2, 2]
原理其實就是當m 遞減到 0時，函數return[]，後又因爲函數調用了8次concat（），所以：[].concat(2).concat(2).concat(2).concat(2).concat(2).concat(2).concat(2).concat(2) === [2, 2, 2, 2, 2, 2, 2, 2]
5. toString() 把數組轉換爲字符串，並返回結果。
語法：array.toString()
定義：
toString() 方法可把數組轉換爲字符串，並返回結果。類似於join()
注意： 這種方法不會改變原始數組。
注意： 數組中的元素之間用逗號分隔。
實例：
/* toString() 不會改變原始數組 */
var arr = [1, 2, 3, 4];
var res = arr.toString();
console.log(res); //=> "1,2,3,4"
（3）Array 對象的判斷、過濾、循環、累加
1. every() 檢測數值元素的每個元素是否都符合條件。
語法：array.every(function(currentValue,index,arr), thisValue)
定義：
every() 方法用於檢測數組所有元素是否都符合指定條件（通過函數提供）。
every() 方法使用指定函數檢測數組中的所有元素：
- 如果數組中檢測到有一個元素不滿足，則整個表達式返回 false ，且剩餘的元素不會再進行檢測。
- 如果所有元素都滿足條件，則返回 true。
注意： every() 不會改變原始數組。
注意： every() 不會對空數組進行檢測。
注意： currentValue 必須。當前元素的值。
注意： index 可選。當前元素的索引值。
注意： arr 可選。當前元素屬於的數組對象。
實例：
/* every() 不會改變原始數組，具有遍歷的作用，返回的是Boolean值 */
var ages = [32, 33, 22, 40];
// 定義判斷函數
function checkAdult(age) {
return age >= 30
}
console.log(ages.every(checkAdult)); //=> false
2. some() 檢測數組元素中是否有元素符合指定條件。
語法：array.some(function(currentValue,index,arr),thisValue)
定義：
some() 方法用於檢測數組中的元素是否滿足指定條件（函數提供）。
some() 方法會依次執行數組的每個元素：
- 如果有一個元素滿足條件，則表達式返回true , 剩餘的元素不會再執行檢測。
- 如果沒有滿足條件的元素，則返回false。
注意： some() 不會改變原始數組。
注意： some() 不會對空數組進行檢測。
參數說明同上；
實例：
/* some() 不會改變原始數組，具有遍歷的作用，返回的是Boolean值 */
var ages = [32, 33, 22, 40];
// 定義判斷函數
function checkAdult(age) {
return age >= 30
}
console.log(ages.some(checkAdult)); //=> true
3. find() 返回符合傳入測試（函數）條件的數組元素。
語法：array.find(function(currentValue, index, arr),thisValue)
定義：
find() 方法返回通過測試（函數內判斷）的數組的第一個且只有一個元素的值。
find() 方法爲數組中的每個元素都調用一次函數執行：
- 當數組中的元素在測試條件時返回 true 時, find() 返回符合條件的元素，之後的值不會再調用執行函數。
- 如果沒有符合條件的元素返回 undefined
注意： find() 並沒有改變數組的原始值。
注意： find() 對於空數組，函數是不會執行的。
參數說明同上；
實例：
/* find() 不會改變原始數組，具有遍歷的作用，返回的是第一個符合判斷條件的元素值，若不存在符合條件的元素就返回undefined */
var ages = [32, 33, 22, 40];
// 定義判斷函數
function checkAdult(age) {
return age >= 30
}
console.log(ages.find(checkAdult)); //=> 32
// 定義判斷函數
function checkAdult2(age) {
return age >= 45
}
console.log(ages.find(checkAdult2)); //=> undefined
4. findIndex() 返回符合傳入測試（函數）條件的數組元素索引。
語法：array.findIndex(function(currentValue, index, arr), thisValue)
定義：
findIndex() 方法返回傳入一個測試條件（函數）符合條件的數組第一個元素位置。 （ 類似於indexOf() ）
findIndex() 方法爲數組中的每個元素都調用一次函數執行：
- 當數組中的元素在測試條件時返回 true 時, findIndex() 返回符合條件的元素的索引位置，之後的值不會再調用執行函數。
- 如果沒有符合條件的元素返回 -1
注意： findIndex() 不會改變數組的原始值。
注意： findIndex() 對於空數組，函數是不會執行的。
實例：
/* findIndex() 不會改變原始數組 */
var ages = [32, 33, 22, 40];
// 定義判斷函數
function checkAdult(age) {
return age >= 35
}
console.log(ages.findIndex(checkAdult)); //=> 3
// 定義判斷函數
function checkAdult2(age) {
return age >= 45
}
console.log(ages.findIndex(checkAdult2)); //=> -1
5. includes() 判斷一個數組是否包含一個指定的值。
語法：arr.includes(searchElement, fromIndex)
定義：
includes() 方法用來判斷一個數組是否包含一個指定的值，如果是返回 true，否則false。
注意： includes() 不會改變數組的原始值。
注意： searchElement 必須。需要查找的元素值（類型要相同，不然會返回false）。
注意： fromIndex 可選。從該索引處開始查找 searchElement。如果爲負值，則按升序從 array.length + fromIndex 的索引開始搜索。默認爲 0。如果fromIndex 大於等於數組長度 ，則返回 false 。該數組不會被搜索；如果 fromIndex 爲負值，計算出的索引將作爲開始搜索searchElement的位置。如果計算出的索引小於 0，則整個數組都會被搜索
實例：
/* includes() 不會改變原始數組 */
[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false
[1, 2, 3].includes(3, 3); // 超出搜索範圍，false
[1, 2, 3].includes(3, -1); // (array.length + fromIndex)=3-1=2，true
[1, 2, NaN].includes('NaN'); // 類型要相同，false
var arr = ['a', 'b', 'c'];
arr.includes('a', -100); //(array.length + fromIndex)<0，全數組搜索， true
6. isArray() 判斷對象是否爲數組。
語法：Array.isArray(obj)
定義：
isArray() 方法用於判斷一個對象是否爲數組。
如果對象是數組返回 true，否則返回 false。
注意： obj爲判斷對象
實例：
/* isArray() 不會改變原始數組 */
var fruits = ["Banana", "Orange", "Apple", "Mango"];
var res = Array.isArray(fruits);
console.log(res) //=> true
7. filter() 檢測數值元素，並返回符合條件所有元素的數組。（重點）
過濾出來並不是過濾掉 , 還可以利用來去重
語法：array.filter(function(currentValue,index,arr), thisValue)
定義：
filter() 方法創建一個新的數組，新數組中的元素是通過檢查指定數組中符合條件的所有元素。
注意： filter() 不會改變原始數組。
注意： filter() 不會對空數組進行檢測。
實例：
/* filter() 不會改變原始數組 */
var ages = [32, 33, 16, 40, 40, 32, 15, 20, 16, 33];
function checkAdult(age) {
return age >= 18;
}
console.log(ages.filter(checkAdult)) //=> [32, 33, 40, 40, 32, 20, 33]
去重實例：
var
res,
ages = [32, 33, 16, 40, 40, 32, 15, 20, 16, 33];
res = ages.filter(function(el,index,self){
return self.indexOf(el) === index;
})
console.log(res); //=> [32, 33, 16, 40, 15, 20]
原理就是：
return self.indexOf(el) === index;
說明：filter函數遍歷數組中每一個元素（el），self表示對象本身通過indexOf尋再到每個el首次出現的位置，如果它與filter遍歷出來的index相等就會被篩選出來（輸出）
實例二：
/* 篩選出奇數 */
var arr = [1, 2, 4, 5, 6, 9, 10, 15];
var r = arr.filter(function (x) {
return x % 2 !== 0; //關鍵作用在 return 中
});
console.log(r); //=> [1, 5, 9, 15]
實例三：
/* 把一個Array中的空字符串刪掉 */
var arr = ['A', '', 'B', null, undefined, 'C', ' '];
var r = arr.filter(function (s) {
return s && s.trim();
});
console.log(arr); // ['A', 'B', 'C']
8. forEach() 數組每個元素都執行一次回調函數。（重點）
語法：array.forEach(function(currentValue, index, arr), thisValue)
定義：
forEach() 方法用於調用數組的每個元素，並將元素傳遞給回調函數。
注意： filter() 不會改變原始數組。
注意： forEach() 對於空數組是不會執行回調函數的。
關鍵是： forEach() 返回值爲undefined。
實例：
9. map() 通過指定函數處理數組的每個元素，並返回處理後的數組。（重點）
語法：array.map(function(currentValue,index,arr), thisValue)
定義：
map() 方法返回一個新數組，數組中的元素爲原始數組元素調用函數處理後的值。
map() 方法按照原始數組元素順序依次處理元素。
注意： map() 不會改變原始數組。
注意： map() 不會對空數組進行檢測。
關鍵是： map() 有返回值
實例：
10. reduce() 將數組元素計算爲一個值（累加器）。
語法：array.reduce(function(total, currentValue, currentIndex, arr), initialValue)
語法：array.reduceRight(function(total, currentValue, currentIndex, arr), initialValue)
定義：
reduce() 方法接收一個函數作爲累加器，數組中的每個值（從左到右）開始縮減，最終計算爲一個值。
reduceRight() 方法接收一個函數作爲累加器，數組中的每個值（從右到左）開始縮減，最終計算爲一個值。
reduce() 可以作爲一個高階函數，用於函數的 compose。
注意： reduce() 對於空數組是不會執行回調函數的。
注意： total 必需。初始值, 或者計算結束後的返回值。
注意： currentValue 必需。當前元素
注意： initialValue 可選。傳遞給函數的初始值
實例：
var numbers = [65, 44, 12, 4];
const res = numbers.reduce((total, currentValue) => total + currentValue, 10);
console.log(res); //=> 135
var numbers = [65, 44, 12, 4];
const res = numbers.reduceRight((total, currentValue) => total + currentValue, 10);
console.log(res); //=> 135
3. 總結
內置對象的公有屬性prototype、__ proto __、constructor是後期面向對象編程的重點。涉及到“兩鏈一包”中的原型鏈、深淺拷貝…
Array對象的常用方法：
Array對象的增、刪、改、查、填充、截取（push、pop、shift、unshift、splice、fill）都會改變原始數組，indexOf、lastIndexOf、slice 除外；
Array對象的排序、連接、分隔、轉換（sort、reverse）會改變原始數組，join、concat、toString 除外；
Array對象的判斷、過濾、循環、累加均不會改變元素數組，對於空數組不會進行檢測。
除了常規的Array對象方法的使用外，數組循環是後期的重中之重。
所以，需要清楚用法還需清楚使用環境：
一般的循環用for,for…in,for…of 和 forEach()
需要映射爲新數組的用 map()（後面的map作用很大！！），
需要篩選出想要的用 filter()，
數值需要進行累加的用reduce()，
如果要找一些值用 some() 和 every()，
如果想知道值的具體位置的可以用 indexOf() 和 lastIndexOf()
不僅如此還可以按照實際情況進行鏈式操作。
最後，來個實例：
/* 鏈式操作 */
var personnel = [
{
id: 5,
name: "Luke Skywalker",
pilotingScore: 98,
shootingScore: 56,
isForceUser: true,
},
{
id: 82,
name: "Sabine Wren",
pilotingScore: 73,
shootingScore: 99,
isForceUser: false,
},
{
id: 22,
name: "Zeb Orellios",
pilotingScore: 20,
shootingScore: 59,
isForceUser: false,
},
{
id: 15,
name: "Ezra Bridger",
pilotingScore: 43,
shootingScore: 67,
isForceUser: true,
},
{
id: 11,
name: "Caleb Dume",
pilotingScore: 71,
shootingScore: 85,
isForceUser: true,
},
];
/* 箭頭函數 es6 規則 */
/* 不要使用 forEach，因爲沒有 return ! ! */
const totalJediScore = personnel
.filter(person => person.isForceUser)
.map(jedi => jedi.pilotingScore + jedi.shootingScore)
.reduce((acc, score) => acc + score, 0);
console.log(totalJediScore) //=> 420，不明白自己看上面