JS: Constantes

Las constantes son espacios de memoria que almacenan valores fijos. Por tanto, los valores de las constantes no se pueden alterar después de ser declaradas. Pueden contener valores numéricos, textuales (string) o lógicos (verdadero o falso) que se pueden leer en cualquier momento.

Al igual que ocurre con las variables, las constantes se pueden explicar con el símil de una caja etiquetada. La caja representa el espacio de memoria, la etiqueta es el identificador o nombre de la constante, mientras que el contenido de la caja es el valor almacenado. En ellas podemos guardar un valor fijo.

El uso de constantes en programación se parece al de las matemáticas, donde una constante representa un valor fijo dentro de una expresión. En JS, una constante garantiza que el identificador permanezca asociado al mismo valor durante toda la ejecución. En ambos casos se comparte la idea de un valor estable. De hecho, el nombre «constante» ya indica la persistencia del valor.

Podemos usar las constantes para una gran cantidad de casos. Por ejemplo, para almacenar valores matemáticos y científicos fijos (el número Pi o la constante de Planck), para almacenar configuraciones de aplicación (una ruta o una URL), para establecer mensajes de texto o para fijar límites y restricciones. En definitiva, se usan cuando se tiene la certeza de que su valor no cambiará nunca.

Declarar constantes

Declarar una constante es el acto de crear un identificador vinculado a un valor, cuya referencia no puede ser modificada más tarde. En JavaScript se usa la palabra const (abreviatura de constante) seguida del nombre que queramos usar. Así, el programa reservará la memoria necesaria. A diferencia de las variables, en las constantes se debe asignar un valor en la misma sentencia.

Sintaxis básica para crear una constante:

const NOMBRE = valor;

Por ejemplo:

const PI = 3.1415927;

En este ejemplo, hemos creado una constante llamada PI que, obviamente, contiene el valor de Pi (π). Este valor nunca va a cambiar.

Si intentamos reasignar un nuevo valor a Pi, el programa devolverá error.

El hecho de que sea necesario inicializar la constante en la misma declaración tiene mucho sentido, pues sabemos que su valor no podrá ser reasignado posteriormente. De hecho, las constantes son elementos de solo lectura. Dicho de otro modo: el identificador (o nombre) de una constante no puede ser reasignado.

Al igual que ocurre con las variables, en JavaScript también se puede declarar múltiples constantes en una misma sentencia, encadenando consecutivamente parejas de nombre y valor, separadas por una coma.

Por ejemplo:

const A = 1, B = 2, C = 3;

Una constante declarada con const solo puede existir una vez con el mismo nombre dentro de un mismo ámbito (scope). Sin embargo, es posible volver a declararla en ámbitos distintos sin que haya conflicto. Esto es así porque, al igual que let, las constantes también tienen ámbito de bloque.

Ámbito (scope) de ‘const’

Las constantes declaradas con const tienen ámbito (scope) de bloque. Esto significa que solo son accesibles dentro de un bloque de JavaScript, generalmente definido por las llaves { y }. Puede ser el cuerpo de una función, un bucle iterativo o simplemente como sentencias de un condicional.

Además, al igual que ocurre con let, el bloque que marca o restringe el ámbito de las constantes es el más cercano. Esto significa que, por ejemplo, si se declara una constante dentro de un condicional que forma parte de un bucle, el bloque que restringe el ámbito de la constante será el del condicional.

for (let ind = 0; ind < 3; ind++) {
  if (ind === 1) {
    const NUM = 144;
    console.log(NUM); // 144
  }
  console.log(NUM); // Error
}

En este ejemplo, se crea un bucle con 3 iteraciones que van de 0 a 2. Cuando el índice equivale a 1, se declara la constante NUM y se imprime su valor. La variable ind es accesible desde cualquier lugar del bucle, mientras que la constante NUM solo es accesible desde dentro del condicional.

