JS 语言的动态性，使我们能够修改对象乃至类型的成员，主要有两种方式：

  1. 对 proto/prototype 进行操作，修改原型对象；
  2. 使用代理 Proxy 对对象进行一次封装，返回包装后的代理对象给用户使用

一、通过修改原型对象

  1. /*增删改 Excel 对象的成员样例*/
  2. class ModifyRangeTypeExample {
  3.     static AddMember() {
  4.         let rng = new Range('B3');
  5.         //1.通过 __proto__ 对象增加成员，是可行的；
  6.         //2.添加方法时，不能建议使用箭头函数，因为在它内部
  7.         //  this is undefined，除非你增加的方法不需要访问
  8.         //  实例本身
  9.         ActiveCell.__proto__.AddressR1C1 = function(){
  10.             return this.Address(false, false, xlR1C1);
  11.         }
  12.         Console.log(rng.AddressR1C1());
  13.         Console.log(rng.Address(false, false, xlR1C1));
  15.         //3.可以添加常字段形式的属性，每个实例访问到的此成
  16.         //  员将是一样的值
  17.         ActiveCell.__proto__.ABCDE = 12345;
  18.         Console.log(rng.ABCDE);
  19.         Console.log(ActiveCell.ABCDE);
  21.         //4.也可以添加带有 getter/setter 的非字段形式的属性
  22.         //4.1.通过 Object.create() 来实现 Data 属性
  23.         ActiveCell.__proto__ = Object.create(
  24.             ActiveCell.__proto__, {
  25.                 Data : {
  26.                     get() {
  27.                         return this.Value();
  28.                     },
  29.                     set(value) {
  30.                         this.Value2 = value;
  31.                     },
  32.                     configurable : true
  33.                 }
  34.             });
  35.         Console.log(rng.Data);
  36.         rng.Data = 'Data Property';
  37.         Console.log(rng.Data);
  39.         //4.2.通过 Object.defineProperty() 来实现 Bold 属性
  40.         Object.defineProperty(ActiveCell.__proto__,
  41.             'Bold', {
  42.                 get() {
  43.                     return this.Font.Bold;
  44.                 },
  45.                 set(value) {
  46.                     this.Font.Bold = value;
  47.                 },
  48.                 configurable : true
  49.             });
  50.         let isBold = rng.Font.Bold;
  51.         Console.log('isBold?:' + isBold);
  52.         rng.Bold = !isBold;
  53.         Console.log('isBold?:' + rng.Bold);
  54.         Console.log('isBold?:' + rng.Font.Bold);
  56.         //4.3.通过 Object.defineProperties 来实现 
  57.         //    Italic/Underline 属性
  58.         Object.defineProperties(ActiveCell.__proto__,
  59.             {
  60.                 Italic : {
  61.                     get() {
  62.                         return this.Font.Italic;
  63.                     },
  64.                     set(value) {
  65.                         this.Font.Italic = value;
  66.                     },
  67.                     configurable : true
  68.                 },
  69.                 Size : {
  70.                     get() {
  71.                         return this.Font.Size;
  72.                     },
  73.                     set(value) {
  74.                         this.Font.Size = value;
  75.                     },
  76.                     configurable : true
  77.                 }
  78.             });
  79.         //Italic Property Test
  80.         let isItalic = rng.Font.Italic;
  81.         Console.log('isItalic?:' + isItalic);
  82.         rng.Italic = !isItalic;
  83.         Console.log('isItalic?:' + rng.Italic);
  84.         Console.log('isItalic?:' + rng.Font.Italic);
  85.         //Size Property Test
  86.         Console.log('font size?:' + rng.Font.Size);
  87.         rng.Size = 9;
  88.         Console.log('new font size?:' + rng.Size);
  89.         Console.log('new font size?:' + rng.Font.Size);
  91.         //5.通过属性描述符来定义属性
  92.         /*描述符(https://segmentfault.com/a/1190000003882976)：
  93.         有数据型描述符和存取型描述符。
  94.         两种类型的描述符都可以有 configurable 和 enumerable 描述符
  95.         configurable : 它是 true 时，表明属性可以被覆写和删除，
  96.                        默认值是 false.
  97.         enumerable : 它是 true 时，属性可以被 for...in 枚举到；默认 false
  98.         数据型描述符，特有的是 value 和 writable 描述符：
  99.         value : 提供属性值
  100.         writable : 它是 true 时，属性值可变；默认值是 false
  101.         存取型描述符(上面 4.1-4.3 都是)，特有的是 get 和 set 描述符
  102.         get : 给属性提供 getter，返回值用作属性值；如果不提供它，则为 undefined
  103.         set : 给属性提供 setter，用来修改属性值，有惟一参数；不提供为 undefined
  104.         */
  105.         Object.defineProperty(ActiveCell.__proto__,
  106.             'Smile', { 
  107.             value : '^_^',
  108.             writable : false,
  109.             enumerable : true,
  110.             configurable : true
  111.         });
  112.         Console.log(rng.Smile);
  113.         try {
  114.             //这句会报错
  115.             rng.Smile = '-_-';
  116.         } catch { }
  117.         Console.log(rng.Smile);
  118.     }
  120.     static ReplaceMember() {
  121.         //1.JS 是基于原型链的，你可以通过 __proto__ 或者
  122.         //  prototype 访问原型，它也是个对象
  123.         //2.你可以为原型对象，添加成员来为属于它的所有实例
  124.         //  添加更多属性与操作（方法）
  125.         //3.对象被构造时固有的成员，你可以通过 
  126.         //  Object.getOwnPropertyNames() 方法来取得，且它
  127.         //  不包含通过 __proto__ 或 prototype 定义在原型上
  128.         //  的成员
  129.         //4.因为实例的固有成员的优先级，要高于附加在
  130.         //  __proto__ 或 prototype 上的同名成员，所以虽然你可
  131.         //  以为原型对象加上同名的成员，但实例对象是无法直接访
  132.         //  问到它们的，所以想覆写固有成员，是做不到的
  133.         //4.1.在 __proto__ 上创建同名方法，以图覆写它：
  134.         ActiveCell.__proto__.Delete = function() {
  135.             Console.log('Deleting range ' + this.Address());
  136.         }    
  137.         let rng = new Range('B2:C3');
  138.         for (let i = 1; i <= rng.Cells.Count; i++)
  139.             rng.Cells.Item(i).Value2 = 
  140.                 rng.Cells.Item(i).Address();
  141.         let sht = rng.Worksheet;
  142.         //由以下两个输出，你会了解到实例直接访问到
  143.         //的还是被构造时固有的 Delete() 方法
  144.         Console.log(sht.Range('B2').Value2);
  145.         rng.Cells.Item(1).Delete();
  146.         Console.log(sht.Range('B2').Value2);
  148.         //但是你仍可以通过如下方式，访问到同名方法
  149.         rng.__proto__.Delete.call(rng);
  151.         //4.2.在 __proto__ 上创建同名属性，以图覆写它：
  152.         Object.defineProperty(ActiveCell.__proto__, 'Text', {
  153.             get() {
  154.                 return this.Address() + " : " + this.Value2.toString();
  155.             },
  156.             set(value) {
  157.                 this.Value2 = value;
  158.             },
  159.             configurable : true,
  160.             enumerale : true
  161.         });
  162.         let cell = sht.Range('B2');
  163.         Console.log(cell.Text);
  164.         try {
  165.             //这句会报错，因为固有的 Text 属性是只读的
  166.             cell.Text = 321;
  167.         } catch { }
  168.         Console.log(cell.Text);    
  169.         //你总可以通过属性的描述符对象拿到 getter/setter，如果提供了
  170.         let desc = Object.getOwnPropertyDescriptor(
  171.             ActiveCell.__proto__, 'Text');
  172.         let setter = desc.set;
  173.         setter.call(cell/*第一个参数绑定 this*/, 111/*设定新值*/);
  174.         let getter = desc.get;
  175.         Console.log(getter.call(cell/*第一个参数绑定 this*/));
  176.     }
  178.     static DeleteMember() {
  179.         //1.删除原型对象上一个不存在的成员
  180.         let result = 'AreYouOkey' in ActiveCell.__proto__ &&
  181.             delete ActiveCell.__proto__.AreYouOkey;
  182.         Console.log('删除 AreYouOkey 成功?:' + result);
  183.         //2.删除原型上已经存在的成员
  184.         ActiveCell.__proto__.YesItIs = 857;
  185.         result = 'YesItIs' in ActiveCell.__proto__ &&
  186.             delete ActiveCell.__proto__;
  187.         Console.log('删除 YesItIs 成功？:' + result);
  189.         let rng = new Range('B2');
  190.         //3.删除对象上已经存在的属性
  191.         try {
  192.             //会失败，因为 configurable = false
  193.             result = 'Text' in rng &&
  194.                 delete rng.Text;
  195.         } catch { result = false; }
  196.         Console.log('删除 Text 成功？:' + result);
  197.         //4.删除对象上已经存在的方法
  198.         try {
  199.             //会失败，因为 configurable = false
  200.             result = 'Address' in rng &&
  201.                 delete rng.Address;
  202.         } catch { result = false; }
  203.         Console.log('删除 Address() 成功？:' + result);        
  204.         //5.对于对象固有属性，可以通过 
  205.         //  Object.getOwnPropertyDescriptor(obj, pptName) 方法
  206.         //  来查看成员的描述符，由 configurable 描述符来确定它是
  207.         //  否支持 delete 操作
  208.         //5.1.固有属性的描述符
  209.         let textDesc = Object.getOwnPropertyDescriptor(rng, 'Text');
  210.         Console.log(JSON.stringify(textDesc, undefined, 4));
  211.         //5.2.固有方法的描述符
  212.         let addressDesc = Object.getOwnPropertyDescriptor(rng, 'Address');
  213.         Console.log(JSON.stringify(addressDesc, undefined, 4));
  214.     }
  216.     static RunAll() {
  217.         let padCenter = (str) => {
  218.             let restWidth = 56 - str.length;
  219.             let left = Math.floor(restWidth / 2);
  220.             let right = left + restWidth % 2;
  221.             return '-'.repeat(left) + str + '-'.repeat(right);
  222.         }
  223.         Console.log(padCenter(ModifyRangeTypeExample.AddMember.name));
  224.         ModifyRangeTypeExample.AddMember();
  225.         Console.log(padCenter(ModifyRangeTypeExample.ReplaceMember.name));
  226.         ModifyRangeTypeExample.ReplaceMember();
  227.         Console.log(padCenter(ModifyRangeTypeExample.DeleteMember.name));
  228.         ModifyRangeTypeExample.DeleteMember();
  229.         ModifyRangeTypeExample.Clear();
  230.     }
  232.     //清除 RunAll() 调用后，创建的成员
  233.     static Clear() {
  234.         for (let name in ActiveCell.__proto__)
  235.             delete ActiveCell.__proto__[name];
  236.     }
  237. }

