JS操做數組

1.  若是數組中存在 item，則返回元素在數組中的位置，不然返回 -1

function indexOf(arr, item) { if(Array.prototype.indexOf) {//IE瀏覽器支不支持indexOf return arr.indexOf(item); } for (var i=0;i<arr.length;i++) { if (arr[i]==item) { return i; } return -1; } }

2.計算給定數組 arr 中全部元素的總和 .有多種解法。

（1）使用forEach函數

function sum(arr) { var s =0; arr.forEach(function(currentValue,index,arr) { s+=currentValue; }，0); return s; }

（2）使用eval, 將字符串轉化爲可執行的代碼，可是性能很差

function sum(arr) { return eval(arr.join('+')); }

(3)函數式編程，以後補充。

數組方法 reduce 用來迭代一個數組，而且把它累積到一個值中。 使用 reduce 方法時，你要傳入一個回調函數，這個回調函數的參數是一個 累加器 （好比例子中的 previousVal) 和當前值 (currentVal）。 reduce 方法有一個可選的第二參數，它能夠被用來設置累加器的初始值。若是沒有在這定義初始值，那麼初始值將變成數組中的第一項，而 currentVal 將從數組的第二項開始。 function sum(arr) { return arr.reduce(function(prev, curr, idx, arr){ return prev + curr; }); }

3. 移除數組 arr 中的全部值與 item 相等的元素。不要直接修改數組 arr，結果返回新的數組

function remove(arr, item) { var result =[]; arr.forEach(function(cur, index, arr) { if (cur!==item) { result.push(cur); } }); return result; }

也能夠用filter

function remove(arr, item) { return arr.filter(function (elem) { return elem !== item; }); }

4. 移除數組 arr 中的全部值與 item 相等的元素，直接在給定的 arr 數組上進行操做，並將結果返回.

splice(index,len,[item])    註釋：該方法會改變原始數組。

splice有3個參數，它也能夠用來替換/刪除/添加數組內某一個或者幾個值

index:數組開始下標        len: 替換/刪除的長度       item:替換的值，刪除操做的話 item爲空

function removeWithoutCopy(arr, item) { for(var i =0;i<arr.length;i++) { if (arr[i]==item) { arr.splice(i,1); i--;       //注意這裏要減去1
 } } return arr; }

5. 在數組 arr 末尾添加元素 item。不要直接修改數組 arr，結果返回新的數組

function append(arr, item) { return arr.concat(item); } 使用concat將傳入的數組或非數組值與原數組合並,組成一個新的數組並返回

function append(arr, item) {
var newArr = arr.slice(0);//slice淺拷貝（start，end）
newArr.push(item);
return newArr;
}

6. 刪除數組 arr 最後一個元素。不要直接修改數組 arr，結果返回新的數組

連接：https://www.nowcoder.com/questionTerminal/df4b0b7a459447538351c4c7008b34e7
來源：牛客網 //利用slice
function truncate(arr) { return arr.slice(0,-1); } //利用filter
function truncate(arr) { return arr.filter(function(v,i,ar) { return i!==ar.length-1; }); } //利用push.apply+pop
function truncate(arr) { var newArr=[]; [].push.apply(newArr, arr); newArr.pop(); return newArr; } //利用join+split+pop 注意！！！：數據類型會變成字符型
function truncate(arr) { var newArr = arr.join().split(','); newArr.pop(); return newArr; } //利用concat+pop
function truncate(arr) { var newArr = arr.concat(); newArr.pop(); return newArr; } //普通的迭代拷貝
function truncate(arr, item) { var newArr=[]; for(var i=0;i<arr.length-1;i++){ newArr.push(arr[i]); } return newArr; }

7. 

在數組 arr 開頭添加元素 item。不要直接修改數組 arr，結果返回新的數組

//利用concat
function prepend(arr, item) { return [item].concat(arr); } //使用push.apply
function prepend(arr, item) { var newArr=[item]; [].push.apply(newArr, arr); return newArr; } //利用slice+unshift/splice
function prepend(arr, item) { var newArr=arr.slice(0); newArr.unshift(item);//newArr.splice(0,0,item);
    return newArr; } //使用join+split+unshift/splice組合
function prepend(arr, item) { var newArr=arr.join().split(','); newArr.unshift(item);//newArr.splice(0,0,item);
    return newArr; } //普通的迭代拷貝
function prepend(arr, item) { var newArr=[]; for(var i=0;i<arr.length;i++){ newArr.push(arr[i]); } newArr.unshift(item); return newArr; }

8. 刪除數組 arr 第一個元素。不要直接修改數組 arr，結果返回新的數組

//利用slice
function curtail(arr) { return arr.slice(1); } //利用filter
function curtail(arr) { return arr.filter(function(v,i) { return i!==0; }); } //利用push.apply+shift
function curtail(arr) { var newArr=[]; [].push.apply(newArr, arr); newArr.shift(); return newArr; } //利用join+split+shift 注意！！！：數據類型會變成字符型
function curtail(arr) { var newArr = arr.join().split(','); newArr.shift(); return newArr; } //利用concat+shift
function curtail(arr) { var newArr = arr.concat(); newArr.shift(); return newArr; } //普通的迭代拷貝
function curtail(arr) { var newArr=[]; for(var i=1;i<arr.length;i++){ newArr.push(arr[i]); } return newArr; }

9. 在數組 arr 的 index 處添加元素 item。不要直接修改數組 arr，結果返回新的數組

function insert(arr, item, index) { var newArr=arr.slice(0); newArr.splice(index,0,item);///////////
    return newArr;////return 另起一行
}

//利用slice+concat
function insert(arr, item, index) { return arr.slice(0,index).concat(item,arr.slice(index)); } //利用concat +splice
function insert(arr, item, index) { var newArr=arr.concat(); newArr.splice(index,0,item); return newArr; } //利用slice+splice
function insert(arr, item, index) { var newArr=arr.slice(0); newArr.splice(index,0,item); return newArr; } //利用push.apply+splice
function insert(arr, item, index) { var newArr=[]; [].push.apply(newArr, arr); newArr.splice(index,0,item); return newArr; } //普通的迭代拷貝
function insert(arr, item, index) { var newArr=[]; for(var i=0;i<arr.length;i++){ newArr.push(arr[i]); } newArr.splice(index,0,item); return newArr; }

10. 統計數組 arr 中值等於 item 的元素出現的次數

//filter()-->利用指定的函數肯定是否在返回的數組中包含某一項
        function count(arr, item) { var count = arr.filter(function(a) { return a === item;   //返回true的項組成的數組
 }); return count.length; } //map()-->對數組中的每一項進行給定函數，
        //返回每次函數條用的結果組成的數組；
        function count(arr, item) { var count = 0; arr.map(function(a) { if(a === item) { count++; } }); return count; } //for循環
        function count(arr, item) { var count = 0; for(var i=0; i<arr.length; i++) { if(arr[i] === item) { count++; } } return count; } //reduce()-->從數組的第一項開始，逐個遍歷到最後；
        function count(arr, item) { var count = arr.reduce(function(prev, curr) { return curr === item ? prev+1 : prev; }, 0); return count; } //forEach()-->對數組中的每一項運行傳入的函數
        function count(arr, item) { var count = 0; arr.forEach(function(a) { a === item ? count++ : 0; }); return count; }