陣列的基本方法如下
1. concat()
該方法用於連線2個或者多個陣列。該方法不會改變現有的陣列，而僅僅會返回被連線陣列的一個副本。
語法：arrayObject.concat(array1,array2,….arrayx);
連線多個陣列，使用逗號隔開；
比如如下程式碼演示：
|
1 2 3 4 5 6 7 |
var arr1 = [1,2,3], arr2 = [4,5,6], arr3 = [7,8,9,1,2,3]; console.log(arr1.concat(arr2,arr3)); // [1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3] console.log(arr1); // [1,2,3] console.log(arr2); // [4,5,6] console.log(arr3); // [7,8,9,1,2,3] |
2.join()
該方法是把陣列中的所有元素放入一個字串中，元素通過指定的分隔符進行分割的。
語法如下：arrayObject.join(separator);
separator: 指定分隔符對陣列中的元素進行分割，如果省略該引數，則會使用逗號作為分隔符。如下程式碼演示：
|
1 2 3 4 5 6 7 |
var arrs = []; arrs[0] = "aa"; arrs[1] = "bb"; arrs[2] = "cc"; console.log(arrs.join()); // aa,bb,cc console.log(arrs.join("/")); // aa/bb/cc console.log(arrs.join("-")); // aa-bb-cc |
3.pop()
該方法刪除陣列的最後一個元素，把陣列的長度減1，並且返回它被刪除元素的值，如果陣列變為空，則該方法不改變陣列，返回undefine值。如下程式碼演示：
|
1 2 3 |
var arrs = [1,2,3,4]; console.log(arrs.pop()); // 4 console.log(arrs); // [1,2,3] |
4.push()
該方法是向陣列末尾新增一個或者多個元素，並返回新的長度。
基本語法：arrayObject.push(newElem1,newElem2,…..newElemX); 演示程式碼如下：
|
1 2 3 4 5 |
var arrs = [1,2,3]; arrs.push(4); console.log(arrs); // [1,2,3,4] arrs.push(5,6); console.log(arrs); // [1,2,3,4,5,6] |
5.reverse()
該方法用於顛倒陣列中元素的順序；
語法如下：arrayObject.reverse();
如下程式碼演示：
|
1 2 |
var arrs = [1,2,3,4]; console.log(arrs.reverse()); //[4,3,2,1] |
6.shift()
該方法用於把陣列的第一個元素從其中刪除，並返回被刪除的值。如果陣列是空的，shift方法將不進行任何操作，返回undefined的值。
如下程式碼演示：
|
1 2 3 4 5 6 7 |
var arrs = [1,2,3,4]; console.log(arrs.shift());// 1 console.log(arrs); // [2,3,4] var arrs2 = []; console.log(arrs2.shift()); // undefined console.log(arrs2); // [] |
7.sort()
1. 該方法是對陣列的元素進行排序；sortby引數規定排序順序，且必須是函式。
如果該方法沒有使用引數，則是按字母的字元編碼的順序進行排序。
2. 如果想按其他標準進行排序，就需要提供比較函式，該函式比較2個值，然後返回一個用於說明這2個值的相對順序的數字，比如比較a與b，返回值如下：
若a小於b，在排序後的陣列中a應該出現在b之前，則返回一個小於0的值。
若a等於b，在排序後的陣列中 a等於b 則返回0；
若a大於b，則返回一個大於0的值；
比如如下程式碼演示：
|
1 2 3 4 5 6 7 |
var arrs = ["tugenhua","longen","alibaba"]; console.log(arrs.sort()); // ["alibaba", "longen", "tugenhua"] var arrs2 = ["15","5","8","12"]; console.log(arrs2.sort(function(a,b){ return a - b; // ["5", "8", "12", "15"] })); |
8.splice()
該方法用於插入，刪除和替換陣列的元素；
基本語法如下：
Array.splice(index,howmany,element1,…..elementX);
Index引數：【必填】是從何處新增/刪除元素，該引數是開始插入或刪除陣列元素的下標，必須是數字；
Howmany: 【必須】應該刪除多少個元素，必須是數字，也可以是0，如果未設定該引數，則刪除從index開始到原陣列結尾的所有元素；
Element1: 【可選】規定要新增到陣列的新元素，從index所指的下標處開始插入；
ElementX: 【可選】 可向陣列中新增若干個元素；
如下程式碼演示：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// 假如原陣列如下 var arrs = [1,2,3,4,5,6]; // 先向陣列的第二個位置中新增一個元素8； arrs.splice(1,0,8); console.log(arrs); // [1, 8, 2, 3, 4, 5, 6] // 接著從arrs陣列中刪除一個元素2 arrs.splice(2,1); console.log(arrs); // [1, 8, 3, 4, 5, 6] // 再接著從arrs陣列中替換一個元素8 使他變為10;如下程式碼： arrs.splice(1,1,10); console.log(arrs); // [1, 10, 3, 4, 5, 6] |
9.toString()
將陣列轉換為一個字串，並且返回這個字串；如下程式碼演示：
|
1 2 |
var arrs = [1,2]; console.log(arrs.toString()); // 1,2 |
10.unshift()
該方法是向陣列的開頭新增一個或者更多元素，並返回新的長度。
如下程式碼演示：
|
1 2 3 |
var arrs = [1,2]; arrs.unshift(3); console.log(arrs); //[3, 1, 2] |
11.slice()
該方法是從已有的陣列中返回指定的元素。
基本語法：arrs.slice(start,end);
start引數【必須】從何處開始選取(包括start)，如果是負數，那麼會從尾部選取，比如-1代表最後一個元素，-2代表倒數第二個元素，以此類推。
End引數【可選】規定是從何處結束選取(不包括end)，如果沒有指定該引數，那麼陣列會包含從start開始到陣列結束的所有元素，如果該引數是負數的話，那麼它規定的是從陣列尾部開始算起的元素。
如下演示：
|
1 2 3 4 5 6 |
var arrs2 = [1,2,3]; console.log(arrs2.slice(1)); // [2,3] console.log(arrs2.slice(0,1));// [1] console.log(arrs2.slice(1,-1)); // [2] console.log(arrs2.slice(2,-1)); // [] console.log(arrs2.slice(0)); // [1,2,3] |
判斷一個陣列中是否有相同的元素
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
/* * 判斷陣列中是否有相同的元素的程式碼 */ // 方案一 function isRepeat1(arrs) { if (arrs.length > 0) { var s = arrs.join(","); for (var i = 0, ilen = arrs.length; i < ilen; i += 1) { if (s.replace(arrs[i], "").indexOf(arrs[i]) > -1) { return true; } } } return false; } // 方案二 function isRepeat2(arrs) { var hash = {}; if (arrs.length > 0) { for (var i = 0, ilen = arrs.length; i < ilen; i += 1) { if (hash[arrs[i]]) { return true; } hash[arrs[i]] = true; } } return false; } var arrs = [1, 4, 3, 2, 5]; console.log(isRepeat1(arrs)); // false var arrs2 = [1, 2, 3, 1]; console.log(isRepeat1(arrs2)); // true var arrs = [1, 4, 3, 2, 5]; console.log(isRepeat2(arrs)); // false var arrs2 = [1, 2, 3, 1]; console.log(isRepeat2(arrs2)); // true |
計算一個陣列中每個元素在陣列中出現的次數；
程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
/* * 計算陣列中每個元素在陣列中出現的個數 * @param {arrs} 陣列 * @method 定義一個新陣列，迴圈當前的陣列，使用一個臨時的變數temp儲存當前的值，外層for迴圈定義一次變數count=0，當做計數器，內部再一次迴圈陣列判斷當前的陣列與外層的陣列某一項是否相等，如是count++; 然後把當前的一項值置為-1，下一次就不會再繼續迴圈了 * @return {newArrs} 返回一個新陣列 */ function arrayElemCount(arrs){ var newArrs = []; if(arrs.length > 0) { for(var i = 0,ilen = arrs.length; i < ilen; i+=1) { var temp = arrs[i]; var count = 0; for(var j = 0,jlen = arrs.length; j < jlen; j+=1) { if(arrs[j] == temp) { count++; arrs[j] = -1; } } newArrs.push(temp + ":" +count); } } return newArrs; } var arrs = [1,2,1,2,3,4,5,6,7,1,2,3]; console.log(arrayElemCount(arrs)); // 列印如下：["1:3", "2:3", "-1:6", "-1:6", "3:2", "4:1", "5:1", "6:1", "7:1", "-1:12", "-1:12", "-1:12"] // 鍵值為-1的，都可以去掉 |
Javascript刪除陣列重複元素的操作
1. 方案一遍歷陣列使用indexOf方法，程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
/* * javascript陣列去重方案一 * @param {arrs} 原陣列 * @method 新建一個新陣列，遍歷原陣列，在新陣列內使用indexOf查詢原陣列內的每一項，如果沒有找到，就把當前的項存入新陣列裡面去，這樣就過濾掉 * 重複項 indexOf方法在IE8及IE8以下不支援，因此有必要封裝一個 * @return {newArrays} 返回新陣列 */ function arrayUnique(arrs) { var newArrays = []; for(var i = 0,ilen = arrs.length; i < ilen; i++) { if(newArrays.indexOf) { if(newArrays.indexOf(arrs[i]) == -1) { newArrays.push(arrs[i]); } }else { if(indexOf(arrs[i],newArrays) == -1) { newArrays.push(arrs[i]); } } } return newArrays; } /* * 為了支援IE8及以下瀏覽器需要封裝一個indexOf方法 * @param {arr,arrs} 某一項 原陣列 * @return 返回陣列某一項 */ function indexOf(arr,arrs){ if(arrs.length > 0) { for(var i = 0,ilen = arrs.length; i < ilen; i+=1) { if(arrs[i] == arr) { return i; } } } return -1; } var arrs = [1,2,3,1,2,3]; console.log(arrayUnique(arrs)); // [1,2,3] |
2. 方案二：陣列下標判斷法；
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
/* * 陣列下標判斷法 * 思路：先定義一個新陣列，迴圈當前陣列，使用indexOf方法，如果在當前的陣列的第i項在當前陣列中的位置是i項的話，說明該項在陣列中並未出現過，存入新陣列，否則的話，在原陣列中出現過，因此需要過濾掉。效能和第一種方案差不多。 * @return {newArrars} 返回新陣列 */ function arrayUnique(arrs) { var newArrays = []; if(arrs.length > 0) { for(var i = 0,ilen = arrs.length; i < ilen; i+=1) { if(arrs.indexOf) { if(arrs.indexOf(arrs[i]) == i) { newArrays.push(arrs[i]); } }else { if(indexOf(arrs[i],arrs) == i) { newArrays.push(arrs[i]); } } } } return newArrays; } /* * 為了支援IE8及以下瀏覽器需要封裝一個indexOf方法 * @param {arr,arrs} 某一項 原陣列 * @return 返回陣列某一項 */ function indexOf(arr,arrs){ if(arrs.length > 0) { for(var i = 0,ilen = arrs.length; i < ilen; i+=1) { if(arrs[i] == arr) { return i; } } } return -1; } var arrs = [1,2,1,3,1]; console.log(arrayUnique(arrs)); // [1,2,3] |
3. 方案三：排序後相鄰去除法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
/* * 排序後相鄰去除法 * @method 新建一個新陣列，遍歷當前的陣列，如果當前的陣列某一項不等於新陣列的最後一項的話，就把當前的項存入新陣列中，最後返回新陣列 */ function arrayUnique(arrs) { var newArrays = []; if(arrs.length > 0) { arrs.sort(); for(var i = 0,ilen = arrs.length; i < ilen; i+=1) { if(arrs[i] !== newArrays[newArrays.length - 1]) { newArrays.push(arrs[i]); } } } return newArrays; } var arrs = [1,2,1,3,1]; console.log(arrayUnique(arrs)); // [1,2,3] |
4. 方案四：物件鍵值對法
程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
/* * 物件鍵值法(該方法效能最優) * @method 定義一個空物件和空新陣列，遍歷當前的陣列，判斷該物件是否存在陣列的某一項，如果不存在 * 就當當前的某一項存入新陣列去，且當前的項置為-1 目的過濾掉重複的項 */ function arrayUnique(arrs) { var newArrays = []; var hash = {}; if(arrs.length > 0) { for(var i = 0,ilen = arrs.length; i < ilen; i+=1) { if(!hash[arrs[i]]) { hash[arrs[i]] = 1; newArrays.push(arrs[i]); } } } return newArrays; } var arrs = [4,5,2,1,2,1,3,1]; console.log(arrayUnique(arrs)); // [4,5,2,1,3] |
Javascript刪除陣列裡面的某個元素。
方案一：使用indexOf和splice()方法刪除某個元素；
程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
/* * 為了支援IE8及以下瀏覽器需要封裝一個indexOf方法 * @param {arr,arrs} 某一項 原陣列 * @return 返回陣列某一項 */ function indexOf(arr,arrs){ if(arrs.length > 0) { for(var i = 0,ilen = arrs.length; i < ilen; i+=1) { if(arrs[i] == arr) { return i; } } } return -1; } /* * 刪除陣列裡面的某個元素 * @param {elem,arrs} 要刪除的元素 原陣列 * 思路：先使用indexOf方法在陣列裡面找到該元素的位置，然後使用splice()方法刪除一個元素 * @return {elem,arrs} 返回一個物件，物件有2個元素，第一個是被刪除的元素elem鍵，另一個是被刪除元素 後的陣列，也就是新陣列 [2,3] */ function removeAttrsElem(elem,arrs){ var newElem; if(arrs.length > 0) { var index = indexOf(elem,arrs); if(index > -1) { newElem = arrs.splice(index,1); } } return { elem: newElem, arrs: arrs } } var arrs = [1,2,3]; var elem = 1; console.log(removeAttrsElem(elem,arrs)); // 返回一個物件 {elem:1,arrs:[2,3]} |
方案二：直接遍歷陣列 取其中某一項 如果某一項與該元素相同的話，直接擷取，和第一種方案類似，比第一種方案簡單
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
/* * 刪除陣列裡面的某個元素 * @param {elem,arrs} 要刪除的元素 原陣列 * 思路：直接遍歷陣列 取其中某一項 如果某一項與該元素相同的話，直接擷取，和第一種方案類似，比第一種方案簡單 * @return {elem,arrs} 返回一個物件，物件有2個元素，第一個是被刪除的元素elem鍵，另一個是被刪除元素 後的陣列，也就是新陣列 [2,3] */ function removeAttrsElem(elem,arrs){ var newElem; if(arrs.length > 0) { for(var i =0,ilen = arrs.length; i < ilen; i+=1) { if(arrs[i] == elem) { newElem = arrs.splice(i,1); } } } return { elem: newElem, arrs: arrs } } var arrs = [1,2,3]; var elem = 1; console.log(removeAttrsElem(elem,arrs)); // 返回一個物件 {elem:1,arrs:[2,3]} |
在javascript中求出2個陣列的相同的元素及不同的元素
思路：先定義一個物件，把A陣列轉換成物件，然後遍歷B陣列，判斷B陣列中某一項是否在A陣列那個物件裡面 如果在的話，說明B陣列與A陣列有相同的元素，否則B陣列和A陣列有不同的元素有哪些；
程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
/* * 求出2個陣列的相同的元素和不同的元素 * 思路：先定義一個物件，把A陣列轉換成物件，然後遍歷B陣列，判斷B陣列中某一項是否在 * A陣列那個物件裡面 如果在的話，說明有相同的元素，否則為不同的元素 */ function getArrsSameAndDiffElem(arrs1,arrs2){ var hash = {}, sameElemArrs = [], diffElemArrs = []; if(arrs1.length > 0) { for(var i = 0,ilen = arrs1.length; i < ilen;i+=1) { hash[arrs1[i]] = 1; } } if(arrs2.length > 0) { for(var j = 0,jlen = arrs2.length; j < jlen; j+=1) { if(hash[arrs2[j]]) { // 說明有相同的元素，把相同的元素存入sameElemArrs陣列裡面去 sameElemArrs.push(arrs2[j]); }else { // 說明是不同的元素，把不同的元素存入diffElemArrs陣列裡面去 diffElemArrs.push(arrs2[j]); } } } return { sameElemArrs: sameElemArrs, diffElemArrs: diffElemArrs } } var arrs1 = ["aac","aab","cfg",'longen','tugenhua','single']; var arrs2 = ["aac","mnc","nba","cba","anta",'tugenhua','single']; console.log(getArrsSameAndDiffElem(arrs1,arrs2)); // 列印出 diffElemArrs = ["mnc","nba","cba","anta"] // 相同的元素 sameElemArrs = ["aac",'tugenhua','single'] |
如上可以看到 arrs2中與arr1中陣列有相同的元素如上，不同的元素也如上；
如果需要判斷arr1中與arr2中陣列相同元素及不同的元素，傳遞引數調換位置即可！
Javascript檢測2個陣列是否相似
判斷2個陣列是否相似的條件：
- 先判斷這兩個物件是否為Array的例項。
- 接著判斷該陣列的長度是否一致。
- 判斷該2個物件的型別是否一樣，先對這2個陣列先轉換為字串後，再進行排序比較，如果該2個物件型別的個數一致，長度一致，且都是陣列，說明該2個陣列是相似的；比如如下：
|
1 2 3 |
var arr11 = [11,true]; var arr22 = [false,22]; |
如上2個陣列是相似的，但是如果2個陣列如下這樣的話
|
1 2 3 |
var arr11 = [11,true]; var arr22 = [false,true]; |
說明2個陣列不相似了~ 程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
function arraysSimilar(arr1,arr2) { if(!(arr1 instanceof Array) || !(arr2 instanceof Array)) { return false; } if(arr1.length !== arr2.length) { return false; } var arrsLen = arr1.length; var tempArrs1 = [], tempArrs2 = []; for(var i = 0; i < arrsLen; i+=1) { var t1 = Object.prototype.toString.apply(arr1[i]); tempArrs1.push(t1); var t2 = Object.prototype.toString.apply(arr2[i]); tempArrs2.push(t2); } return tempArrs1.sort().join() === tempArrs2.sort().join() ? true : false; } var arr1 = ["aa","cc",false,"bb"]; var arr2 = ["11","cc","11",false]; console.log(arraysSimilar(arr1,arr2)); // true var arr11 = [11,true]; var arr22 = [false,22]; console.log(arraysSimilar(arr11,arr22)); // true |
如何判斷該物件是否為陣列。
1. typeof
首先我們會想到的是使用typeof來檢測資料型別，但是對於Function, String, Number, Undefined等這幾種基本型別來說，使用typeof來檢測都可以檢測到，比如程式碼如下：
|
1 2 3 4 5 |
function test(){} console.log(typeof 1); // number console.log(typeof test); // function console.log(typeof "yunxi"); // string console.log(typeof undefined); // undefined |
但是對於陣列或者正則來說，使用typeof來檢測的話，那就滿足不了，因為當我們檢測陣列或者正則的話，那麼返回的型別將會是一個物件object，如下程式碼所示：
|
1 2 |
console.log(typeof []); // object console.log(typeof /\d+/g); // object |
2. Instanceof
由此我們很容易會想到使用instanceof來檢測某個物件是否是陣列的例項，該檢測會返回一個布林型(boolean),如果是陣列的話，返回true，否則的話返回false；我們再來看下上面的檢測是否為陣列的程式碼如下：
|
1 2 |
console.log([] instanceof Array); // true console.log(/\d+/g instanceof Array); // false |
如上可以看到使用instanceof確實可以判斷是否為陣列的列子;
3. constructor屬性
在javascript中，每個物件都有一個constructor屬性，它引用了初始化該物件的建構函式，比如判斷未知物件的型別，因此我們可以如下寫一個方法：程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 |
function isArray(obj) { return typeof obj == 'object' && obj.constructor == Array } // 測試demo console.log(isArray([])); // true var a = {"a":1}; console.log(isArray(a)); // false var b = [1,2,3]; console.log(isArray(b)); // true console.log(isArray(/\d+/g));// false |
如上可以看到，通過呼叫isArray 方法也可以判斷是否為陣列的列子。
我們現在可以看到，對於第二點和第三點分別使用instanceof方法和constructor屬性貌似都可以來判斷是否為陣列了，但是也有列外情況，比如在跨框架iframe的時候使用頁面中的陣列時，會失敗，因為在不同的框架iframe中，建立的陣列是不會相互共享其prototype屬性的；如下程式碼測試即可得到驗證~
|
1 2 3 4 5 6 7 8 9 |
var iframe = document.createElement('iframe'); document.body.appendChild(iframe); xArray = window.frames[window.frames.length-1].Array; var arr = new xArray("1","2","3","4","5"); //這個寫法IE下是不支援的，標準瀏覽器firefox，chrome下有 console.log(arr); // 列印出 ["1", "2", "3", "4", "5"] console.log(arr instanceof Array); // false console.log(arr.constructor === Array); // false |
如上的方法我們都不能來判斷一個物件是否為陣列的方式; 但是我們在看ECMA262中可以看到，可以使用 Object.prototype.toString.call()方法來判斷一個物件是否為陣列；如下程式碼：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
function isArray(obj) { return Object.prototype.toString.call(obj) == '[object Array]'; } // 程式碼呼叫 console.log(isArray([])); // true console.log(isArray([1,2,3])); // true var iframe = document.createElement('iframe'); document.body.appendChild(iframe); xArray = window.frames[window.frames.length-1].Array; var arr = new xArray("1","2","3","4","5"); console.log(arr); // ["1","2","3","4","5"] console.log(isArray(arr)); // true |
js將類陣列物件轉換成陣列物件
首先我們來看一下類陣列，什麼是類陣列，類陣列有什麼特徵呢？
具有：有指向物件的數字索引 及 length屬性值；
不具有：它不具有陣列的方法，比如push，slice，pop等方法；
Javascript中常見的類陣列有arguments, HTMLCollection的集合(比如document.getElementsByClassName,document.getElementsByTagName)等方法，常見的類陣列物件有如下：
document.getElementsByClassName, document.getElementsByTagName,document.getElementsByName,arguments等等；比如如下測試程式碼：類陣列可以有length屬性，可以遍歷，但是它並不是陣列的例項，如下程式碼：
|
1 2 3 4 5 6 7 8 |
function elems(){ for(var i = 0, ilen = arguments.length; i < ilen; i+=1) { console.log(arguments[i]); // 迴圈2次 列印出 1,2 } console.log(arguments instanceof Array);// false } elems(1,2); |
我們再來測試下arguments是否和陣列一樣有push方法；測試程式碼如下：
|
1 2 3 4 |
function test(){ console.log(arguments.push(1)); //arguments.push is not a function } test(); |
在控制檯中列印出 arguments.push is not a function 報錯，說明類陣列並不是一個真正的陣列，因為它沒有陣列的方法；
但是我們可以將類陣列轉換為陣列，我們可以使用slice()方法call物件；slice()方法可以將一個類陣列物件/集合轉換成一個陣列，只需要使用陣列原型上的slice方法call這個物件，即Array.prototype.slice.call(arguments);即可將類陣列轉換為陣列，或者我們也可以使用[].slice.call(arguments);來轉換陣列；
如下程式碼：
|
1 2 3 4 5 6 |
function test(){ //var args = [].slice.call(arguments); var args = Array.prototype.slice.call(arguments); console.log(args.push(1)); //1 } test(); |
使用上面的 [].slice.call()方法和 Array.prototype.slice.call()方法都可以將類陣列轉換為陣列的，比如上面的args就是轉換後的陣列，其後就擁有push()方法；
當然如果我們不嫌麻煩的話，我們可以先在函式內部定義一個新陣列，然後使用arguments.length的屬性遍歷每一項，把每一項存入到新陣列裡面去也是可以的，但是這樣做並沒有上面的好；如下程式碼：
|
1 2 3 4 5 6 7 8 |
function elems(){ var newArrs = []; for(var i = 0, ilen = arguments.length; i < ilen; i+=1) { newArrs[i] = arguments[i]; } console.log(newArrs); // [1,2] } elems(1,2); |
查詢陣列中最大值與最小值
最小值演算法如下：
- 將陣列中第一個元素賦值給一個變數，把這個變數作為最小值；
- 開始遍歷陣列，從第二個元素開始依次和第一個元素進行比較。
- 如果當前的元素小於當前的最小值的話，就把當前的元素值賦值給最小值；
- 移動到下一個元素，繼續對第三步操作；
- 當陣列元素遍歷結束時，這個變數儲存的就是最小值；
程式碼如下：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// 查詢陣列中最小值 function arrayMin(arrs){ var min = arrs[0]; for(var i = 1, ilen = arrs.length; i < ilen; i+=1) { if(arrs[i] < min) { min = arrs[i]; } } return min; } // 程式碼測試 var rets = [2,4,5,6,7,9,10,15]; console.log(arrayMin(rets));//2 |
上面是對陣列中的數值進行比較的，如果陣列中的數字是字串的話，先要把字串轉換成數字再進行比較即可，因為字串比較的不是值，而是ASCII編碼，比如2的ASCLL編碼會大於15的ASCII編碼，因為15的編碼第一個數字是1,2的ASCII編碼肯定大於1的；
求最大值的演算法和上面類似：
1.將陣列中第一個元素賦值給一個變數，把這個變數作為最大值；
2.開始遍歷陣列，從第二個元素開始依次和第一個元素進行比較。
3.如果當前的元素大於當前的最大值的話，就把當前的元素值賦值給最大值；
4移動到下一個元素，繼續對第三步操作；
5.當陣列元素遍歷結束時，這個變數儲存的就是最小值；
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
// 在陣列中查詢最大值 function arrayMax(arrs) { var max = arrs[0]; for(var i = 1,ilen = arrs.length; i < ilen; i++) { if(arrs[i] > max) { max = arrs[i]; } } return max; } // 程式碼測試 var rets = [2,4,5,6,7,9,10,15]; console.log(arrayMax(rets));//15 |