es6 家用充电（ES6）

变量let    
    
    
  、const

ES5 中    
    
    
  ，使用 var 定义变量（ var 是 variable 的简写）  
    
    
    
。

ES6 中   


     


     


     
，新增了 let 和 const 来定义变量：

let：定义变量



 




 




 




，替代 var

     


     


     


  。

const：定义常量（定义后   

   

   

 ，不可修改） 




 




 




 
。

1   


     


     


     
、let：定义变量

举例 1：

{ let a = hello; } console.log(a); // 打印结果报错：Uncaught ReferenceError: a is not defined

上方代码    

     

     

     ，打印报错  

   

   

   

。

举例 2：

var a = 2; { let a = 3; } console.log(a); // 打印结果：2

通过上面两个例子可以看出




  




  




  




，用块级作用域内  


  


  


， 用let 声明的变量     
     
     
     ，只在局部起作用

     

     

     

 。

经典面试题：

let 可以防止数据污染




   




   




   



，我们来看下面这个 for 循环的经典面试题  




  




  




  。

1



 




 




 




、用 var 声明变量：

for (var i = 0; i < 10; i++) { console.log(循环体中: + i); } console.log(循环体外: + i);

上方代码的最后一行可以正常打印结果
 



 



 



，且最后一行的打印结果是 10  


  


  


  


。说明循环体外定义的变量 i                   ，是全局作用域下的 i
     
     
     
。

2   

   

   

 、用 let 声明变量：

for (let i = 0; i < 10; i++) { console.log(循环体中: + i); // // 每循环一次 




    




    




    


，就会在 { } 所在的块级作用域中
















，重新定义一个新的变量 i } console.log(循环体外: + i);

上方代码的关键在于：每次循环都会产生一个块级作用域                  ，每个块级作用域中会重新定义一个新的变量 i
   




   




   




   。

另外  



     



     



     

，上方代码的最后一行

















，打印会报错 



 



 



 


。因为用 let 定义的变量 i    
    
    
  ，只在{ }这个块级作用域里生效                。

总结：我们要习惯用 let 声明   


     


     


     
，减少 var 声明带来的污染全局空间

    




    




    




   。

为了进一步强调 let 不会带来污染



 




 




 




，需要说明的是：当我们定义了let a = 1时   

   

   

 ，如果我们在同一个作用域内继续定义let a = 2    

     

     

     ，是会报错的

















。

2    

     

     

     、const：定义常量

在程序开发中




  




  




  




，有些变量是希望声明后  


  


  


，在业务层就不再发生变化     
     
     
     ，此时可以用 const 来定义常量                 。常量就是值（内存地址）不能变化的量

     



     



     



   。

举例：

const name = smyhvae; //定义常量

用 const 声明的常量




   




   




   



，只在局部（块级作用域内）起作用；而且
 



 



 



，用 const 声明常量时                   ，必须赋值 




    




    




    


，否则报错
















。

let 和 const 的特点【重要】

不属于顶层对象 Window

不允许重复声明

不存在变量提升 必须先定义后使用

暂时性死区 当内部变量与外部你变量同名时
















，内部变量屏蔽外部变量

支持块级作用域 该变量在该作用域不会消失

相反                  ， 用var声明的变量：存在变量提升




  




  




  




、可以重复声明  


  


  


、没有块级作用域  
    
    
    
。

var/let/const 的共同点

全局作用域中定义的变量  



     



     



     

，可以在函数中使用

     


     


     


  。

函数中声明的变量

















，只能在函数及其子函数中使用    
    
    
  ，外部无法使用 




 




 




 
。

this 指向

this:是函数体内的内置对象（this只能出现在函数体内）

1     
     
     
     、以函数的形式（包括普通函数




   




   




   



、定时器函数
 



 



 



、立即执行函数）调用时   


     


     


     
，this 的指向永远都是 window  

   

   

   

。比如fun();相当于window.fun();

2                   、以方法的形式调用时



 




 




 




，this 指向调用方法的那个对象

3 




    




    




    


、以构造函数的形式调用时   

   

   

 ，this 指向实例对象

