js數組的方法如何使用

㈠ Web前端工程師要知道的JavaScript數據方法匯總

今天小編要跟大家分享的文章是關於Web前端工程師要知道的JavaScript數據方法匯總。在JavaScript中，數組是一個特殊的變數，用於存儲不同的元素。它具有一些內置屬性和方法，可用於根據需要添加，刪除，迭代或操作數。並且了解JavaScript數組方法可以提升你的開發技能。

在本文中，我們將介紹15種關於JavaScript的數組方法，這些方法可以幫助你正確地處理數據。


§1.some()


§2.rece()


§3.Every()


§4.map()


§5.flat()


§6.filter()


§7.forEach()


§8.findIndex()


§9.find()


§10.sort()


§11.concat()


§12.fill()


§13.includes()


§14.reverse()


§15.flatMap()


注意，大多數情況下，我們將簡化作為參數傳遞的函數。


//.some(test=>{if(test===
"d"){returntest}})//We'.some(test=>
test==="d")


1、some()


此方法為參數傳遞的函數測試數組。如果有一個元素與測試元素匹配，則返回true，否則返回false。譯者註：some()
不會對空數組進行檢測;some()不會改變原始數組。


constmyAwesomeArray=["a","b","c","d","e"]


myAwesomeArray.some(test=>test==="d")


//------->Output:true


2、rece()


此方法接收一個函數作為累加器。它為數組中的每個元素依次執行回調函數，不包括數組中被刪除或者從未被賦值的元素。函數應用於累加器，數組中的每個值最後只返回一個值。譯者註：rece()
方法接受四個參數：初始值(上一次回調的返回值)，當前元素值，當前索引，原數組。


constmyAwesomeArray=[1,2,3,4,5]


myAwesomeArray.rece((total,value)=>total*value)


//1*2*3*4*5


//------->Output=120


3、Every()


此方法是對數組中每項運行給定函數，如果數組的每個元素都與測試匹配，則返回true，反之則返回false。


constmyAwesomeArray=["a","b","c","d","e"]


myAwesomeArray.every(test=>test==="d")


//------->Output:falseconstmyAwesomeArray2=["a","a","a","a",
"a"]


myAwesomeArray2.every(test=>test==="a")


//------->Output:true


4、map()


該方法返回一個新數組，數組中的元素為原始數組元素調用函數處理後的值。它按照原始數組元素順序依次處理元素。譯者註：map()
不會對空數組進行檢測;map()不會改變原始數組。


constmyAwesomeArray=[5,4,3,2,1]myAwesomeArray.map(x=>x*x)


//------->Output:25


//16


//9


//4


//1


5、flat()


此方法創建一個新數組，其中包含子數組上的holden元素，並將其平整到新數組中。請注意，此方法只能進行一個級別的深度。


constmyAwesomeArray=[[1,2],[3,4],5]


myAwesomeArray.flat()


//------->Output:[1,2,3,4,5]


6、filter()


該方法接收一個函數作為參數。並返回一個新數組，該數組包含該數組的所有元素，作為參數傳遞的過濾函數對其返回true。譯者註：filter()方法是對數據中的元素進行過濾，也就是說是不能修改原數組中的數據，只能讀取原數組中的數據，callback需要返回布爾值;為true的時候，對應的元素留下來;為false的時候，對應的元素過濾掉。


constmyAwesomeArray=[{id:1,name:"john"},


{id:2,name:"Ali"},{id:3,name:"Mass"},


{id:4,name:"Mass"},]


myAwesomeArray.filter(element=>element.name==="Mass")


//------->Output:0:{id:3,name:"Mass"},


//1:{id:4,name:"Mass"}


7、forEach()


此方法用於調用數組的每個元素。並將元素傳遞給回調函數。譯者注:forEach()對於空數組是不會執行回調函數的。


constmyAwesomeArray=[{id:1,name:"john"},


{id:2,name:"Ali"},{id:3,name:"Mass"},]


myAwesomeArray.forEach(element=>console.log(element.name))


//------->Output:john


//Ali


//Mass


8、findIndex()


