关于牛客网“JS能力测评”之数组部分答案整理

前言

---

2019.7.23更新
通过案例巩固数组知识。在牛客网在线编程专题之“JS能力测评”的基础上，会陆续增加关于数组的题目。大部分答案解析的源自于在牛客网中每道题的讨论界面，里面有各路大神不同的思路，我只是将其整理起来。

链接：https://www.nowcoder.com/ta/js-assessment
来源： 牛客网（牛客网 > 首页 > 在线编程 > JS能力测评经典题）
MDN数组文档：Web开发技术>JavaScript>JavaScript参考>JavaScript标准内置对象>Array

2019.8.1更新
陆陆续续罗列完一系列方法后，其实都是在数组的各种函数上进行操作，在此，提醒自己，要详细了解其用法、原理、返回值等等东西。
注意要区分相似函数的用法！！！

如下方，多次用到：push()、slice()、splice()、reduce()、forEach()、filter()、map()、indexOf()、lastIndexOf()等等。

1、查找数组元素位置

---

• 题目描述：
  找出元素 item 在给定数组 arr 中的位置。
  如果数组中存在 item，则返回元素在数组中的位置，否则返回 -1。
• 示例：
  输入：[ 1, 2, 3, 4 ], 3
  输出：2

我的代码：

function indexOf(arr, item) {
    for(var i=0;i<arr.length;i++){
        if(arr[i]===item){
            return i;
        }
    }
    return -1;   
}

解决方案：

(1)使用indexOf方法解决。

indexOf()方法：

• 可返回数组中某个指定的元素位置。
• 该方法将从头到尾地检索数组，看它是否含有对应的元素。开始检索的位置在数组 start 处或数组的开头（没有指定 start 参数时）。如果找到一个 item，则返回 item 的第一次出现的位置。开始位置的索引为 0。
• 如果在数组中没找到指定元素则返回 -1。

lastIndexOf() 方法：

• 与indexOf()方法相反，该方法可返回一个指定的元素在数组中最后出现的位置，从该字符串的后面向前查找。

function indexOf(arr,item){
    return arr.indexOf(item);
}

(2)如果浏览器不支持indexOf怎么办呢？

function indexOf(arr, item) {
    if (Array.prototype.indexOf){   //判断当前浏览器是否支持
        return arr.indexOf(item);
    } else {
        for (var i = 0; i < arr.length; i++){
            if (arr[i] === item){
                return i;
            }
        }
    }     
    return -1;     //总是把return -1暴露在最外层
}

(3)支持数组arr中的数据类型为对象, 数组, 等。

//eg: var arr = [{age: 1}, '1', 2, true, [1,2]], 依然可以测试。
function indexOf(arr, item) {
    if (!arr || !arr.length) {
        return -1;
    }
    for (var i = 0, len = arr.length; i < len; i++) {
        // 支持 arr[i] 为对象，数组等
        if (JSON.stringify(arr[i]) === JSON.stringify(item)) {
            return i
        }
    }
    return -1;
}

2、数组求和

---

• 题目描述：
  计算给定数组 arr 中所有元素的总和
• 输出描述：
  数组中的元素均为 Number 类型
• 示例：
  输入：[ 1, 2, 3, 4 ]
  输出：10

我的代码：

function sum(arr) {
    var sum=0;
    for(var i=0;i<arr.length;i++){
        sum=sum+arr[i];
    }
    return sum;
}

解决方案：

(1)不考虑算法复杂度，用递归做。

function sum(arr) {
    var len = arr.length;
    if(len == 0){
        return 0;
    } else if (len == 1){
        return arr[0];
    } else {
        return arr[0] + sum(arr.slice(1));
    }
}

(2)常规循环。（就是我使用的方法）

(3)函数式编程 map-reduce。

Array.prototype.reduce()方法： 对数组中的每个元素执行一个由您提供的reducer函数(升序执行)，将其结果汇总为单个返回值。

