js能力测评

1. 查找数组元素的位置

描述：

输入：
[ 1, 2, 3, 4 ], 3
输出：
2

-1 方法一

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

1. 使用for循环，基本方法。

-2 方法二

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

1. indexOf的返回值需要注意，indexOf返回的索引从0开始。
2. indexOf查找到第一个成员之后便会返回，不会再继续查找后续的成员。

-3 方法三

function indexOf(arr, item) {
    let index = -1;
    arr.forEach(function(val, ind) {
        if (val === item) {
            index = ind
        }
    })
    return index;
}

1. forEach会对数组的每个元素执行一次提供的函数。
2. 由于1的特性，所以在这个这个题目中实际上是浪费性能的。

-4 方法四

function indexOf(arr, item) {
    return arr.findIndex(val=>item===val);
}

1. findIndex()方法返回数组中满足提供的测试函数的第一个元素的索引。
2. 这个方法的效率明显比forEach的效率要高。

---

2. 数组求和

描述：

输入：
[ 1, 2, 3, 4 ]
输出:
10

-1 方法一

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

1. for循环，常规方法。

-2 方法二

function sum(arr) {
    let res = 0;
    arr.forEach(val=>res+=val);
    return res;
}

1. forEach常规方法。

---

3. 移除数组中的元素

描述：

输入
[1, 2, 3, 4, 2], 2
输出
[1, 3, 4]

-1 方法一

function remove(arr, item) {
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === item) {
            delete arr[i];
            //arr[i] = null;
        }
    }
    return arr;
}

1. 首先说明该方法是错误的，delete可以删除变量的内存，但是对于数组而言，他的length长度依然没有变化，者对于我们来说是不完美的。

-2 方法二

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

1. 使用栈的方法，如果不是item则入栈。
2. 其实可以使用forEach进行简化操作，读者可以自行实践
3. 因为forEach是for循环的功能相似，所以今后forEach将不再使用。

-3 方法三

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

1. 创建一个新数组, 其包含通过所提供函数实现的测试的所有元素。

---

4. 移除数组的元素（在原数组中操作）

描述：

和题目3一样，不过要求在原数组上进行操作

-1 方法一

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

1. 需要注意一点，改变原数组会导致数组中的索引发生变换，其他地方常规。
2. 复习splice的用法：
   参数1： 需要添加/删除的元素的起始位置。
   参数2： <=0 表示添加， >0 表示添加元素的个数。
   参数3： 添加的元素。

---

5. 添加元素

描述：

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

-1 方法一

function append(arr, item) {
    // 数组的拷贝
    let arra = [];
    for (let i =0; i < arr.length; i++) {
        arra[i] = arr[i];
    }

    // 添加元素
    arra.push(10);
    return arra;
}

1. 不能直接赋值，因为数组是复杂数据类型，所以只能手动拷贝数组，上述方法是简单的拷贝，也叫浅拷贝，如果成员也为复杂数据类型，那么就需要进行深拷贝。
2. 熟悉数组的数据结构
   栈： push(压栈)、pop(弹栈)
   队列： unshift(入队)、shift(出队)

6. 数组合并

描述：

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

-1 解构

function concat(arr1, arr2) {
    return arra = [...arr1, ...arr2];
}

1. es6的解构语法，需要注意一点解构的方法依然只能实现浅拷贝。

2- concat

function concat(arr1, arr2) {
    let arr = [];
    arr = arr.concat(arr1, arr2);
    return arr;
}

1. concat不会改变原来的数组。
2. concat返回的数组只会对原数组进行浅拷贝。

---

7. 查找重复元素

描述：

输入
[1, 2, 4, 4, 3, 3, 1, 5, 3]
输出
[1, 3, 4]

-1 方法一

function duplicates(arr) {
    let obj = {};
    for (let i = 0; i < arr.length; i++) {
        if (obj[arr[i]] >= 0) {
            obj[arr[i]]++; 
        } else {
            obj[arr[i]] = 0;
        }
    }
    
    let arr1 = [];
    for (let key in obj) {
        if (obj[key] > 0) {
            arr1.push(key - 0);
        }
    }
    return arr1;

}

1. 使用对象的方法保存每个元素出现的次数。

-2 方法二

function duplicates(arr) {
    let arr1 = [];
    for (let i = 0; i < arr.length; i++) {
        if (arr.indexOf(arr[i]) !== arr.lastIndexOf(arr[i]) && arr1.indexOf(arr[i]) < 0) {
            arr1.push(arr[i]);
        }
    }
    return arr1;
}

1. 如果元素重复了，则indexOf和lastIndexOf返回的值不相等。

-3 方法三

function duplicates(arr) {
    let arr1 = [];
    let arr2 = [...arr];
    arr2.sort((a, b)=>a-b);
    for (let i = 0; i < arr2.length; i++) {
        if (arr2[i] === arr2[i+1] && arr1.indexOf(arr2[i]) < 0) {
            arr1.push(arr2[i]);
            i++;
        }
    }
    return arr1.sort((a,b)=>a-b);
}

1. 先进行排序
2. 判断前后元素是否相等，如果相等，则压入栈中，同时i++提高性能。

如果有小伙伴还有更好的算法，可以在评论区进行评论，大家一起交流学习。