4
















、以事件绑定函数的形式调用时    

     

     

     ，this 指向绑定事件的对象

5                  、使用 call 和 apply 调用时




  




  




  




，this 指向指定的那个对象

第 1 条的举例：

function fun() { console.log(this); console.log(this.name); } var obj1 = { name: smyh, sayName: fun, }; var obj2 = { name: vae, sayName: fun, }; var name = 全局的name属性; //以函数形式调用  


  


  


，this是window fun(); //可以理解成 window.fun()

打印结果：

Window 全局的name属性

上面的举例可以看出     
     
     
     ，this 指向的是 window 对象




   




   




   



，所以 this.name 指的是全局的 name

     

     

     

 。

第 2 条的举例：

function fun() { console.log(this); console.log(this.name); } var obj1 = { name: smyh, sayName: fun, }; var obj2 = { name: vae, sayName: fun, }; var name = 全局的name属性; //以方法的形式调用
 



 



 



，this是调用方法的对象 obj2.sayName();

打印结果：

Object vae

上面的举例可以看出                   ，this 指向的是 对象 obj2 




    




    




    


，所以 this.name 指的是 obj2.name  




  




  




  。

ES6 箭头函数中 this 的指向

ES6 中的箭头函数并不使用上面的准则
















，而是会继承外层函数调用的 this 绑定（无论 this 绑定到什么）  


  


  


  


。

bind() 方法 bind() 方法的作用

bind() 方法不会调用函数                  ，但是可以改变函数内部的 this 指向
     
     
     
。

把call()  



     



     



     

、apply()

















、bind()这三个方法做一下对比  



     



     



     

，你会发现：实际开发中

















， bind() 方法使用得最为频繁
   




   




   




   。如果有些函数    
    
    
  ，我们不需要立即调用   


     


     


     
，但是又想改变这个函数内部的this指向



 




 




 




，此时用 bind() 是最为合适的 



 



 



 


。

语法：

新函数 = fn1.bind(想要将this指向哪里, 函数实参1, 函数实参2);

参数：

第一个参数：在 fn1 函数运行时   

   

   

 ，指定 fn1 函数的this 指向                。如果不需要改变 this 指向    

     

     

     ，则传 null

    




    




    




   。

其他参数：fn1 函数的实参

















。

解释：它不会调用 fn1 函数




  




  




  




，但会返回 由指定this 和指定实参的原函数拷贝                 。可以看出  


  


  


， bind() 方法是有返回值的

     



     



     



   。

箭头函数

定义箭头函数的语法

语法：

(参数1, 参数2 ...) => { 函数体 }

解释：

如果有且仅有 1 个形参     
     
     
     ，则()可以省略

如果函数体内有且仅有 1 条语句




   




   




   



，则{}可以省略
 



 



 



，但前提是                   ，这条语句必须是 return 语句
















。

举例

写法 1    
    
    
  、定义和调用函数：（传统写法）

function fn1(a, b) { console.log(haha); return a + b; } console.log(fn1(1, 2)); //输出结果：3

写法 2   


     


     


     
、定义和调用函数：（ES6 中的写法）

const fn2 = (a, b) => { console.log(haha); return a + b; }; console.log(fn2(1, 2)); //输出结果：3

上面的两种写法 




    




    




    


，效果是一样的  
    
    
    
。

从上面的箭头函数中
















，我们可以很清晰地看到变量名



 




 




 




、参数名   

   

   

 、函数体

     


     


     


  。

【重要】在箭头函数中                  ，如果方法体内只有一句话  



     



     



     

，且这句话是 return 语句

















，那就可以把 {}省略 




 




 




 
。写法如下：

const fn2 = (a, b) => a + b; console.log(fn2(1, 2)); //输出结果：3

在箭头函数中    
    
    
  ，如果形参只有一个参数   


     


     


     
，则可以把()省略  

   

   

   

。写法如下：

const fn2 = (a) => { console.log(haha); return a + 1; }; console.log(fn2(1)); //输出结果：2 箭头函数的 this 的指向