此方法返回傳入一個測試條件(函數)符合條件的數組第一個元素位置。它為數組中的每個元素都調用一次函數執行，當數組中的元素在測試條件時返回true時,
findIndex()返回符合條件的元素的索引位置，之後的值不會再調用執行函數。如果沒有符合條件的元素返回-1譯者註：findIndex()
對於空數組，函數是不會執行的，findIndex()並沒有改變數組的原始值。


constmyAwesomeArray=[{id:1,name:"john"},


{id:2,name:"Ali"},{id:3,name:"Mass"
},]myAwesomeArray.findIndex(element=>element.id===3)


//------->Output:2myAwesomeArray.findIndex(element=>element.id
===7)


//------->Output:-1


9、find()


此方法返回通過測試(函數內判斷)的數組的第一個元素的值。find()方法為數組中的每個元素都調用一次函數執行：當數組中的元素在測試條件時回true
時,find()返回符合條件的元素，之後的值不會再調用執行函數。如果沒有符合條件的元素返回undefined。譯者注:find()
對於空數組，函數是不會執行的;find()並沒有改變數組的原始值。


constmyAwesomeArray=[{id:1,name:"john"},


{id:2,name:"Ali"},{id:3,name:"Mass"},]
myAwesomeArray.find(element=>element.id===3)


//------->Output:{id:3,name:"Mass"}


myAwesomeArray.find(element=>element.id===7)


//------->Output:undefined


10、sort()


此方法接收一個函數作為參數。它對數組的元素進行排序並返回它。也可以使用含有參數的sort()方法進行排序。


constmyAwesomeArray=[5,4,3,2,1]


//.sort((a,b)=>a-b)


//------->Output:[1,2,3,4,5]


//.sort((a,b)=>b-a)


//------->Output:[5,4,3,2,1]


11、concat()


此方法用於連接兩個或多個數組/值，它不會改變現有的數組。而僅僅返回被連接數組的一個新數組。


constmyAwesomeArray=[1,2,3,4,5]const


myAwesomeArray2=[10,20,30,40,50]


myAwesomeArray.concat(myAwesomeArray2)


//------->Output:[1,2,3,4,5,10,20,30,40,50]


12、fill()


此方法的作用是使用一個固定值來替換數組中的元素。該固定值可以是字母、數字、字元串、數組等等。它還有兩個可選參數，表示填充起來的開始位置(默認為0)與結束位置(默認為array.length)。譯者註：fill()
方法用於將一個固定值替換數組的元素。


constmyAwesomeArray=[1,2,3,4,5]


//Thefirstargument(0)isthevalue


//Thesecondargument(1)isthestartingindex


//Thethirdargument(3).fill(0,1,
3)


//------->Output:[1,0,0,4,5]


13、includes()


此方法用於判斷字元串是否包含指定的子字元串。如果找到匹配的字元串則返回true，否則返回false。


譯者註：includes()方法區分大小寫。


constmyAwesomeArray=[1,2,3,4,5]myAwesomeArray.includes(3)


//------->Output:truemyAwesomeArray.includes(8)


//------->Output:false


14、reverse()


此方法用於顛倒數組中元素的順序。第一個元素成為最後一個，最後一個元素將成為第一個。


constmyAwesomeArray=["e","d","c","b","a"]


myAwesomeArray.reverse()


//------->Output:['a','b','c','d','e']


15、flatMap()


該方法將函數應用於數組的每個元素，然後將結果壓縮為一個新數組。它在一個函數中結合了flat()和map()。


constmyAwesomeArray=[[1],[2],[3],[4],[5]]


myAwesomeArray.flatMap(arr=>arr*10)


//------->Output:[10,20,30,40,50]


//With.flat()and.map()myAwesomeArray.flat().map(arr=>arr*10)


//------->Output:[10,20,30,40,50]


以上就是小編今天為大家分享的關於Web前端工程師要知道的JavaScript數據方法匯總的文章，希望本篇文章能夠對正在從事web前端工作的小夥伴們有所幫助，想要了解更多web前端知識的小夥伴們有所幫助，想要了解更多web前端相關知識記得關注北大青鳥web培訓官網。最後祝願小夥伴們工作順利！


