这篇文章主要介绍了ES10 特性的完整指南小结，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧

本篇文章主要介绍了ES10 特性的完整指南，分享给大家，具体如下：

ES10 还只是一个草案。但是除了 Object.fromEntries 之外，Chrome 的大多数功能都已经实现了，为什么不早点开始探索呢?当所有浏览器都开始支持它时，你将走在前面，这只是时间问题。

在新的语言特性方面，ES10 不如 ES6 重要，但它确实添加了一些有趣的特性(其中一些功能目前还无法在浏览器中工作: 2019/02/21)

在 ES6 中，箭头函数无疑是最受欢迎的新特性，在 ES10 中会是什么呢?

这里创建了 match.groups.color 和 match.groups.bird ：

[code]const string = 'black*raven lime*parrot white*seagull';
const regex = /(?<color>.*?)\*(?<bird>[a-z0-9]+)/g;
while (match = regex.exec(string))
{
 let value = match[0];
 let index = match.index;
 let input = match.input;
 console.log(`${value} at ${index} with '${input}'`);
console.log(match.groups.color);
 console.log(match.groups.bird);
}[/code]

需要多次调用 regex.exec 方法来遍历整个搜索结果集。 在每次迭代期间调用.exec 时，将显示下一个结果（它不会立即返回所有匹配项。），因此使用 while 循环。

输出如下：

black*raven at 0 with 'black*raven lime*parrot white*seagull'
black
raven
lime*parrot at 11 with 'black*raven lime*parrot white*seagull'
lime
parrot
white*seagull at 23 with 'black*raven lime*parrot white*seagull'
white
seagull

但奇怪的是:

如果你从这个正则表达式中删除 /g，你将永远在第一个结果上创建一个无限循环。这在过去是一个巨大的痛苦。想象一下，从某个数据库接收正则表达式时，你不确定它的末尾是否有 /g，你得先检查一下。

使用 .matchAll() 的好理由

• 在与捕获组一起使用时，它可以更加优雅,捕获组只是使用 () 提取模式的正则表达式的一部分。
• 它返回一个迭代器而不是一个数组，迭代器本身是有用的。
• 迭代器可以使用扩展运算符 (…) 转换为数组。
• 它避免了带有 /g 标志的正则表达式，当从数据库或外部源检索未知正则表达式并与陈旧的RegEx 对象一起使用时，它非常有用。
• 使用 RegEx 对象创建的正则表达式不能使用点 (.) 操作符链接。
• 高级: RegEx 对象更改跟踪最后匹配位置的内部 .lastindex 属性，这在复杂的情况下会造成严重破坏。

.matchAll() 是如何工作的?

让我们尝试匹配单词 hello 中字母 e 和 l 的所有实例， 因为返回了迭代器，所以可以使用 for…of 循环遍历它：

[code]// Match all occurrences of the letters: "e" or "l" 
let iterator = "hello".matchAll(/[el]/);
for (const match of iterator)
 console.log(match);[/code]

这一次你可以跳过 /g， .matchall 方法不需要它，结果如下:

[ 'e', index: 1, input: 'hello' ] // Iteration 1
[ 'l', index: 2, input: 'hello' ] // Iteration 2
[ 'l', index: 3, input: 'hello' ] // Iteration 3

使用 .matchAll() 捕获组示例：

.matchAll 具有上面列出的所有好处。它是一个迭代器，可以用 for…of 循环遍历它,这就是整个语法的不同。

[code]const string = 'black*raven lime*parrot white*seagull';
const regex = /(?<color>.*?)\*(?<bird>[a-z0-9]+)/;
for (const match of string.matchAll(regex)) {
 let value = match[0];
 let index = match.index;
 let input = match.input;
 console.log(`${value} at ${index} with '${input}'`);
console.log(match.groups.color);
 console.log(match.groups.bird);
}[/code]

请注意已经没有 /g 标志，因为 .matchAll() 已经包含了它，打印如下：

black*raven at 0 with 'black*raven lime*parrot white*seagull'
black
raven
lime*parrot at 11 with 'black*raven lime*parrot white*seagull'
lime
parrot
white*seagull at 23 with 'black*raven lime*parrot white*seagull'
white
seagull

也许在美学上它与原始正则表达式非常相似，执行while循环实现。但是如前所述，由于上面提到的许多原因，这是更好的方法，移除 /g 不会导致无限循环。

新的Function.toString()

函数是对象，并且每个对象都有一个 .toString() 方法，因为它最初存在于Object.prototype.toString() 上。 所有对象（包括函数）都是通过基于原型的类继承从它继承的。

