Las constantes

Como vimos en el artículo de conceptos básicos de JS, las constantes en JavaScript son como variables, ósea, se les puede asignar un valor de cualquiera de los tipos que se le pueden asignar a una variable, pero NO se pueden reasignar más adelante.

let variable = 5; // <= asigno variable al número 5
variable = 6; // <= esto funciona

const constante = 5; // <= asigno constante al número 5
constante = 6; // <= esto NO funciona

Y esto se usa para valores que tienen que permanecer inmutables a lo largo del código, como una url de una api, pero las constantes de JS tienen un pequeño problema.

¿Cual es este problema?

Si ya has usado JS en algún momento, tal vez ya sepas cuál es ese problema, pero si estas comenzando con la programación es probable que aún no te hayas topado con él.

Este problema es que las constantes ¡¡SI SE PUEDEN REASIGNAR!!, bueno, no exactamente, se puede reasignar lo interno a las constantes. Ejemplo:

const arr = [1, 2, 3];
console.log(arr); // <= [1, 2, 3]
arr.push(6);
console.log(arr); // <= [1, 2, 3, 6]

pude insertar un valor al arreglo a pesar de que el arreglo es una constante y esto es código completamente valido que NO da error, pero si intentara redefinir la constante como algo distinto a un arreglo sí daría error.

const arr = [1, 2, 3];
console.log(arr);
arr = {
  name: "hola",
};
console.log(arr);

Este código SÍ lanza error TypeError: Assignment to constant variable, si lo piensas un poco tiene sentido, ya que hacer un push a un arreglo no es una asignación en sí pero si tomamos un objeto y asignamos un valor distinto a uno de sus atributos sí daría error, ¿no?

NO

const arr = {
  name: "hola",
};
console.log(arr); // <= { name: 'hola' }
arr.name = "no puede ser";
console.log(arr); // <= { name: 'no puede ser' }

Como se ve en el ejemplo anterior, esto es código valido de JS y si hay una asignación, pero ¿Por qué?, pues porque de nuevo no estas asignando un nuevo valor a la variable en sí, sino que estas asignando un nuevo valor a un atributo dentro de la constante.

Y para demostrar que también pasa con arreglos veamos el siguiente ejemplo:

const arr = [1, 2, 3];
console.log(arr); // <= [ 1, 2, 3 ]
arr[0] = 2;
console.log(arr); // <= [ 2, 2, 3 ]

Otra vez, código completa mente valido de JS.

¿Por qué pasa esto?

Esto ocurre debido a cómo funcionan los arreglos y los objetos de JS.

¿Como funcionan?

Simple, cuando asignas una variable como un arreglo u objeto el tipo de la variable es 'object'.

let arr = [];
let obj = { name: "hola" };
console.log(typeof arr); // <= 'object'
console.log(typeof obj); // <= 'object'

Pero la asignación solo hace relación a la parte más exterior de la variable, es decir, SOLO la definición de arreglo u objeto, pero NO los valores internos de la variable, es decir, para JS arr[0] u obj.name son distintos a arr u obj, sino que están relacionados.

Desde un punto de vista más técnico, una variable es una asignación de una dirección de memoria, ósea, una variable es una dirección en RAM como si de una dirección de una calle se tratara y NO hacen referencia al valor en dicha dirección de memoria y cuando asignas un arreglo o un objeto, esa dirección en realidad es un grupo de direcciones reservadas para un arreglo o un objeto y por la naturaleza de los arreglos en JS, estos pueden variar de tamaño, por lo que añadir o eliminar elementos de un arreglo no cuenta como redefinir la variable.

En el caso de los objetos, aunque lo anterior también es verdad, también existe el hecho de que no se tiene control del valor de los atributos dentro del objeto, por lo que estos se pueden modificar.

Ejemplo añadiendo atributos a un objeto:

const obj = { name: "hola" };
console.log(obj); // <= { name: 'hola' }
obj.lastname = "pepe";
console.log(obj); // <= { name: 'hola', lastname: 'pepe' }

Conclusión

Como ya hemos visto, en JS los objetos y los arreglos definidos en una constante, a pesar de ser una constante, los atributos internos de la variable sí se pueden modificar, esto debido a como se definen las variables, los arreglos y los objetos dentro de JS y a que la variable no referencia directamente los valores internos de los 'object', sino que a la dirección en memoria, por lo que hay que tener cuidado a la hora de trabajar con constantes que sean arreglos u objetos o algún otro tipo de dato similar.