js數組其他

1. js中如何獲取數組中的一部分元素

js獲取數組中的一部分元素，有2種方法：slice和filter函數，下面分別介紹。

slice

slice的定義和內用法如下，用於截取數組的一容段

2. JS數組有哪些常見演算法

合並數組 - concat()
用數組的元素組成字元串 - join()
刪除數組的最後一個元素 - pop()
數組的末尾添加新的元素 - push()
將一個數組中的元素的順序反轉排序 - reverse()
刪除數組的第一個元素 - shift()
從一個數組中選擇元素 - slice()
數組排序（按字母順序或數字大小升序）- sort()
在數組的第2位置添加元素 - splice()
var fruits = ["Banana", "Orange", "Apple", "Mango"];
fruits.splice(2,0,"Lemon","Kiwi");
轉換數組到字元串 -toString()
在數組的開頭添加新元素 - unshift()

3. JS中如何獲取數組中的一部分元素

需要抄准備的材料分別是：電腦、html編輯器、瀏覽器。

1、首先，打開html編輯器，新建html文件，例如：index.html。

4. JS數組方法

數組的創建方式
1.字面量的形式： var arr=[1,2,3];
1.構造函數： var arr1=new Array();//不常用

Array構造函數有一個很大的缺陷，就是不同的參數，會導致它的行為不一致。
1.單個數值作為參數，參數表示數組的元素個數

可以看到，Array作為構造函數，行為很不一致。因此，不建議使用它生成新數組，直接使用數組字面量是更好的做法。

push/pop/unshift/shift//增加、刪除元素 （數組的方法，所以使用時應調用
數組名.方法名（））

arr. slice/splice//截取元素
arr.slice(); 原數組不發生改變
無參數時，返回原數組，相當於數組的復制。
一個參數時，從參數作為下標的元素截取，至數組結束。
二個參數時，從第一個參數作為下標（索引）的元素開始截取，到第二個參數作為下標的元素結束，但不包括第二個參數作為下標的函數。 （起始元素包含，結尾元素不包含）
多個參數時，前兩個參數起效，後邊的參數無效。
arr.splice(); 原數組改變
無參數時，返回空數組。
一個參數時，從參數作為下標的元素截取，至數組結束。
二個參數時，從第一個參數作為下標（索引）的元素開始截取，即表示截取的起始位置，第二個參數表示截取的元素個數。
多個參數時，前兩個參數起效，後邊的參數從原數組的截取起始位置開始填充，填充到原數組。
reverse/sort//改變元素位置
arr.reverse(); //數組翻轉(元素位置顛倒)
arr.sort(); 從小到大排序，但遵循的是字元串的按位比較規則，所以排序結果容易出現異常。

join();//不改變原數組
join() 以指定參數作為連接符，將所有數組成員連接為一個字元串返回。如果不提供參數，默認用逗號分隔。

concat();//拼接數組 不改變原數組

ES5新增數組操作方法
indexOf (item) 返回元素在數組中對應的索引值，找不到的話，返回-1，用以測試元素是否存在於數組中
forEach(function(item,index)) 遍歷數組,沒有返回值
map(function(item,index)) 遍歷數組,存在返回值
filter(function(item)) {return item>2} 返回大於2的元素
some 返回布爾值，條件部分成立|| arr.some(function(item){return item>2} )
every 返回布爾值，條件全部成立&& arr.every(function(item){return item>2} )
rece (對數組中的所有元素調用指定的回調函數。該回調函數的返回值為累積結果，並且此返回值在下一次調用該回調函數時作為參數提供。)arr.rece(function(a,b){return a+b;});

toString()和toLocaleString()
功能：將數組的每個元素轉化為字元串，並且輸出用逗號分隔的字元串列表。功能類似join()；
參數：無
輸出：字元串

indexOf()和lastIndexOf()
功能：搜索整個數組中具有給定值的元素，返回找到的第一個元素的索引或者如果沒有找到就返回-1；lastIndexOf為反向搜索。
參數：元素的值，起點索引（可選）
輸出：索引值或-1

