Es6数组学习

ECMAScript是JavaScript的标准（语法规范）
Javascript用于遵循这个规范
使用vscode编写代码：
在扩展中搜索 Live Serve、JavaScript（ES6） 并安装


在.html文件 右键 选择open with Live Serve 可以运行该html文件

数组方法（7种）：

forEach

Es5方法（for循环）：

var colors =["red","blue","green"];
for(var i=0;i<colors.length;i++){
    console.log(colors[i]);
}

ES6方法（forEach）：

colors.forEach(function(color){
    console.log(color);
})

效果：

map

类似于对象，也是键值对的集合，但是“键”的范围不限于字符串，各种类型的值（包括对象）都可以当作键。也就是说，Object 结构提供了“字符串—值”的对应，Map 结构提供了“值—值”的对应，是一种更完善的 Hash 结构实现

1、假设有一个数组（A），将A数组中的值以双倍的形式放到数组B中并打印

var numbers =[1,2,3];

var doubleNumbers=[];

//es5
for(var i=0;i<numbers.length;i++){
    doubleNumbers.push(numbers[i]*2);
}
//打印最终doubleNumbers值
console.log(doubleNumbers);
//打印doubleNumbers各个值
for(var i=0;i<doubleNumbers.length;i++){
    console.log(doubleNumbers[i]);
}
//es6 map
var doubled=numbers.map(function(number){
    return number*2;
})
console.log(doubled);
//es6 forEach
doubled.forEach(function(number){
    console.log(number);
})

假设有一个对象数组（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);

总结:map需要返回值，如果不给return，默认返回underfined
map返回的是一个新的数组

filter（过滤）

假设有一个对象数组（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"){//判断type值
        filteredProducts.push(porducts[i]);//加入到filteredProducts
    }
    console.log(filteredProducts);
}
//es6
var filter2=porducts.filter(function(product)
//定义新的数组
{
    return product.type==="vegetable";
});
console.log(filter2);

假设有一个对象数组（A），过滤掉不满足以下条件的对象
条件：蔬菜 数量大于0，价格小于十

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

假设有两个对象数组（A，B），根据A中的id值，过滤掉B数组不符合的数据

var post={id:4,title:"四"};
var comments=[
    {postId:4,content:"Angular4"},
    {postId:3,content:"Vue.js"},
    {postId:2,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));

find

假设有一个对象数组（A），找到符合条件的对象

var users=[
    {name:"一"},
    {name:"二"},
    {name:"三"},
];
//es5方法
var user;
for(var i=0;i<users.length;i++){
    if(users[i].name==="二"){
        user=users[i];
        break;//解决找到后的循环
    }
}
// console.log(user);
//es6  find(只会找到第一个需要找到的)
user =users.find(function(user){
    return user.name==="三";
});
console.log(user);

假设有一个对象数组（A），根据指定对象的条件找到数组中符合的对象

var posts=[
    {id:1,title:"NOde.js"},
    {id:2,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));

reduce（可代替forEach和map）

计算数组中所有值的和
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(sum,number){
return sum+number;
},0)
console.log(sumValue);

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(sum,number){
    return sum+number;
},0)//0初始化的值
console.log(sumValue);

将数组中对象的某个属性抽离到另一个数组中

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

判断字符串中的括号是否对称

function balanceParents(string){
    return !string.split("").reduce(function(previous,char){//split切割字符串变为数组
        if(previous<0){return previous};
        if(char=="("){return++previous;}
        if(char==")"){return--previous;}
        return previous;
    },0)
};
console.log(balanceParents("(((()"));