How operator overloading should be used

This time I will show you how to use operator overloading and what are the precautions for using operator overloading. The following is a practical case, let's take a look.

Recently I have to do data processing, and I have customized some data structures, such as Mat, Vector, Point, etc. I have to repeatedly define the four arithmetic operations such as addition, subtraction, multiplication and division, and the code It doesn't seem very intuitive. It's really annoying that JavaScript doesn't have operator overloading, which is a function like C and C#, so I wanted to "save the country" by automatically implementing operator overloading in the translation code. The implementation idea is actually very simple, just write an interpreter. Compile the code. For example:

S ​​= A B (B - C.fun())/2 D

is translated into

`S = replace(replace(A , ' ', replace(replace(B,'',(replace(B,'-',C.fun())))),'/',2),' ',D)`

In the replace function, we call the corresponding operator function of the object. The replace function code is as follows:

/**
 * 转换方法
 * @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 + '运算符无法识别'
  }
}

The implementation of replacement is very simple. Without too much explanation, the important part is how to compile the code. The implementation of the four arithmetic operations when studying data structure in college is the basis of this translation, with slight differences. Briefly describe the process:

1. Split the expression, extract variables and operators to obtain the metaarray A
2. Traverse the metaarray

If the elements are operators addition, subtraction, multiplication and division, then from Pop the previous element from the stack and convert it to replace(last, operator,
If the element is ')', pop the element from the stack, splice it until it encounters '(', and push it into the stack. You need to pay attention here' ('Whether there is a function call or replace before the element. If it is a function call or replace, you need to continue to pop the data forward and close the replacement function.
If it is a general element, check whether the previous element is replaced. If so , you need to splice ')' to close the replace function, otherwise the element will be pushed directly onto the stack.

3. Combine the stack sequence obtained in step 2 to get the compiled expression.

According to the above process, implement the code:

/**
 * 表达式转换工具方法
 * @param code
 */
export function translate (code) {
  let data = []
  let tmp_code = code.replace(/\s/g,'')
  let tmp = []
  let vari = tmp_code.split(/["]+[^"]*["]+|[']+[^']*[']+|\*\*|\+|-|\*|\/|\(|\)|\?|>[=]|[=]|[=]| {
    result += value
  })
  return result
}

The expression compilation method has been written. The next step is how to make the written code translated by our translator, which means a container is needed. Two methods: one One is to redefine the method attributes in the class constructor, and the other is to pass the code as a parameter into our custom method. Next, let’s introduce the redefined method in the class constructor:

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

As can be seen from the above , we use Object.defineProperty to redefine it in the constructor. translate_block is to divide the entire code block and translate it. The code is as follows:

/**
 * 类代码块转换工具
 * @param name
 * @param block
 * @returns {string}
 */
export function translate_block (name , block) {
  let codes = block.split('\n')
  let reg = new RegExp('^' + name + '$')
  console.log(reg.source)
  codes[0] = codes[0].replace(name,'function')
  for(let i = 1; i <p style="text-align: left;">For new classes, we only need to inherit the OOkay class to Use operator overloading. For code that inherits from non-OOkay classes, we can use injection, as follows: </p><pre class="brush:php;toolbar:false">/**
   * 非继承类的注入方法
   * @param target
   */
  static inject (target) {
    let protos = Object.getOwnPropertyNames(Object.getPrototypeOf(target))
    protos.forEach((proto, key, own) => {
      if (proto != 'constructor') {
        Object.defineProperty(target, proto, {
          value:new Function(translate_block(proto, target[proto].toString())).call(target)
        })
      }
    })
  }

For code in non-classes, we need a container. Here I use two methods, one Use it in an ookay script, like this

The other is to pass the code as a parameter into the __$$__ method, which compiles the code and executes it, as follows:

static __$__(fn) {
    if(!(fn instanceof Function)){
      throw '参数错误'
    }
    (new Function(translate_block('function',fn.toString()))).call(window)()
  }

I believe you have mastered the method after reading the case in this article. Please pay attention for more exciting things. Other related articles on php Chinese website!

Recommended reading:

Vue Nuxt.js makes server-side rendering

Angular Use HMR code parsing

The above is the detailed content of How operator overloading should be used. For more information, please follow other related articles on the PHP Chinese website!