Array.from()
功能：將兩類對象轉為真正的數組：類似數組的對象和可遍歷的對象
參數：待轉換的對象，第二個參數可選，作用類似於數組的map方法，用來對每個元素進行處理，將處理後的值放入返回的數組。
輸出：數組

Array.of()
功能：將一組值，轉換為數組。
參數：數組元素
輸出：數組

Within()
功能：在當前數組內部，將指定位置的成員復制到其他位置，返回變化後的數組。
參數：索引（從該位置開始替換數據）；索引（從該位置開始讀取數據，默認為0，負值表示倒數）；索引（到該位置前停止讀取，默認為最大索引）
輸出：返回當前替換後的數組。
注意：改變了當前數組

find()和findIndex()
功能：找到第一個符合條件的數組成員。
參數：回調函數，所有數組成員依次執行該函數，直到找到第一個返回值為true的成員。回調函數可以接受三個參數，依次為值，位置，原數組。
輸出：find()返回找到的成員；findIndex()返回成員的位置。

fill()
功能：使用給定的值，填充一個數組。
參數：第一個參數為待填充的值，第二和第三參數可選，分別表示填充的起始和結束位置(不包括)。
輸出：填充後的數組

entries()、keys()、values()
功能：用於遍歷數組，可以用for…of循環進行遍歷。區別是keys()是對鍵名的遍歷、values是對鍵值的遍歷、entries()是對鍵值對的遍歷。
參數：無
輸出：遍歷器對象

includes()
功能：表示某個數組是否包含給定的值
參數：第一個參數必選（待檢查的給定值），第二個參數可選，表示搜索的起始位置，默認為0，負數表示倒數的位置。
輸出：一個布爾值。
注意：和indexOf的區別，indexOf進行了運算符的強比對，會導致對NaN誤判。

5. JavaScript不使用for循環，還有其他方法快速新建一個指定長度的數組，並且每個元素的值就是

1、定義數組

var arr1 = [];//通過[]方式定義一個數組
var arr2 = new Array(2);//通過Array對象定義一個數組

2、for循環賦值

for(var i=0;i<arr2.length;i++){//循環數組
arr2[i] = i;//為arr2賦每個數組元素賦值
arr1[i]=i;//往arr1中賦數組初始值
}

6. js中怎麼把值放入數組中

方法解析如下：

1、push：將參數添加到原數組末尾，並返回數組的長度。

測試代碼如下回：

7. JS Array(數組)所有操作方法，改變數組方法、不改變數組方法

定義：返回由所有參數值組成的數組，如果沒有參數，就返回一個空數組。
目的：Array.of() 出現的目的是為了解決上述構造器因參數個數不同，導致的行為有差異的問題。

參數：
第一個參數(必需):要轉化為真正數組的對象。
第二個參數(可選): 類似數組的map方法，對每個元素進行處理，將處理後的值放入返回的數組。
第三個參數(可選): 用來綁定this。

ps：splice方法從數組中添加/刪除項目，然後返回被刪除的項目

語法： array.splice(index,howmany,item1,.....,itemX)
參數:
index：必需。整數，規定添加/刪除項目的位置，使用負數可從數組結尾處規定位置。
howmany：必需。要刪除的項目數量。如果設置為 0，則不會刪除項目。
item1, …, itemX： 可選。向數組添加的新項目。
返回值: 如果有元素被刪除,返回包含被刪除項目的新數組。

刪除元素

刪除並添加

不刪除只添加

ps：方法接受兩個參數，一個從哪裡開始，一個是到哪裡結束（但是不包括這個結束的元素本身）。如果是負數，就從倒數第幾個。

參數可選: 規定排序順序的比較 函數 。
默認情況下sort()方法沒有傳比較函數的話，默認按字母升序，如果不是元素不是字元串的話，會調用toString()方法將元素轉化為字元串的Unicode(萬國碼)位點，然後再比較字元。

