1. 如果数组中存在 item，则返回元素在数组中的位置，否则返回 -1
1function indexOf(arr, item) { 2 if(Array.prototype.indexOf) {//IE浏览器支不支持indexOf 3 return arr.indexOf(item); 4 } 5 for (var i=0;i<arr.length;i++) { 6 if (arr[i]==item) { 7 return i; 8 } 9 return -1; 10 } 11 12}
2.计算给定数组 arr 中所有元素的总和 .有多种解法。
（1）使用forEach函数
1function sum(arr) { 2 var s =0; 3 arr.forEach(function(currentValue,index,arr) { 4 s+=currentValue; 5 }，0); 6 return s; 7}
（2）使用eval, 将字符串转化为可执行的代码，但是性能不好
1function sum(arr) { 2return eval(arr.join('+')); 3}
(3)函数式编程，之后补充。
1数组方法 reduce 用来迭代一个数组，并且把它累积到一个值中。 2 3使用 reduce 方法时，你要传入一个回调函数，这个回调函数的参数是一个 累加器 （比如例子中的 previousVal) 和当前值 (currentVal）。 4 5reduce 方法有一个可选的第二参数，它可以被用来设置累加器的初始值。如果没有在这定义初始值，那么初始值将变成数组中的第一项，而 currentVal 将从数组的第二项开始。 6 7 8function sum(arr) { 9 return arr.reduce(function(prev, curr, idx, arr){ 10 return prev + curr; 11 }); 12}
3. 移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组
1function remove(arr, item) { 2 var result =[]; 3 arr.forEach(function(cur, index, arr) { 4 if (cur!==item) { 5 result.push(cur); 6 } 7 }); 8 return result; 9}
也可以用filter
1function remove(arr, item) { 2 return arr.filter(function (elem) { 3 return elem !== item; 4 }); 5}
4. 移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回.
splice(index,len,[item]) 注释：该方法会改变原始数组。
splice有3个参数，它也可以用来替换/删除/添加数组内某一个或者几个值
index:数组开始下标 len: 替换/删除的长度 item:替换的值，删除操作的话 item为空
1function removeWithoutCopy(arr, item) { 2 for(var i =0;i<arr.length;i++) { 3 if (arr[i]==item) { 4 arr.splice(i,1); 5 i--; //注意这里要减去1 6 } 7 } 8 return arr; 9}
5. 在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组
1function append(arr, item) { 2 return arr.concat(item); 3} 4使用concat将传入的数组或非数组值与原数组合并,组成一个新的数组并返回
function append(arr, item) {
var newArr = arr.slice(0);//slice浅拷贝（start，end）
newArr.push(item);
return newArr;
}
6. 删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组
1链接：https://www.nowcoder.com/questionTerminal/df4b0b7a459447538351c4c7008b34e7 2来源：牛客网 3 4//利用slice 5function truncate(arr) { 6 return arr.slice(0,-1); 7} 8//利用filter 9function truncate(arr) { 10 return arr.filter(function(v,i,ar) { 11 return i!==ar.length-1; 12 }); 13} 14//利用push.apply+pop 15function truncate(arr) { 16 var newArr=[]; 17 [].push.apply(newArr, arr); 18 newArr.pop(); 19 return newArr; 20} 21//利用join+split+pop 注意！！！：数据类型会变成字符型 22function truncate(arr) { 23 var newArr = arr.join().split(','); 24 newArr.pop(); 25 return newArr; 26} 27//利用concat+pop 28function truncate(arr) { 29 var newArr = arr.concat(); 30 newArr.pop(); 31 return newArr; 32} 33//普通的迭代拷贝 34function truncate(arr, item) { 35 var newArr=[]; 36 for(var i=0;i<arr.length-1;i++){ 37 newArr.push(arr[i]); 38 } 39 return newArr; 40}
7.
在数组 arr 开头添加元素 item。不要直接修改数组 arr，结果返回新的数组
1//利用concat 2function prepend(arr, item) { 3 return [item].concat(arr); 4} 5//使用push.apply 6function prepend(arr, item) { 7 var newArr=[item]; 8 [].push.apply(newArr, arr); 9 return newArr; 10} 11//利用slice+unshift/splice 12function prepend(arr, item) { 13 var newArr=arr.slice(0); 14 newArr.unshift(item);//newArr.splice(0,0,item); 15 return newArr; 16} 17//使用join+split+unshift/splice组合 18function prepend(arr, item) { 19 var newArr=arr.join().split(','); 20 newArr.unshift(item);//newArr.splice(0,0,item); 21 return newArr; 22} 23//普通的迭代拷贝 24function prepend(arr, item) { 25 var newArr=[]; 26 for(var i=0;i<arr.length;i++){ 27 newArr.push(arr[i]); 28 } 29 newArr.unshift(item); 30 return newArr; 31}
8. 删除数组 arr 第一个元素。不要直接修改数组 arr，结果返回新的数组
1//利用slice 2function curtail(arr) { 3 return arr.slice(1); 4} 5//利用filter 6function curtail(arr) { 7 return arr.filter(function(v,i) { 8 return i!==0; 9 }); 10} 11//利用push.apply+shift 12function curtail(arr) { 13 var newArr=[]; 14 [].push.apply(newArr, arr); 15 newArr.shift(); 16 return newArr; 17} 18//利用join+split+shift 注意！！！：数据类型会变成字符型 19function curtail(arr) { 20 var newArr = arr.join().split(','); 21 newArr.shift(); 22 return newArr; 23} 24//利用concat+shift 25function curtail(arr) { 26 var newArr = arr.concat(); 27 newArr.shift(); 28 return newArr; 29} 30//普通的迭代拷贝 31function curtail(arr) { 32 var newArr=[]; 33 for(var i=1;i<arr.length;i++){ 34 newArr.push(arr[i]); 35 } 36 return newArr; 37}
9. 在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组
1function insert(arr, item, index) { 2 var newArr=arr.slice(0); 3 newArr.splice(index,0,item);/////////// 4 return newArr;////return 另起一行 5} 6 7//利用slice+concat 8function insert(arr, item, index) { 9 return arr.slice(0,index).concat(item,arr.slice(index)); 10} 11//利用concat +splice 12function insert(arr, item, index) { 13 var newArr=arr.concat(); 14 newArr.splice(index,0,item); 15 return newArr; 16} 17//利用slice+splice 18function insert(arr, item, index) { 19 var newArr=arr.slice(0); 20 newArr.splice(index,0,item); 21 return newArr; 22} 23//利用push.apply+splice 24function insert(arr, item, index) { 25 var newArr=[]; 26 [].push.apply(newArr, arr); 27 newArr.splice(index,0,item); 28 return newArr; 29} 30//普通的迭代拷贝 31function insert(arr, item, index) { 32 var newArr=[]; 33 for(var i=0;i<arr.length;i++){ 34 newArr.push(arr[i]); 35 } 36 newArr.splice(index,0,item); 37 return newArr; 38}
10. 统计数组 arr 中值等于 item 的元素出现的次数
1//filter()-->利用指定的函数确定是否在返回的数组中包含某一项 2 function count(arr, item) { 3 var count = arr.filter(function(a) { 4 return a === item; //返回true的项组成的数组 5 }); 6 return count.length; 7 } 8 //map()-->对数组中的每一项进行给定函数， 9 //返回每次函数条用的结果组成的数组； 10 function count(arr, item) { 11 var count = 0; 12 arr.map(function(a) { 13 if(a === item) { 14 count++; 15 } 16 }); 17 return count; 18 } 19 //for循环 20 function count(arr, item) { 21 var count = 0; 22 for(var i=0; i<arr.length; i++) { 23 if(arr[i] === item) { 24 count++; 25 } 26 } 27 return count; 28 } 29 //reduce()-->从数组的第一项开始，逐个遍历到最后； 30 function count(arr, item) { 31 var count = arr.reduce(function(prev, curr) { 32 return curr === item ? prev+1 : prev; 33 }, 0); 34 return count; 35 } 36 //forEach()-->对数组中的每一项运行传入的函数 37 function count(arr, item) { 38 var count = 0; 39 arr.forEach(function(a) { 40 a === item ? count++ : 0; 41 }); 42 return count; 43 }