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