A diferencia de lo que ocurría con var, las constantes declaradas con const no se añaden como propiedades del objeto global (window en navegadores o globalThis). Esto evita errores inesperados.

También hay que tener en cuenta que si se declara una constante en la raíz de un archivo que haya sido cargado como un módulo, ya sea mediante import o con <script type="module">, el ámbito se limita al módulo. Dicho de otra manera, el ámbito de las constantes no se comparte con otros archivos.

Nombrar constantes

Para nombrar constantes se aplican las mismas reglas definidas en la mayoría de identificadores. Se permite utilizar letras, números, el símbolo del dólar ($) y el guión bajo (_). No obstante, no pueden iniciar con un número; tampoco pueden contener espacios, guiones medios (-) ni otros símbolos especiales. Además, se debe evitar el uso de cualquier palabra clave reservada.

Sobre el estilo, existe una convención muy extendida que consiste en escribir los nombres de las constantes en mayúsculas. Esto facilita distinguirlas de las variables sin tener que revisar su declaración. Cuando el nombre de la constante está formado por varias palabras, se suelen separar con guiones bajos (_).

Veamos algunos ejemplos:

const RED = '#ff0000';
const MAX = 5000;
const IS_ADMIN = true;
const ROOT_PATH = '/dev/system/';

La inmutabilidad de los valores

En JavaScript, cuando se crea una constante, lo que se hace realmente es crear una referencia inmutable. Esto no significa que su valor sea necesariamente inmutable; esto dependerá del tipo de dato. Los datos primitivos no tienen la misma naturaleza que os objetos y los arrays. Veamos sus diferencias.

Tipos de datos primitivos

Los tipos de datos primitivos son inmutables por naturaleza. En JavaScript hay siete tipos de datos primitivos: los números (enteros y decimales), los números enteros muy grandes (BigInt), las cadenas de texto (string), los valores lógicos o booleanos, la ausencia de valor (null), variable sin valor (undefined) y los valores únicos (symbol). Una vez creados, su valor no puede reasignarse.

const NUM = 10;
const TXT = "Hola";

// No se pueden reasignar
NUM = 20; // Error
TXT = "Chao"; // Error

Objetos y arrays

En cambio, los objetos y los arrays son estructuras mutables. Esto significa que su contenido interno puede modificarse, incluso cuando se han declarado con const. Lo único que permanece fijo es la referencia: el nombre de la constante no puede volver a señalar hacia otro objeto o array, pero sí se pueden modificar las propiedades o los elementos que ya contiene.

Por ejemplo, creamos un objeto literal llamado PERSONA. La constante no puede ser reasignada a otro objeto distinto, pero las propiedades del objeto sí pueden modificarse. Lo hacemos de la siguiente manera:

const PERSONA = {nombre: "ABC", edad: 25};
PERSONA.edad = 50; // Permitido

En este otro ejemplo, creamos un array que contiene una lista con números. Lo que hacemos es añadir un número más a la constante LISTA.

const LISTA = [1, 2, 3, 4];

LISTA.push(5); // Permitido

Por tanto, lo interesante de usar const con un objeto o un array es evitar una nueva asignación de forma accidental. Así se garantiza que la constante se refiere siempre al mismo elemento, lo que da mayor seguridad en el código. Esto también facilita el mantenimiento en proyectos grandes.

El hoisting con ‘const’

Antes de ejecutarse, las constantes se elevan (hoisting) al inicio de su bloque para reservar espacio en memoria, pero no se inicializan hasta que se alcanza su declaración. En cambio, las antiguas variables declaradas con var se elevan y sí se inicializan automáticamente con undefined. Esto permite usar las variables var antes de declararlas, pero es una práctica no recomendada.

Durante este período previo a la declaración, las constantes (const) permanecen en una zona denominada Temporal Dead Zone (TDZ) o «zona temporal muerta», que abarca desde el inicio del bloque hasta la línea de su declaración.

Resumen comparativo: