一、支持大部分 ES6 特性

1.class

下面是关于 ES6 引入的经典类的试验代码：

  1. /*参数类型异常 ：用于封装参数类型异常信息*/
  2. class ParameterTypeError extends Error {
  3.     constructor(paramName, paramType) {
  4.         if (!(typeof paramName == 'string'))
  5.             throw new ParameterTypeError('paramName', String);
  6.         if (!(paramType instanceof Function))
  7.             throw new ParameterTypeError('paramType', Function);
  8.         let msg = 'Parameter "' + paramName +
  9.             '" must be a ' + paramType.name +
  10.             ' object.';
  11.         super(msg);
  12.         this.ParameterName = paramName;
  13.         this.ParameterType = paramType;
  14.     }
  15.     toString() {
  16.         return ParameterTypeError.name + ' : ' + this.message;
  17.     }
  18.     static check(param, paramName, paramType) {
  19.         if (!((param instanceof paramType) ||
  20.             (typeof param == paramType.name.toLowerCase())))
  21.             throw new ParameterTypeError(paramName, paramType);
  22.     }
  23. }
  24. /*经典类
  25. 它只支持如下形式：
  26. class ClassName {
  27.     //现行（ES6）支持的类成员类型如下：
  28.     InstanceMethod() {...}
  29.     static StaticMethod() {...}
  30.     get InstanceProperty() {...}
  31.     set InstanceProperty(value) {...}
  32.     static get StaticProperty() {...}
  33.     static set StaticProperty(value) {...}
  34.     //ES2022 state4(finished) 提案增补类成员类型如下：
  35.     InstanceField        //公有实例字段
  36.     #PrivateInstanceField
  37.     #PrivateInstanceMethod() {...}
  38.     get #PrivateInstanceProperty {...}
  39.     set #PrivateInstanceProperty {...}
  40.     static StaticField    //公有静态字段
  41.     static #PrivateStaticField 
  42.     static #PrivateStaticMethod {...}
  43.     //暂缺提案支持的成员类型如下：
  44.     static get #PrivateStaticProperty {...}
  45.     static set #PrivateStaticProperty {...}
  46.     //TC39 state3 阶段提案支持
  47.     static {...} //静态构造函数
  48. }*/
  49. class Point {
  50.     constructor(x, y) {
  51.         ParameterTypeError.check(x, 'x', Number);
  52.         ParameterTypeError.check(y, 'y', Number);
  53.         this.x = x;
  54.         this.y = y;
  55.         Point.count++;
  56.     }
  57.     static get count() {
  58.         if (Point._count == undefined)
  59.             Point._count = 0;
  60.         return Point._count;
  61.     }
  62.     static set count(value) {
  63.         if (Point._count == undefined)
  64.             Point._count = 0;
  65.         Point._count = value;
  66.     }
  67.     static get Version() {
  68.         return '2D';
  69.     }
  70.     toString() {
  71.         return '(' + this.x + ', ' + this.y + ')';
  72.     }
  73.     distanceTo(p) {
  74.         ParameterTypeError.check(p, 'p', Point);
  75.         return Math.sqrt(
  76.             Math.pow(this.x - p.x, 2) +
  77.             Math.pow(this.y - p.y, 2));
  78.     }
  79.     static distanceBetween(p1, p2) {
  80.         ParameterTypeError.check(p1, 'p1', Point);
  81.         ParameterTypeError.check(p2, 'p2', Point);
  82.         return Math.sqrt(
  83.             Math.pow(p1.x - p2.x, 2) +
  84.             Math.pow(p1.y - p2.y, 2));
  85.     }
  86. }
  87. class NamedPoint extends Point {
  88.     constructor(name, x, y) {
  89.         ParameterTypeError.check(name, 'name', String);
  90.         super(x, y);
  91.         this._name = name;
  92.     }
  93.     get name() {
  94.         return this._name;
  95.     }
  96.     toString() {
  97.         return this._name + super.toString();
  98.     }
  99. }
  100. function classTest() {
  101.     let p = new Point(3, 4);
  102.     Console.log('p = ' + p);
  103.     let np = new NamedPoint("ShotTarget", 6, 8);
  104.     Console.log('np = ' + np);
  105.     //为只读属性赋值是无效的，但也不报错
  106.     np.name = "WTF";
  107.     Console.log('np = ' + np);
  108.     Console.log('np.name = ' + np.name);
  109.     Console.log('p.distanceTo(np) = ' + p.distanceTo(np));
  110.     Console.log('instance count : ' + Point.count);
  111.     //静态方法，会被子类继承
  112.     Console.log(NamedPoint.distanceBetween(np, p));
  113.     //实例方法，会被子类继承
  114.     Console.log(np.distanceTo(p));
  115.     //静态属性
  116.     Console.log('static property Version : ' + Point.Version);
  117.     //静态属性，会被子类继承
  118.     Console.log(NamedPoint.count);
  119.     //自定义异常
  120.     try {
  121.         p.distanceTo(33);
  122.     } catch(e) {
  123.         Console.log(e.message);
  124.         Console.log(e);
  125.     }
  126. }