在【立即窗口】里面输入 ModifyRangeTypeExample.RunAll(); 然后回车，即可执行以上测试，其输出如下：

  1. -----------------------AddMember------------------------
  2. R[2]C[1]
  3. R[2]C[1]
  4. 12345
  5. 12345
  6. Data Property
  7. isBold?:false
  8. isBold?:true
  9. isBold?:true
  10. isItalic?:false
  11. isItalic?:true
  12. isItalic?:true
  13. font size?:11
  14. new font size?:9
  15. new font size?:9
  16. ^_^
  17. ^_^
  18. ---------------------ReplaceMember----------------------
  19. $B$2
  20. $B$3
  21. Deleting range $B$2:$C$3
  22. $B$3
  23. $B$3
  24. $B$2 : 111
  25. ----------------------DeleteMember----------------------
  26. 删除 AreYouOkey 成功?:false
  27. 删除 YesItIs 成功？:true
  28. 删除 Text 成功？:false
  29. 删除 Address() 成功？:false
  30. {
  31.     "value": "111",
  32.     "writable": false,
  33.     "enumerable": true,
  34.     "configurable": false
  35. }
  36. {
  37.     "writable": false,
  38.     "enumerable": true,
  39.     "configurable": false
  40. }

综上：

  1. 我们总可以通过对象的 proto 访问到对象的原型，并在此原型对象上增添一些成员，这总是没问题的
  2. 因为对象被构造产生的成员的访问优先级，高于原型对象上增添的同名成员，所以实际上并不能覆写已有的成员
  3. 因为内置对象的成员大多数是 configurable == false，即不可改变与删除，所以删除成员就别想了

