ES6语法

发表于   |   分类于   |     |  

[TOC]

块级作用域

let

  • let作用域：大括号块中、函数内部
  • let声明不会被提升，所以会出现临时死区(TDZ)
  • 如果作用域中存在的某个标识符再次使用let关键字声明就会报错
  • let在for这类的循环中，每次迭代都会创建一个新的变量，并以之前的同变量名值初始化

const

  • 每个通过const声明的变量必须进行初始化
  • const与let都是块级标识符，只在当前代码块内有效
  • const也不会被提升
  • const常量名不能与var、let变量名重名
  • const声明对象不允许修改绑定，可以修改绑定的对象的属性值，如：
    const Person={name:”ww”}; Person.name=”aaa”;
  • const在for-in for-of循环中使用行为与let一样，都会每次创建一个新的绑定

ES6中，默认使用const，确实需要改变的变量使用let

函数

参数默认值

  • ES5中使用默认参数的方法是：name=name||mick;
  • ES6中直接在函数接收参数里定义参数默认值:function Person(name,age=18)
  • 只有当不为参数传入值或者主动为它传入undefined是才会使用默认值，传入null并不会使用默认值
  • 参数的默认值可以通过调用函数来获得，函数不会在声明时调用，只有在传参时才会调用
  • 函数参数后面的参数可以用前面的参数作为默认值，因为前面的先声明

默认值对arguments影响

  • ES5中：
    非严格模式下，命名参数的变化会与arguments对象实时更新
    严格模式下，arguments传入的是参数的静态副本，不会随参数变化而变化
  • ES6中，如果一个参数使用了默认值，无论是在严格还是非严格模式下，arguments对象都与命名参数分离

不定参数

在函数命名参数前添加...表示这时一个补丁参数，该参数为一个数组，包含着自它之后传入的所有参数

1
2
3
4
function Person(name,age,...others){
	for(let i=0;i<others.length-1;i++){
	}
}

  • 每个函数最多只能定义一个不定参数，而且一定要放在末尾

块级函数

  • ES6可以在代码块中声明一个函数，称为块级函数
  • 块级函数
    在严格模式下：会将声明提升至代码块顶部
    在非严格模式下：提升至外围函数或全局的顶部

箭头函数

  • 目标是替代匿名函数，语法更简洁
  • this arguments super new.targets这些值由外围最近的一层非箭头函数决定
  • 不能通过new调用
  • 没有原型prototype
  • 无论时严格还是非严格模式下，箭头函数都不支持重复声明命名函数
  • 箭头函数形式：
    1.一个参数：let test = param => returnValue;
    2.多参数： let test=(param1,param2) => param1+param2;
    3.无参： let test=() => returnValue;
    4.多表达式函数体：let test = (param1,param2) =>{return param1+param2;};
    5.空函数： let test = () => {};
    6.返回对象字面量： let test=id => ({id:id , name:”aaa”});//返回的对象字面量要用括号包起来

尾调用

  • 是指函数作为另一个函数的最后一条执行语句被调用
  • 尾调用优化：不建立新的栈帧，清除并重用当前的栈帧。减少内存的使用，避免栈溢出错误
  • 满足下面两个个条件才可以被JavaScript引擎自动优化尾调用：
    1.尾调用不访问当前栈帧的变量，不是闭包
    2.函数返回结果直接作为返回值，没有其他运算

Promise异步

romise是一种封装未来值的易于复用的异步任务管理机制,主要解决地狱回调和控制异步的顺序

Promise的三种状态

  • fulfilled：满足，成功
  • rejected：拒绝，失败
  • pending：初始状态
    注：settled是指fulfilled，rejected状态之一。

Promise()构造函数

1
2
3
4
5
6
7
8
9
10
11
12
13
// resolver为 function(resolve, reject){ ... }
function Promise(resolver){
	  if(resolver && typeof resolver !== 'function'){ throw new Error('Promise resolver is not a function') }
	  //当前promise对象的状态
	  this.state = PENDING;
	  //当前promise对象的数据（成功或失败）
	  this.data = UNDEFINED; 
	  //当前promise对象注册的回调队列
	  this.callbackQueue=[]; 
	  //执行resove()或reject()方法
	  if(resolver) executeResolver.call(this, resolver);
}
Promise.prototype.then = function(){}
  • 构造器初始化：
    1
    2
    3
    4
    5
    6
    new Promise(function(resolve, reject){
    		resolve(value1);//异步调用成功的函数并传值
    		reject(value2);
    } ).then(function(value1){
    		//成功，接收value1
    },function(value2){//失败});

构造函数用于生成Promise对象，executor函数在Promise构造函数执行时同步执行。
resolve，reject函数被调用时分别将Promise状态设置为fulfilled，rejected

Promise实例方法：then( onfulfilled, onrejected ), catch( onrejected )

then和catch用于处理Promise fullfilled成功或者rejected失败时候的情况。
更加推荐的做法：
myPromise.then(onfulfilled).catch(onrejected);
这样的好处：
1.then，catch区分开，分别处理成功，失败，代码更容易理解。
2.then().then().then().catch(); then，catch方式可以捕获到前面多个then中的异常。

Promise可以链式调用的原因？

因为Promise.prototype.then方法和Promise.prototype.catch方法都返回Promise对象。所以可以链式调用:

1
myPromise.then(xxx).then(xxx);

特点

所谓 Promise，就是一个对象，用来传递异步操作的消息。它代表了某个未来才会知道结果的事件（通常是一个异步操作），并且这个事件提供统一的 API，可供进一步处理。
Promise 对象有以下两个特点：

(1)、对象的状态不受外界影响。Promise 对象代表一个异步操作，有三种状态：Pending（进行中）、Resolved（已完成，又称 Fulfilled）和 Rejected（已失败）。只有异步操作的结果，可以决定当前是哪一种状态，任何其他操作都无法改变这个状态。这也是 Promise 这个名字的由来，它的英语意思就是「承诺」，表示其他手段无法改变。
(2)、一旦状态改变，就不会再变，任何时候都可以得到这个结果。Promise 对象的状态改变，只有两种可能：从 Pending 变为 Resolved 和从 Pending 变为 Rejected。只要这两种情况发生，状态就凝固了，不会再变了，会一直保持这个结果。就算改变已经发生了，你再对 Promise 对象添加回调函数，也会立即得到这个结果。这与事件（Event）完全不同，事件的特点是，如果你错过了它，再去监听，是得不到结果的。
有了 Promise 对象，就可以将异步操作以同步操作的流程表达出来，避免了层层嵌套的回调函数。此外，Promise 对象提供统一的接口，使得控制异步操作更加容易。
Promise 也有一些缺点。首先，无法取消 Promise，一旦新建它就会立即执行，无法中途取消。其次，如果不设置回调函数，Promise 内部抛出的错误，不会反应到外部。第三，当处于 Pending 状态时，无法得知目前进展到哪一个阶段（刚刚开始还是即将完成）。

热评文章