ES2016与ES2017特性

ES2016特性:

  1. Array.prototype.includes(数组元素判断)
// 语法
Array.prototype.includes(value:任意值): return boolean
// 例子
['a', 'b', 'c'].includes('a')
> true
['a', 'b', 'c'].includes('d')
> false

includes 方法与 indexOf 方法很相似——下面两个表达式是等价的:

arr.includes(x)
arr.indexOf(x) >= 0

唯一的区别是 includes() 方法能找到 NaN,而 indexOf() 不行:

[NaN].includes(NaN)
> true
[NaN].indexOf(NaN)
> -1

另外 includes 不会区分 +0-0 (这也与其他 JavaScript 特性表现一致):

[-0].includes(+0)
> true
  1. Exponentiation Operator(求冥运算)
// 语法
x ** y
// 例子
let a = 2 ** 3 // 2*2*2 = 2^3
let b = 3 ** 2 // 3*3 = 3^2

其实与以下表达式 Math.pow(x, y) 结果相同:

let a = 7 ** 12
let b = 2 ** 7
console.log(a === Math.pow(7,12)) // true
console.log(b === Math.pow(2,7)) // true

另外还可以简写:

let a = 7
a **= 12
let b = 2
b **= 7
console.log(a === Math.pow(7,12)) // true
console.log(b === Math.pow(2,7)) // true

ES2017特性:

  1. String.prototype.padStart / String.prototype.padEnd(字符串填充)
    正如其名,这俩函数的作用就是在字符串的头部和尾部增加新的字符串,并且返回一个具有指定长度的新的字符串。你可以使用指定的字符、字符串或者使用函数提供的默认值-空格来填充源字符串。
// 语法
str.padStart(targetLength [, padString])
str.padEnd(targetLength [, padString])

padStart 从字符串开端左边开始填充,并且返回给定长度的字符串,如果不给定填充字符串,将使用默认字符空格,具体示例如下:

'es8'.padStart(2);          // 'es8',如果长度小于原字符串,返回原字符串
'es8'.padStart(5);          // '  es8'
'es8'.padStart(6, 'woof');  // 'wooes8',如果填充字符串+原字符串长度大于给定长度,则从填充字符串左边开始截取(这是由于与其他语言PHP、Ruby保持一致)
'es8'.padStart(14, 'wow');  // 'wowwowwowwoes8'
'es8'.padStart(7, '0');     // '0000es8',如果填充字符串+原字符串长度小于给定长度,则从填充字符串重复填充

padEnd 从字符串尾端右边开始填充,并且返回给定长度的字符串,如果不给定填充字符串,将使用默认字符空格,具体示例如下:

'es8'.padEnd(2);          // 'es8',如果长度小于原字符串,返回原字符串
'es8'.padEnd(5);          // 'es8  '
'es8'.padEnd(6, 'woof');  // 'es8woo',如果填充字符串+原字符串长度大于给定长度,则从填充字符串左边开始截取(这是由于与其他语言PHP、Ruby保持一致)
'es8'.padEnd(14, 'wow');  // 'es8wowwowwowwo'
'es8'.padEnd(7, '6');     // 'es86666',如果填充字符串+原字符串长度小于给定长度,则从填充字符串重复填充
  1. Object.values / Object.entries
    Object.values 函数将会返回一个数组,该数组的内容是函数参数(一个对象)可遍历属性的属性值。
// 语法
Object.values(obj)
// 示例
const obj = { x: 'xxx', y: 1 };
Object.values(obj); // ['xxx', 1]
const obj = ['e', 's', '8']; // same as { 0: 'e', 1: 's', 2: '8' };
Object.values(obj); // ['e', 's', '8']
// when we use numeric keys, the values returned in a numerical 
// order according to the keys
const obj = { 10: 'xxx', 1: 'yyy', 3: 'zzz' };
Object.values(obj); // ['yyy', 'zzz', 'xxx']
Object.values('es8'); // ['e', 's', '8']

