# ¿Por qué podemos agregar valores a un arreglo declarado con const en Javascript/TypeScript?

Cuando estamos programando en TypeScript (o JavaScript), a menudo utilizamos la palabra clave `const` para declarar variables que no queremos que cambien. Pero, **¿qué sucede cuando declaramos un arreglo con** `const` **y luego intentamos agregarle más valores?** ¡Sorpresa! Funciona sin problemas y esto a veces nos parece un bug o que no es el comportamiento deseado.

Hoy vamos a explorar por qué sucede esto y cómo podemos usarlo a nuestro favor.

#### **Entendiendo** `const` en TypeScript/Javascript

Primero, recordemos qué hace realmente `const`. Cuando declaramos una variable con `const`, estamos diciendo que esa **variable no puede ser reasignada a un valor diferente**. Por ejemplo:

```typescript
const numero = 10;
numero = 20; // Error: No se puede reasignar una variable constante.
```

En este caso, TypeScript lanza un error porque intentamos **cambiar el valor** de una variable que fue declarada como `const`.

#### **Entonces, ¿qué pasa con los arreglos?**

Aquí es donde las cosas se ponen interesantes. Cuando declaramos un arreglo (o cualquier objeto) con `const`, estamos **haciendo que la referencia a ese arreglo no pueda cambiar**. Pero, y este es un gran "pero", ¡eso no significa que los contenidos del arreglo sean inmutables! y es donde está nuestra respuesta.

Veamos un ejemplo:

```typescript
const miArreglo = [1, 2, 3];
miArreglo.push(4); // Esto funciona sin problemas
console.log(miArreglo); // Salida: [1, 2, 3, 4]
```

Como puedes ver, el uso de `push` para agregar un nuevo valor a `miArreglo` no causa ningún error. Esto es porque `const` asegura que **la referencia al arreglo** (es decir, la ubicación en la memoria donde se almacena ese arreglo) **no puede cambiar**. Sin embargo, los elementos dentro de ese arreglo son completamente modificables.

#### **Mutabilidad de los objetos y arreglos**

En programación, la mutabilidad se refiere a la capacidad de un objeto para ser modificado después de su creación. Los arreglos y objetos en JavaScript y TypeScript son por naturaleza mutables. Esto significa que, aunque no puedas reasignar un nuevo arreglo a una variable `const`, sí puedes cambiar los elementos dentro de ese arreglo.

```typescript
miArreglo[0] = 10; // Esto también funciona
console.log(miArreglo); // Salida: [10, 2, 3, 4]
```

#### **Conclusión: Usando** `const` con inteligencia

Utilizar `const` es una excelente manera de asegurarte de que las referencias a tus objetos y arreglos no cambien accidentalmente en tu código. Pero es importante recordar que `const` no convierte esos objetos en inmutables. Puedes, y a menudo querrás, modificar los elementos dentro de esos arreglos u objetos.

Así que la próxima vez que declares un arreglo con `const`, recuerda: puedes agregar, eliminar y modificar sus elementos tanto como quieras, mientras no intentes reasignar el arreglo en sí.

---

Espero que esta explicación te haya ayudado a entender mejor cómo funciona `const` en TypeScript y por qué es posible agregar valores a un arreglo declarado con `const`.