其输出如下：

  1. p = (3, 4)
  2. np = ShotTarget(6, 8)
  3. np = ShotTarget(6, 8)
  4. np.name = ShotTarget
  5. p.distanceTo(np) = 5
  6. instance count : 2
  7. 5
  8. 5
  9. static property Version : 2D
  10. 2
  11. Parameter "p" must be a Point object.
  12. ParameterTypeError : Parameter "p" must be a Point object.

2.Proxy

  1. //居中填充
  2. String.prototype.padCenter = 
  3.   function(targetLength, padString = ' ') {
  5.   if (typeof targetLength != 'number')
  6.     throw new TypeError('Parameter "targetLength" ' +
  7.                         'must be a number object.');
  9.   if (typeof padString != 'string') {
  10.     if (padString === null)
  11.       padString = 'null';
  12.     else
  13.       padString = padString.toString();
  14.   }
  16.   let padStrWidth = padString.length;    
  17.   if (padStrWidth == 0) return this;
  19.   let restWidth = targetLength - this.length;
  20.   if (restWidth <= 0) return this;
  22.   let leftWidth = Math.trunc(restWidth / 2);
  23.   let rightWidth = leftWidth + restWidth % 2;
  25.   if (padString.length == 1) {
  26.     return padString.repeat(leftWidth) + this + 
  27.       padString.repeat(rightWidth);
  28.   } else {
  29.     if (leftWidth == 0)
  30.       return this + padString[0];
  31.     else {
  33.       //leftPart
  34.       let leftRepeat = Math.trunc(leftWidth / padStrWidth);    
  35.       let leftRest = leftWidth - leftRepeat * padStrWidth;    
  36.       let leftStr = padString.repeat(leftRepeat) +
  37.           padString.substr(0, leftRest);
  38.       //rightPart
  39.       let rightRepeat = Math.trunc(rightWidth / padStrWidth);
  40.       let rightRest = rightWidth - rightRepeat * padStrWidth;
  41.       let rightStr = padString.repeat(rightRepeat) +
  42.           padString.substr(0, rightRest);
  44.       return leftStr + this + rightStr;
  45.     }
  46.   }
  47. }
  49. /*Proxy handler 可对应于
  50.   Reflect.apply()
  51.   Reflect.construct()
  52.   Reflect.defineProperty()
  53.   Reflect.deleteProperty()
  54.   Reflect.get()
  55.   Reflect.getOwnPropertyDescriptor()
  56.   Reflect.getPrototypeOf()
  57.   Reflect.has()
  58.   Reflect.isExtensible()
  59.   Reflect.ownKeys()
  60.   Reflect.preventExtensions()
  61.   Reflect.set()
  62.   Reflect.setPrototypeOf()
  63.   实现想要的代理
  64. */
  65. class ES6ProxyTest {
  66.     //既然 Reflect.set(target, key, value[, receiver]) 有
  67.     //要设置的属性的键和值，我们就可以通过 set 代理，在一个
  68.     //对象的定义的外部：
  69.     //1.通过键，拦截对某些属性的写入
  70.     //2.通过值，检验类型，拦截非法写入
  71.     //3.通过键，重定向属性的写入，就像为属性设置一些假名一样
  72.     static SetProxy() {
  73.         let p = new Point(3, 8);
  74.         let pp = new Proxy(p, {
  75.             set:function(target, key, value, receiver){
  76.                 //Reflect.set(target, key, value[, receiver])
  77.                 //target : 用于接收属性（被代理的对象）的对象
  78.                 //key : 要写入的属性的键（字符串或Symbol类型）
  79.                 //value : 要写入的属性新值
  80.                 //receiver : 如果 target 对象的 key 属性有 setter，
  81.                 //         receiver 则为 setter 调用时的 this 值。
  82.                 //return : 返回一个 Boolean 值，表明操作的成败
  83.                 let success = Reflect.set(target, key, value, receiver);
  84.                 if (success) {
  85.                     //Console 在此不可用
  86.                     Debug.Print('property '+ key +' on '+ 
  87.                         target + ' set to '+ value);
  88.                 }
  89.                 //必须返回操作成败状态，否则报错
  90.                 return success;
  91.             }
  92.         });
  93.         pp.xxx = 13;
  94.         Console.log(p.xxx);
  95.     }
  97.     //既然 Reflect.get(target, key[, receiver]) 提供了要读取
  98.     //的属性的键，我们就可以通过 get 代理，在对象的定义的外部：
  99.     //1.通过键，拦截对某些属性的读取
  100.     //2.通过键，伪造一些不存在的属性
  101.     //3.通过键，实现类同假名的属性
  102.     static GetProxy() {
  103.         var obj = new Proxy({}, {
  104.           get: function (target, key, receiver) {
  105.               //Console 在此不可用
  106.             Debug.Print(`getting ${key}!`);
  107.             //Reflect.get(target, key[, receiver])
  108.             //target : 被代理的对象
  109.             //key : 要读取的属性的键（字符串或Symbol类型）
  110.             //receiver : 如果 target 对象的 key 属性有 getter， 
  111.             //           receiver 则为 getter 调用时的 this 值。
  112.             //return : 属性的值。
  113.             return Reflect.get(target, key, receiver);
  114.           }
  115.         });
  116.         obj.count = 1;
  117.         ++obj.count;
  118.     }
  120.     /*Reflect.apply(target, thisArg, argsList)
  121.       target : 被代理对象，请确保它是一个 Function 对象
  122.       thisArg : 函数调用时绑定的对象
  123.       argsList : 函数调用时传入的实参列表，该参数应该是一个类数组的对象。
  124.       return : 调用函数返回的结果
  125.       通过这种代理：
  126.       1.检验调用时传入的参数
  127.       2.阻止函数被调用
  128.     */
  129.     static ApplyProxy() {
  130.         function sum (...values){
  131.             return values.reduce((pre, cur) => pre + cur, 0);
  132.         }
  134.         let sumProxy = new Proxy(sum, {
  135.             apply : function(target, thisArg, argsList){
  136.                 argsList.forEach(arg => {
  137.                     if(typeof arg !== "number")
  138.                         throw new TypeError("所有参数必须是数字，亲！");
  139.                 });
  140.                 return Reflect.apply(target, thisArg, argsList);
  141.             }
  142.         });
  144.         try {
  145.             let r = sumProxy(3, 5, 'hello');
  146.             Console.log(r);
  147.         } catch(e) {
  148.             Console.log(e.message);
  149.         }
  150.         Console.log(sumProxy(3, 8, 5));
  151.     }
  153.     /*Reflect.construct(target, argsList[, newTarget])
  154.       target : 被运行的目标构造函数
  155.       argsList : 类数组，目标构造函数调用时的参数。
  156.       newTarget : 可选，作为新创建对象的原型对象的 constructor 属性，
  157.                     参考 new.target 操作符，默认值为 target。      
  158.     */
  159.     static ConstructProxy() {
  160.         function sum (...values){
  161.             return values.reduce((pre, cur) => pre + cur, 0);
  162.         }
  164.         let sumProxy = new Proxy(sum, {
  165.             construct:function(target, argsList){
  166.                 throw new TypeError("亲，该函数不能通过 new 调用。");
  167.             }
  168.         });
  170.         try {
  171.             let x = new sumProxy(3, 5, 7);
  172.         } catch(e) {
  173.             Console.log(e.message);
  174.         }
  175.     }
  177.     //禁止向指定单元格区域写入数据
  178.     static ForbidSetValue() {
  179.         let rng = new Range('B1:D3');
  180.         rng.Value2 = 32;
  182.         let rngProxy = new Proxy(rng, {
  183.             set : function(target, key, value, receiver) {
  184.                 if (key === 'Value2') {
  185.                     throw new Error('无法设置属性')
  186.                 } else
  187.                     return Reflect.set(target, key, value, receiver);
  188.             }
  189.         });
  191.         try {
  192.             rngProxy.Value2 = 168;
  193.         } catch(e) {
  194.             Console.log(e.message);
  195.         }
  196.         Console.log(rngProxy.Text);
  197.     }
  199.     //运行所有测试用例
  200.     static RunAll() {
  201.         let members = Object.getOwnPropertyNames(ES6ProxyTest);
  202.         let notCall = ['length', 'prototype', 'name', 'RunAll'];
  203.         for (let member of members) {
  204.             if (!notCall.includes(member)) {
  205.                 Console.log(member.padCenter(56, '-'));
  206.                 eval(`ES6ProxyTest.${member}()`);
  207.             }
  208.         }
  209.     }
  210. }

