toSorted() frente a sort(): cómo ordenar arrays en JavaScript sin mutacionesArtículo · digest del 18 de octubre
Gráfico vectorial editorial minimalista: división de un array de números en dos cintas paralelas que ilustra la ordenación inmutable con toSorted sin mutar los datos originales.
Artículo2 secciones≈ 5 min

toSorted() frente a sort(): cómo ordenar arrays en JavaScript sin mutaciones

Imagina una escena que seguro conoces de sobra: estás programando el filtro de un catálogo en React o Vue. El usuario hace clic en «Más baratos primero», llamas a products.sort(), actualizas el estado... y no pasa nada. En la consola los datos aparecen ordenados, pero la interfaz sigue congelada. O peor aún: de repente se vuelve a renderizar el widget del carrito que ni siquiera debía enterarse de tus cambios.

La raíz del problema es la naturaleza mutadora del clásico Array.prototype.sort(). Modifica el array original directamente en memoria (in-place) y devuelve una referencia al mismo objeto: arr === arr.sort(). Los frameworks declarativos dependen de la comparación superficial de referencias (shallow comparison) en hooks como useMemo y useEffect. Si la referencia no cambia, el framework asume que no hace falta volver a renderizar.

Durante años hemos tirado de apaños como [...arr].sort() o arr.slice().sort(). Pero a partir del estándar ECMAScript 2023 (con la propuesta Change Array by Copy), JavaScript incorporó el método nativo Array.prototype.toSorted(). Hoy ya funciona en todos los navegadores y runtimes modernos (Node.js 20+, Bun, Deno).

Ya vimos hacia dónde iba el lenguaje cuando analizamos los métodos Iterator Helpers en Stage 4 para evaluación perezosa. toSorted() resuelve una pieza vecina del mismo puzle: hacer que trabajar con arrays sea seguro y predecible.

Trampas clásicas: sorpresa alfabética y huecos en el array

Aunque el método viene a salvarnos de las mutaciones, hereda intactas las rarezas históricas de su antecesor:

  1. Ordenación lexicográfica por defecto. Si llamas a [3, 10, 2].toSorted() sin argumentos, JavaScript convierte amablemente los números en cadenas y los ordena por puntos de código Unicode UTF-16: [10, 2, 3]. La función comparadora numérica (a, b) => a - b sigue siendo obligatoria.
  2. Arrays dispersos (Sparse Arrays). Si el array tiene huecos vacíos tras borrar elementos o crearlo con new Array(5), toSorted() materializa esos huecos como valores undefined explícitos y los manda ordenadamente al final del array resultante sin pasar por el comparador.
// Datos numéricos de partida
const scores = [45, 100, 12, 8, 99];

// TRAMPA: ¡ordenar sin comparador trata los números como cadenas!
const lexicographical = scores.toSorted();
console.log(lexicographical); 
// [100, 12, 45, 8, 99] — ¡el 100 queda antes que el 12 y el 8 se va al final!

// CORRECTO: pasamos una función de comparación numérica
const ascending = scores.toSorted((a, b) => a - b);
console.log(ascending); 
// [8, 12, 45, 99, 100]

// El array original scores permanece intacto:
console.log(scores); 
// [45, 100, 12, 8, 99]

// Y esto es lo que hace el viejo sort():
const mutated = scores.sort((a, b) => a - b);
console.log(scores === mutated); 
// true — ¡el array original queda mutado en el sitio!
La trampa de la copia superficial de objetos

toSorted() crea un array nuevo en el nivel superior, pero solo hace una copia superficial (shallow copy). Si los elementos son objetos o estructuras anidadas, el nuevo array guarda referencias a las mismas zonas de memoria. Cambiar sortedList[0].price = 999 modificará al instante ese mismo objeto en el initialList original. Si necesitas aislar el estado por completo, combínalo con structuredClone() o clona los objetos al renderizar.

Uso en componentes React y rendimiento

En código real de interfaz, toSorted() evita asignaciones innecesarias del operador spread. Motores como V8 y SpiderMonkey optimizan esta llamada en C++ nativo: reservan de entrada la memoria exacta del array destino y colocan las referencias ordenadas en una sola pasada:

import React, { useState } from react;

export function ProductCatalog({ initialProducts }) {
  const [products] = useState(initialProducts);
  const [sortOrder, setSortOrder] = useState(asc);

  // Ordenación segura sin riesgo de romper el estado del padre:
  // toSorted() devuelve una referencia nueva a un array distinto
  const sortedProducts = products.toSorted((a, b) => {
    return sortOrder === asc ? a.price - b.price : b.price - a.price;
  });

  return (
    <section className="catalog">
      <div className="toolbar">
        <button onClick={() => setSortOrder(asc)}>Сначала дешёвые</button>
        <button onClick={() => setSortOrder(desc)}>Сначала дорогие</button>
      </div>
      <ul>
        {sortedProducts.map((item) => (
          <li key={item.id}>
            <strong>{item.title}</strong> — {item.price} ₽
          </li>
        ))}
      </ul>
    </section>
  );
}

Junto con sus métodos hermanos toReversed(), toSpliced() y with(), el JavaScript moderno permite por fin escribir código inmutable limpio en el día a día sin tener que arrastrar librerías externas como Lodash o Immer.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 3