• 语法：
  arr.reduce(callback(accumulator, currentValue[, index[, array]])[, initialValue])
• 参数：
  • callback： 执行数组中每个值的函数，包含四个参数：
    • accumulator： 累计器累计回调的返回值; 它是上一次调用回调时返回的累积值，或initialValue（见于下方）。
    • currentValue： 数组中正在处理的元素。
    • currentIndex 可选： 数组中正在处理的当前元素的索引。 如果提供了initialValue，则起始索引号为0，否则为1。
    • array可选： 调用reduce()的数组。
  • initialValue 可选： 作为第一次调用 callback函数时的第一个参数的值。 如果没有提供初始值，则将使用数组中的第一个元素。 在没有初始值的空数组上调用 reduce 将报错。
• 返回值： 函数累计处理的结果。

//此处的 currentIndex 、 array 和 ,0 可省略不写。
function sum(arr) {
    return arr.reduce(function(accumulator, currentValue, currentIndex, array){
        return accumulator + currentValue;
    },0);
}

Array.prototype.reduce()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce

(4)forEach遍历。

Array.prototype.forEach()方法： 对数组的每个元素执行一次提供的函数。

• 语法：arr.forEach(callback[, thisArg]);
• 参数：
  • callback： 为数组中每个元素执行的函数，该函数接收三个参数：
    • currentValue： 数组中正在处理的当前元素。
    • index 可选： 数组中正在处理的当前元素的索引。
    • array 可选： forEach() 方法正在操作的数组。
  • thisArg 可选： 可选参数。当执行回调函数时用作 this 的值(参考对象)。
• 返回值： undefined.

//其中参数idx和arr可以省略
function sum(arr) {
    var s = 0;
    arr.forEach(function(val, idx, arr) {
        s += val;
    }, 0);
    return s;
};

Array.prototype.forEach()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach

(5)eval()&&arr.join()。

• eval()函数： 会将传入的字符串当做 JavaScript 代码进行执行。
  • 语法：eval(string)
  • 参数：string一个表示 JavaScript 表达式、语句或一系列语句的字符串。表达式可以包含变量与已存在对象的属性。
  • 返回值： 返回字符串中代码的返回值。如果返回值为空，则返回 undefined。
• Array.prototype.join()方法：
  将一个数组（或一个类数组对象）的所有元素连接成一个字符串并返回这个字符串。如果数组只有一个项目，那么将返回该项目而不使用分隔符。
  • 语法：arr.join([separator])
  • 参数：separator指定一个字符串来分隔数组的每个元素。如果需要，将分隔符转换为字符串。如果省略()，数组元素用逗号分隔。默认为 “,”。如果separator是空字符串("")，则所有元素之间都没有任何字符。
  • 返回值： 一个所有数组元素连接的字符串。如果 arr.length 为0，则返回空字符串。

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

Array.prototype.join()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/join
eval()函数详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/eval

3、移除数组中的元素（不在原数组修改）

---

• 题目描述：
  移除数组 arr 中的所有值与 item 相等的元素。不要直接修改数组 arr，结果返回新的数组。
• 示例：
  输入：[1, 2, 3, 4, 2], 2
  输出：[1, 3, 4]

我的代码：

function remove(arr, item) {
    var newArr=new Array();
    for(var i=0;i<arr.length;i++){
        if(arr[i]!=item){
           newArr.push(arr[i]); 
        }
    }
    return newArr;
}

解决方案：

(1)splice()。

Array.prototype.splice()方法： 通过删除或替换现有元素或者原地添加新的元素来修改数组,并以数组形式返回被修改的内容。此方法会改变原数组。
注意：splice() 与 slice() 两者要区分开！！！