在立即窗口中输入 ES6ProxyTest.RunAll(); ，然后回车，其输出如下：

  1. ------------------------SetProxy------------------------
  2. property xxx on (3, 8) set to 13
  3. 13
  4. ------------------------GetProxy------------------------
  5. getting count!
  6. -----------------------ApplyProxy-----------------------
  7. 所有参数必须是数字，亲！
  8. 16
  9. ---------------------ConstructProxy---------------------
  10. 亲，该函数不能通过 new 调用。
  11. ---------------------ForbidSetValue---------------------
  12. 无法设置属性
  13. 32

二、实测支持到 ES2019

0.示例代码运行环境的设置代码

因为使用了全局表达式，请将【工具】》【选项】》【编译】》【禁止全局作用域表达式】取消勾选

  1. //获取字符串位宽（即字符串占的字符宽度）
  2. String.prototype.byteWidth = function() {
  3.     var length = 0;
  4.     Array.from(this).map(function(char){
  5.         //字符编码大于255，说明是双字节字符
  6.         if (char.charCodeAt(0) > 255) {
  7.             length += 2;
  8.         } else {
  9.             length++;
  10.         }
  11.     });
  13.     return length;
  14. };
  16. {/*Console 对象的增强*/
  17.     //控制台默认分隔线字符
  18.     Console.__proto__.DefaultSepLineSepChar = '-';
  19.     //控制台默认的分隔线宽度
  20.     Console.__proto__.DefaultSepLineWidth = 56;
  22.     //向控制台输出分隔线
  23.     Console.__proto__.PrintSepLine =
  24.         function(byteWidth, sepChar) {
  25.         if (sepChar == undefined)
  26.             sepChar = this.DefaultSepLineSepChar;
  27.         else
  28.             sepChar = sepChar.toString()[0];
  30.         if (byteWidth == undefined)
  31.             byteWidth = this.DefaultSepLineWidth;
  33.         if (typeof byteWidth != 'number' ||
  34.             byteWidth < 0)
  35.             throw new Error('byteWidth 必须是非负数');
  36.         else
  37.             byteWidth = Math.floor(byteWidth);
  39.         let sepLine;
  40.         if (sepChar.byteWidth() == 1)
  41.             sepLine = sepChar.repeat(byteWidth);
  42.         else
  43.             sepLine = sepChar.repeat(byteWidth / 2);
  45.         Console.log(sepLine);
  46.     };
  48.     //向控制台输出分隔线
  49.     Console.__proto__.PrintNamedSepLine =
  50.         function(name, byteWidth, sepChar) {
  51.         if (name == undefined)
  52.             throw new Error('必须提供 name 参数');
  53.         else 
  54.             name = name.toString()
  55.                 .replace('\n', '')
  56.                 .replace('\r', '');
  57.         if (sepChar == undefined)
  58.             sepChar = this.DefaultSepLineSepChar;
  59.         else
  60.             sepChar = sepChar.toString()[0];
  62.         if (byteWidth == undefined)
  63.             byteWidth = this.DefaultSepLineWidth;
  65.         if (typeof byteWidth != 'number' ||
  66.             byteWidth < 0)
  67.             throw new Error('byteWidth 必须是非负数');
  68.         else
  69.             byteWidth = Math.floor(byteWidth);
  71.         let sepLine = name;
  72.         let selfWidth = name.byteWidth();
  73.         if (byteWidth > selfWidth) {
  74.             let restWidth = byteWidth - selfWidth;
  75.             let leftPadWidth = Math.floor(restWidth / 2);
  76.             let rightWidth = Math.floor(restWidth / 2) +
  77.                 restWidth % 2;
  78.             if (sepChar.byteWidth() == 1)
  79.                 sepLine = sepChar.repeat(leftPadWidth) +
  80.                     sepLine + sepChar.repeat(rightWidth);
  81.             else
  82.                 sepLine = sepChar.repeat(leftPadWidth / 2) +
  83.                     sepLine + sepChar.repeat(rightWidth /2);
  84.         }
  86.         Console.log(sepLine);
  87.     };  
  89.     //向控制台一次输出多个值，避免手动拼接字符串
  90.     Console.__proto__.WriteAll = function() {
  91.         if (arguments.length == 0) return;
  92.         let info = Array.prototype.map
  93.             .call(arguments, v => {
  94.                 if (v === null)
  95.                     return 'null';
  96.                 else if(v === undefined)
  97.                     return 'undefined';
  98.                 else
  99.                     return v.toString();
  100.             })
  101.             .join('; ');
  102.         Console.log(info);
  103.     };
  105.     //向控制台作讲述式输出
  106.     Console.__proto__.Tell = function(description, value) {
  107.         if (value === null)
  108.             Console.log(description + ' : null');
  109.         else if (value === undefined)
  110.             Console.log(description + ' : undefined');
  111.         else
  112.             Console.log(description + ' : ' + value.toString());
  113.     };  
  114. }

