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