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;
}