1.ES2016_ES7 特性测试

  1. function ES2016_ES7() {
  2.     //ES2016 只添加了两个功能：
  3.     let arr = [1, 2, 3];
  4.     //1. Array.prototype.includes()
  5.     if (typeof arr.includes == 'function') {
  6.         Console.Tell('arr.includes(2)', arr.includes(2));
  7.         Console.Tell('arr.includes(31)', arr.includes(31));
  8.     }
  9.     //2. 指数运算符
  10.     Console.Tell('3**3', 3**3);
  11. }

2.ES2017_ES8 特性测试

  1. function ES2017_ES8() {
  2.     let obj = { one : 1, two : 2, three : 3 };
  3.     //1.Object.values() 获取对象的所有属性值
  4.     Console.PrintNamedSepLine('Object.values(obj)');
  5.     if (typeof Object.values == 'function') {
  6.         let values = Object.values(obj);
  7.         Console.log(values instanceof Array);
  8.         Console.log(values.toString());
  9.     }
  11.     //2.Object.entries() 获取对象的属性名-值对
  12.     Console.PrintNamedSepLine('Object.entries(obj)');
  13.     if (typeof Object.entries == 'function') {
  14.         let entries = Object.entries(obj);
  15.         Console.log(entries instanceof Array);
  16.         Console.log(entries[0] instanceof Array);
  17.         Console.log(entries[0][0] + ' : ' + entries[0][1]);
  18.         for (let [k, v] of entries)
  19.             Console.log(k + ' => ' + v);
  20.     }
  22.     //3.Object.getOwnPropertyDescriptors() 获取一个对象的所有自身属性的
  23.     //  描述符。属性描述符（property descriptor）对象：
  24.     //value：就是属性的值，默认 undefined
  25.     //writable：决定属性能否被赋值
  26.     //get：访问器函数（getter），函数或 undefined，在取属性值时被调用
  27.     //set：设置器函数（setter），函数或 undefined，在设置属性值时被调用
  28.     //enumerable：决定 for in 或 Object.keys 能否枚举该属性
  29.     //configurable：决定该属性能否被删除，以及除 value 和 writable 外的
  30.     //              其他特性是否可以被修改
  31.     Console.PrintNamedSepLine('Object.getOwnPropertyDescriptors(obj)');
  32.     if (typeof Object.getOwnPropertyDescriptors == 'function') {
  33.         let x = Object.getOwnPropertyDescriptors(obj);
  34.         Console.Tell('Object.getOwnPropertyDescriptors(obj)', x);
  35.     }
  37.     //4.String.prototype.padStart()/padEnd() 字符串左/右填充
  38.     Console.PrintNamedSepLine('String.padStart/padEnd');
  39.     if (typeof String.prototype.padStart === 'function' &&
  40.         typeof String.prototype.padEnd == 'function') {
  41.         let str = 'hello';
  42.         Console.log(str.padStart(10, '+'));
  43.         Console.log(str.padEnd(10, '-'));               
  44.     }
  46.     //5.结尾逗号，对象定义、数组定义和函数参数列表等等
  47.     Console.PrintNamedSepLine('尾逗号');
  48.     {
  49.         let gift = {
  50.             Name : 'Computer',
  51.             Price : 5000,
  52.             Color : 'black',
  53.         };
  54.         Console.log(JSON.stringify(gift));
  55.         let exGrilFriends = [
  56.             'Lily Morgen',
  57.             'John Smith',
  58.             'Kate William',
  59.         ];
  60.         Console.log(exGrilFriends.toString());
  61.         let func = function(
  62.             firstPartNumber,
  63.             secondPartNumber,
  64.             ) { Console.log(firstPartNumber + '/' + secondPartNumber); }
  65.         func(321, 123);
  66.     }
  68.     //6.ShareArrayBuffer ...
  69. }