• 语法：array.splice(start[, deleteCount[, item1[, item2[, ...]]]])
• 参数：
  • start：
    指定修改的开始位置（从0计数）。如果超出了数组的长度，则从数组末尾开始添加内容；如果是负值，则表示从数组末位开始的第几位（从-1计数，这意味着-n是倒数第n个元素并且等价于array.length-n）；如果负数的绝对值大于数组的长度，则表示开始位置为第0位。
  • deleteCount 可选：
    整数，表示要移除的数组元素的个数。
    如果 deleteCount 大于 start 之后的元素的总数，则从 start 后面的元素都将被删除（含第 start 位）。
    如果 deleteCount 被省略了，或者它的值大于等于array.length - start(也就是说，如果它大于或者等于start之后的所有元素的数量)，那么start之后数组的所有元素都会被删除。
    如果 deleteCount 是 0 或者负数，则不移除元素。这种情况下，至少应添加一个新元素。
  • item1, item2, … 可选：
    要添加进数组的元素,从start 位置开始。如果不指定，则 splice() 将只删除数组元素。
• 返回值： 由被删除的元素组成的一个数组。如果只删除了一个元素，则返回只包含一个元素的数组。如果没有删除元素，则返回空数组。

function remove(arr,item){
    var newarr = arr.slice(0);
    for(var i=0;i<newarr.length;i++){
        if(newarr[i] == item){
            newarr.splice(i,1);
            i--;
        }
    }
    return newarr;
}

Array.prototype.splice()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/slice

(2)push()。（就是我使用的方法）

(3)filter()。

Array.prototype.filter()方法： 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

• 语法：var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
• 参数：
  • callback： 用来测试数组的每个元素的函数。返回 true 表示该元素通过测试，保留该元素，false 则不保留。它接受以下三个参数：
    • element： 数组中当前正在处理的元素。
    • index可选： 正在处理的元素在数组中的索引。
    • array可选： 调用了 filter 的数组本身。
  • thisArg可选： 执行 callback 时，用于 this 的值。
• 返回值： 一个新的、由通过测试的元素组成的数组，如果没有任何数组元素通过测试，则返回空数组。

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

Array.prototype.filter()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/filter

4、移除数组中的元素（原数组修改）

---

• 题目描述：
  移除数组 arr 中的所有值与 item 相等的元素，直接在给定的 arr 数组上进行操作，并将结果返回。
• 示例：
  输入：[1, 2, 2, 3, 4, 2, 2], 2
  输出：[1, 3, 4]

我的代码：

function removeWithoutCopy(arr, item) {
    for(var i=0;i<arr.length;i++){
        if(arr[i]==item){
            arr.splice(i,1);
            i--;
        }
    }
    return arr;
}

解决方案：

(1)splice()。

我使用的便是该方法，方法的解释说明请看上面的第3题移除数组中的元素（不在原数组修改）。

(2)shift()&&push()。该想法很独特

Array.prototype.shift()方法： 从数组中删除第一个元素，并返回该元素的值。***此方法更改数组的长度。***
注意：删除数组的最后一个元素是pop()方法。

• 语法：arr.shift()
• 返回值： 从数组中删除的元素; 如果数组为空则返回undefined。
• 描述：
  • shift 方法移除索引为 0 的元素(即第一个元素)，并返回被移除的元素，其他元素的索引值随之减 1。如果 length 属性的值为 0 (长度为 0)，则返回 undefined。
  • shift 方法并不局限于数组：这个方法能够通过 call 或 apply 方法作用于类似数组的对象上。但是对于没有 length 属性（从0开始的一系列连续的数字属性的最后一个）的对象，调用该方法可能没有任何意义。

function removeWithoutCopy(arr, item) {
    var n=arr.length;
     for(var i=0;i<n;i++){
         if(arr[0]!==item)   
             arr.push(arr[0]);
         arr.shift();
           
    }
    return arr;
}
/*
假设对n的赋值 var n=arr.length 删去，在for循环直接使用arr.length去判断。会导致：
由于当arr[0] == item时，会删除arr[0]，此时数组长度减1，这会使得遍历数组的循环少比较了1个元素。
因此应按照楼上答案那样，先将数组长度arr.length取出来赋值给变量n, 在循环中使比较条件为一常量，
这样才能完成对整个数组每个元素的比较。

作者：代码：codebread；注释：Mars687
链接：https://www.nowcoder.com/questionTerminal/a93dd26ebb8c425d844acc17bcce9411?f=discussion
来源：牛客网
*/