比較函數的兩個參數
sort的比較函數有兩個默認參數，要在函數中接收這兩個參數，這兩個參數是數組中兩個要比較的元素，通常我們用 a 和 b 接收兩個將要比較的元素：

sort排序常見用法
數組元素為數字的升序、降序:

數組多條件排序

自定義比較函數

定義: 在當前數組內部，將指定位置的成員復制到其他位置,並返回這個數組。
語法: array.Within(target, start = 0, end = this.length)
參數:
三個參數都是數值，如果不是，會自動轉為數值.
target（必需）：從該位置開始替換數據。如果為負值，表示倒數。
start（可選）：從該位置開始讀取數據，默認為 0。如果為負值，表示倒數。
end（可選）：到該位置前停止讀取數據，默認等於數組長度。使用負數可從數組結尾處規定位置。
瀏覽器兼容(MDN): chrome 45,Edge 12,Firefox32,Opera 32,Safari 9, IE 不支持

從上述例子:
第一個參數是開始被替換的元素位置
要替換數據的位置范圍:從第二個參數是開始讀取的元素，在第三個參數前面一個元素停止讀取
數組的長度不會改變
讀了幾個元素就從開始被替換的地方替換幾個元素

參數:
第一個元素(必須): 要填充數組的值
第二個元素(可選): 填充的開始位置,默認值為0
第三個元素(可選)：填充的結束位置，默認是為this.length

使用join方法或者下文說到的toString方法時，當數組中的元素也是數組或者是對象時會出現什麼情況？

join()/toString()方法在數組元素是數組的時候，會將裡面的數組也調用join()/toString(),如果是對象的話，對象會被轉為[object Object]字元串。

如上述栗子：調用數組的toLocaleString方法，數組中的每個元素都會調用自身的toLocaleString方法，對象調用對象的toLocaleString,Date調用Date的toLocaleString。

該方法的效果和join方法一樣，都是用於數組轉字元串的，但是與join方法相比沒有優勢，也不能自定義字元串的分隔符，因此不推薦使用。
ps：當數組和字元串操作的時候，js 會調用這個方法將數組自動轉換成字元串

ps：字元串也有一個slice() 方法是用來提取字元串的，不要弄混了。
參數:
begin(可選): 索引數值,接受負值，從該索引處開始提取原數組中的元素,默認值為0。
end(可選):索引數值(不包括),接受負值，在該索引處前結束提取原數組元素，默認值為數組末尾(包括最後一個元素)。

如上：新數組是淺拷貝的，元素是簡單數據類型，改變之後不會互相干擾。

如果是復雜數據類型(對象,數組)的話，改變其中一個，另外一個也會改變

原因在定義上面說過了的：slice()是淺拷貝，對於復雜的數據類型淺拷貝，拷貝的只是指向原數組的指針，所以無論改變原數組，還是淺拷貝的數組，都是改變原數組的數據。

ES6擴展運算符...合並數組：
因為ES6的語法更簡潔易懂，所以現在合並數組我大部分採用...來處理，...運算符可以實現cancat的每個栗子，且更簡潔和具有高度自定義數組元素位置的效果。

參數:
searchElement(必須):被查找的元素
fromIndex(可選):開始查找的位置(不能大於等於數組的長度，返回-1)，接受負值，默認值為0。
嚴格相等的搜索:
數組的indexOf搜索跟字元串的indexOf不一樣,數組的indexOf使用嚴格相等===搜索元素，即數組元素要完全匹配才能搜索成功。
注意：indexOf()不能識別NaN

參數:
searchElement(必須): 被查找的元素
fromIndex(可選): 逆向查找開始位置，默認值數組的長度-1，即查找整個數組。
關於fromIndex有三個規則:
正值。如果該值大於或等於數組的長度，則整個數組會被查找。
負值。將其視為從數組末尾向前的偏移。(比如-2，從數組最後第二個元素開始往前查找)
負值。其絕對值大於數組長度，則方法返回 -1，即數組不會被查找。