3.ES2018_ES9 特性测试

  1. function ES2018_ES9() {
  2.     {//1.剩余参数
  3.         Console.PrintNamedSepLine('剩余参数');
  4.         let func = function(a, b, ...rest) {
  5.             let sum = a + b;
  6.             if (rest.length == 0)
  7.                 return sum;
  8.             else {
  9.                 for (let x of rest) 
  10.                     sum += x;
  11.                 return sum;
  12.             }
  13.         };
  14.         Console.log(func(1, 2));
  15.         Console.log(func(1, 2, 3));
  16.         Console.log(func(1, 2, 3, 4));
  17.     }
  19.     {//2.正则表达式 s 模式，dotAll，即包含换行符
  20.         Console.PrintNamedSepLine('正则表达式 s 模式');
  21.         let isMatch = /hello.es9/.test('hello\nes9');
  22.         Console.log(isMatch);
  23.         isMatch = /hello.es9/s.test('hello\nes9');
  24.         Console.log(isMatch);
  25.     }
  27.     {//3.正则之命名捕获组
  28.         Console.PrintNamedSepLine('正则之命名捕获组');
  29.         let str = "Jim is 12."; 
  30.         let re = /(?<name>\w+) is (?<age>\d+)/;
  31.         let matches = re.exec(str);
  32.         Console.log(matches.toString());
  33.         for (let ppt in matches) 
  34.             Console.log(ppt);
  35.         Console.log(matches.groups);
  36.         for (let ppt in matches.groups)
  37.             Console.log(ppt);
  38.         Console.log('age is ' + matches.groups['age']); 
  39.     }
  41.     {//4.正则表达式之反向断言
  42.         Console.PrintNamedSepLine('正则表达式之反向断言');
  43.         let s = 'he is 12 years old. he has 3 cars.';
  44.         //4.1.右匹配断言 : (?=...)
  45.         Console.log('4.1 => ' + s.match(/\d+(?= cars)/));
  46.         //4.2.右不匹配断言 : (?!...)
  47.         Console.log('4.2 => ' + s.match(/\d+(?! cars)/));
  48.         //4.3.左匹配断言 : (?<=...)
  49.         Console.log('4.3 => ' + s.match(/(?<=has )\d+/));
  50.         //4.2.左不匹配断言 : (?<!...)
  51.         Console.log('4.4 => ' + s.match(/(?<!has )\d+/));
  52.     }   
  55.     {//5.正则表达式 u 模式，即字符集模式，支持\p{字符集名}，
  56.     //  或\P{字符集名}形式匹配...
  57.         Console.PrintNamedSepLine('正则表达式 u 模式')
  58.         let re = /\p{White_Space}+/u;
  59.         let wsStrs = ['\n', '\r', ' ', '\n\r'];
  60.         wsStrs.forEach(x => Console.log(re.test(x)));
  61.     }
  63.     //6.async/await...
  64.     //7.promise.finally...
  65. }