Array.prototype.shift()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/shift

5、添加元素（数组末尾）

---

• 题目描述：
  在数组 arr 末尾添加元素 item。不要直接修改数组 arr，结果返回新的数组。
• 示例：
  输入：[1, 2, 3, 4], 10
  输出：[1, 2, 3, 4, 10]

我的代码：

function append(arr, item) {
    var newArr=arr.slice(0);
    newArr.push(item);
    return newArr;
}

解决方案：

(1)slice()&&push()。

我使用的便是该方法。
Array.prototype.slice()方法： 返回一个新的数组对象，这一对象是一个由 begin 和 end 决定的原数组的浅拷贝（包括 begin，不包括end）。 原始数组不会被改变。

• 语法：arr.slice([begin[, end]])
• 参数：
  • begin可选：
    提取起始处的索引，从该索引开始提取原数组元素，默认为 0。
    如果该参数为负数，则表示从原数组中的倒数第几个元素开始提取，slice(-2) 表示提取原数组中的倒数第二个元素到最后一个元素（包含最后一个元素）。
    如果省略 begin，则 slice 从索引 0 开始。
    如果 begin 大于原数组的长度，则会返回空数组。
  • end可选：
    提取终止处的索引，在该索引处结束提取原数组元素，默认为 0。slice 会提取原数组中索引从 begin 到 end 的所有元素 （包含 begin，但不包含 end） 。
    slice(1,4) 会提取原数组中从第二个元素开始一直到第四个元素的所有元素 （索引为 1, 2, 3的元素） 。
    如果该参数为负数， 则它表示在原数组中的倒数第几个元素结束抽取。 slice(-2,-1) 表示抽取了原数组中的倒数第二个元素到最后一个元素（不包含最后一个元素，也就是只有倒数第二个元素）。
    如果 end 被省略，则slice 会一直提取到原数组末尾。
    如果 end 大于数组的长度，slice 也会一直提取到原数组末尾。
• 返回值： 一个含有被提取元素的新数组。

Array.prototype.slice()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/slice

(2)concat()。

Array.prototype.concat()方法： 用于合并两个或多个数组。***此方法不会更改现有数组，而是返回一个新数组。***

• 语法：var new_array = old_array.concat(value1[, value2[, ...[, valueN]]])
• 参数：
  • valueN 可选： 将数组和/或值连接成新数组。详情请参阅下文描述。
• 返回值： 新的 Array 实例。

var append3 = function(arr, item) {
    return arr.concat(item);
};

Array.prototype.concat()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/concat

6、删除数组最后一个元素

---

• 题目描述：
  删除数组 arr 最后一个元素。不要直接修改数组 arr，结果返回新的数组。
• 示例：
  输入：[1, 2, 3, 4]
  输出：[1, 2, 3]

我的代码：

function truncate(arr) {
    var newArr=arr.slice(0);
    newArr.splice(-1,1);
    return newArr;
}

解决方案：

此处来源：
作者： soulor.魂
链接： https://www.nowcoder.com/questionTerminal/df4b0b7a459447538351c4c7008b34e7?f=discussion
来源： 牛客网

(1)silce()。

该方法不会改变原数组。

function truncate(arr) {
    return arr.slice(0,-1);
}

(2)filter。

function truncate(arr) {
    return arr.filter(function(v,i,ar) {
        return i!==ar.length-1;
    });
}

(3)push.apply+pop。

Function.prototype.apply()方法： 调用一个具有给定this值的函数，以及作为一个数组（或类似数组对象）提供的参数。
***注意：call()方法的作用和 apply() 方法类似，区别就是call()方法接受的是参数列表，而apply()方法接受的是一个参数数组。***

