EcmaScript 6

En ocasiones puede que tengamos un objeto que represente un valor que podría ser de tipo primitivo, es decir, un boolean, string o number (principalmente). Para acceder a este valor podríamos tener un método que llamemos “manualmente” cuando queramos usar el objeto como valor primitivo, pero JavaScript nos proporciona un atajo, y es sobrescribir el método valueOf(). Si tenemos dicho método implementado, cuando sea necesario usar el objeto como si fuera un tipo primitivo, el intérprete pasará a llamarlo de forma transparente para nosotros.

Veamos primero un ejemplo de una posible clase que representara un instante de tiempo con horas, minutos y segundos.

class Time {
  #hours = 0;
  #minutes = 0;
  #seconds = 0;

  constructor(hours, minutes, seconds) {
    this.#hours = hours;
    this.#minutes = minutes;
    this.#seconds = seconds;
  }

  getSeconds() {
    return (
        TimeWithoutValueOf.getSecondsInHours(this.#hours) +
        TimeWithoutValueOf.getSecondsInMinutes(this.#minutes) +
        this.#seconds
    );
  }

  static getSecondsInHours(hours) {
    return hours * 3600;
  }

  static getSecondsInMinutes(minutes) {
    return minutes * 60;
  }
}

const timeWithoutValueOf = new Time(1, 30, 45);

// Muestra por consola: Without valueOf(): [object Object]10
console.log("Without valueOf(): ", timeWithoutValueOf + 10);

// Muestra por consola: With valueOf(): 5455
console.og("getSeconds(): ", timeWithoutValueOf.getSeconds() + 10);

Como podemos observar en el ejemplo anterior, si intentamos operar con el objeto y un valor primitivo, en este caso sumarle 10, el resultado es que ambos elementos se convierten a cadena, siendo el resultado la concatenación del toString() de la clase (como no lo hemos sobrescrito, será "[object Object]"), y "10".

Hagamos una ligera modificación en la clase Time, añadiendo el método famoso:

class Time {
  ...

  valueOf() {
    return this.getSeconds();
  }
}

const timeWithValueOf = new Time(1, 30, 45);

// Muestra por consola: With valueOf(): 5455
console.log("With valueOf(): ", timeWithValueOf + 10);

// Muestra por consola: With valueOf(): 5455
console.og("getSeconds(): ", timeWithValueOf.getSeconds() + 10);

Ahora se puede comprobar, como si se realiza la suma correctamente. Esto es porque el intérprete de JavaScript intenta buscar un método valueOf() en el objeto, de forma que al encontrarse en esta nueva versión, se termina llamando, y puesto que devolvemos un valor primitivo de tipo numérico, se realiza la suma correctamente. En resumen, la implementación del método valueOf(), permite que un objeto actúe como un valor primitivo.

Más artículos de esta serieParte 1. ClasesParte 2. Herencia y Parte 3. Miembros estáticos

Comparte este artículo con quien quieras
Diferencias entre var y let en JavaScript
Receta: Validar valores numéricos en JavaScript

Leave a Comment

Your email address will not be published. Required fields are marked *

El tiempo límite ha expirado. Por favor, recarga el CAPTCHA.