Explorando el setPrototypeOf() en JavaScript

Aprende a usar la función setPrototypeOf() para mejorar la herencia y la reutilización del código en JavaScript

La función setPrototypeOf() es una herramienta poderosa en JavaScript que permite establecer el prototipo de un objeto, lo que puede ser útil para mejorar la herencia y la reutilización del código. Esta función se utiliza a menudo en situaciones donde deseamos cambiar el prototipo de un objeto existente o establecer un nuevo prototipo para un objeto.

Ejemplo 1: Crear una clase personalizada

class MiClase {
    constructor(nombre) {
        this.nombre = nombre;
    }
}

const miInstancia = new MiClase('Ejemplo');
console.log(miInstancia); // Output: MiClase { nombre: 'Ejemplo' }

setPrototypeOf(): Supongamos que queremos agregar un método personalizado a nuestra clase MiClase. Puede hacerlo de la siguiente manera:

const miClasePersonalizada = {
    mostrarNombre() {
        console.log(this.nombre);
    }
};

Object.setPrototypeOf(MiClase.prototype, miClasePersonalizada);

const nuevoInstancia = new MiClase('Nuevo Ejemplo');
nuevoInstancia.mostrarNombre(); // Output: Nuevo Ejemplo

Ahora, todas las instancias de MiClase tendrán acceso al método mostrarNombre().

Ejemplo 2: Extender una clase existente

class Padre {
    constructor(nombre) {
        this.nombre = nombre;
    }
}

const padreInstancia = new Padre('Padre');
console.log(padreInstancia); // Output: Padre { nombre: 'Padre' }

setPrototypeOf(): Supongamos que queremos crear una clase Hijo que extienda de Padre. Puede hacerlo de la siguiente manera:

const hijoPrototype = {
    mostrarNombre() {
        console.log(this.nombre);
    }
};

Object.setPrototypeOf(Hijo, Padre);
Object.setPrototypeOf(Hijo.prototype, hijoPrototype);

class Hijo extends Padre {
    constructor(nombre, apellido) {
        super(nombre);
        this.apellido = apellido;
    }
}

const hijoInstancia = new Hijo('Hijo', 'Apellido');
hijoInstancia.mostrarNombre(); // Output: Hijo

Ahora, Hijo extiende de Padre y tiene acceso a los métodos y propiedades de ambas clases.

Ejemplo 3: Crear un objeto iterable personalizado

class MiIterable {
    constructor(valores) {
        this.valores = valores;
    }
}

const miIterableInstancia = new MiIterable([1, 2, 3]);
console.log(miIterableInstancia); // Output: MiIterable { valores: [1, 2, 3] }

setPrototypeOf(): Supongamos que queremos agregar un método personalizado a MiIterable para que sea iterable. Puede hacerlo de la siguiente manera:

const miIterablePrototype = {
    [Symbol.iterator]() {
        return {
            valores: this.valores,
            index: 0
        };
    }
};

Object.setPrototypeOf(MiIterable.prototype, miIterablePrototype);

for (const valor of miIterableInstancia) {
    console.log(valor); // Output: 1, 2, 3
}

Ahora, MiIterable es un objeto iterable y se puede utilizar en ciclos como for...of.

Ejemplo 4: Composición de funciones

function sumar(a, b) {
    return a + b;
}

function multiplicar(a, b) {
    return a * b;
}

const resultadoSuma = sumar(2, 3);
console.log(resultadoSuma); // Output: 5

const resultadoMultiplicacion = multiplicar(2, 3);
console.log(resultadoMultiplicacion); // Output: 6

setPrototypeOf(): Supongamos que queremos crear una función calcular() que pueda llamar a ambas funciones. Puede hacerlo de la siguiente manera:

const calcularPrototype = {
    sumar(a, b) {
        return a + b;
    },
    multiplicar(a, b) {
        return a * b;
    }
};

Object.setPrototypeOf(calcular, calcularPrototype);

function calcular(funcion, a, b) {
    return funcion(a, b);
}

const resultadoSuma = calcular(calcular.sumar, 2, 3);
console.log(resultadoSuma); // Output: 5

const resultadoMultiplicacion = calcular(calcular.multiplicar, 2, 3);
console.log(resultadoMultiplicacion); // Output: 6

Ahora, la función calcular() tiene acceso a las funciones sumar() y multiplicar().

Conclusión

En resumen, setPrototypeOf() es una herramienta útil en JavaScript que puede ayudarte a mejorar la herencia y la reutilización del código. Al entender y aplicar correctamente esta función, podrás crear aplicaciones más eficientes y escalables. Asegúrate de probar tus cambios y comprender los posibles efectos secundarios antes de implementarla en tus proyectos.