4.ES2019_ES10 特性测试

  1. function ES2019_ES10 () {
  2.     //1.Object.fromEntries() 从对象的属性名值对数组转换回对象，
  3.     //  与 Object.entries() 功能相反；NA
  4.     Console.PrintNamedSepLine('Object.fromEntries');
  5.     if (typeof Object.fromEntries == 'function') {
  6.         let obj = { one : 1, two : 2, three : 3 };
  7.         let entries = Object.entries(obj);
  8.         let objSame = Object.fromEntries(entries);
  9.         Console.log(objSame);
  10.     }
  12.     //2.Array.prototype.flat 将数组打平
  13.     Console.PrintNamedSepLine('Array.prototype.flat([depth])');
  14.     if (typeof Array.prototype.flat === 'function') {
  15.         Console.Tell('[1, [2, 3]].flat()', JSON.stringify(
  16.             [1, [2, 3]].flat()));
  17.         Console.Tell('[1, [2, 3, [1]]].flat()', JSON.stringify(
  18.             [1, [2, 3, [1]]].flat()));
  19.         Console.Tell('[1, [2, 3, [1]]].flat(2)', JSON.stringify(
  20.             [1, [2, 3, [1]]].flat(2)));
  21.     } 
  23.     //3.Array.prototype.flatMap 类同于 Linq-SelectMany
  24.     Console.PrintNamedSepLine('Array.prototype.flatMap');
  25.     if (typeof Array.prototype.flatMap === 'function') {
  26.         Console.Tell('[1, [2, 3]].flatMap(x => x)', JSON
  27.             .stringify([1, [2, 3]].flatMap(x => x)));
  28.         let strs = ['Jobs Steven', 'is', 'great'];
  29.         let elementProcessor = x => x.split(' ');
  30.         Console.log(JSON.stringify(strs) + '.flatMap(' +
  31.             elementProcessor.toString() + ') :\n' +
  32.             JSON.stringify(strs.flatMap(elementProcessor)));
  33.         Console.log('[1, 2, 3].map(x => [x * 2]) :\n' +
  34.             JSON.stringify([1, 2, 3].map(x => [x * 2])));
  35.         Console.log('[1, 2, 3].flatMap(x => [x * 2]) :\n' +
  36.             JSON.stringify([1, 2, 3].flatMap(x => [x * 2])));
  37.     }
  39.     //4.String.prototype.trimStart/trimEnd
  40.     Console.PrintNamedSepLine('String.prototype.trimStart/trimEnd');
  41.     if (typeof String.prototype.trimStart === 'function' &&
  42.         typeof String.prototype.trimEnd === 'function') {
  43.         let s = '   yes  ';
  44.         Console.log(JSON.stringify(s) + '.trimStart() = ' +
  45.             JSON.stringify(s.trimStart()));
  46.         Console.log(JSON.stringify(s) + '.trimEnd() = ' +
  47.             JSON.stringify(s.trimEnd()));
  48.     }
  50.     //5.Symbol.protoype.description
  51.     Console.PrintNamedSepLine('Symbol.protoype.description');
  52.     if (Symbol.iterator.description != undefined) {
  53.         Console.log('Symbol.iterator.description = ' +
  54.             Symbol.iterator.description);
  55.     }
  57.     //6.Array.prototype.sort([compareFunction]) : 增加了一个参数
  58.     //  可以按照指定规则排序，而不是默认的将元素字符串化后排序
  59.     Console.PrintNamedSepLine('Array.prototype.sort([compareFunction])');
  60.     {
  61.         let names = ['Joe Smith', 'Jobs Steven', 'Bill Gates'];
  62.         let compFunc = (a, b) => a.length - b.length;
  63.         Console.log(JSON.stringify(names));
  64.         names.sort(compFunc);
  65.         Console.log(JSON.stringify(names));
  66.     }
  67. }

