WPS JSA 宏编程（JS）：2.对各版本 ES 特性的支持

一、支持大部分 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 class Point { 25     constructor(x, y) { 26         ParameterTypeError.check(x, 'x', Number); 27         ParameterTypeError.check(y, 'y', Number); 28         this.x = x; 29         this.y = y; 30         Point.count++; 31     } 32     static get count() { 33         if (Point._count == undefined) 34             Point._count = 0; 35         return Point._count; 36     } 37     static set count(value) { 38         if (Point._count == undefined) 39             Point._count = 0; 40         Point._count = value; 41     } 42     static get Version() { 43         return '2D'; 44     } 45     toString() { 46         return '(' + this.x + ', ' + this.y + ')'; 47     } 48     distanceTo(p) { 49         ParameterTypeError.check(p, 'p', Point); 50         return Math.sqrt( 51             Math.pow(this.x - p.x, 2) + 52             Math.pow(this.y - p.y, 2)); 53     } 54     static distanceBetween(p1, p2) { 55         ParameterTypeError.check(p1, 'p1', Point); 56         ParameterTypeError.check(p2, 'p2', Point); 57         return Math.sqrt( 58             Math.pow(p1.x - p2.x, 2) + 59             Math.pow(p1.y - p2.y, 2)); 60     } 61 } 62 class NamedPoint extends Point { 63     constructor(name, x, y) { 64         ParameterTypeError.check(name, 'name', String); 65         super(x, y); 66         this._name = name; 67     } 68     get name() { 69         return this._name; 70     } 71     toString() { 72         return this._name + super.toString(); 73     } 74 } 75 function classTest() { 76     let p = new Point(3, 4); 77     Console.log('p = ' + p); 78     let np = new NamedPoint("ShotTarget", 6, 8); 79     Console.log('np = ' + np); 80     //为只读属性赋值是无效的，但也不报错 81     np.name = "WTF"; 82     Console.log('np = ' + np); 83     Console.log('np.name = ' + np.name); 84     Console.log('p.distanceTo(np) = ' + p.distanceTo(np)); 85     Console.log('instance count : ' + Point.count); 86     //静态方法，会被子类继承 87     Console.log(NamedPoint.distanceBetween(np, p)); 88     //实例方法，会被子类继承 89     Console.log(np.distanceTo(p)); 90     //静态属性 91     Console.log('static property Version : ' + Point.Version); 92     //静态属性，会被子类继承 93     Console.log(NamedPoint.count); 94     //自定义异常 95     try { 96         p.distanceTo(33); 97     } catch(e) { 98         Console.log(e.message); 99         Console.log(e);100     }101 }

其输出如下：

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

2.Proxy

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

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

------------------------SetProxy------------------------
property xxx on (3, 8) set to 13
13
------------------------GetProxy------------------------
getting count!
-----------------------ApplyProxy-----------------------
所有参数必须是数字，亲！
16
---------------------ConstructProxy---------------------
亲，该函数不能通过 new 调用。
---------------------ForbidSetValue---------------------
无法设置属性
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     }); 12      13     return length; 14 }; 15  16 {/*Console 对象的增强*/ 17     //控制台默认分隔线字符 18     Console.__proto__.DefaultSepLineSepChar = '-'; 19     //控制台默认的分隔线宽度 20     Console.__proto__.DefaultSepLineWidth = 56; 21      22     //向控制台输出分隔线 23     Console.__proto__.PrintSepLine = 24         function(byteWidth, sepChar) { 25         if (sepChar == undefined) 26             sepChar = this.DefaultSepLineSepChar; 27         else 28             sepChar = sepChar.toString()[0]; 29          30         if (byteWidth == undefined) 31             byteWidth = this.DefaultSepLineWidth; 32              33         if (typeof byteWidth != 'number' || 34             byteWidth < 0) 35             throw new Error('byteWidth 必须是非负数'); 36         else 37             byteWidth = Math.floor(byteWidth); 38          39         let sepLine; 40         if (sepChar.byteWidth() == 1) 41             sepLine = sepChar.repeat(byteWidth); 42         else 43             sepLine = sepChar.repeat(byteWidth / 2); 44              45         Console.log(sepLine); 46     }; 47      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]; 61          62         if (byteWidth == undefined) 63             byteWidth = this.DefaultSepLineWidth; 64              65         if (typeof byteWidth != 'number' || 66             byteWidth < 0) 67             throw new Error('byteWidth 必须是非负数'); 68         else 69             byteWidth = Math.floor(byteWidth); 70          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         } 85              86         Console.log(sepLine); 87     };  
 88      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     };104     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         else112             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     }10     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     }21     22     //3.Object.getOwnPropertyDescriptors() 获取一个对象的所有自身属性的23     //  描述符。属性描述符（property descriptor）对象：24     //value：就是属性的值，默认 undefined25     //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     }36     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     }45     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     }67     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     }18     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     }26     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     }40     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     }   
53     54     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     }62     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     }11     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     } 
22     23     //3.Array.prototype.flatMap 类同于 Linq-SelectMany24     Console.PrintNamedSepLine('Array.prototype.flatMap');25     if (typeof Array.prototype.flatMap === 'function') {26         Console.Tell('[1, [2, 3]].flatMap(x => x)', JSON27             .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     }38     39     //4.String.prototype.trimStart/trimEnd40     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     }49     50     //5.Symbol.protoype.description51     Console.PrintNamedSepLine('Symbol.protoype.description');52     if (Symbol.iterator.description != undefined) {53         Console.log('Symbol.iterator.description = ' +54             Symbol.iterator.description);55     }56     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'); }10     11     //2.String.prototype.matchAll12     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     }19     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'); }26     27     //4.Bigint : 新增类型28     Console.PrintNamedSepLine('Bigint 类型');29     Console.log('是否支持 Bigint 类型?:' + 
30         (typeof Bigint != 'undefined'));31         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'); }20     21     //2.数字分隔符22     Console.PrintNamedSepLine('数字分隔符');23     try {24         let num = eval('1_5000');25         Console.log(num);26     } catch { Console.log('Nonsupport'); }27     28     //3.String.prototype.replaceAll29     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     }34     35     //4.WeakRefs & FinalizationRegistry对象 ...36     //5.Promise.any & AggregateError ...37 }