Anula el comportamiento predeterminado de los operadores de comparación en JavaScript

Question

Tengo una clase de JavaScript personalizada (creada usando John Resig's Simple Javascript Inheritance). Quiero poder comparar dos instancias de esta clase, usando los símbolos ==, <, >, >= y <=.

¿Cómo anulo los comparadores de mi clase personalizada?

Answer 1

esto no se puede hacer de la manera en que usted está sugiriendo que debería hacerse (aunque eso sería bueno). La mejor manera que he visto este hecho es poner en práctica en el prototipo de un conjunto de métodos para actuar como comparativos:

gte : function(obj){ // greater than or equal 
    // return custom comparison with this as the object comparable on the left 
}, 
gt : function(obj){...}, // greater than but not equal 
eq : function(obj){...}, // equal to 
// etc. 

estaba pensando en este problema somemore hoy en el trabajo y no hay una forma alternativa para aprovechar los operadores de comparación estándar, pero tienen comparaciones de objetos personalizados. El truco sería tener una propiedad (getter) en el objeto que representa el estado comparable. Esto requeriría que todas las instancias del objeto se evalúen con el mismo valor numérico dadas las mismas propiedades comparables. Como ejemplo vamos a hablar vectores:

function Vector(x,y,z){ 
    this.comp = function(){ 
    // assuming these are floats you may wish to create a comparable level of 
    // precision. But this gets the point across. 
    return x + (y * 10) + (z * 100); 
    } 
} 

entonces cuando se configura vectores:

var v1 = new Vector(1,1,1); 
var v2 = new Vector(1,0,1); 
v1.comp() > v2.comp() // true 

esto sólo funciona, por supuesto, si se trata de objetos que pueden dividirse en simples expresión numérica del valor , pero lo positivo es que el código de implementación para obtener el efecto básico es bastante bajo e incluso se puede llegar a hacer que el objeto sea una función que devuelve la expresión numérica de sus componentes.

function Vector(x,y,z){ 
    var v = function v(){ 
    return v.x + (v.y * 10) + (v.z * 100); 
    } 
    v.x = x; 
    v.y = y; 
    v.z = z; 
    return v; 
} 

ahora tiene todos los beneficios del objeto con comparaciones numéricas fáciles y es incluso un poco escueto.

Answer 2

Intenta anular valueOf(). A continuación, puede escribir cosas como esta:

if (obj1.valueOf() === obj2.valueOf()) 
if (obj1.valueOf() < obj2.valueOf()) 
if (obj1.valueOf() > obj2.valueOf()) 

Así que cada vez que necesito un tipo especial de objeto JavaScript para anular la comparación Acabo de añadir valueOf al prototipo. Funciona muy bien para los tipos primitivos, ya que valueOf simplemente devuelve el valor.

Solo ten cuidado con los nulos.

Answer 3

Lee es correcto, si implementa valueOf al comparar objetos (no con === o! ===) esto se usará, pero también deberá usar toString porque se usa al ordenar matrices para algunos razón.

function Test(value){ 
    this.value=value; 
} 
Test.prototype.toString=function(){ 
    console.log("tostring called"); 
    // could do something with case sensitiveness here 
    return new String(this.valueOf()); 
} 
Test.prototype.valueOf=function(){ 
    console.log("valueof called"); 
    return this.value; 
} 

var t1=new Test(11); 
var t2=new Test(1.1); 
var arr=[t1,t2]; 
console.log(arr.sort()); 
console.log(t1>=t2);