5.ES2020_ES11 特性测试

  1. function ES2020_ES11() {
  2.     //1.链式判断运算符；NA
  3.     Console.PrintNamedSepLine('链式判断运算符');
  4.     try {   
  5.         let obj = { one : 1, two : 2, three : 3 };
  6.         //直接写下面这句会编译不过，所以在这儿用 eval
  7.         //Console.log(obj?.yes?.toExponential());   
  8.         eval('Console.log(Math?.dk?.good == undefined)');
  9.     } catch { Console.log('Nonsupport'); }
  11.     //2.String.prototype.matchAll
  12.     Console.PrintNamedSepLine('String.prototype.matchAll')
  13.     if (typeof String.prototype.matchAll == 'function') {
  14.         let regex = /t(e)(st(\d?))/g;
  15.         let string = 'test1test2test3';
  16.         let allMatches = [...string.matchAll(regex)];
  17.         Console.log(allMatches.toString());
  18.     }
  20.     //3.Null判断运算符 : 如果左值是 null/undefined，使用右值
  21.     Console.PrintNamedSepLine('Null判断运算符');
  22.     try {
  23.         let x = eval('ksdfksk ?? false');
  24.         Console.log(x);
  25.     } catch { Console.log('Nonsupport'); }
  27.     //4.Bigint : 新增类型
  28.     Console.PrintNamedSepLine('Bigint 类型');
  29.     Console.log('是否支持 Bigint 类型?:' + 
  30.         (typeof Bigint != 'undefined'));
  32.     //5.Promise.*...
  33.     //6.import ...
  34.     //7.export ...
  35. }