这意味着我们以前已经有 funcion.toString() 方法了。

但是 ES10 进一步尝试标准化所有对象和内置函数的字符串表示。 以下是各种新案例：

典型的例子:

[code]function () { console.log('Hello there.'); }.toString();[/code]

控制台输出(函数体的字符串格式:)

[code]⇨ function () { console.log('Hello there.'); }[/code]

下面是剩下的例子:

直接在方法名 .toString()

[code]Number.parseInt.toString();
⇨ function parseInt() { [native code] }[/code]

绑定上下文:

[code]function () { }.bind(0).toString();
⇨ function () { [native code] }
[/code]

内置可调用函数对象:

[code]Symbol.toString();
⇨ function Symbol() { [native code] }[/code]

动态生成的函数:

[code]function* () { }.toString();
⇨ function* () { }[/code]

prototype.toString

[code]Function.prototype.toString.call({});
⇨ Function.prototype.toString requires that 'this' be a Function"[/code]

可选的 Catch Binding

在过去，try/catch 语句中的 catch 语句需要一个变量。 try/catch 语句帮助捕获终端级别的错误:

[code]try {
 // Call a non-existing function undefined_Function
 undefined_Function("I'm trying");
}
catch(error) {
 // Display the error if statements inside try above fail
 console.log( error ); // undefined_Function is undefined
}[/code]

在某些情况下，所需的错误变量是未使用的:

[code]try {
 JSON.parse(text); // <--- this will fail with "text not defined"
 return true; <--- exit without error even if there is one
}
catch (redundant_sometmes) <--- this makes error variable redundant
{
 return false;
}[/code]

编写此代码的人通过尝试强制 true 退出 try 子句。但是，这并不是实际发生的情况

[code](() => {
 try {
  JSON.parse(text)
  return true
 } catch(err) {
  return false
 }
})()
=> false[/code]

在 ES10 中，捕获错误的变量是可选的

现在可以跳过错误变量:

[code]try {
 JSON.parse(text);
 return true;
}
catch
{
 return false;
}[/code]

目前还无法测试上一个示例中的 try 语句的结果，但一旦它出来，我将更新这部分。

标准化 globalThis 对象

这在ES10之前， globalThis 还没有标准化。

在产品代码中，你可以自己编写这个怪物，在多个平台上“标准化”它:

[code]var getGlobal = function () {
 if (typeof self !== 'undefined') { return self; }
 if (typeof window !== 'undefined') { return window; }
 if (typeof global !== 'undefined') { return global; }
 throw new Error('unable to locate global object');
};[/code]

但即使这样也不总是奏效。因此，ES10 添加了 globalThis 对象，从现在开始，该对象用于在任何平台上访问全局作用域:

[code]// 访问全局数组构造函数
globalThis.Array(0, 1, 2);
⇨ [0, 1, 2]

// 类似于 ES5 之前的 window.v = { flag: true }
globalThis.v = { flag: true };

console.log(globalThis.v);
⇨ { flag: true }[/code]

Symbol.description

description 是一个只读属性，它返回 Symbol 对象的可选描述。

[code]let mySymbol = 'My Symbol';
let symObj = Symbol(mySymbol);
symObj; // Symbol(My Symbol)
symObj.description; // "My Symbol"[/code]

Hashbang 语法

也就是 unix 用户熟悉的 shebang。它指定一个解释器(什么将执行JavaScript文件?)。

ES10标准化，我不会对此进行详细介绍，因为从技术上讲，这并不是一个真正的语言特性，但它基本上统一了 JavaScript 在服务器端的执行方式。

[code]$ ./index.js[/code]

代替

[code]$ node index.js[/code]

ES10类:private、static 和 公共成员

新的语法字符 #octothorpe（hash tag）现在用于直接在类主体的范围内定义变量，函数，getter 和 setter ......以及构造函数和类方法。

下面是一个毫无意义的例子，它只关注新语法:

[code]class Raven extends Bird {
#state = { eggs: 10};
// getter
 get #eggs() { 
  return state.eggs;
 }
// setter
 set #eggs(value) {
  this.#state.eggs = value;
 }
#lay() {
  this.#eggs++;
 }
constructor() {
  super();
  this.#lay.bind(this);
 }
#render() {
  /* paint UI */
 }
}[/code]

老实说，我认为这会让语言更难读。

代码部署后可能存在的BUG没法实时知道，事后为了解决这些BUG，花了大量的时间进行log 调试，这边顺便给大家推荐一个好用的BUG监控工具 Fundebug。

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持