ES10（2019）新特性

Array新增flat()和flatMap()方法

flat()和flatMap()本质上就是是归纳（reduce）与合并（concat）的操作。

Array.prototype.flat(depth)

flat() 方法会按照一个可指定的深度递归遍历数组，并将所有元素与遍历到的子数组中的元素合并为一个新数组返回。
flat()方法最基本的作用就是数组降维，depth作为深度，默认为1。
其次，还可以利用flat()方法的特性来去除数组的空项

let arr = [1, 2, [3, 4]];
console.log(arr.flat()); // [1, 2, 3, 4]

let arr1 = [1, 2, [3, 4, [5, 6]]];
console.log(arr1.flat()); // [1, 2, 3, 4, [5, 6]]
 
console.log(arr1.flat(2)); // [1, 2, 3, 4, 5, 6]

// 利用flat()方法的特性来去除数组的空项
let arr2 = [1, 2, , 4, 5];
console.log(arr2.flat()); // [1, 2, 4, 5]

Array.prototype.flatMap()

flatMap()方法首先使用映射函数映射每个元素，然后将结果压缩成一个新数组。它与 map 和 深度值1的flat()几乎相同，但flatMap通常在合并成一种方法的效率稍微高一些。

let arr = [1, 2, 3, 4];
arr.map(x => [x * 2]); // [[2], [4], [6], [8]]
arr.map(x => [x * 2]).flat(); // [2, 4, 6, 8]
 
arr.flatMap(x => [x * 2]); // [2, 4, 6, 8]
 
// flatMap函数返回的数组只会展开一层
arr.flatMap(x => [[x * 2]]); // [[2], [4], [6], [8]]

String新增trimStart()和trimEnd()方法

这两个方法和trim()都是用于去除字符串空格，不同的是trim()方法用于删除字符串的头尾空格，trimStart()和trimEnd()去除字符串首尾空白字符。

let str = " dcd ";
console.log(str.trim()); // 删除字符串的头尾空白字符
console.log(str.trimStart()); // 删除字符串的头部空白字符
console.log(str.trimEnd()); // 删除字符串的尾部空白字符
console.log(str); // 不会改变原始字符串

Object.fromEntries()

Object.fromEntries()和Object.entries()相反。

Object.fromEntries() 函数传入一个键值对的列表，并返回一个带有这些键值对的新对象。通过 Object.fromEntries， 可以将 Map 转化为 Object。

const entries = new Map([
  ["foo", "bar"],
  ["baz", 42]
]);

const obj = Object.fromEntries(entries);

console.log(obj); // expected output: Object { foo: "bar", baz: 42 }

Symbol.prototype.description

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

console.log(Symbol("desc").description); // expected output: "desc"

console.log(Symbol.iterator.description); // expected output: "Symbol.iterator"

console.log(Symbol.for("foo").description); // expected output: "foo"

console.log(`${Symbol("foo").description}bar`); // expected output: "foobar"

String.prototype.matchAll

matchAll()方法返回一个包含所有匹配正则表达式及分组捕获结果的迭代器。在matchAll 出现之前，通过在循环中调用regexp.exec来获取所有匹配项信息（regexp需使用/g标志）

const regexp = RegExp('foo*','g');
const str = 'table football, foosball';
 
while ((matches = regexp.exec(str)) !== null) {
    console.log(`Found ${matches[0]}. Next starts at ${regexp.lastIndex}.`);
    // expected output: "Found foo. Next starts at 9."
    // expected output: "Found foo. Next starts at 19."
}

如果使用matchAll，就可以不必使用while循环加exec方式（且正则表达式需使用／g标志）。使用matchAll会得到一个迭代器的返回值，配合 for…of, array spread, or Array.from() 可以更方便实现功能

const regexp = /t(e)(st(\d?))/g;
const str = "test1test2";
const array = [...str.matchAll(regexp)];
console.log(array[0]); // expected output: Array ["test1", "e", "st1", "1"]
console.log(array[1]); // expected output: Array ["test2", "e", "st2", "2"]

Function.prototype.toString()现在返回精确字符，包括空格和注释

function sum(a, b) {
  return a + b;
}

console.log(sum.toString());
// expected output: "function sum(a, b) {
//                     return a + b;
//                   }"

console.log(Math.abs.toString());
// expected output: "function abs() { [native code] }"

修改 catch 绑定

在 ES10 之前，我们必须通过语法为 catch 子句绑定异常变量，无论是否有必要。很多时候 catch 块是多余的。 ES10 提案使我们能够简单的把变量省略掉。

// 之前是   
try {} catch(e) {}　

// 现在是
try {} catch {}

允许在字符串中使用行分隔符（U + 2028）和段分隔符（U + 2029）符号

JavaScript 字符串允许直接输入字符，以及输入字符的转义形式。举例来说，“中”的 Unicode 码点是 U+4e2d，你可以直接在字符串里面输入这个汉字，也可以输入它的转义形式\u4e2d，两者是等价的。

"中" === "\u4e2d" // true

但是，JavaScript 规定有5个字符，不能在字符串里面直接使用，只能使用转义形式。例如反斜杠，必须要转义写成\或者\u005c。
U+005C：反斜杠（reverse solidus)
U+000D：回车（carriage return）
U+2028：行分隔符（line separator）
U+2029：段分隔符（paragraph separator）
U+000A：换行符（line feed）

但是JSON 格式允许字符串里面直接使用 U+2028（行分隔符）和 U+2029（段分隔符）。如果使用JSON.parse解析的json字符串中包含这两个字符，就会报错。

const json = '"\u2029"';
JSON.parse(json); 

为了消除这个报错，ES2019允许JavaScript字符串直接输入 U+2028（行分隔符）和 U+2029（段分隔符）。

const PS = eval("'\u2029'");

JSON.stringify

根据标准，JSON 数据必须是 UTF-8 编码。但是，现在的JSON.stringify()方法有可能返回不符合 UTF-8 标准的字符串。

具体来说，UTF-8 标准规定，0xD800到0xDFFF之间的码点，不能单独使用，必须配对使用。比如，\uD834\uDF06是两个码点，但是必须放在一起配对使用，代表字符?。这是为了表示码点大于0xFFFF的字符的一种变通方法。单独使用\uD834和\uDFO6这两个码点是不合法的，或者颠倒顺序也不行，因为\uDF06\uD834并没有对应的字符。

JSON.stringify()的问题在于，它可能返回0xD800到0xDFFF之间的单个码点。

JSON.stringify('\u{D834}') // "\u{D834}"

为了确保返回的是合法的 UTF-8 字符，ES2019 改变了JSON.stringify()的行为。如果遇到0xD800到0xDFFF之间的单个码点，或者不存在的配对形式，它会返回转义字符串，留给应用自己决定下一步的处理。

JSON.stringify('\u{D834}') // ""\\uD834""
JSON.stringify('\uDF06\uD834') // ""\\udf06\\ud834""