Object.entries 函数与 Object.values函数类似,也是返回一个数组,只不过这个数组是对象自身可迭代属性 [key-value] 的对数组。

// 语法
Object.entries(obj)
// 示例
const obj = { x: 'xxx', y: 1 };
Object.entries(obj); // [['x', 'xxx'], ['y', 1]]
const obj = ['e', 's', '8'];
Object.entries(obj); // [['0', 'e'], ['1', 's'], ['2', '8']]
const obj = { 10: 'xxx', 1: 'yyy', 3: 'zzz' };
Object.entries(obj); // [['1', 'yyy'], ['3', 'zzz'], ['10': 'xxx']]
Object.entries('es8'); // [['0', 'e'], ['1', 's'], ['2', '8']]
  1. Object.getOwnPropertyDescriptors
    该函数返回指定对象(参数)的所有自身属性描述符。所谓自身属性描述符就是在对象自身内定义,不是通过原型链继承来的属性。
Object.getOwnPropertyDescriptors(obj)

obj 参数即为源对象,该函数返回的每个描述符对象可能会有的 key 值分别是:configurableenumerablewritablegetsetvalue。示例代码如下:

const obj = { 
  get es7() { return 777; },
  get es8() { return 888; }
};
Object.getOwnPropertyDescriptor(obj);
// {
//   es7: {
//     configurable: true,
//     enumerable: true,
//     get: function es7(){}, //the getter function
//     set: undefined
//   },
//   es8: {
//     configurable: true,
//     enumerable: true,
//     get: function es8(){}, //the getter function
//     set: undefined
//   }
// }
  1. 函数参数列表和调用中的尾逗号
    此处结尾逗号指的是在函数参数列表中最后一个参数之后的逗号以及函数调用时最后一个参数之后的逗号。ES8 允许在函数定义或者函数调用时,最后一个参数之后存在一个结尾逗号而不报 SyntaxError 的错误。示例代码如下:
    // 函数声明时
    function es8(var1, var2, var3,) {
      // ...
    }
    // 函数调用时
    es8(10, 20, 30,);

ES8的这项新特性受启发于对象或者数组中最后一项内容之后的逗号,如 [10, 20, 30,] 和 { x: 1, } 。

  1. 异步函数
    由 async 关键字定义的函数声明定义了一个可以异步执行的函数,它返回一个 AsyncFunction 类型的对象。异步函数的内在运行机制和 Generator 函数非常类似,但是不能转化为 Generator 函数。
    示例代码如下:
    function fetchTextByPromise() {
      return new Promise(resolve => { 
        setTimeout(() => { 
          resolve("es8");
        }, 2000);
      });
    }
    async function sayHello() { 
      const externalFetchedText = await fetchTextByPromise();
      console.log(`Hello, ${externalFetchedText}`); // Hello, es8
    }
    sayHello();

有了 async/await,我们的代码执行异步看起来像执行同步一样。可以从头到尾读起来非常简单和易懂,因为出现结果顺序和函数题中从头到尾顺序一样啊!

6.共享内存与原子操作
当内存被共享时,多个线程可以并发读、写内存中相同的数据。原子操作可以确保那些被读、写的值都是可预期的,即新的事务是在旧的事务结束之后启动的,旧的事务在结束之前并不会被中断。这部分主要介绍了 ES8 中新的构造函数 SharedArrayBuffer 以及拥有许多静态方法的命名空间对象 Atomic
Atomic 对象类似于 Math 对象,拥有许多静态方法,所以我们不能把它当做构造函数。 Atomic 对象有如下常用的静态方法:

  • add/sub - 为某个指定的value值在某个特定的位置增加或者减去某个值
  • and/or/xor - 进行位操作
  • load - 获取特定位置的值

参考资料:
https://github.com/tc39/ecma262
http://www.jianshu.com/p/a138a525c287
https://github.com/xitu/gold-miner/blob/master/TODO/es8-was-released-and-here-are-its-main-new-features.md

推荐阅读更多精彩内容