• 语法：func.apply(thisArg, [argsArray])
• 参数：
  • thisArg：可选的。 在func函数运行时使用的this值。请注意，this可能不是该方法看到的实际值：如果这个函数处于非严格模式下，则指定为null或undefined时会自动替换为指向全局对象，原始值会被包装。
  • argsArray：可选的。 一个数组或者类数组对象，其中的数组元素将作为单独的参数传给func函数。如果该参数的值为null或undefined，则表示不需要传入任何参数。从ECMAScript 5 开始可以使用类数组对象。
• 返回值： 调用有指定this值和参数的函数的结果。

function truncate(arr) {
    var newArr=[];
    [].push.apply(newArr, arr);
    newArr.pop();
    return newArr;
}

Function.prototype.apply()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Function/apply

(4)join+split+pop。

注意：数据类型会变成字符型。还有split()的用于刚好与join()相反。

String.prototype.split()方法： 使用指定的分隔符字符串将一个String对象分割成字符串数组，以将字符串分隔为子字符串，以确定每个拆分的位置。 Tip：如果空字符串("")被用作分隔符，则字符串会在每个字符之间分割。

• 语法：str.split([separator[, limit]])
• 参数：
  • separator： 指定表示每个拆分应发生的点的字符串。separator 可以是一个字符串或正则表达式。 如果纯文本分隔符包含多个字符，则必须找到整个字符串来表示分割点。如果在str中省略或不出现分隔符，则返回的数组包含一个由整个字符串组成的元素。如果分隔符为空字符串，则将str原字符串中每个字符的数组形式返回。
  • limit： 一个整数，限定返回的分割片段数量。当提供此参数时，split 方法会在指定分隔符的每次出现时分割该字符串，但在限制条目已放入数组时停止。如果在达到指定限制之前达到字符串的末尾，它可能仍然包含少于限制的条目。新数组中不返回剩下的文本。
• 返回值： 返回源字符串以分隔符出现位置分隔而成的一个Array。

function truncate(arr) {
    var newArr = arr.join().split(',');
    newArr.pop();
    return newArr;
}

String.prototype.split()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String/split

(5)concat+pop。

function truncate(arr) {
    var newArr = arr.concat();
    newArr.pop();
    return newArr;
}

(6)普通的迭代拷贝。

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，结果返回新的数组。
• 输出描述：
  如果数组中存在 item，则返回元素在数组中的位置，否则返回 -1。
• 示例：
  输入：[1, 2, 3, 4], 10
  输出：[10, 1, 2, 3, 4]

我的代码：

function prepend(arr, item) {
    var newArr=arr.slice(0);
    newArr.unshift(item);
    return newArr;
}

解决方案：

(1)concat()。

function prepend(arr, item) {
    return [item].concat(arr);
}

(2)push.apply。

function prepend(arr, item) {
    var newArr=[item];
    [].push.apply(newArr, arr);
    return newArr;
}

(3)slice+unshift/splice。

Array.prototype.unshift()方法：将一个或多个元素添加到数组的开头，并返回该数组的新长度(该方法修改原有数组)。**

• 语法：arr.unshift(element1, ..., elementN)
• 参数：
  • elementN： 要添加到数组开头的元素或多个元素。
• 返回值： 当一个对象调用该方法时，返回其length属性值。

function prepend(arr, item) {
    var newArr=arr.slice(0);
    newArr.unshift(item);//newArr.splice(0,0,item);
    return newArr;
}

Array.prototype.unshift()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift

(4)join+split+unshift/splice。

function prepend(arr, item) {
    var newArr=arr.join().split(',');
    newArr.unshift(item);//newArr.splice(0,0,item);
    return newArr;
}

(5)普通的迭代拷贝。

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，结果返回新的数组。
• 示例：
  输入：[1, 2, 3, 4]
  输出：[2, 3, 4]

我的代码：

function curtail(arr) {
    var newArr=arr.slice(1);
    return newArr;
}

