精华内容
下载资源
问答
  • ES6总结及面试题集合

    2019-10-12 17:38:52
    ES6总结及面试题集合 ES6总结及面试题集合 ES6总结及面试题集合
  • es6新特性 1、新增了块级作用域 由(let const)定义时生成 let和const的区别 let可以声明变量不赋值 const声明必须赋值 let声明的变量可以改变 const一经赋值不能改变 他们都不支持预解析 2、新增了箭头函数 对函数...

    es6新特性概括 面试你不愁

    1、新增了块级作用域
    由(let const)定义时生成
    let和const的区别
    let可以声明变量不赋值 const声明必须赋值
    let声明的变量可以改变 const一经赋值不能改变
    他们都不支持预解析
    2、新增了箭头函数
    对函数表达式的简写形式
    ()=>{}
    this指向上下文 没有arguments(所有实参的集合)
    3、新增了模板字符串
    符号
    与普通字符串相比有以下优势:
    可以换行书写
    可以拼接变量${num}
    4、新增了基本数据类型
    symbol
    5、新增了解构赋值
    6、新增了数组的一些API
    7、新增了模块化的导入导出
    8、新增了set和map数据结构
    9、新增了定义类的语法糖 class
    10、新增了构造器 Generator
    11、新增了数组和对象的扩展运算符

    展开全文
  • 前端面试-说说你常用的ES6新特性

    千次阅读 2019-11-01 19:35:15
    ES6新特性 1.变量声明const 和 let 2.模板对象与字符串模板 3.箭头函数 4.类的引入 5.参数默认值,不定参数,拓展参数 6.import和 export 7.promise、async/await介绍 8.set和map ...

    ES6新特性

    1.变量声明const 和 let
    2.字符串模板
    3.箭头函数
    4.类的引入
    5.参数默认值,不定参数,拓展参数
    6.import和 export
    7.promise、async/await介绍
    8.set和map
    9.for-in 和 for-of

    1.变量声明 constlet

    作用:
    1.防止全局变量泄露
    2.防止变量提升带来的覆盖问题

    let:作用类似于var,用来声明变量,但是所声明的变量,只在let命令所在的代码块内有效

    const:声明常量,一旦声明不可修改,不可重复声明

    • 对于简单类型的数据(数值、字符串、布尔值),值就保存在变量指向的那个内存地址,因此等同于常量。
    • 对于复合类型的数据(主要是对象和数组),变量指向的内存地址,保存的只是一个指向实际数据的指针,const只能保证这个指针是固定的(即总是指向另一个固定的地址),不能保证指向的数据结构不可变。

    如果要保证指向的数据结构不可变,需要自行封装。

    2.字符串模板

    在一些函数中我们经常会用到字符串的拼接
    在ES6中可以使用 新的语法 ${NAME} 并将它放到反引号中即可实现拼接

    3.箭头函数

    箭头函数与ES5中的普通函数最大的区别就是改变了函数中this的指向

    • 普通函数this指向函数体前面的事件对象
    • 箭头函数则指向函数上下文中this所指的对象

    4.类的引入

    在ES6 中引入了类的概念,创造一个类
    首先注意一点:class没有预解析,实例化一定要放在下面
    在类中可以通过constructor构造函数,new一个实例的时候,构造函数自动执行
    在class中,extends就代表继承的意思,super就是指向父类的构造函数,指代了整个prototype对象或者proto指针指向对象。

    5.参数默认值,不定参数,拓展参数

    在ES6中可以直接在函数声明的过程中设置默认参数

    var link = function(height = 50, color = 'red', url = 'http://azat.co') {
      ...
    }
    

    6.import和 export

    export 可以用来暴露方法和变量

    import {port, getAccounts} from 'module';
    console.log(port); // 3000
    

    import 需要用 import {name} from 'xxx’语法导入

    import * as service from 'module';
    console.log(service.port); // 3000
    

    7.promise、async/await介绍

    ES6中出现了promise异步函数

    var wait1000 =  new Promise((resolve, reject)=> {
      setTimeout(resolve, 1000);   
    }).then(()=> {
      console.log('Yay!');
    });
    

    其中,resolve代表执行回调成功的函数
    而reject代表执行回调失败的函数

    8.setmap

    • set元素不允许重复
      set可用作数组去重
    new Set([11,22,33,22])
    
    • map类似对象,但是它的 key可以为任意数据类型

    9.for-in 和 for-of

    • for in 取 key;for of 取 value
    • for of只能用于数组遍历,for in 还可以用于对象属性的遍历
    展开全文
  • ES6新特性 ES6新特性比较多, 可以将这个特性分为功能和语法糖两个类别. 在回答问题时也会比较有条理 定义变量let, const ES6中可以使用let定义变量, const定义常量, 二者是块级作用域 这里说一下let和var的区别 var...

    本文只做总结, 不做详细解释

    ES6新特性

    ES6新特性比较多, 可以将这个特性分为功能和语法糖两个类别.
    在回答问题时也会比较有条理

    定义变量let, const

    ES6中可以使用let定义变量, const定义常量, 二者是块级作用域

    这里说一下let和var的区别

    • var在全局声明的变量可以通过window获取到, 成为了window的属性
    • let的作用域只在代码块内,块外无效;var全局有效
    {
      let a = 10;
      var b = 1;
    }
    
    a // ReferenceError: a is not defined.
    b // 1
    

    那道经典的for循环中setTimeout打印0,1,2的面试题就是这个原因

    详见 - 参考链接

    • let不像var会有变量提升,所以变量一定要在声明后使用,否则报错 , var在声明前使用会是undefined
    // var 的情况
    console.log(foo); // 输出undefined
    var foo = 2;
    
    // let 的情况
    console.log(bar); // 报错ReferenceError
    let bar = 2;
    
    • let 有暂时性死区
      这样就导致typeof不安全了
    typeof x; // ReferenceError
    let x;
    

    函数扩展

    • 函数参数默认值
    • 函数的rest参数
    function add(...rest) {
      let sum = 0;
    
      for (var val of rest) {
        sum += val;
      }
    
      return sum;
    }
    
    add(2, 5, 3) // 10
    
    • 箭头函数

    箭头函数没有自己的this对象,内部的this就是定义时上层作用域中的this。也就是说,箭头函数内部的this指向是固定的,相比之下,普通函数的this指向是可变的。

    • 尾调用优化

    详见阮大大教程

    promise

    不详细说了, 参考

    模板字符串

    `Hello ${'World'}`
    

    延展操作符

    let objClone = { ...obj };
    

    解构赋值

    //数组
    var a, b; //先声明变量
    
    [a, b] = [1, 2];
    console.log(a); // 1
    console.log(b); // 2
    
    //对象
    const student = {
      name:'Ming',
      age:'18',
      city:'Shanghai'  
    };
    
    const {name,age,city} = student;
    

    对象的解构与数组有一个重要的不同。数组的元素是按次序排列的,变量的取值由它的位置决定;而对象的属性没有次序,变量必须与属性同名,才能取到正确的值。

    这里就有一个react的面试题出现了

    为什么react hooks要返回数组而不是对象?

    原因就是数组解构赋值时可以自定义名称, 而对象不可以. 但是在一个组件中会用到多个hooks, 为了方便自定义命名, 所以使用数组而不是对象

    模块化

    exportimportES6

    // profile.js
    var firstName = 'Michael';
    var lastName = 'Jackson';
    var year = 1958;
    
    export { firstName, lastName, year };
    
    //其他文件中
    import {firstName, lastName, year} from './profile.js'
    

    模块的问题以后专门写一篇

    ES6中引入了类class, 其实它是一个语法糖

    class Point {
      constructor(x, y) {
        this.x = x;
        this.y = y;
      }
    
      toString() {
        return '(' + this.x + ', ' + this.y + ')';
      }
    }
    
    //等同于
    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);
    

    后面也会专门写一篇
    看阮大大吧

    ES7新特性

    • 数组新方法 includes(), 之前的indexOf是通过判断是否返回-1来判断数组中是否包含某元素, 而includes直接返回布尔值

    • 指数运算符**, 等效于Math.pow(..)

    console.log(2**10);// 输出1024
    

    ES8新特性

    • async/await
    • Object.values(): 返回的是Object自身属性的所有值,不包括继承的值
    • Object.entries(): 函数返回一个给定对象自身可枚举属性的键值对的数组
    • String.prototype.padStartString.prototype.padEnd: 允许将空字符串或其他字符串添加到原始字符串的开头或结尾
    const str1 = '5';
    console.log(str1.padStart(10, '0'));
    // 0000000005
    console.log(str1.padEnd(10, '0'));
    //5000000000
    
    展开全文
  • 四、模板字符串概述:应用场景:五、简化对象和函数写法概述:六、箭头函数概述:箭头函数的注意点:特性:应用场景:七、ES6中函数参数的默认值概述:八、rest参数概述:九、扩展运算符介绍:应用:十、Symbol概述...


    一、let 关键字

    特性

    let 关键字用来声明变量,使用 let 声明的变量有几个特点:

    • 不允许重复声明;
    • 块儿级作用域(局部变量);
    • 不存在变量提升;
    • 不影响作用域链;

    let创建变量代码示例:

    // let关键字使用示例:
    let a; // 单个声明
    let b,c,d; // 批量声明
    let e = 100 ; // 单个声明并赋值
    let f = 521 , g = 'iloveyou', h = []; // 批量声明并赋值
    

    不允许重复声明:

    let dog = "狗";
    let dog = "狗";
    // 报错:Uncaught SyntaxError: Identifier 'dog' has already been declared
    

    块儿级作用域(局部变量):

    let cat = "猫";
    console.log(cat);
    }
    console.log(cat);
    // 报错:Uncaught ReferenceError: cat is not defined
    

    不存在变量提升:

    // 什么是变量提升:就是在变量创建之前使用(比如输出:输出的是默认值),let不存在,var存在;
    console.log(people1); // 可输出默认值
    console.log(people2); // 报错:Uncaught ReferenceError: people2 is not defined
    var people1 = "大哥"; // 存在变量提升
    let people2 = "二哥"; // 不存在变量提升
    

    不影响作用域链:

    // 什么是作用域链:很简单,就是代码块内有代码块,跟常规编程语言一样,上级代码块中的局部变量下级可用
    {
        let p = "大哥";
        var s;               //p的作用域是块(花括号内)级的,而s的作用域为全局
        function fn() {
            console.log(p); // 这里是可以使用的
        }
        fn();
    }
    

    应用场景:

    以后声明变量使用 let 就对了;

    二、const 关键字

    特性

    const 关键字用来声明常量 ,const 声明有以下特点:

    • 声明必须赋初始值·;
    • 标识符一般为大写(习惯);
    • 不允许重复声明;
    • 值不允许修改;
    • 块儿级作用域(局部变量);

    const创建变量代码示例:

    // const声明常量
    const DOG = "旺财";
    console.log(DOG);
    // 1. 声明必须赋初始值;
    const CAT;
    // 报错:Uncaught SyntaxError: Missing initializer in const  declaration
    
    // 2. 标识符一般为大写(习惯);
    const dog = "旺财"; // 小写也不错
    
    // 3. 不允许重复声明;
    const CAT = "喵喵";
    const CAT = "喵喵";
    // 报错:Uncaught SyntaxError: Identifier 'CAT' has already been declared
    
    //  注意:对数组元素的修改和对对象内部的修改是可以的(数组和对象存的是引用地址);
    // 4. 值不允许修改;
    const CAT = "喵喵";
    CAT = "咪咪";
    // 特例:
    const arr = ['55','66'];
    arr.push('77');  //arr的中已经接上了‘77’ 这是因为arr指向的地址并没有发生改变
    // 报错:Uncaught TypeError: Assignment to constant variable.
    
    // 5. 块儿级作用域(局部变量);
    {
    	const CAT = "喵喵";
    	console.log(CAT);
    }
    console.log(CAT);
    // 报错:Uncaught ReferenceError: CAT is not defined
    

    应用场景:

    声明对象类型使用 const,非对象类型声明选择 let;

    三、变量和对象的解构赋值

    什么是解构赋值

    ES6允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构赋值;

    // ES6 允许按照一定模式,从数组和对象中提取值,对变量进行赋值,这被称为解构赋值;
     // 1、数组的解构赋值
     const F4 = ["大哥", "二哥", "三哥", "四哥"];
     let [a, b, c, d] = F4;
     // 这就相当于我们声明4个变量a,b,c,d,其值分别对应"大哥","二哥","三哥","四哥"
     console.log(a + b + c + d); // 大哥二哥三哥四哥
     // 2、对象的解构赋值
     const F3 = {
         name: "大哥",
         age: 22,
         sex: "男",
         xiaopin: function () { // 常用
             console.log("我会演小品!");
         }
     }
     let {
         name,
         age,
         sex,
         xiaopin
     } = F3; // 注意解构对象这里用的是{}
     console.log(name + age + sex + xiaopin); // 大哥22男
     xiaopin(); // 此方法可以正常调用
     //好像只是一个指向
     console.log(name===F3.name);//true
     console.log(xiaopin===F3.xiaopin);//true 
    

    应用场景:

    频繁使用对象方法、数组元素,就可以使用解构赋值形式;

    四、模板字符串

    概述:

    模板字符串(template string)是增强版的字符串,用反引号(`)标识,特点:

    • 字符串中可以出现换行符;
    • 可以使用 ${xxx} 形式引用变量
    
    // 声明字符串的方法:单引号('')、双引号("")、反引号(``)
    // 声明
    let string = `我也一个字符串哦!`;
    console.log(string);
    // 特性
    // 1、字符串中可以出现换行符
    let str =
        `<ul>
    		<li>大哥</li>
    		<li>二哥</li>
    		<li>三哥</li>
    		<li>四哥</li>
    	</ul>`;
        console.log(str);
        // 2、可以使用 ${xxx} 形式引用变量
        let s = "大哥";
        let out = `${s}是我最大的榜样!`;
    
        console.log(out);
    

    应用场景:

    当遇到字符串与变量拼接的情况使用模板字符串

    五、简化对象和函数写法

    概述:

    ES6 允许在大括号里面,直接写入变量和函数,作为对象的属性和方法。这样的书写更加简洁;

    // ES6允许在对象的大括号内直接写入变量和函数作为对象的属性和方法
    // 变量和函数
    let name = "訾博";
    let change = function () {
        console.log("活着就是为了改变世界!");
    }
    //创建对象
    const school = {
        // 完整写法
        // name:name,
        // change:change
        // 简化写法
        name,
        change,
        // 声明方法的简化
        say() {
            console.log("言行一致!");
        }
    }
    school.change();
    school.say();
    

    六、箭头函数

    概述:

    ES6允许使用箭头(=>)定义函数,箭头函数提供了一种更加简洁的函数书写方式,箭头函数多用于匿名函数的定义;

    箭头函数的注意点:

    • 如果形参只有一个,则小括号可以省略;
    • 函数体如果只有一条语句,则花括号可以省略,并省略return,函数的返回值为该条语句的执行结果;
    • 箭头函数 this 指向声明时所在作用域下 this 的值;
    • 箭头函数不能作为构造函数实例化;
    • 不能使用 arguments;

    特性:

    • 箭头函数的this是静态的,始终指向函数声明时所在作用域下的this的值;
    • 不能作为构造实例化对象;
    • 不能使用 arguments 变量;
    // ES6允许使用箭头(=>)定义函数
    // 传统写法:无参数
    var say = function () {
        console.log("hello!");
    }
    say();
    
    // ES写法2:无参数
    let speak = () => console.log("hello 哈哈!");
    speak();
    
    // 传统写法:一个参数
    var hello = function (name) {
        return "hello " + name;
    }
    console.log(hello("pj"));
    
    // ES6箭头函数:一个参数
    let hi = name => "hi " + name;
    console.log(hi("pj"));
    
    // 传统写法:多个参数
    var sum = function (a, b, c) {
        return a + b + c;
    }
    console.log(sum(1, 2, 3));
    // ES6箭头函数:多个参数
    let he = (a, b, c) => a + b + c;
    console.log(he(1, 2, 3));
    
    // 特性
    // 1、箭头函数的this是静态的,始终指向函数声明时所在作用域下的this的值
    const school = {
        name: "大哥",
    }
    // 传统函数
    function getName() {
        console.log("getName:" + this.name);
    }
    // 箭头函数
    getName1 = () => console.log("getName1:" + this.name);
    window.name = "訾博";
    // 直接调用
    getName();
    getName1();
    // 使用call调用
    getName.call(school);
    getName1.call(school);
    // 结论:箭头函数的this是静态的,始终指向函数声明时所在作用域下的this的值
    
    // 2、不能作为构造实例化对象
    let Persion = (name,age) => {
    this.name = name;
    this.age = age;
    }
    let me = new Persion("pj",24);
    console.log(me);
    // 报错:Uncaught TypeError: Persion is not a constructor
    
    
    // 3、不能使用 arguments 变量
    let fn = () => console.log(arguments);
    fn(1,2,3);
    // 报错:Uncaught ReferenceError: arguments is not defined
    

    应用场景:

    • 箭头函数适合与this无关的回调,定时器,数组的方法回调
    • 箭头函数不适合与 this 有关的回调,事件回调,对象的方法

    七、ES6中函数参数的默认值

    概述:

    ES允许给函数的参数赋初始值;

    //ES6 允许给函数参数赋值初始值
    //1. 形参初始值 具有默认值的参数, 一般位置要靠后(潜规则)
    function add(a, b, c = 10) {
        return a + b + c;
    }
    let result = add(1, 2);
    console.log(result); // 13
    //2. 与解构赋值结合
    // 注意这里参数是一个对象
    function connect({//参数
        host = "127.0.0.1",
        username,
        password,
        port
    }) {//函数体
        console.log(host)
        console.log(username)
        console.log(password)
        console.log(port)
    }
    connect({
        host: 'atguigu.com',
        username: 'root',
        password: 'root',
        port: 3306
    })
    

    八、rest参数

    概述:

    ES6 引入 rest 参数,用于获取函数的实参,用来代替 arguments;

    // ES6 引入 rest 参数,用于获取函数的实参,用来代替 arguments;
    // ES5获取实参的方式
    function data() {
        console.log(arguments);
    }
    
    data("大哥", "二哥", "三哥", "四哥");
    // ES6的rest参数...args,rest参数必须放在最后面
    function data(...args) {
       // args是一个数组
        console.log(args); // fliter some every map
    }
    data("大哥", "二哥", "三哥", "四哥");
    

    九、扩展运算符

    介绍:

    … 扩展运算符

    能将数组转换为逗号分隔的参数序列;

    扩展运算符(spread)也是三个点(…)。它好比rest 参数的逆运算,将一个数组转为用逗号分隔的参数序列,对数组进行解包;

    // ... 扩展运算符能将数组转换为逗号分隔的参数序列
    //声明一个数组 ...
    const tfboys = ['易烊千玺', '王源', '王俊凯'];
    // => '易烊千玺','王源','王俊凯'
    // 声明一个函数
    function chunwan() {
        console.log(arguments);
    }
    chunwan(...tfboys); // chunwan('易烊千玺','王源','王俊凯')
    

    应用:

    //1. 数组的合并
    const kuaizi = ['王太利', '肖央'];
    const fenghuang = ['曾毅', '玲花'];
    // 传统的合并方式
    // const zuixuanxiaopingguo = kuaizi.concat(fenghuang);
    const zuixuanxiaopingguo = [...kuaizi, ...fenghuang];
    console.log(zuixuanxiaopingguo);
    
    //2. 数组的克隆
    const sanzhihua = ['E', 'G', 'M'];
    const sanyecao = [...sanzhihua]; // ['E','G','M']
    console.log(sanyecao);
    
    //3. 将伪数组转为真正的数组
    const divs = document.querySelectorAll('div');
    const divArr = [...divs];
    console.log(divArr); // arguments
    

    十、Symbol

    概述

    ES6 引入了一种新的原始数据类型 Symbol,表示独一无二的值。它是JavaScript 语言的·第七种数据类型·,是一种类似于字符串的数据类型;

    特点

    • Symbol 的值是唯一的,用来解决命名冲突的问题;
    • Symbol 值不能与其他数据进行运算;
    • Symbol定义的对象属性不能使用for…in循环遍历 ,但是可以使用Reflect.ownKeys 来获取对象的所有键名;

    基本使用:

    //创建Symbol
    let s = Symbol();
    // console.log(s, typeof s);
    let s2 = Symbol('尚硅谷');
    let s3 = Symbol('尚硅谷');
    console.log(s2 == s3); // false
    //Symbol.for 创建
    let s4 = Symbol.for('尚硅谷');
    let s5 = Symbol.for('尚硅谷');
    console.log(s4 == s5); // true
    //不能与其他数据进行运算
    // let result = s + 100;
    // let result = s > 100;
    // let result = s + s;
    
    //七种数据类型
    // USONB you are so niubility
    
    // u undefined
    // s string symbol
    // o object
    // n null number
    // b boolean
    

    Symbol创建对象属性:

    // 向对象中添加方法 up down        
    let game = {            
    	name: '俄罗斯方块',            
    	up: function () {},            
    	down: function () {}        
    };        
    // 我们要往game对象里面添加方法,但是怕game对象已经存在同名方法,所以我们这时使用到了Symbol        
    // 方式一        
    // 声明一个对象        
    let methods = {            
    	up: Symbol(),
    	down: Symbol()
    };        
    game[methods.up] = function () {
    	console.log("我可以改变形状");
    }
    game[methods.down] = function () {
    	console.log("我可以快速下降!!");
    }
    console.log(game);
    //调用方法
    game[methods.up]();
    
    
    // 方式二        
    let youxi = {            
    	name: "狼人杀", 
    	[Symbol('say')]: function () {
    		console.log("我可以发言")            
    	},
    	[Symbol('zibao')]: function () {
    		console.log('我可以自爆');
    	}
    }
    console.log(youxi);
    let say = Symbol('say'); //'say'类似一个注解作用,没有实际意义
    let youxi1 = {
    	name: "狼人杀",
    	[say]: function () {
    		console.log("我可以发言")            
    	},
    	[Symbol('zibao')]: function () {
    		console.log('我可以自爆');
    	}
    }
    // 调用
    youxi1[say]();
    

    Symbol内置值:
    概述:
    除了定义自己使用的 Symbol 值以外,ES6 还提供了 11 个内置的 Symbol 值,指向语言内部使用的方
    法。可以称这些方法为魔术方法,因为它们会在特定的场景下自动执行;

    Symbol内置值:

    概述:

    除了定义自己使用的 Symbol 值以外,ES6 还提供了 11 个内置的 Symbol 值,指向语言内部使用的方
    法。可以称这些方法为魔术方法,因为它们会在特定的场景下自动执行;

    方法:

    • Symbol.isConcatSpreadable 对象的 Symbol.isConcatSpreadable属性等于的是一个布尔值,表示该对象用于Array.prototype.concat()时,是否可以展开。
    • Symbol.species创建衍生对象时,会使用该属性Symbol.match 当执行 str.match(myObject)时,如果该属性存在,会调用它,返回该方法的返回值。
    • Symbol.replace 当该对象被.replace(myObject)方法调用时,会返回该方法的返回值。
    • Symbol.search 当该对象被 str. search(myObject)方法调用时,会返回该方法的返回值。
    • Symbol.split 当该对象被 str. split(myObject)方法调用时,会返回该方法的返回值。
    • Symbol.iterator 对象进行 for…of 循环时,会调用Symbol.iterator 方法,返回该对象的默认遍历
    • Symbol.toPrimitive该对象被转为原始类型的值时,会调用这个方法,返回该对象对应的原始类型值。
    • Symbol. toStringTag 在该对象上面调用 toString 方法时,返回该方法的返回值
    • Symbol. unscopables 该对象指定了使用 with 关键字时,哪些属性会被 with环境排除。

    特别的: Symbol内置值的使用, 都是作为某个对象类型的属性去使用 ;

     class Person {
    	 static[Symbol.hasInstance](param) {
    		 console.log(param);  
    		 ///可以自定义类型检测
    		 console.log("我被用来检测类型了");
    		 return false;
     	}
     }
     let o = {};
     console.log(o instanceof Person);
     const arr = [1, 2, 3];
     const arr2 = [4, 5, 6];
     // 合并数组:false数组不可展开,true可展开
     arr2[Symbol.isConcatSpreadable] = false;
     console.log(arr.concat(arr2));
    
    展开全文
  • 面试-es6新特性

    2020-08-10 13:58:11
    1.let, const let命令也用于声明对象,但是作用域为局部。 { let a = 10; var b = 1; } 在函数外部可以获取到b,获取不到a,因此例如for循环计数器就适合使用let。...const用于声明一个常量,设定后值不会再改变。...
  • 面试es6新特性

    2020-10-27 09:23:52
    循环加载 对象遍历 数组遍历 数组项的全部遍历 数组项的其他遍历 数组去重 ES6新特性总结 其他小点 项目亮点 let 命令和const命令 let命令 新增了let和const命令,用法类似于var,但是所声明的变量,只在let命令所在...
  • 前端面试题总结---ES6新特性

    千次阅读 2020-07-23 13:11:37
    ES6新特性 一、let,const $(function(){ //es6 ECMAscript规范,js实现 //let const var === 声明变量 var a = 'hello'; let b = 'hi'; // 1.不存在变量提升 console.log(c); var c = 'c'; === // ...
  • ES6ES6新特性

    2017-07-20 12:51:48
    这是从别的博客上学到的,在这里做个整理:   (1)箭头操作符=>  简化了函数的书写。操作符左边为输入的参数,而右边则是进行的操作以及返回的值Inputs=>outputs。   var array = [1, 2, 3];...//ES6 array.forEac
  • ES6新特性有哪些?

    千次阅读 2020-12-17 17:41:23
    ES6新特性有哪些?https://www.cnblogs.com/ruhaoren/p/11575179.html 一、的原始类型和变量声明 1,symbol  在ES6之前,我们知道JavaScript支持8种数据类型:Object,String,Boolean,Number,Null,...
  • ES6面试

    千次阅读 2020-04-25 17:38:04
    1.箭头函数中的this指向定义时当前周围的作用...3. es6中和原型一样用来继承的class和继承是怎么实现的? 贴上 class Point { // ... } typeof Point // "function",类的数据类型就是函数 Point === Point.p...
  • https://juejin.im/post/5db25338e51d452a032ba738
  • 啥是ES5,啥又是ES6? 首先ES是ECMAScript的缩写;而ECMAScript是网页脚本和语言...那么面试官的问题来了,es5和6有啥区别,es6有什么新特性呢? es5中声明变量只有var,声明函数只有function es6中又增加了let,consth
  • 面试ES6新特性

    2021-03-10 23:23:46
    ES6 新特性 块级作用域let和const,变量提升。Var变量定义在赋值之前,引用时不会报错,因为编译时将var定义提前,执行位置不变。函数声明会提升到变量声明之前。 块级作用域中的函数声明也会被提前,例如 if.....
  • ES6面试题letconst变量的解构赋值数组的解构对象的解构模板字符串简化对象写法箭头函数函数参数默认值rest参数扩展运算符扩展运算符的应用 let 1:变量声明不能重复 2:块级作用域 3:不存在变量提升 4:不影响作用...
  • 前言在面试的时候,ES6几乎已成必问问题,对ES6还摸棱两可的小伙伴们看完这篇文章将不再迷茫,建议收藏。1.let 变量声明以及特性声明变量leta; letb,c,d; ...
  • ES6常见的面试

    万次阅读 多人点赞 2019-01-12 23:47:15
    1.es6熟悉吗,说几个es6的新增方法 (1)新增声明命令let和const 在es6中通常用 let 和 const 来声明,let 表示变量、const 表示常量。 特点: let 和 const 都是块级作用域。以{}代码块作为作用域范围...
  • ES6新特性

    2021-07-01 18:28:31
    大家好,我是杨振宁的师弟,今天给大家介绍ES6新特性 let/const关键字 var关键字存在变量提升,let/const关键字定义变量作用域在块内 严格模式 use strict 类的概念 箭头函数 (params)=>{函数体}从作用域链的上...
  • Web前端ES6部分 面试

    2020-04-26 21:46:28
    1、es5和es6的区别,说一下你所知道的es6 ECMAScript5,即ES5,是ECMAScript的第五次修订,于2009年完成标准化 ECMAScript6,即ES6,是...ES6新增的一些特性: 1)let声明变量和const声明常量,两个都有块级作用...
  • Es6有哪些新特性 let(定义变量) const(定义常量 块级作用域(只对let、const有效) arrow (箭头函数) class 类 数据结构 map、set 数组解构、对象解构 let和var的区别 通过 let 声明的变量没有变量提升,不能...
  • 关于作用域const(声明一个只读的常量)常见面试题 let(声明局部变量) let特点是什么? 作用域为 块级作用域、无变量提升、同一作用域内不可以重复声明 和var的区别? var 作用域为 函数作用域、有变量提升、可以...
  • 关于ES6新特性

    2021-07-27 14:54:11
    关于es6新特性的总结: 看完这篇HTTP,跟面试官扯皮就没问题了 Vue.js面试题整理 必须要会的 50 个React 面试题 前端ES6面试ES6 新特性 总结 ES6常用新特性总结 es6新特性有哪些 博客园大佬_龙恩0707 阮一峰 ES6...
  • 1.默认参数 function sum(a,b=0){ } sum(10) 不给b传惨 默认b等于0 2.模板文本 var a=10 console.log(`a的值是${a}`) 能解析里面的变量值 ...我前几天面试的问题 祝大家都找到好工作  
  • es6+常见面试

    千次阅读 2018-12-25 16:35:52
    1.es6新特性,哪些在项目中使用举例说明 let const 解构 箭头函数 Set去重 新增数据类型Symbol 模板字符串`` 类怎么实现继承 模块化 promise async / await 2. var let const 区别 3.Set 怎么去重 4.模板字符...
  • js ES6新特性

    2020-06-25 10:24:28
    有阮老师的大作在线可阅,就不班门弄斧了。详情请戳:https://es6.ruanyifeng.com/#README
  • 下面我将会慢慢的介绍一些常用的ES6语法特性,这其中有很大一部分引用于阮一峰老师的《ECMAScript 6 入门》,算是自己对这本书的一个笔记吧。 1、let 和 const 命令 ES5 只有两种声明变量的方法:var命令和...
  • ES6中有哪些新特性 1)let const的引入 let声明变量和const声明常量,两个都有块级作用域  ES5中是没有块级作用域的,并且var有变量提升,在let中,使用的变量一定要进行声明 2)箭头函数  ES6中的函数定义不再...
  • ES6新特性-解构赋值

    2021-07-14 01:38:09
    ES6新特性的学习一.解构赋值的理解二.数组的解构三.对象的解构四.字符串的解构赋值五.解构赋值的主要用途(1)交换变量的值(2)提取 JSON 数据(3)从函数返回多个值 一.解构赋值的理解 解构赋值语法是一种 ...
  • JavaScript ES6新特性

    2020-02-29 21:43:43
    今天要给大家介绍的是es6,相信学习前端方面的同学朋友们都知道es6是非常重要的一个版块,虽然目前依旧是es5的天下,但是es6已经开始越来越完善,使用越来越广泛,下面就给大姐详细的介绍一下! ES6相关概念 ES 的全称是 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 9,725
精华内容 3,890
关键字:

es6新特性面试