必看！！！数组常用的方法（ES6）

一、forEach：遍历数组

var colors = ["red","blue","green"];
// ES5遍历数组方法
for(var i = 0; i < colors.length; i++){ console.log(colors[i]);//red blue green
}

// ES6 forEach
colors.forEach(function(color){console.log(color);//red blue green
});

我们再来看个例子：遍历数组中的值,并计算总和

var numbers = [1,2,3,4,5];
var sum = 0;
numbers.forEach(number=>sum+=number)
console.log(sum)//15

二、map：将数组映射成另一个数组

map通过指定函数处理数组的每个元素，并返回处理后新的数组，map 不会改变原始数组。

forEach和map的区别在于，forEach没有返回值。 map需要返回值，如果不给return，默认返回undefined

使用场景1 假定有一个数值数组(A),将A数组中的值以双倍的形式放到B数组

var numbers = [1,2,3];
var doubledNumbers = [];
// es5写法
for(var i = 0; i < numbers.length; i++){doubledNumbers.push(numbers[i] * 2);
}
console.log(doubledNumbers);//[2,4,6]

// es6 map方法
var doubled = numbers.map(function(number){return number * 2;
})
console.log(doubled);//[2,4,6]

使用场景2 假定有一个对象数组(A),将A数中对象某个属性的值存储到B数组中

var cars = [{model:"Buick",price:"CHEAP"},{model:"BMW",price:"expensive"}
];
var prices = cars.map(function(car){return car.price;
})
console.log(prices);//["CHEAP", "expensive"]

三、filter：从数组中找出所有符合指定条件的元素

filter() 检测数值元素，并返回符合条件所有元素的数组。 filter() 不会改变原始数组。

使用场景1：假定有一个对象数组(A),获取数组中指定类型的对象放到B数组中

var porducts = [{name:"cucumber",type:"vegetable"},{name:"banana",type:"fruit"},{name:"celery",type:"vegetable"},{name:"orange",type:"fruit"}
];
// es5写法
var filteredProducts = [];
for(var i = 0; i < porducts.length; i++){if(porducts[i].type === "fruit"){filteredProducts.push(porducts[i]);}
}
console.log(filteredProducts);//[{name: "cucumber", type: "vegetable"},{name: "celery", type: "vegetable"}]

// es6 filter
var filtered2 = porducts.filter(function(product){return product.type === "vegetable";
})
console.log(filtered2);

使用场景2：假定有一个对象数组(A),过滤掉不满足以下条件的对象 条件: 蔬菜 数量大于0,价格小于10

var products = [{name:"cucumber",type:"vegetable",quantity:0,price:1},{name:"banana",type:"fruit",quantity:10,price:16},{name:"celery",type:"vegetable",quantity:30,price:8},{name:"orange",type:"fruit",quantity:3,price:6}
];
products = products.filter(function(product){return product.type === "vegetable" && product.quantity > 0 && product.price < 10
})
console.log(products);//[{name:"celery",type:"vegetable",quantity:30,price:8}]

使用场景3：假定有两个数组(A,B),根据A中id值,过滤掉B数组不符合的数据

var post = {id:4,title:"Javascript"};
var comments = [{postId:4,content:"Angular4"},{postId:2,content:"Vue.js"},{postId:3,content:"Node.js"},{postId:4,content:"React.js"},
];
function commentsForPost(post,comments){return comments.filter(function(comment){return comment.postId === post.id;})
}
console.log(commentsForPost(post,comments));//[{postId:4,content:"Angular4"},{postId:4,content:"React.js"}]

四、find：返回通过测试（函数内判断）的数组的第一个元素的值

它的参数是一个回调函数，所有数组成员依次执行该回调函数，直到找出第一个返回值为true的成员，然后返回该成员。如果没有符合条件的成员，则返回undefined。 使用场景1 假定有一个对象数组(A),找到符合条件的对象

 var users = [{name:"Jill"},{name:"Alex",id:2},{name:"Bill"},{name:"Alex"}];
// es5方法var user;for(var i = 0; i < users.length; i++){if(users[i].name === "Alex"){user = users[i];break;//找到后就终止循环}}console.log(user);// {name:"Alex",id:2}

// es6 find
user = users.find(function(user){return user.name === "Alex";
})
console.log(user);// {name:"Alex",id:2}找到后就终止循环

使用场景2：假定有一个对象数组(A),根据指定对象的条件找到数组中符合条件的对象

var posts = [{id:3,title:"Node.js"},{id:1,title:"React.js"}
];
var comment = {postId:1,content:"Hello World!"};
function postForComment(posts,comment){return posts.find(function(post){return post.id === comment.postId;})
}
console.log(postForComment(posts,comment));//{id: 1, title: "React.js"}

五、every&some

every：数组中是否每个元素都满足指定的条件

some:数组中是否有元素满足指定的条件