原文|#/blog/15-must-known-javascript-array-methods-in-2020/譯文|web前端開發(ID：web_qdkf)譯者|web小二

㈡ js數組的sort方法到底怎麼使用呢

你可以直接通過定義一個短語指針在數組中重新進行排列就可以了

㈢ js數組的map方法

這樣子數據的map方法，這個應該是龍哥更好地進行一些信息的錄入，所以我認為這應該是在信息錄入，這個還能夠更好地進行監察權，這這個應該能夠更好的進行查詢使用的。

㈣ js數組幾種常見的操作方法

關於js數組的用法有很多，下面主要針對一些簡單的操作，比如合並，反轉，添加刪除等簡單的操作總結一下。

關於js數組的用法有很多，下面主要針對一些簡單的操作，比如合並，反轉，添加刪除等簡單的操作總結一下。

第一：讀取數組 for循環

方法如下：

var ay=[1,"sdsd","sdsd"]
for (var i=0;i<ay.length;i++) {

console.log("index:"+i+" "+ay[i]) //index：0 1 index：1 sdsd index：2 sdsd

}

第二：合並數組 concat

方法如下：

var arr1=['w','e','s'];

var arr2=['e','y','u'];
var arr3=arr1.concat(arr2);
console.log(arr3) //['w','e','s''e','y','u'];
第三：數組變為字元串格式 join

方法如下：

var arr1=['w','e','s'];

var arr4=arr1.join()
console.log(arr4) //w,e,s

第四：刪除最後一個元素,針對老數組是刪除最後一個,針對新數組是返回最後一個 pop

var arr6=["d","s","t"];
var arr7=arr6.pop();
console.log(arr6) //["d","s"];
console.log(arr7);// t

第五：添加最後一個元素，針對老數組最後一個元素後面添加一個元素，新數組返回元素個數 push

var arr8=["i","u","t"];

var arr9=arr8.push("k");

console.log(arr8); //["i","u","t","k"];

console.log(arr9); // 4

第六：shift() 和pop()一樣，不同的是操作的是開頭刪除的元素shift（）；具體操作不在展示
第七：unshiift()和push一樣，不同的是操作的是開頭添加的元素unshift（）；具體操作不再展示

第八：反轉數組 reverse

方法如下：

var arr1=['w','e','s'];

var arr10=arr1.reverse()

console.log(arr10) //['s','e','w'];

第九：數組排序 sort a-b正向 b-a 反向

正向

var arr11=[3,1,5,8,28]
var arr12=arr11.sort(function (a,b) {
return a-b;
})
console.log(arr12) //[1,3,5,8,28];

反向

var arr13=arr11.sort(function (a,b) {
return b-a;
})
console.log(arr13) //[28,8,5,3,1]

第十：數組截取 數組截取的方法主要有slice 和splice，另外說到截取我這里隨便也把字元串截取帶上，字元串截取的方法主要有substr 和substring

（1）slice 使用方法arr.slice(m,n);其中arr為數組，m，n為兩個參數，意思是從已有數組中返回選定的元素，截取位置均為下標，其中m必須，為起始位置，可以為負值，n為結束位置（截取位置並不包含）。

示例如下：

①只有起起始值，並且為正，默認的從起始位置一直到整個數組結束，起始下標從0開始

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1)
console.log(arr) //[2,3,5,6,8,9] 老數組是沒有變化的，下面不在列舉，都是一樣的
console.log(arr1) //[3,5,6,8,9] 只有起始參數，並且為正值，返回新數組從下標1開始截取

②只有起始值，並且為負，默認的是從起始位置一直到整個數組結束，此處沒有起始值，數組的最後一個下標是-1，比如此例，如果從-6開始取，必定是整個數組

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1)
console.log(arr1) //[9] 只有起始參數，並且為負值，從數組尾部截取元素

③有起始值和結束值，並且為正，此處需注意下標是從小到大，比如你（3，1）肯定是取不到值的，另外截取的下標個數並不包含最後一個下標

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(1,4)
console.log(arr1) //[3,5,6] 此時是從下標1開始到下標4，但是需要注意的是並不包含下標4，准確的說是1-3的下標

