El tipo Symbol en JavaScript

Un Symbol es un tipo de dato primitivo en JavaScript que representa un identificador único y persistente.

A diferencia de otros tipos de datos primitivos como number, string o boolean, los símbolos son siempre únicos.

Esto significa que cada vez que creas un nuevo símbolo, obtienes un valor distinto que no se puede duplicar

Creación de un Symbol

Para crear un Symbol, simplemente utilizamos la función constructora Symbol() sin la palabra clave new.

const mySymbol = Symbol();

Descripción de un Symbol

Es posible proporcionar una descripción opcional al crear un Symbol. Esta descripción puede ser útil para identificar el propósito del Symbol.

const nombre = Symbol('Nombre del símbolo');

La descripción de un símbolo no afecta su unicidad, pero puede ser útil para la depuración.

let simbolo = Symbol('mi simbolo');
console.log(simbolo.toString()); // Imprime: Symbol(mi simbolo)

Unicidad de los Symbols

La principal característica de los símbolos su valor es siempre único y diferente del de todos los demás (incluso si dos símbolos tienen la misma descripción).

let simbolo1 = Symbol('descripcion');
let simbolo2 = Symbol('descripcion');

console.log(simbolo1 === simbolo2); // Imprime: false

Usos del Tipo Symbol

Evitar sobreescritura de propiedades

Uno de los usos más comunes de los Symbols es como claves para las propiedades de objetos, para evitar que sean sobreescritas por accidente.

Vamos a verlo con un ejemplo

let objeto = {
  propiedad: 'valor 1'
};

// Más adelante, otra parte del código añade una propiedad con el mismo nombre:
objeto.propiedad = 'valor 2';

console.log(objeto.propiedad);  // Imprime: 'valor 2'

// Creamos un Symbol con una descripción
let simboloPropiedad = Symbol('propiedad');

let objeto = {};

// Usamos el Symbol como clave para la propiedad
objeto[simboloPropiedad] = 'valor 1';

// Más adelante, intentamos añadir otra propiedad con el mismo nombre,
// pero como usamos un Symbol, no hay sobrescritura
let otroSimbolo = Symbol('propiedad');
objeto[otroSimbolo] = 'valor 2';

// Accedemos a las propiedades usando los Symbols
console.log(objeto[simboloPropiedad]);  // Imprime: 'valor 1'
console.log(objeto[otroSimbolo]);       // Imprime: 'valor 2'

Métodos y propiedades simbólicas

JavaScript incluye varios símbolos integrados que se usan como claves para métodos y propiedades especiales. Estos símbolos están definidos en el objeto Symbol.

Símbolos globales con Symbol.for()

Otro uso diferente de los Symbos ocurre con el método Symbol.for(). Este permite crear un símbolo global que es accesible en todo el entorno de ejecución.

Si intentas crear un símbolo con la misma clave, devolverá el mismo símbolo. Es decir, Symbol.for() lleva una especie de “registro global” de símbolos.

const simboloGlobal1 = Symbol.for('miSimbolo');
const simboloGlobal2 = Symbol.for('miSimbolo');

console.log(simboloGlobal1 === simboloGlobal2); // Imprime: true

Ejemplos prácticos

const propiedadPrivada = Symbol('privado');

class MiClase {
    constructor(valor) {
        this[propiedadPrivada] = valor;
    }

    obtenerValor() {
        return this[propiedadPrivada];
    }
}

let instancia = new MiClase(123);

console.log(instancia.obtenerValor()); // Imprime: 123

const NOMBRE = Symbol('nombre');

const persona = {
  [NOMBRE]: 'Juan',
  edad: 30,
};

console.log(persona[NOMBRE]); // Resultado: Juan

const clave1 = Symbol('clave1');
const clave2 = Symbol('clave2');

const miObjeto = {
  [clave1]: 'Valor 1',
  [clave2]: 'Valor 2',
  nombre: 'Objeto',
};

const symbols = Object.getOwnPropertySymbols(miObjeto);
console.log(symbols); // Resultado: [Symbol(clave1), Symbol(clave2)]