解决方案：

(1)slice。

我使用的是该方法。

(2)filter。

function curtail(arr) {
    return arr.filter(function(v,i) {
        return i!==0;
    });
}

(3)push.apply+shift。

function curtail(arr) {
    var newArr=[];
    [].push.apply(newArr, arr);
    newArr.shift();
    return newArr;
}

(4)join+split+shift。

注意！！！：数据类型会变成字符型

function curtail(arr) {
    var newArr = arr.join().split(',');
    newArr.shift();
    return newArr;
}

(5)concat+shift。

function curtail(arr) {
    var newArr = arr.concat();
    newArr.shift();
    return newArr;
}

(6)普通的迭代拷贝。

function curtail(arr) {
    var newArr=[];
    for(var i=1;i<arr.length;i++){
        newArr.push(arr[i]);
    }
    return newArr;
}

9、数组合并

---

• 题目描述：
  合并数组 arr1 和数组 arr2。不要直接修改数组 arr，结果返回新的数组。
• 示例：
  输入：[1, 2, 3, 4], [‘a’, ‘b’, ‘c’, 1]
  输出：[1, 2, 3, 4, ‘a’, ‘b’, ‘c’, 1]

我的代码：

function concat(arr1, arr2) {
    var arr=[];
    for(var i=0;i<arr1.length;i++){
        arr.push(arr1[i]);
    }
    for(var i=0;i<arr2.length;i++){
        arr.push(arr2[i]);
    }
    return arr;
}

解决方案：

(1)concat。

concat()不会改变原本数组。

function concat(arr1, arr2) {
    return arr1.concat(arr2);
}

(2)slice+push.apply。

function concat(arr1, arr2) {
    var newArr=arr1.slice(0);
    [].push.apply(newArr, arr2);
    return newArr;
}

(3)slice+push。

function concat(arr1, arr2) {
    var newArr=arr1.slice(0);
    for(var i=0;i<arr2.length;i++){
        newArr.push(arr2[i]);
    }
    return newArr;
}

(4)普通的迭代拷贝。

我使用的就是该方法。

10、添加元素

---

• 题目描述：
  在数组 arr 的 index 处添加元素 item。不要直接修改数组 arr，结果返回新的数组。
• 示例：
  输入：[1, 2, 3, 4], ‘z’, 2
  输出：[1, 2, ‘z’, 3, 4]

我的代码：

function insert(arr, item, index) {
    var newArr=arr.slice(0);
    newArr.splice(index,0,item);
    return newArr;
}

解决方案：

(1)slice+concat。

function insert(arr, item, index) {
    return arr.slice(0,index).concat(item,arr.slice(index));
}

(2)concat +splice。

function insert(arr, item, index) {
    var newArr=arr.concat();
    newArr.splice(index,0,item);
    return newArr;
}

(3)slice+splice。

我使用的就是该方法。

(4)push.apply+splice。

function insert(arr, item, index) {
    var newArr=[];
    [].push.apply(newArr, arr);
    newArr.splice(index,0,item);
    return newArr;
}

(5)普通的迭代拷贝。

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

11、计数

---

• 题目描述：
  统计数组 arr 中值等于 item 的元素出现的次数。
• 示例：
  输入：[1, 2, 4, 4, 3, 4, 3], 4
  输出：3

我的代码：

function count(arr, item) {
    var sum=0;
    for(var i=0;i<arr.length;i++){
        if(arr[i]==item){
            sum++;
        }
    }
    return sum;
}

解决方案：

(1)filter。

利用指定的函数确定是否在返回的数组中包含某一项。

function count(arr, item) {
    var count = arr.filter(function(a) {
        return a === item;   //返回true的项组成的数组
    });
    return count.length;
}

(2)map。

Array.prototype.map()方法： 创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。

注意：map()、forEach()、reduce() 三者要区分开！！！

• map()与forEach()仅区别在返回值，前者返回的是数组，后者返回的是undefined。而reduce()返回的是函数累计处理的结果，通常是一个数值。

• reduce相对两者会稍有区别，但也是一个个数组元素进入回调函数。

• 语法：

var new_array = arr.map(function callback(currentValue[, index[, array]]) {
 // Return element for new_array 
}[, thisArg])

• 参数：
  • callback： 生成新数组元素的函数，使用三个参数：
    • currentValue：callback数组中正在处理的当前元素。
    • index 可选：callback数组中正在处理的当前元素的索引。
    • array 可选：callback map方法被调用的数组。
  • thisArg 可选： 执行callback函数时使用的this 值。
• 返回值： 一个新数组，每个元素都是回调函数的结果。

function count(arr, item) {
    var count = 0;
    arr.map(function(a) {
        if(a === item) {
            count++;
        }
    });
    return count;
}

Array.prototype.map()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/map

(3)for循环。

我使用的就是该方法。

(4)reduce。

从数组的第一项开始，逐个遍历到最后。

function count(arr, item) {
    var count = arr.reduce(function(prev, curr) {
        return curr === item ? prev+1 : prev;
    }, 0);
    return count;
}

(5)forEach。

对数组中的每一项运行传入的函数。

function count(arr, item) {
    var count = 0;
    arr.forEach(function(a) {
        a === item ? count++ : 0;
    });
    return count;
}

12、查找重复元素

---

• 题目描述：
  找出数组 arr 中重复出现过的元素。
• 示例：
  输入：[1, 2, 4, 4, 3, 3, 1, 5, 3]
  输出：[1, 3, 4]

我的代码：

function duplicates(arr) {
    var newArr=[];
    for(var i=0;i<arr.length;i++){
        for(var j=i+1;j<arr.length;j++){
            if(arr[i]==arr[j]&&newArr.indexOf(arr[i])==-1){
                newArr.push(arr[i]);
            }
        }
    }
    return newArr;
}

解决方案：

(1)普通迭代代码。

两个for循环嵌套，时间复杂度O(n^2)。我使用的便是该方法。

(2)sort(),先排序后判断。

**Array.prototype.sort()方法：**用就地算法对数组的元素进行排序，并返回数组。默认排序顺序是在将元素转换为字符串，然后比较它们的UTF-16代码单元值序列时构建的。由于它取决于具体实现，因此无法保证排序的时间和空间复杂性。

• 语法：arr.sort([compareFunction])
• 参数：
  • compareFunction 可选： 用来指定按某种顺序进行排列的函数。如果省略，元素按照转换为的字符串的各个字符的Unicode位点进行排序。
    • firstEl： 第一个用于比较的元素。
    • secondEl： 第二个用于比较的元素。
• 返回值： 一个含有被提取元素的新数组。

注意：此处有个bug，返回的数组顺序可能有问题。

function duplicates(arr) {
    var a=arr.sort(),b=[];
    for(var i in a){
        if(a[i]==a[i-1] && b.indexOf(a[i])==-1) b.push(a[i]); 
    }
    return b;
}

Array.prototype.sort()方法详细解释：
https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Array/sort

(3)forEach,这个思路有趣。

思路：
1、分别使用indexOf和lastIndexOf判断同一元素的位置，如果一样，表示元素只有一个，否则有多个。
2、同时，要判断压入的数组是否已经存在该元素。
注：时间复杂度依旧是O(n^2)。

function duplicates(arr) {
 var result = [];
    arr.forEach(function(elem){
       if(arr.indexOf(elem) !=arr.lastIndexOf(elem) && result.indexOf(elem) == -1){
           result.push(elem);
       }
    });
    return result;
}

(4)时间复杂度为O(n)。

思路：遍历数组，将数组的元素和数组出现的次数分别作为对象属性和值。遍历对象，取出次数大于1的即可。T(n)=n+n=O(n)。