④有起始值和結束值，並且為負，此處需注意下秒也是從小到大，同理，比如（-1，-6）也是肯定取不到值的，另外截取的下標個數也並不包含最後一個下標

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-6,-1)
console.log(arr1) //[2,3,5,6,8]

⑤有起始值和結束值，並且正負都有

負值到0

var arr=[2,3,5,6,8,9]
var arr1=arr.slice(-1,0)

//剛剛都看到了，數組下標都是從小到大的，所以說如果正負都有的情況下，理論上應該可以取值的，比如這個例子，-1為9的小標，0為2的下標，所以取值應該為 [9]，但是結果並不是這樣的
console.log(arr1) //[ ] 從這里可以看出他的結果是為空的，所以從負值到0結果是取不到的

負值到正直

var arr=[2,3,5,6,8,9]

var arr1=arr.slice(-1,2)

//那從負值到正值呢，同樣也是取不到值的

console.log(arr1) //[ ]

正直到負值

var arr=[2,3,5,6,8,9]

var arr1=arr.slice(2,-1)

//那從正直到負值，這個理論上是取不到的，但是看下結果

console.log(arr1) //[ 5，6，8] 從結果可以看出是可以取的 原理是2的下標為5，-1的下標為9，不包含結束位置下標

總結：這個方法看著可能會麻煩些（也可能被我寫的麻煩啦），比如正到負等，不知道大家都是怎麼操作，我一般用這個取值都是只截取正的，所以這個實際操作還是非常簡單的。

（2）splice 像數組中添加或者刪除元素
arr.splice(m,n,index,index1,...,indexx)
m是起始位置，n是刪除元素的個數，index是要添加的元素，在不添加元素的前提下，只有第一個參數是必須的，後面兩個都不是必須的，在需要添加元素的情況下，三個元素都是必須的，此方法和slice是不一樣的，這個返回的是被刪除的元素

示例如下：

只刪除不添加

注意看此例，是（1，2）刪除兩個，如果是（1，0），則表示刪除零個，也就是不刪除的意思，如果只有一個參數則表示從這里開始刪除，比如是（1）則為[2]，當然這個也是可以取負值，但是這個和slice是不一樣的，只能起始位置取負值，因為刪除的個數不可能為負值，slice可以取（2，-1），這個就截然不同啦，但是剛剛也說啦，slice是不可以起始位置取負值，結束位置取正的，但是這個是可以的，比如（-1，0）則表示從-1開始刪除零個，結果為[2,3,5,6,8,9]，（-6，2),結果為[5,6,8,9]，另外這個刪除的第二個值如果寫的過大，也只是刪除從本下標到最後一個，比如（2，78）為[2,3]

var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2)
console.log(arr) // [2,6,8,9] 注意看此處才是我們要的數組，從下標1開始刪除刪除兩個
console.log(arr1) //[3,5] 此處是我們刪除掉的數組

刪除加添加 具體的和上面的差不多，主要添加了添加元素的效果，這個也可以添加多個元素

var arr=[2,3,5,6,8,9]
var arr1=arr.splice(1,2,"il")
console.log(arr) //[2,"li",6,8,9]
console.log(arr1) //[3,5]

總結：此方法用的時候，一般也都是只取正值

（3）substr 這個是字元串的用法 用法arr.substr(m,n) m必選也可以負值 n選填，注意看這個並不是結束為止而是截取的個數

示例如下：

只有一個參數 默認從此下標開始，取後面所有的

正值

var arr="sdhgfhf"
var arr1=arr.substr(1)
console.log(arr)// "sdhgfhf"這個是不變的，下面不再列舉
console.log(arr1)//"dhgfhf" 從下標1開始取後面所有的

負值

var arr="sdhgfhf"
var arr1=arr.substr(-2)
console.log(arr1)//"hf" 從下標-2開始取後面所有的

兩個參數，從第一個下標開始，截取到下標2的長度

var arr="sdhgfhf"
var arr1=arr.substr(1，3)
console.log(arr1)//"dhg" 從下標1開始取後面所有的 同理如果為負值，比如（-6，3）則為"hjf";後面的始終為長度

總結：此方法需注意不要和數組的混淆，這個是截取長度的