二、通过代理的方式

  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. }

三、修改原型来汉化对象模型

  1. /*借助原型对象汉化对象成员样例*/
  2. class ChinesizationRangeTypeExample {
  3.     static Do() {        
  4.         ActiveCell.__proto__.取地址 = function() {
  5.             return this.Address(...arguments);
  6.         };
  8.         Object.defineProperty(ActiveCell.__proto__, '值', {
  9.             get() { return this.Value2; },
  10.             set(value) { this.Value2 = value; },
  11.               configurable : true,
  12.               enumerable : true
  13.         });
  15.         ActiveCell.__proto__.取值 = function() {
  16.             return this.Value();
  17.         }        
  18.     }
  20.     static Undo() {
  21.         for (let name in ActiveCell.__proto__)
  22.             delete ActiveCell.__proto__[name];    
  23.     }
  25.     static CallGetterSetterOtherWay() {    
  26.         let rng = new Range('A1:B3, C5:E4');
  27.         rng.值 = 159;
  29.         let cell = rng.Cells.Item(1);
  30.         Console.log(cell.值);
  32.         let desc = Object.getOwnPropertyDescriptor(
  33.             ActiveCell.__proto__, '值');
  35.         let setter = desc.set;
  36.         setter.call(cell/*第一个参数绑定 this*/, 357/*设置新值*/);
  37.         Console.log(cell.值);
  39.         //也可以通过 getter 来读取值
  40.         let getter = desc.get;
  41.         Console.log(getter.call(cell/*绑定this*/));
  42.     }    
  44.     static CallMethodOtherWay() {
  45.         let cell = new Range('A1');
  46.         let address = ActiveCell.__proto__.取地址
  47.             .call(cell/*第一个参数绑定 this*/);
  48.         Console.log(address);
  49.     }
  51.     static WorkonIt() {
  52.         let rng = new Range('B2');
  53.         Console.log(rng.取地址());
  54.         Console.log(rng.取地址(true, true, xlR1C1));
  55.         rng.值 = 32;
  56.         Console.log(rng.值);
  57.         Console.log(rng.取值());            
  58.     }
  60.     static RunAll() {
  61.         //执行汉化
  62.         ChinesizationRangeTypeExample.Do();
  64.         //测试汉化
  65.         ChinesizationRangeTypeExample.WorkonIt();
  67.         //别样调用属性
  68.         ChinesizationRangeTypeExample.CallGetterSetterOtherWay();
  70.         //别样调用方法
  71.         ChinesizationRangeTypeExample.CallMethodOtherWay();
  73.         //撤销汉化
  74.         ChinesizationRangeTypeExample.Undo();
  75.     }
  76. }

其输出如下：

  1. $B$2
  2. R2C2
  3. 32
  4. 32
  5. 357
  6. $A$1