這次帶給大家如何使用JS實作運算子重載，如何使用JS實作運算子重載的注意事項有哪些，以下就是實戰案例，一起來看一下。
最近要做資料處理，自訂了一些資料結構，像是Mat,Vector,Point之類的，對於加減乘除之類的四則運算還要重複定義，程式碼顯得不是很直觀，javascript沒有運算子重載這個像C 、C#之類的功能的確令人不爽，於是想“曲線救國”，自動將翻譯代碼實現運算符重載，實現思路其實很簡單，就是編寫一個解釋器，將代碼編譯。例如：
S = A B (B - C.fun())/2 D
#翻譯成
/**
* 转换方法
* @param a
* @param op
* @param b
* @returns {*}
* @private
*/
export function __replace__(a,op,b){
if(typeof(a) != 'object' && typeof(b) != 'object'){
return new Function('a','b','return a' + op + 'b')(a,b)
}
if(!Object.getPrototypeOf(a).isPrototypeOf(b)
&& Object.getPrototypeOf(b).isPrototypeOf(a)){
throw '不同类型的对象不能使用四则运算'
}
let target = null
if (Object.getPrototypeOf(a).isPrototypeOf(b)) {
target = new Function('return ' + b.__proto__.constructor.name)()
}
if (Object.getPrototypeOf(b).isPrototypeOf(a)) {
target = new Function('return ' + a.__proto__.constructor.name)()
}
if (op == '+') {
if (target.__add__ != undefined) {
return target.__add__(a, b)
}else {
throw target.toString() +'\n未定义__add__方法'
}
}else if(op == '-') {
if (target.__plus__ != undefined) {
return target.__plus__(a, b)
}else {
throw target.toString() + '\n未定义__plus__方法'
}
}else if(op == '*') {
if (target.__multiply__ != undefined) {
return target.__multiply__(a, b)
}else {
throw target.toString() + '\n未定义__multiply__方法'
}
} else if (op == '/') {
if (target.__pide__ != undefined) {
return target.__pide__(a, b)
}else {
throw target.toString() + '\n未定义__pide__方法'
}
} else if (op == '%') {
if (target.__mod__ != undefined) {
return target.__mod__(a, b)
}else {
throw target.toString() + '\n未定义__mod__方法'
}
} else if(op == '.*') {
if (target.__dot_multiply__ != undefined) {
return target.__dot_multiply__(a, b)
}else {
throw target.toString() + '\n未定义__dot_multiply__方法'
}
} else if(op == './') {
if (target.__dot_pide__ != undefined) {
return target.__dot_pide__(a, b)
}else {
throw target.toString() + '\n未定义__dot_pide__方法'
}
} else if(op == '**') {
if (target.__power__ != undefined) {
return target.__power__(a, b)
}else {
throw target.toString() + '\n未定义__power__方法'
}
}else {
throw op + '运算符无法识别'
}
}2、遍歷元數組
如果元素是'）',則從堆疊中彈出元素，拼接直到遇到'('，並壓入堆疊。在這裡需要注意'（'元素前是否為函數調用或replace，如果是函數調用或replace，則需要繼續向前彈出數據，閉合replace函數的閉合。
如果是一般元素，則查看前一個元素是否replace ，如果是，則需要拼接')'使得replace函數閉合，否則直接將元素壓入堆疊。 。一個容器，兩種方法：一種就是類別建構器重新定義方法屬性，另一種就是將程式碼作為參數傳入我們自訂的方法。
由上面可以看出，我們使用Object.defineProperty在建構器中重新定義了，translate_block是對整個程式碼區塊分割得到進行翻譯，程式碼如下：
/**
* 表达式转换工具方法
* @param code
*/
export function translate (code) {
let data = []
let tmp_code = code.replace(/\s/g,'')
let tmp = []
let vari = tmp_code.split(/["]+[^"]*["]+|[']+[^']*[']+|\*\*|\+|-|\*|\/|\(|\)|\?|>[=]|<[=]|={2}|:|&{2}|\|{2}|\{|\}|=|%|\.\/|\.\*|,/g)
let ops = tmp_code.match(/["]+[^"]*["]+|[']+[^']*[']+|\*\*|\+|-|\*|\/|\(|\)|\?|>[=]|<[=]|={2}|:|&{2}|\|{2}|\{|\}|=|%|\.\/|\.\*|,/g)
for (let i = 0,len = ops.length; i < len; i++) {
if (vari[i] != '') {
tmp.push(vari[i])
}
if (ops[i] != '') {
tmp.push(ops[i])
}
}
tmp.push(vari[ops.length])
for (let i = 0; i < tmp.length; i++){
let item = tmp[i]
if(/\*\*|\+|-|\*|\/|%|\.\/|\.\*/.test(tmp[i])) {
let top = data.pop()
let trans = '__replace__(' + top + ',\'' + tmp[i] + '\','
data.push(trans)
}else{
if (')' == tmp[i]) {
let trans0 = tmp[i]
let top0 = data.pop()
while (top0 != '(') {
trans0 = top0 + trans0
top0 = data.pop()
}
trans0 = top0 + trans0
let pre = data[data.length - 1]
while(/[_\w]+[\.]?[_\w]+/.test(pre)
&& !/^__replace__\(/.test(pre)
&& pre != undefined) {
pre = data.pop()
trans0 = pre + trans0
pre = data[data.length - 1]
}
pre = data[data.length - 1]
while(pre != undefined
&& /^__replace__\(/.test(pre)){
pre = data.pop()
trans0 = pre + trans0 + ')'
pre = data[data.length - 1]
}
data.push(trans0)
}else {
let pre = data[data.length - 1]
let trans1 = tmp[i]
while(pre != undefined
&& /^__replace__\(/.test(pre)
&& !/\*\*|\+|-|\*|\/|\(|\?|>[=]|<[=]|={2}|:|&{2}|\|{2}|\{|=|\}|%|\.\/|\.\*/.test(item)
&& !/^__replace__\(/.test(item)) {
if(tmp[i + 1] == undefined){
pre = data.pop()
trans1 = pre + trans1 + ')'
break;
}else{
pre = data.pop()
trans1 = pre + trans1 + ')'
pre = data[data.length - 1]
}
}
data.push(trans1)
}
}
}
let result = ''
data.forEach((value, key, own) => {
result += value
})
return result
}還有就是將程式碼作為參數傳入__$$__方法，該方法編譯程式碼並執行，如下：
export default class OOkay {
constructor () {
let protos = Object.getOwnPropertyNames(Object.getPrototypeOf(this))
protos.forEach((proto, key, own) => {
if(proto != 'constructor'){
Object.defineProperty(this, proto, {
value:new Function(translate_block(proto, this[proto].toString())).call(this)
})
}
})
}
}這樣就實現了運算子的重載
相信看了本文案例你已經掌握了方法，更多精彩請關注php中文網其它相關文章！ Vue實作內部元件輪播切換效果
怎麼使用Angular5為元件標籤新增樣式class
以上是如何使用JS實作運算子重載的詳細內容。更多資訊請關注PHP中文網其他相關文章！
