ES6简单入门--面试题

超、凢脫俗 2022-03-06 13:16 233阅读 0赞

var可以**多次声明同一个变量**\--在其他编程语言是没办法想象的

var a =0;
    
    var a = 99;

（2）var会造成**变量提升**

(function rr() {
    
    if(true) {
    
    var a = 666;
    
    }
    
    console.log(a); //输出666
    })()

ES6变量声明关键字：let 变量声明；const 常量声明。解决了var前面提到的两个缺点。

let以及const都是块级作用域。

常见面试题：

for(var a = 0; a < 3; a++) {
    
    setTimeout(function() {
    
    console.log(a);
    
    }, 1000)
    
    })
    //输出 3 3 3

如何将结果输出为0, 1, 2

es5处理方法 -- 用函数制造块级作用域---利用闭包实现

for(var a = 0; a < 3; a++) {
      (function (a) {
        setTimeout(function() {
          console.log(a);
        }, 1000)
      })(a)
    }
    //输出结果0,1,2

es6处理方法 -- 更加简单明了

for(let a = 0; a < 3; a++) {
      setTimeout(function() {
        console.log(a);
      }, 1000)
    }
    //输出结果为：0,1,2

=================================总结===========================================================

## 1.Let和Const ##

let用来声明变量：特点：  
        (1)不存在变量提升  
        (2)存在暂时性死区，ReferenceError  
        (3)不允许重复声明

(4)只在声明的块级作用域内有效

const用来声明常量：特点：  
        (1)一旦声明必须初始化，常量的至不能变。  
        (2)只在声明的块级作用域内有效  
        (3)不会提升，存在暂时性死区，先声明后使用 。  
        (4)不可重复声明

const本质：  
        保证的并不是变量的值不得改动。而是变量指向的那个内存地址不得改动。对于简单数据类型来说，值就保存在变量指向的内存地址中，因而等同于常量。但对于复合类型的数据而言，变量指向的内存地址保存的只是一个指针，const只能保证这个指针是固定的，至于它指向的数据结构是不是可变的，这完全不能控制

块级作用域  
    为什么需要块级作用域？  
        (1)内层变量可能会覆盖外层变量  
        (2)用来计数的循环变量泄露为全局变量。  
    块级作用域中函数声明规则：  
        (1)允许在块级作用域中声明函数  
        (2)函数声明类似于var，即会提升到全局作用域或函数作用域的头部。  
        (3)函数声明还会提升到块级作用域的头部。  
\---------------------

## 2、函数 （箭头函数） ##

箭头函数  
    箭头函数this的指向时固定化的，这非常有利于封装回掉函数。this指向的固定化并不是因为箭头函数内部绑定this的机制，实际原因是箭头函数根本没有自己的this，导致内部函数的this就是外层代码块的this，正因为它没有this，所以不能作为构造函数。  
    (1)函数体内的this对象，就是定义时所在的对象，而不是运行时所在的对象。  
    (2)不可以当作构造函数，就是不能使用new命令  
    (3)不能使用arguments对象，该对象在函数体内不存在，如果要用，可以使用rest代替  
    (4)不能使用yield命令，因此箭头函数不能作为Generate函数。  
（1）不需要function关键字来创建函数

es5创建函数

var aa = function() {}

es6创建函数

var aa = () => {}

(2)可以极大的简写函数

es5函数

var fn = function(a) {
      return a + 5
    }

可以利用箭头函数简写为：

var fn = a => a + 5;

简写规则：

当函数所传参数只有一个时，可以去掉();        eg: (a) => \{\}   简写为：a => \{\}  
当函数体中只返回值，而没有其他操作时，可以去掉\{\}；eg: (a, b) => \{return a+b\} 简写为：(a, b) => a+b  
（3）继承上下文的关键字this

es5继承上下文的关键字

var fn = function() {
    }
    fn.bind(this)

es6继承上下文的关键字

var fn = () => {}

\---------------------

## 3、数组 ##

新增常用的4个方法

（1）map --映射

let arr=[66,59,80];
    let result=arr.map(item => {
      if(item >= 60){
        return "及格"
      }else{
        return "不及格"
      }
    });
    //result:["及格", "不及格", "及格"]

（2）reduce --汇总

let arr = [12,69,180,8763];
     
    let result = arr.reduce((tmp, item, index) => {
       console.log(tmp, item, index);
       return tmp + item;
    });
    console.log(result);//求和

（3）filter --过滤

（4）forEach --迭代

let arr=[12,5,8,9];
     
    arr.forEach((item,index)=>{
       console.log(index+': '+item); //0: 12  1: 5  2: 8  3: 9
    });

4、函数的参数

（1）收集参数

function show(a, b, ...args){
      console.log(args)
    }
    show(1,2,3,4,5,6) //输出[3,4,5,6]

（2）展开数组

const arr1 = [1,2,3];
    const arr2 = [4,5,6];
    console.log([...arr1, ...arr2]); //输出[1,2,3,4,5,6]
    console.log(...arr1); //输出1，2，3

（3）默认值

const show = (a=666, b=999) => {
      console.log(a); //输出666
      console.log(b); //输出999
    }
     
    show();

5、解构赋值

(1)左右两边结构必须一样；

(2)右边必须是个合法的值；

(3)声明和赋值不能分开(必须在一句话里完成)；

let [a,b,c]=[1,2,3,999];
    let {e,d,g}={e: 4, d: 5, f: 6, g: 7};
    console.log(a,b,c,e,d,g);
    //输出1 2 3 4 5 7

6、字符串

(1)多了两个新方法: startsWith endsWith

//startsWith

(2)字符串模板

优点：方便字符串拼接；可以折行

let title='标题';
    let content='内容';
    let str='<div>\
      <h1>'+title+'</h1>\
      <p>'+content+'</p>\
    </div>';
     
    let str2=`<div>
      <h1>${title}</h1>
      <p>${content}</p>
    </div>`;

参考文档：  
原文：https://blog.csdn.net/barret007/article/details/79478118