6.ES2021_ES12 特性测试

  1. function ES2021_ES12() {
  2.     //1.复合逻辑赋值运算符：??=/&&=/||=
  3.     Console.PrintNamedSepLine('复合逻辑赋值运算符');
  4.     try {
  5.         //以下相当于 let xx = xx ?? 1;
  6.         //即，如果 xx == null/undefined, 赋值为 1
  7.         let x = eval('let xx ??= 1; xx;');
  8.         Console.log(x);
  9.     } catch { Console.log('Nonsupport'); }
  10.     try {
  11.         //以下相当于 let yy = yy && true;
  12.         let y = eval('let yy &&= true; yy;');
  13.         Console.log(y);
  14.     } catch { Console.log('Nonsupport'); }
  15.     try {
  16.         //以下相当于 let zz = zz || true;
  17.         let z = eval('let zz ||= true; zz;');
  18.         Console.log(z);
  19.     } catch { Console.log('Nonsupport'); }
  21.     //2.数字分隔符
  22.     Console.PrintNamedSepLine('数字分隔符');
  23.     try {
  24.         let num = eval('1_5000');
  25.         Console.log(num);
  26.     } catch { Console.log('Nonsupport'); }
  28.     //3.String.prototype.replaceAll
  29.     Console.PrintNamedSepLine('String.prototype.replaceAll');
  30.     if (typeof String.prototype.replaceAll === 'function') {
  31.         Console.log("'hello world'.replaceAll('o', '_') :" +
  32.             'hello world'.replaceAll('o', '_'));
  33.     }
  35.     //4.WeakRefs & FinalizationRegistry对象 ...
  36.     //5.Promise.any & AggregateError ...
  37. }