使用场景1：计算对象数组中每个电脑操作系统是否可用，大于16位操作系统表示可用,否则不可用

//ES5方法
var computers = [{name:"Apple",ram:16},{name:"IBM",ram:4},{name:"Acer",ram:32}
];
var everyComputersCanRunProgram = true;
var someComputersCanRunProgram = false;
for(var i = 0; i < computers.length; i++){var computer = computers[i];if(computer.ram < 16){everyComputersCanRunProgram = false;}else{someComputersCanRunProgram = true;}
}
console.log(everyComputersCanRunProgram);//false
console.log(someComputersCanRunProgram);//true

//ES6 some every 
var every = computers.every(function(computer){return computer.ram > 16;
})
console.log(every);//false
var some = computers.some(function(computer){return computer.ram > 16;
})
console.log(some);//true

一言以蔽之：Every: 全真即真；Some: 一假即假

使用场景2：假定有一个注册页面,判断所有input内容的长度是否大于0

function Field(value){this.value = value;
}
Field.prototype.validate = function(){return this.value.length > 0;
}
//ES5方法
var username = new Field("henrywu");
var telephone = new Field("18888888888");
var password = new Field("my_password");
console.log(username.validate());//true
console.log(telephone.validate());//true
console.log(password.validate());//true
//ES6 some every
var fields = [username,telephone,password];
var formIsValid = fields.every(function(field){return field.validate();
})
console.log(formIsValid);//true
if(formIsValid){// 注册成功
}else{// 给用户一个友善的错误提醒
}

六、reduce：将数组合成一个值

reduce() 方法接收一个方法作为累加器，数组中的每个值(从左至右) 开始合并，最终为一个值。

使用场景1： 计算数组中所有值的总和

 var numbers = [10,20,30];var sum = 0;
//es5 方法
for(var i = 0; i < numbers.length; i++){sum += numbers[i];
}
console.log(sum);

// es6 reduce
var sumValue = numbers.reduce(function(sum2,number2){console.log(sum2);//0 10 30 60return sum2 + number2;
},0);//sum2初始值为0
console.log(sumValue);

使用场景2： 将数组中对象的某个属性抽离到另外一个数组中

 var primaryColors = [{color:"red"},{color:"yellow"},{color:"blue"}];var colors = primaryColors.reduce(function(previous,primaryColor){previous.push(primaryColor.color);return previous;},[]);console.log(colors);//["red", "yellow", "blue"]

使用场景3：判断字符串中括号是否对称

function balancedParens(string){return !string.split("").reduce(function(previous,char){if(previous < 0) { return previous;}if(char == "("){ return ++previous;}if(char == ")"){ return --previous;}return previous;},0);
}
console.log(balancedParens("((())))"));

关于数组的10个操作方法！

1.shift() 方法：把数组的第一个元素删除，并返回第一个元素的值

var movePos=[1,2];
movePos.shift()
console.log(movePos)//[2]

document.write(movePos.length);//1

2.concat() 方法：用于连接两个或多个数组,并返回一个新数组，新数组是将参数添加到原数组中构成的 

3. join() 方法：用于把数组中的所有元素放入一个字符串。元素是通过指定的分隔符进行分隔的。

返回一个字符串。该字符串是通过把 arrayObject 的每个元素转换为字符串，然后把这些字符串连接起来，在两个元素之间插入separator 字符串而生成的。

var movePos=[11,22];

var arr=movePos.join("+");
document.write(arr)  //11+22

4.  pop() 方法：用于删除并返回数组的最后一个(删除元素)元素,如果数组为空则返回undefined ,把数组长度减 1

5. push() 方法：可向数组的末尾添加一个或多个元素，并返回新的长度，（用来改变数组长度）。

6.reverse() ：方法用于颠倒数组中元素的顺序。

7.slice() 方法：可从已有的数组中返回选定的元素。slice(开始截取位置，结束截取位置)

8.splice() ：方法向/从数组中添加/删除项目，然后返回被删除的项目。

    splice() 方法可删除从 index 处开始的零个或多个元素，并且用参数列表中声明的一个或多个值来替换那些被删除的元素。

    var movePos =[111,222,333,444];

    movePos.splice(2,1,"666")//movePos.splice(开始删除的下表位置,删除数组元素的个数，向数组添加的新项目。);从下标2开始删除一位，并用666替换删除下表位置的元素
    document.write(movePos + "<br />")

unshift() 方法可向数组的开头添加一个或更多元素，并返回新的长度。

9.unshift：将参数添加到原数组开头，并返回数组的长度 

var movePos =[111,222,333,444];
movePos.unshift("55555")
document.write(movePos + "<br />")//55555,111,222,333,444

10.sort(orderfunction)：按指定的参数对数组进行排序 
var movePos =["444","111","333","222"];

movePos.sort(1)

document.write(movePos + "<br />")//55555,111,222,333,444