function duplicates(arr) {
    var obj = {};
    var repeatList = [];
    //遍历数组，将数组的值作为obj的索引，出现次数为值
    arr.forEach(function(item){
        if(obj[item]){
            obj[item] +=1;
        }else{
            obj[item] = 1;
        }
    });
    //获取对象自身属性
    var propertyNames = Object.getOwnPropertyNames(obj);
    //遍历对象，将重复出现的元素取出
    propertyNames.forEach(function(item){
        if(obj[item] > 1){
            repeatList.push(parseInt(item));
        }
    });
    return repeatList; 
}

13、求二次方

---

• 题目描述：
  为数组 arr 中的每个元素求二次方。不要直接修改数组 arr，结果返回新的数组。
• 示例：
  输入：[1, 2, 3, 4]
  输出：[1, 4, 9, 16]

我的代码：

function square(arr) {
    var newArr=[];
    for(var i=0;i<arr.length;i++){
        newArr.push(arr[i]*arr[i]);
    }
    return newArr;
}

解决方案：

(1)map。

每个元素调用一次函数，最终将每次结果汇成数组返回，不影响原数组。

function square(arr) {
      return arr.map(function(e) {
          return e * e;
      })
  }
  // ES6箭头函数版
  const square = arr => arr.map(e => e * e);

(2)forEach。

用法与map类似，只是该函数会修改原数组，一开始需声明一个新数组。

function square(arr) {
    var result=[];
    arr.forEach(function(e) {
        result.push(e*e);
    })
    retrun result;
  }

(3)普通迭代代码。

for循环，将数组中的每个元素运算后用push()压入新数组。我使用的是该方法。

14、查找元素位置

---

• 题目描述：
  在数组 arr 中，查找值与 item 相等的元素出现的所有位置。
• 示例：
  输入：‘abcdefabc’
  输出：[0, 6]

我的代码：

function findAllOccurrences(arr, target) {
    var newArr=[];
    for(var i=0;i<arr.length;i++){
        if(arr[i]==target){
            newArr.push(i);
        }
    }
    return newArr;
}

解决方案：

(1)filter。

数组中每个元素调用一次回调函数测试元素是否符合函数内容，返回true表示该元素通过测试，保留该元素，false则不保留，不修改原数组。

function findAllOccurrences(arr, target) {
    var result=[];
    arr.filter(function(item,index){
        return item===target&&result.push(index);
    });
    return result;
}

(2)for,普通迭代代码。

使用for循环遍历判断，将得到的结果压入新数组，返回新数组。
我使用的便是该方法。

(3)lastIndexOf+slice/splice。

此处注意在循环中index的变化，因为是从后查找，数组长度的变化对其会有影响。

function findAllOccurrences(arr, target) {
    var result=[],index=arr.lastIndexOf(target);
    while(index>-1){
        result.push(index);
        arr.splice(index,1);//arr=arr.slice(0,index);
        index=arr.lastIndexOf(target);
    }
    return result;
}

(4)indexOf。

function findAllOccurrences(arr, target) {
    var result=[],index=arr.indexOf(target);
    while(index>-1){
        result.push(index);
        index=arr.indexOf(target,index+1);
    }
    return result;
}

15、数组去重

---

在这里直接放各种链接得了。

学习数组去重地址：
JavaScript数组去重（12种方法，史上最全）
JavaScript 高性能数组去重

顺便先简单说下各种用法和思路：

1. 利用ES6 Set去重（ES6中最常用）；
2. 利用for嵌套for，然后splice去重（ES5中最常用）；
3. 利用indexOf去重；
4. 利用sort()；
5. 利用对象的属性不能相同的特点进行去重（这种数组去重的方法有问题，不建议用，有待改进）；
6. 利用includes；
7. 利用hasOwnProperty；
8. 利用filter；
9. 利用递归去重；
10. 利用Map数据结构去重；
11. 利用reduce+includes；
12. […new Set(arr)]。

文章作者：Loaln
文章链接：https://loaln.github.io/2019/07/23/web-note-2-array/
转载请保留原文链接及作者。