JavaScript数组方法 -- 还有去重方法
目录
一、增
1、push() 结尾处添加
2、unshift() 开头处添加
3、concat() 合并链接数组
二、删
1、pop() 从数组弹出项目
2、shift() 位移元素
3、splice() 拼接数组
4、slice() 裁剪数组
三、改
1、splice() 可拼接数组，删除数组
四、查
1、indexOf() -- 迭代数组
2、lastIndexOf()
3、find() 查找 -- 迭代数组
4、findIndex()
五、 排序方法
1、reverse() 反转数组
2、sort() 数组排序
六、转换方法
1、join()
2、 toString()
七、迭代方法
1、indexOf() -- 迭代数组
2、find() 查找 -- 迭代数组
3、some()
4、forEach()
5、every() 检查所有数组
6、reduce() 循环累加
7、filter() 过滤器
8、map()
八、去重方法
1、 利用ES6 Set去重（ES6中最常用）
2、利用for嵌套for，然后splice去重（ES5中最常用）
3、利用indexOf 和 foreach去重
4、利用contact去重，这个方法会产生一个新的数组
5、Array.prototype.push.apply() ，这个方法优点是不会产生新数组
6、利用 数组递归去重
7、利用对象的属性不能相同的特点进行去重
数组的方法有很多，接下里我们一 一介绍一下：
一、增
下面这三种是会对原数组产生影响的。
1、push() 结尾处添加
接收任意数量的参数。
1.push()方法（在数组结尾处）向数组添加一个新的元素；
2.push()方法返回新数组的长度；
2、unshift() 开头处添加
1.
unshift()方法（在开头）向数组添加新元素，并“反向位移”旧元素；
3、concat() 合并链接数组
1.concat()方法可以使用任意数量的数组参数；
2.concat()方法通过合并（连接）现有数组来创建一个新数组；
3.concat()方法不会更改现有数组。它总是返回一个新数组；
4.concat()方法也可以将值作为参数。
二、删
下面前三种都会影响原数组，最后一项不影响原数组：
1、pop() 从数组弹出项目
1.pop()方法从数组中删除最后一个元素；
2.pop()方法返回“被弹出”的值；
2、shift() 位移元素
位移与弹出等同，但处理首个元素而不是最后一个
1.
shift()方法会删除首个数组元素，并把所有其他元素“位移”到更低的索引；
2.shift()方法返回被“位移出”的字符串；
3、splice() 拼接数组
1.splice()方法可用于向数组添加新项；
第一个参数定义添加元素的位置，第二个参数定义应删除多少个元素，其余参数定义要添加的参数。
2.splice()方法返回一个包含已删除项的数组；3.使用
splice()在数组中不留“空洞”的情况下移除元素；
4、slice() 裁剪数组
1.slice()方法用数组的某个片段切出新数组；
2.slice()方法创建新数组。它不会从源数组中删除任何元素；
3.
slice()可接受两个参数，比如 (1, 3)，该方法会从开始参数选取元素，直到结束参数（不包括）为止，如果结束参数被省略，则slice()会切出数组的剩余部分 ；
三、改
即修改原来数组的内容，常用splice
1、splice() 可拼接数组，删除数组
使用
splice()在数组中不留“空洞”的情况下移除元素；
四、查
即查找元素，返回元素坐标或者元素值
1、indexOf() -- 迭代数组
1.indexOf()方法在数组中搜索元素值并返回其位置(第一个位置是0开始）；
扩展：
判断一个字符串中是否含有某几个字符：
//如果存在则执行 if(no.indexOf('LSB') != -1 ){ _this.createContract(new_no) } //如果不存在则执行 if(no.indexOf('LSB') == -1 ){ _this.createContract(new_no) }
2、lastIndexOf()
Array.lastIndexOf()与Array.indexOf()类似，但是从数组结尾开始搜索
3、find() 查找 -- 迭代数组
find()方法返回通过测试函数的第一个数组元素的值；
第一个参数表示项目值、第二个参数--项目索引、第三个参数--数组本身
4、findIndex()
findIndex()方法返回通过测试函数的第一个数组元素的索引
五、 排序方法
1、reverse() 反转数组
reverse()方法反转数组中的元素，可以使用它以降序对数组进行排序；
2、sort() 数组排序
sort()方法以字母顺序对数组进行排序 ;
- sort(首元素地址(必填), 尾元素地址的下一个地址(必填), 比较函数(非必填));
如果直接sort（数组名），则从小到大排序（即升序），以下为倒叙
六、转换方法
1、join()
join()方法也可将所有数组元素结合为一个字符串，它的行为类似 toString()，还可以规定分隔符；
2、 toString()
toString()把数组转换为数组值（逗号分隔）的字符串
七、迭代方法
1、indexOf() -- 迭代数组
2、find() 查找 -- 迭代数组
3、some()
它返回的是一个 Boolean 类型的值。数组中有至少一个元素通过回调函数的测试就会返回
true；所有元素都没有通过回调函数的测试返回值才会为 false。如果用一个空数组去测试的话返回的是false。some()方法只要找到指定的值，return true就会停止循环。
语法：
arr.some(callback(element[, index[, array]])[, thisArg])callback用来测试每个元素的函数，接受三个参数：element（数组中正在处理的元素），index（数组中正在处理元素的索引值），array（some()被调用的数组），thisArg（执行callback时使用的this）
4、forEach()
forEach()方法用于调用数组的每个元素，并将元素传递给回调函数。不会在中途终止循环。
语法：
arr.forEach(callback(currentValue [, index [, array]])[, thisArg])callback用来测试每个元素的函数，接受三个参数：element（数组中正在处理的元素），index（数组中正在处理元素的索引值），array（some()被调用的数组），thisArg（执行callback时使用的this）
5、every() 检查所有数组
every()方法检查所有数组值是否通过测试；对数组每一项都运行传入的函数，如果对每一项函数都返回 true ，则这个方法返回 true；
6、reduce() 循环累加
reduce()方法对数组中的每个元素按序执行一个由您提供的 reducer 函数，每一次运行 reducer 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。
7、filter() 过滤器
filter()方法创建一个新数组，其包含通过所提供函数实现的测试的所有元素。
filter不会改变原数组，它返回过滤后的新数组。
filter遍历的元素范围在第一次调用callback之前就已经确定了。语法：
var newArray = arr.filter(callback(element[, index[, array]])[, thisArg])
8、map()
map()方法通过对每个数组元素执行函数来创建新数组；
map()方法不会对没有值的数组元素执行函数；
map()方法不会更改原始数组；
map方法会给原数组中的每个元素都按顺序调用一次callback函数。callback每次执行后的返回值（包括 undefined）组合起来形成一个新数组。callback函数只会在有值的索引上被调用；那些从来没被赋过值或者使用delete删除的索引则不会被调用。
八、去重方法
1、 利用ES6 Set去重（ES6中最常用）
function unique (arr) {
return Array.from(new Set(arr))
}
var arr = [1,1,'true','true',true,true,15,15,false,false, undefined,undefined, null,null, NaN, NaN,'NaN', 0, 0, 'a', 'a',{},{}];
console.log(unique(arr))
//[1, "true", true, 15, false, undefined, null, NaN, "NaN", 0, "a", {}, {}]
2、利用for嵌套for，然后splice去重（ES5中最常用）
function unique(arr){
for(var i=0; i3、利用indexOf 和 foreach去重
Array.prototype.distinct = function (){
var arr = this,
result = [],
len = arr.length;
arr.forEach(function(v, i ,arr){ //这里利用map，filter方法也可以实现
var bool = arr.indexOf(v,i+1); //从传入参数的下一个索引值开始寻找是否存在重复
if(bool === -1){
result.push(v);
}
})
return result;
};
var a = [1,1,1,1,1,1,1,1,1,2,2,2,2,2,2,3,3,3,3,3,3,3,2,3,3,2,2,1,23,1,23,2,3,2,3,2,3];
var b = a.distinct();
console.log(b.toString()); //1,23,2,34、利用contact去重，这个方法会产生一个新的数组
function concatArr(arr1, arr2){
var arr = arr1.concat(arr2);
arr = unique1(arr);//再引用上面的任意一个去重方法
return arr;
}5、Array.prototype.push.apply() ，这个方法优点是不会产生新数组
var a = [1, 2, 3];
var b = [4, 5, 6];
Array.prototype.push.apply(a, b);//a=[1,2,3,4,5,6]
//等效于:a.push.apply(a, b);
//也等效于[].push.apply(a, b);
function concatArray(arr1,arr2){
Array.prototype.push.apply(arr1, arr2);
arr1 = unique1(arr1);
return arr1;
}6、利用 数组递归去重
可以先学习一下什么是数组递归：什么是递归，通过这篇文章，让你彻底搞懂递归 - 知乎
Array.prototype.distinct = function (){
var arr = this,
len = arr.length;
arr.sort(function(a,b){ //对数组进行排序才能方便比较
return a - b;
})
function loop(index){
if(index >= 1){
if(arr[index] === arr[index-1]){
arr.splice(index,1);
}
loop(index - 1); //递归loop函数进行去重
}
}
loop(len-1);
return arr;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,56,45,56];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,45,567、利用对象的属性不能相同的特点进行去重
Array.prototype.distinct = function (){
var arr = this,
i,
obj = {},
result = [],
len = arr.length;
for(i = 0; i< arr.length; i++){
if(!obj[arr[i]]){ //如果能查找到，证明数组元素重复了
obj[arr[i]] = 1;
result.push(arr[i]);
}
}
return result;
};
var a = [1,2,3,4,5,6,5,3,2,4,56,4,1,2,1,1,1,1,1,1,];
var b = a.distinct();
console.log(b.toString()); //1,2,3,4,5,6,56