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

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

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

B. 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

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

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

C. 關於js數組的幾種方法

js定義變數很靈活的
var arr = ();
var arr = [];
var arr = new Array();
這些都可以。

D. 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

E. JS數組去重的幾種常見方法

js 數組去重

1

註：應該也可以適用於 object數組，但是本人沒有進行驗證，貼出來僅供你參考

第一種是比較常規的方法思路：1.構建一個新的數組存放結果2.for循環中每次從原數組中取出一個元素，用這個元素循環與結果數組對比3.若結果數組中沒有該元素，則存到結果數組中代碼如下:

Array.prototype.unique1 = function(){ var res = [this[0]]; for(var i = 1; i < this.length; i++){ var repeat = false; for(var j = 0; j < res.length; j++){ if(this[i] == res[j]){ repeat = true; break; } } if(!repeat){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique1());

第二種方法比上面的方法效率要高思路：1.先將原數組進行排序2.檢查原數組中的第i個元素與結果數組中的最後一個元素是否相同，因為已經排序，所以重復元素會在相鄰位置3.如果不相同，則將該元素存入結果數組中代碼如下：

Array.prototype.unique2 = function(){ this.sort(); //先排序 var res = [this[0]]; for(var i = 1; i < this.length; i++){ if(this[i] !== res[res.length - 1]){ res.push(this[i]); } } return res;}var arr = [1, 'a', 'a', 'b', 'd', 'e', 'e', 1, 0]alert(arr.unique2());

二種方法也會有一定的局限性，因為在去重前進行了排序，所以最後返回的去重結果也是排序後的。如果要求不改變數組的順序去重，那這種方法便不可取了。第三種方法（推薦使用）思路：1.創建一個新的數組存放結果2.創建一個空對象3.for循環時，每次取出一個元素與對象進行對比，如果這個元素不重復，則把它存放到結果數組中，同時把這個元素的內容作為對象的一個屬性，並賦值為1，存入到第2步建立的對象中。說明：至於如何對比，就是每次從原數組中取出一個元素，然後到對象中去訪問這個屬性，如果能訪問到值，則說明重復。代碼如下：

Array.prototype.unique3 = function(){ var res = []; var json = {}; for(var i = 0; i < this.length; i++){ if(!json[this[i]]){ res.push(this[i]); json[this[i]] = 1; } } return res;}var arr = [112,112,34,'你好',112,112,34,'你好','str','str1'];alert(arr.unique3());

F. 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()

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

不明白你的意思。
js里的數組只有一種。只不過是有三種定義方式。
fruit=new
array(3);//
fruit=new
array();
fruit[0]="蘋果";
fruit[1]="梨子";
fruit[2]="橘子";
fruit=new
array("蘋果"，"梨子"，"橘子");
fruit=["蘋果"，"梨子"，"橘子"];

H. js中數組去重的幾種方法

I. js數組哪些方法返回

JavaScript中創建數組有兩種方式
（一）使用 Array 構造函數：

var arr1 = new Array(); //創建一個空數組
var arr2 = new Array(20); // 創建一個包含20項的數組
var arr3 = new Array("lily","lucy","Tom"); // 創建一個包含3個字元串的數組

（二）使用數組字面量表示法：

var arr4 = []; //創建一個空數組
var arr5 = [20]; // 創建一個包含1項的數組
var arr6 = ["lily","lucy","Tom"]; // 創建一個包含3個字元串的數組

數組的方法有數組原型方法，也有從object對象繼承來的方法，這里我們只介紹數組的原型方法，數組原型方法主要有以下這些：
join()
push()和pop()
shift() 和 unshift()
sort()
reverse()
concat()
slice()
splice()
indexOf()和 lastIndexOf() （ES5新增）
forEach() （ES5新增）
map() （ES5新增）
filter() （ES5新增）
every() （ES5新增）
some() （ES5新增）
rece()和 receRight() （ES5新增）

J. js數組中有哪些方法呢

Array.from()
Array.isArray()
Array.of()
Array.prototype.concat()
Array.prototype.Within()
Array.prototype.entries()
Array.prototype.every()
Array.prototype.fill()
Array.prototype.filter()
Array.prototype.find()
Array.prototype.findIndex()
Array.prototype.flat()
Array.prototype.flatMap()
Array.prototype.forEach()
Array.prototype.includes()
Array.prototype.indexOf()
Array.prototype.join()
Array.prototype.keys()
Array.prototype.lastIndexOf()
Array.prototype.map()
Array.prototype.pop()
Array.prototype.push()
Array.prototype.rece()
Array.prototype.receRight()
Array.prototype.reverse()
Array.prototype.shift()
Array.prototype.slice()
Array.prototype.some()
Array.prototype.sort()
Array.prototype.splice()
Array.prototype.toLocaleString()
Array.prototype.toSource()
Array.prototype.toString()
Array.prototype.unshift()
Array.prototype.values()

非常多。自己搜索一下就知道了。沒有判斷數組的方法，但是可以判斷數組方法有很多，例如[1, 2, 3, 4, 5].constructor.name

導航:首頁 > 使用方法 > js數組的常用方法

js數組的常用方法

與js數組的常用方法相關的資料