（4）substring 用法arr.substring(m,n) 兩個參數，m必須，起始位置 ，n選填，截取下標的結束位置，此用法和上面slice有點類似，但是需要注意的是此方法是不支持負值的

示例如下：

只有一個參數

var arr="sdhgfhf"
var arr1=arr.substring(1)
console.log(arr1)//"dhgfhf"從下標1開始取後面所有的

兩個參數

var arr="sdhgfhf"
var arr1=arr.substring(1,3)
console.log(arr1)// "dh"從下標1開始截取到下標3，但是不包含3

總結：此方法不支持負值，只針對下標來截取的

最後，以上主要是總結的數組的一些簡單的操作方法，學無止境，繼續努力。

㈤ js數組排序的幾種方法

一、 冒泡排序
平均復雜度：o(n^2) 空間復雜度：o(1) 穩定性：穩定
步驟： 1、比較相鄰的元素。如果第一個比第二個大，就交換他們兩個；
2、對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對，這樣，最後的元素應該會是最大的數；
3、針對所有的元素重復以上的步驟，除了最後一個；
4、持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
二、選擇排序
平均復雜度：o(n^2) 空間復雜度：o(1) 穩定性：不穩定
步驟： 1、每一次循環，找到最小的那個數，並用變數記住它的索引
2、然後將最小值放在它該在的位置上
3、持續對越來越少的元素重復上面的步驟
三、插入排序
平均復雜度：o(n^2) 空間復雜度：o(1) 穩定性：穩定
（1）直接插入排序：將第一個數和第二個數排序，然後構成一個有序序列；將第三個數插入進去，構成一個新的有序序列；對第四個數、第五個數......直到最後一個數，重復第二步
（2）二分插入排序：將尋找每個數插入位置的方法改為折半比較即可
四、Shell排序（插入排序的一種，又稱為縮小增量排序）
平均復雜度：o(nlogn) 空間復雜度：o(1) 穩定性：不穩定
步驟：把數組按下標的一定增量分組，然後對每組使用直接插入排序
想學習更多前端開發的知識，就來北京尚學堂！

㈥ Javascript中數組的常用方法有哪些

concat()連接兩個或更多的數組，並返回結果。
join()把數組的所有元素放入一個字元串。元素通過指定的分隔符進行分隔。
pop()刪除並返回數組的最後一個元素
push()向數組的末尾添加一個或更多元素，並返回新的長度。
reverse()顛倒數組中元素的順序。
shift()刪除並返回數組的第一個元素
slice()從某個已有的數組返回選定的元素
sort()對數組的元素進行排序
splice()刪除元素，並向數組添加新元素。
toSource()返回該對象的源代碼
toString()把數組轉換為字元串，並返回結果。
toLocaleString()把數組轉換為本地數組，並返回結果。
unshift()向數組的開頭添加一個或更多元素，並返回新的長度。
valueOf()返回數組對象的原始值

㈦ js中操作數組的幾個常用方法

1.
Array.shift()------刪除並返回第一個元素
作用：從數組中刪除第一個元素（即下標為0的元素），並返回該元素。
注意：1）刪除元素之後，數組的長度-1。2）如果數組是空的，那麼
shift()
方法將不進行任何操作，返回
undefined
值。

㈧ Js中數組有哪些方法

你是想列舉一下看看：

數組有length屬性（取長度），toString()方法（轉換為字元串），join()方法（用指定字元連接數組元素）
其他還有：
•棧方法 push( ) pop( )
•隊列方法 shift( ) unshift( )
•排序方法 reverse( ) sort( )
•操作方法 concat( ) slice( ) splice( )
•位置方法 indexOf( ) lastIndexOf( )
•迭代方法 every( ) filter( ) forEach( ) map( ) some( )
•歸並方法 rece() receRight( )

你可以看一看這本書《JavaScript高級程序設計（第3版）》，介紹的比較系統，不要被名字嚇到，其實是針對初學者。

或者你看看網路文庫的這篇：
http://wenku..com/view/b9ca918884868762caaed5b1.html

㈨ js中怎麼把值放入數組中

方法解析如下：

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

測試代碼如下：