參數：
searchElement(必須):被查找的元素
fromIndex(可選):默認值為0，參數表示搜索的起始位置，接受負值。正值超過數組長度，數組不會被搜索，返回false。負值絕對值超過長數組度，重置從0開始搜索。
includes方法是為了彌補indexOf方法的缺陷而出現的:
indexOf方法不能識別NaN
indexOf方法檢查是否包含某個值不夠語義化，需要判斷是否不等於-1，表達不夠直觀

8. JS 數組相關操作

push()可以將某些值加入到數組的最後一個位置，並且不限制添加數量（註：數組長度是有限制的），如果需要添加多項內容使用逗號隔開即可，加入後數組長度會增加。

let a=[1,2,3,4,5,6,7,8];

a.push(9,10);

console.log(a);// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

pop()會移除數組的最後一個元素。

let a=[1,2,3,4,5,6,7,8];

a.pop();

console.log(a);// [1, 2, 3, 4, 5, 6, 7]

shift() 會移除數組的第一個元素。

let a=[1,2,3,4,5,6,7,8];

a.shift();

console.log(a);// [2, 3, 4, 5, 6, 7, 8]

unshift() 會將指定的元素添加到數組的第一個位置。

let a=[1,2,3,4,5,6,7,8];

a.unshift(100,200,300);

console.log(a);// [100, 200, 300, 1, 2, 3, 4, 5, 6, 7, 8]

reverse()會將數組反轉

let a=[1,2,3,4,5,6,7,8];

a.reverse();

console.log(a);// [8, 7, 6, 5, 4, 3, 2, 1]

splice()可以移除或新增數列的元素，它包含了三個參數，第一個是要移除或要添加的序列號( 必填)，第二個是要移除的長度( 選填，若不填則從第一個參數序號位置開始，後方的所有元素都會被移除，若設定為0則不會有元素被移除)，第三個是要替換的內容( 選填 )

let a=[1,2,3,4,5,6,7,8];

a.splice(5,1);

console.log(a);// [1, 2, 3, 4, 5, 7, 8] ( 6 被移除了 )

添加第三個參數就能夠添加或替換元素。

let a=[1,2,3,4,5,6,7,8];

a.splice(5,1,100);

console.log(a);// [1, 2, 3, 4, 5, 100, 7, 8] ( 6 被移除，100加到第5個位置 )

let b=[1,2,3,4,5,6,7,8];

b.splice(5,3,100,200,300);

console.log(b);// [1, 2, 3, 4, 5, 100, 200, 300] ( 6,7,8 被移除，100,200,300 加到第 5,6,7 個位置 )

let c=[1,2,3,4,5,6,7,8];

c.splice(5,0,100);

console.log(c);// [1, 2, 3, 4, 5, 100, 6, 7, 8] ( 沒有元素被移除，100 加到第 5 個位置 )

sort()可以針對數組的元素進行排序，里頭包含了一個排序用的判斷函數，函數內必須包含兩個參數，這兩個參數分別代表數組里的第n個和第n+1 個元素，通過比較第n和第n+1個元素的大小來進行排序。

let a=[1,3,8,4,5,7,6,2];

a.sort((x,y)=>y-x);

console.log(a);// [8, 7, 6, 5, 4, 3, 2, 1]

a.sort((x,y)=>x-y);

console.log(a);// [1, 2, 3, 4, 5, 6, 7, 8]

如果不使用判斷函數， 默認會將元素轉換成字串，並採用unicode來判斷 ，這也會造成某些數字的排序錯誤，如下段示例：

let a=[1,3,8,4,5,7,6,2,9,10,11];

a.sort();

console.log(a);// [1, 10, 11, 2, 3, 4, 5, 6, 7, 8, 9]

Within()能復制數組中的某些元素，並將它們放到同一個數組指定的位置，Within()有三個參數，第一個是要置換的位置(必填)，第二個是從什麼位置開始復制(選填，預設0 )，第三個是停止復制的元素的前一個位置(選填，默認值等於數組長度)。