ES6 之前的普通函数中：this 指向的是函数被调用的对象（也就是说



 




 




 




，谁调用了函数   

   

   

 ，this 就指向谁）

     

     

     

 。

而 ES6 的箭头函数中：箭头函数本身不绑定 this    

     

     

     ，this 指向的是箭头函数定义位置的 this（也就是说




  




  




  




，箭头函数在哪个位置定义的  


  


  


，this 就跟这个位置的 this 指向相同）  




  




  




  。

const obj = { name: 123 }; function fn1() { console.log(this); // 第一个 this return () => { console.log(this); // 第二个 this }; } const fn2 = fn1.call(obj); fn2();

打印结果：

obj obj

代码解释：

上面的代码中     
     
     
     ，箭头函数是在 fn1()函数里面定义的




   




   




   



，所以第二个 this 跟 第一个 this 指向的是同一个位置  


  


  


  


。又因为
 



 



 



，在执行 fn1.call(obj)之后                   ，第一个 this 就指向了 obj 




    




    




    


，所以第二个 this 也是指向 了 obj
     
     
     
。

变量的解构赋值

解构赋值：ES6 允许我们
















，按照一一对应的方式                  ，从数组或者对象中提取值  



     



     



     

，再将提取出来的值赋值给变量
   




   




   




   。

解构：分解数据结构；赋值：给变量赋值 



 



 



 


。

解构赋值在实际开发中可以大量减少我们的代码量

















，并且让程序结构更清晰                。

数组的解构赋值

数组的结构赋值：将数组中的值按照位置提取出来    
    
    
  ，然后赋值给变量

    




    




    




   。

语法

在 ES6 之前   


     


     


     
，当我们在为一组变量赋值时



 




 




 




，一般是这样写：

var a = 1; var b = 2; var c = 3;

或者是这样写：

var arr = [1, 2, 3]; var a = arr[0]; var b = arr[1]; var c = arr[2];

现在有了 ES6 之后   

   

   

 ，我们可以通过数组解构的方式进行赋值：（根据位置进行一一对应）

let [a, b, c] = [1, 2, 3];

二者的效果是一样的    

     

     

     ，但明显后者的代码更简洁优雅

















。

对象的解构赋值

对象的结构赋值：将对象中的值按照属性匹配的方式提取出来




  




  




  




，然后赋值给变量                 。

语法

在 ES6 之前  


  


  


，我们从接口拿到 json 数据后     
     
     
     ，一般这么赋值：

var name = json.name; var age = json.age; var sex = json.sex;

上面这种写法




   




   




   



，过于麻烦了

     



     



     



   。

现在
 



 



 



，有了 ES6 之后                   ，我们可以使用对象解构的方式进行赋值
















。举例如下：

const person = { name: qianfan, age: 25, sex: 男 }; let { name, age, sex } = person; // 对象的结构赋值 console.log(name); // 打印结果：qianguyihao console.log(age); // 打印结果：28 console.log(sex); // 打印结果：男

上方代码可以看出 




    




    




    


，对象的解构与数组的结构
















，有一个重要的区别：数组的元素是按次序排列的                  ，变量的取值由它的位置决定；而对象的属性没有次序  



     



     



     

，是根据键来取值的  
    
    
    
。

圆括号的使用

如果变量 foo 在解构之前就已经定义了

















，此时你再去解构    
    
    
  ，就会出现问题

     


     


     


  。下面是错误的代码   


     


     


     
，编译会报错：

let foo = haha; { foo } = { foo: smyhvae }; console.log(foo);

要解决报错



 




 




 




，只要在解构的语句外边   

   

   

 ，加一个圆括号即可：

let foo = haha; ({ foo } = { foo: smyhvae }); console.log(foo); //输出结果：smyhvae 字符串解构

字符串也可以解构    

     

     

     ，这是因为




  




  




  




，此时字符串被转换成了一个类似数组的对象 




 




 




 
。举例如下：

const [a, b, c, d] = hello; console.log(a); console.log(b); console.log(c); console.log(typeof a); //输出结果：string

打印结果：

h e l string