ES 6（一）

 

1. var let 和const：都是用来声明变量的。相比而言let和const都有代码块的概念，只有在代码块内有效，const和c中的define差不多，只要声明不可修改。并且在声明时必须初始化。测试代码：

   //var  
   var name1="test1out";
   if(1){
   	var name1="test1";
   	alert(name1);//test1
   }
   alert(name1);//test1
   //let
   let name2="test2out";
   if(1){
   	let name2="test2";
   	alert(name2);//test2
   }
   alert(name2);//test2out
   //var  
   var test3=[];
   for(var i=0;i<10;i++){
   	test3[i]=function(){
   		alert(i);
   	}
   }
   test3[6]();//10
   //let
   var test4=[];
   for(let j=0;j<10;j++){
   	test4[j]=function(){
   		alert(j);
   	}
   }
   test4[6]();//6
   

   　　

2. 解构赋值：

    1 let dog = "dog";
    2 let cat = "cat";
    3 let animal={dog,cat};
    4 console.log(animal);//{dog:"dog",cat:"cat"}
    5 
    6 //or
    7 let dog = {
    8     type: "animal",
    9     many: 2
   10 }
   11 let{type,many}=dog;
   12 console.log(type,many);//animal 2

    

3. 从函数返回多个值：

    1   //返回array
    2   function returnArray(){
    3       return [1,2,3]
    4   }
    5   let [a,b,c]=returnArray();
    6   console.log(a,b,c)//1,2,3
    7   //返回object
    8   function returnObject(){
    9       return {
   10         d:1,
   11          e:2,
   12          f:3
   13      }
   14  }
   15  let {d,e,f}=returnObject();
   16  console.log(d,e,f)//1,2,3
   17  
   18  //json
   19  let jsonData={
   20     id:42,
   21      status:true,
   22      data:[12,"成功"]
   23  }
   24 let {id,status,data}=jsonData;
   25  console.log(id,status,data[1]);
   26 //输入模块的制定方法
   27 const {modela,modelb}=require("map");

    

4. es6允许直接写入变量和函数，例如：

   1 const a="b";
   2 const c={a}; //{a:"b"}

    1 const o={
    2     method(){
    3         return true;
    4     }
    5 }
    6 //相当于
    7 const o={
    8     method:function(){
    9         return true;
   10     }
   11 }

    

5. Object.assign()方法：用于对象合并，同名时后面的会覆盖掉前面的。
6. 函数扩展：

    1 //默认值
    2 //ES6之前,需要处理才能用
    3 function log(a, b) {
    4     if(b === "undefined") {
    5         b = flag;
    6     }
    7     console.log(a, b)
    8     log(c); //c world
    9 }
   10 //ES6
   11 function log(a, b='flag') {
   12     console.log(a, b)
   13     log(c); //c world
   14 }
   15 //函数
   16 var f=v=>v;
   17 //相当于
   18 var f=function(v){
   19     return v;
   20 }
   21 //不需要传参
   22 var f=()=>{ var a=5;return a};
   23 //对象报错问题 ,要用两个大括号，外面一个代表的是代码块
   24 let f()=>{{id:"a",name:"luo"}};
   25 //this问题,因为当我们使用箭头函数时，函数体体内的 this对象，为从外部继承的this
   26 class Animal{
   27     constructor(){
   28         this.type="animal"
   29     }
   30     says(say){
   31         setTimeout(()=>{
   32             console.log(this.type+"says"+say)
   33         },1000)
   34     }
   35 }
   36 var animals=new Animal();
   37 animal.says("hi")//animal says hi

    

7. 模板字符串或变量：他的输出模板和模板引擎差不多，反引号（·）标识，可用于当做普通字符串或定义多行字符串或在字符串中嵌入变量。
8. 可用trim方法销毁换行
9. class（类）的基本语法：

   //javas中，生成实例对象的传统方法是通过构造函数：
   function Point(x,y){
       this.x=x;
       this.y=y;
       
   }
   Point.prototype.toString=function(){
       return '('+this.x+','+this.y+')';
   }
   var p=new Point(1,2);
   console.log(p);

   这种方式对于熟悉c和c++的人们来说会带来一定的困惑因此ES6引入Class的概念，可以用来定义类：

    1 class Point {
    2     constructor(x, y) {
    3         this.x = x;
    4         this.y = y;
    5     }
    6     toString() {
    7         return '(' + this.x + ',' + this.y + ')';
    8     }
    9 }
   10 
   11 var p = new Point(1, 2);
   12 console.log(p);//{x:1,y:2}

    

转载于:https://www.cnblogs.com/tllw/p/7774449.html