let a=[1,2,3,4,5,6,7,8];

a.Within(2);

console.log(a);// [1,2,1,2,3,4,5,6] ( 因 7 和 8 超過數組長度，只出只復制到6 )

let b=[1,2,3,4,5,6,7,8];

b.Within(3,1,3);

console.log(b);// [1,2,3,2,3,6,7,8] ( 復制 2,3 取代 4,5 )

fill()會把數組中所有元素，置換為指定的值，fill()有三個參數，第一個是准備要置換的內容(必填)，第二個是從什麼位置開始置換(選填，不設定就全部置換) ，第三個是停止置換的元素的前一個位置(選填，預設等於數組長度)。

let a=[1,2,3,4,5,6,7,8];

a.fill('a');

console.log(a);// ['a','a','a','a','a','a','a','a']

let b=[1,2,3,4,5,6,7,8];

b.fill('b',3,5);

console.log(b);// [1,2,3,'b','b',6,7,8]

length可以取得數組的長度。

let a=[1,2,3,4,5,6,7,8];

console.log(a.length);// 8

indexOf() 會判斷數組中是否包含某個值，判斷的方式為「由左而右」，如果有包含就返回這個值在數組中的索引值，如果沒有就返回-1，有兩個參數，第一個參數表示要判斷的值( 必填)，第二個參數表示從數組的哪個位置開始判斷( 選填，預設為0 )。

let a=[1,2,3,4,5,6,7,8];

console.log(a.indexOf(4));// 3

console.log(a.indexOf(4,5));// -1 ( 在6,7,8中搜索有沒有4 )

lastIndexOf() 會判斷數組中是否包含某個值，判斷的方式為「由右而左」，如果有包含就返回這個值在數組中的索引值，如果沒有就返回-1，這個方法有兩個參數，第一個參數表示要判斷的值( 必填)，第二個參數表示判斷從數組的哪個位置開始從右往左查找( 選填，默認為整個數組長度-1 )。

let a=[1,2,3,4,5,6,7,8];

console.log(a.lastIndexOf(3));// 2

console.log(a.lastIndexOf(3,1));// -1 ( 只在1,2中判斷，所以沒有 3 )

find()會將數組中的「每一個」元素帶入指定的函數內做判斷，並會返回第一個符合判斷條件的元素，如果沒有元素符合則會返回undefined。

let a=[1,2,3,4,5,6,7,8];

console.log(a.find(e=>e>3));// 4

console.log(a.find(e=>e<0));// undefined

findIndex()會將數組中的「每一個」元素帶入指定的函數內做判斷，並會返回第一個符合判斷條件元素的位置索引，如果沒有元素符合則會返回-1。

let a=[1,2,3,4,5,6,7,8];

console.log(a.findIndex(e=>e>3));// 3

console.log(a.findIndex(e=>e<0));// -1

filter()會將數組中的「每一個」元素帶入指定的函數內做判斷，如果元素符合判斷條件則會返回，組成一個新的數組。

let a=[1,2,3,4,5,6,7,8];

console.log(a.filter(e=>e>3));// [4, 5, 6, 7, 8]

console.log(a.filter(e=>e%2==0));// [2, 4, 6, 8]

forEach()會將數組中每個元素套用到指定的函數里進行運算，函數有三個參數，第一個參數表示每個元素的值( 必填)，第二個參數為該元素的索引值( 選填)，第三個參數則表示原本的數組( 選填)。

let a=[1,2,3,4,5];

let b=0;

a.forEach(item=>{b=b+item;});

console.log(b);// 15 ( 1+2+3+4+5 )

如果結合第二和第三個參數進行搭配使用，就能做到改變原本數組的效果。

let a=[1,2,3,4,5];

a.forEach((item,index,arr)=>{arr[index]=item*10;});

console.log(a);// [10,20,30,40,50]

join()可以將數組中所有元素，變成由指定的字元分割合並在一起組合成字元串進行呈現，若沒有指定字元默認會用「逗號」合並。

