ES6 let const 、箭头函数、数组

let命令

let 用于声明变量，类似于var， 声明的变量只在代码块中有效

{
    let a=66；
    var b=88；
}
alert（a）  //a is not defined
alert（b）  //88

let 不能重复声明——不允许在相同作用域内重复声明同一个变量

function(){
    let a=1;
    let a=2;
}//报错   Identifier 'a' has already been declared

const命令

const用来声明常量——一旦声明值就不能改变

let a=12;
a=5;
console.log(a)   //5

const a=3;
a=10;
//严格模式下对已经初始化的常量赋值会报错。  Assignment to constant variable.
//非严格模式下对已经初始化的常量赋值不报错但是无效。 3

严禁只声明 不赋值

const c;
//严格模式下 只声明不赋值 就会报错
//非严格模式下  undefined

箭头函数

1. 只有一个参数,()可以省
2. 只有一个语句 并且是return {}可以省

function (a,b,c){
  //代码
}
(a,b,c)=>{
  //代码
}

function show(fn){
    fn(12,6)
}
/*
show(function(a,b){
    console.log(a+b)
})
*/
show((a,b)=>{
    console.log(a+b)
})

let show=function(a){
    alert(a);
}
let show=(a)=>{
    alert(a);
}
let show=a=>{    //只有一个参数,()可以省
    alert(a);
}

let sum=(a,b)=>{
    return a+b;
}
let sum(a,b)=a+b    //只有一个语句 并且是return  {}可以省

参数扩展–剩余参数

function show(a,b,c,...arg){
    alert(arg)
}
show(12,5,31,32,11,2,8)
//32,11,2,8
//...arg 必须放在最后

//展开数组
let arr=[12,2,3];
//    ...arr    =>  12,2,3
function sum(a,b,b){
    console.log(a+b+c);
}
sum(...arr)

let arr2=[1,2,3,4,5];
let arr3=[66,77,88];
let result=[...arr2,arr3];
console.log(result);

数组

• map 映射 [31,55,66,88,99] =>[不及格，不及格，及格，一般，优秀]

let arr=[12,4,5,66];
/*
let arr2=arr.map(function(item){
    //console.log(item)  //12,4,5,66
    //return 1;   //1,1,1,1
    return item*2
})
*/
let arr2=arr.map(item=>item*2)
alert(arr2)   //  24,8,10,132

• reduce 汇总
  三个参数 tmp item index

let arr=[12,3,5,63,31,78]
let res=arr.reduce((tmp,item,index)=>{
    console.log(tmp);
    return tmp+item;
});
console.log(arr);
//求平均值
let arr=[21,53,6,1,86,52];
let result=arr.reduce((tmp,item,index)=>{
    if(index<arr.length-1){
        return tmp+item
    }else{   //最后一次 加上最后一位数  除以 length
        return (tmp+item)/arr.length;
    }
})
console.log(result)

• filter 过滤 [x,x,x,x,x] => [x,x,…]

let arr=[12,33,21,46,27,86,32,99];
/*
let arr2=arr.filter(item=>{
    if(item%2==0){
        return false;
    }else{
        return true;
    }
})
*/
let arr2=arr.filter(item=>item%2;)
alert(arr2)  //33,21,27,99

• forEach 迭代、遍历

let arr=[12,21,5,7,42];
arr.forEach(item=>{
    alert(item)
})

arr.forEach((item,index)=>{
    //alert('第'+index+'个是'+item);
    alert(`第${index}个是${item}`);
})
//  ``反单引号

字符串

字符串模板 xxx${变量}xxx;

let str='avc
drf';
console.log(str)//正常js 不能换行输出 报错

let str=`dse
ads`
//原样输出

面向对象

//js
function User(name,pass){
    this.name=name;
    this.pass=pass
}
User.prototype.login=function(){
    console.log(`登录成功`)
}
//ES6
class User{
    constructor(name,pass){
        this.name=name;
        this.pass=pass
    };
    login(){
        console.log(`成功`)
    }
}
class VIPUser extends User{
    constructor(name,pass,level){
        super(name,pass);
        this.level=level;
    }
    download(){
        console.log(`下载功能`)
    }
};

let v=new VIPUser('wjs','123456','6');
console.log(v.name)
console.log(v.level);

alert(v instanceof VIPUser)

promise

//创建Promise
let p=new Promise(function(resolve,reject){

})

p.then(arr=>{
    console.log(‘成功’)
},err=>{
    console.log('失败了')
})   //两个回调函数 其实就是 resolve reject

• 解构赋值

let [a,b,c]=[12,3,5]

console.log(a)
console.log(b)
console.log(c)
// 12 3 5
let {a,b,c}={a:12,b:22,c:33}

Promise.all([
    $.ajax({
        url:'1.txt',dataType:'json'
    }),
    $.ajax({
        url:'2.txt',dataType:'json'
    }),
    $.ajax({
        url:'3.txt',dataType:'json'
    })
]).then(arr=>{
    let [a1,json,a2]=arr;
    console.log(a1);
    console.log(a2);
    console.log(json);
},err=>{
    console.log(err)
})