let a=[1,2,3,4,5,6,7,8];

console.log(a.join());// 1,2,3,4,5,6,7,8

console.log(a.join(''));// 12345678

console.log(a.join('@@'));// 1@@2@@3@@4@@5@@6@@7@@8

concat()可以將兩個數組合並在一起，如果是使用ES6語法也可以用擴展運算符...來代替。

let a=[1,2,3,4,5];

let b=[6,7,8,9];

let c=a.concat(b);

let d=[...a,...b];// 使用 ...

console.log(c);// [1,2,3,4,5,6,7,8,9]

console.log(d);// [1,2,3,4,5,6,7,8,9]

slice()可以截取出數組某部份的元素為一個新的數組，有兩個必填的參數，第一個是起始位置，第二個是結束位置( 操作時數字減1 )。

let a=[1,2,3,4,5,6,7,8];

let b=a.slice(2,4);

console.log(b);// [3, 4]

map()會處理數組中每個元素，最後返回一個新的數組，里頭有一個函數( 必填) 和一個返回函數里的this參數( 選填)，函數內又包含三個參數，第一個是每個元素的值( 必填)，第二個是當前元素的索引值( 選填)，第三個是當前的數組( 選填)。

let a=[1,2,3,4,5,6,7,8];

let b=a.map(e=>{returne+10;});

console.log(b);// [11, 12, 13, 14, 15, 16, 17, 18]

使用第二個和第三個參數的示例:

let a=[1,2,3,4,5,6,7,8];

let b=a.map((e,i,arr)=>{return`${e}${i}${arr.find(e=>e%5==1)}`;// 組合成「元素 + 索引值 + 除以五餘數為1的第一個元素」});

console.log(b);// ['101', '211', '321', '431', '541', '651', '761', '871']

如果要使用回調函數里this的參數，則「不能使用」箭頭函數，因為箭頭函數的this指向和函數的this指向不同，所以要用一般的函數處理。

let a=[1,2,3,4,5,6,7,8];

let b=a.map(function(e){

    returne+this;// 此處的 this為10

},10);

console.log(b);// [11, 12, 13, 14, 15, 16, 17, 18]

rece() 可以將數組中每個元素進行計算，每次計算的結果會再與下個元素作計算，直到結束為止，里頭包含一個函數( 必填) 和初始計算的數值( 選填)，函數內有四個參數，第一個是計算的值( 必填)，第二個是取得的元素(必填)，第三個是該元素的索引值( 選填)，第四個是原本的數組(選填)。

let a=[1,2,3,4,5,6,7,8];

let b=a.rece(function(total,e){returntotal+e;});

console.log(b);// 36 ( 1+2+3+4+5+6+7+8=36 )

receRight() 和rece()大同小異，只是其計算方式是由右到左，對於加法來說沒什麼影響，但對於減法而言就有差異。

let a=[1,2,3,4,5,6,7,8];

let b=a.rece(function(total,e){returntotal-e;});

console.log(b);// -34 ( 1-2-3-4-5-6-7-8 = -34 )

let c=a.receRight(function(total,e){returntotal-e;});

console.log(c);// -20 ( 8-7-6-5-4-3-2-1 = -20 )

flat()可以將一個多維數組的深度轉成一維(扁平化或稱作降維)，它有一個選填的參數，代表要轉換的深度數字，預設為1（只展開一層放到一維數組里，如果是2，只展開2層放到一維數組里），如果深度有很多層，可使用Infinity來全部展開成一維數組。

let a=[1,2,[3],[4,[5,[6]]]];

let b=a.flat();

let c=a.flat(2);

let d=a.flat(Infinity);

console.log(b);// [1, 2, 3, 4, [5, [6]]]

console.log(c);// [1, 2, 3, 4, 5, [6]]

console.log(d);// [1, 2, 3, 4, 5, 6]

flatMap()的方法等於map()和flat()的組合，在運算後直接將數組扁平化處理。

let a=[1,2,[3],[4,5]];

let b=a.flatMap(e=>e+1);

let c=a.map(e=>e+1).flat();

console.log(b);// [2, 3, "31", "4,51"] ( 可以看到 b 和 c 得到的結果相同 )

console.log(c);// [2, 3, "31", "4,51"]

Array.isArray()能判斷一個元素是否為數組，如果是就返回true，不然就返回false。

let a=[1,2,3,4,5,6,7,8];

let b=123;letc='hello';

let d={d1:1,d2:2};

console.log(Array.isArray(a));// true

console.log(Array.isArray(b));// false

console.log(Array.isArray(c));// false

console.log(Array.isArray(d));// false

Array.from()會將「類數組」或是「可迭代的對象」轉換成數組，Array.from()有兩個參數，第一個參數為「類數組對象」或「可迭代的對象」(必填)，第二個參數則是改變轉換成數組元素的函數(選填)。

類數組對象具有length 屬性以及索引化index 的元素，可迭代對象表示具有可以利用迭代的方式取得它自己本身的元素，例如Map 和Set...等。( 參考MDN 說法 )

let a='abcde';

let b=Array.from(a);

console.log(b);// ['a','b','c','d','e']

let c=Array.from(a,e=>e+e);

console.log(c);// ['aa','bb','cc','dd','ee']

類數組對象寫法必須包含length 屬性，且對象的key須為0開始的數字，對應轉換後的元素索引。

let a={'0':14,'2':13,'1':7,'3':9,'4':6,length:5};

let b=Array.from(a);

console.log(b);// [14,7,13,9,6]

Array.of()可以快速將數字、字串等內容，轉換成數組。

let a=Array.of(1,'a',2,'b',3);

console.log(a);// [1, "a", 2, "b", 3]

toString()會把整個數組轉換成字元串。

let a=[1,2,3,4,5,6,7,8];

let b=a.toString();

console.log(b);// 1,2,3,4,5,6,7,8

every()會將數組中的「每一個」元素帶入指定的函數內做判斷，只要有任何一個元素不符合判斷條件，會回返回false，如果全部符合，就會回傳true。

let a=[1,2,3,4,5,6];

console.log(a.every(e=>e>3));// fasle ( 因為1、2 小於 3，3 等於 3 )

console.log(a.every(e=>e>0));// true

some()會將數組中的「每一個」元素帶入指定的函數內做判斷，只要有任何一個元素符合判斷條件，就會返回true，如果全都不符合，才會返回false。

let a=[1,2,3,4,5,6];

console.log(a.some(e=>e>3));// 返回 true，因為 4、5、6 大於 3

console.log(a.some(e=>e>6));// 返回 fasle，因為全都小於或等於 6

includes()會判斷數組中是否包含某個值，如果有包含就返回true，否則返回false，有兩個參數，第一個參數表示要判斷的值( 必填)，第二個參數表示從數組的哪個位置開始判斷( 選填)。

let a=[1,2,3,4,5,6,7,8];

console.log(a.includes(2));// true

console.log(a.includes(2,2));// false ( 在 3,4,5,6,7,8 查找有沒有 2 )

valueOf()會返回數組的原始值，如果原本的數組有修改，那麼返回的原始值也會跟著改變（相當淺復制）

let a=[1,2,3,4,5,6,7,8];

let b=a.valueOf();

console.log(a);// [1, 2, 3, 4, 5, 6, 7, 8]

let c=a.valueOf();

a.shift();

console.log(a);// [2, 3, 4, 5, 6, 7, 8]

console.log(b);// [2, 3, 4, 5, 6, 7, 8] ( 因為 a 的原始值更新了，所以 b 也變了 )

console.log(c);// [2, 3, 4, 5, 6, 7, 8]

keys()會返回數組中的每一個索引值( key )成為一個新的Array Iterator對象，因為是Array Iterator對象，可以使用for...of進行迭代。

let a=['a','b','c','d','e'];

let b=a.keys();

for(let key of b){

    console.log(key);// 1、2、3、4、5

}