JS Array Sort

sort ordena los elementos de un array. Por defecto convierte los elementos a texto y los compara como strings.

const numbers = [10, 2, 30, 4];
 
numbers.sort();
 
// [10, 2, 30, 4]

Ese resultado sorprende porque "10" va antes que "2" al comparar texto carácter por carácter.

Mutación

sort modifica el array original.

const numbers = [3, 1, 2];
const sorted = numbers.sort();
 
// numbers: [1, 2, 3]
// sorted: [1, 2, 3]
// numbers === sorted: true

Si necesitas mantener el array original, usa toSorted o copia antes de ordenar.

const numbers = [3, 1, 2];
 
const sorted = numbers.toSorted((a, b) => a - b);
const sortedCopy = [...numbers].sort((a, b) => a - b);

Comparator

La función de comparación recibe dos elementos: a y b.

array.sort((a, b) => {
  return resultado;
});

El valor devuelto decide el orden:

• Menor que 0: a va antes que b.
• Igual a 0: se mantiene el orden relativo entre a y b.
• Mayor que 0: b va antes que a.

Ordenar números

Algoritmo típico para rankings, precios, métricas y resultados numéricos.

const scores = [40, 100, 1, 5, 25, 10];
 
const asc = scores.toSorted((a, b) => a - b);
const desc = scores.toSorted((a, b) => b - a);
 
// asc: [1, 5, 10, 25, 40, 100]
// desc: [100, 40, 25, 10, 5, 1]

La resta funciona porque:

• Si a - b es negativo, a es menor y va antes.
• Si a - b es positivo, b es menor y va antes.
• Si es 0, ambos tienen el mismo valor de orden.

Ordenar objetos por propiedad

Patrón habitual en tablas, listados, dashboards y respuestas de API.

const products = [
  { name: "Monitor", price: 220 },
  { name: "Mouse", price: 35 },
  { name: "Keyboard", price: 80 },
];
 
const byPrice = products.toSorted((a, b) => a.price - b.price);
 
// [
//   { name: "Mouse", price: 35 },
//   { name: "Keyboard", price: 80 },
//   { name: "Monitor", price: 220 }
// ]

Ordenar por fecha

Conviene convertir las fechas a número para compararlas.

const posts = [
  { title: "A", publishedAt: "2026-05-10" },
  { title: "B", publishedAt: "2026-01-22" },
  { title: "C", publishedAt: "2026-06-01" },
];
 
const newestFirst = posts.toSorted((a, b) => {
  return new Date(b.publishedAt).getTime() - new Date(a.publishedAt).getTime();
});
 
// C, A, B

Si el formato es ISO YYYY-MM-DD, también se puede ordenar como string:

const newestFirst = posts.toSorted((a, b) => {
  return b.publishedAt.localeCompare(a.publishedAt);
});

Ordenar strings

Para strings con tildes, mayúsculas o reglas de idioma, usa localeCompare.

const names = ["Óscar", "Ana", "Álvaro", "Zoe"];
 
const sortedNames = names.toSorted((a, b) => {
  return a.localeCompare(b, "es");
});
 
// ["Álvaro", "Ana", "Óscar", "Zoe"]

Ver también: localeCompare

Ordenar por varios criterios

Algoritmo típico para tablas: primero por un campo y, si empatan, por otro.

const users = [
  { name: "Ana", role: "admin", age: 31 },
  { name: "Luis", role: "user", age: 25 },
  { name: "Marta", role: "admin", age: 28 },
  { name: "Carlos", role: "user", age: 25 },
];
 
const byRoleThenAgeThenName = users.toSorted((a, b) => {
  return (
    a.role.localeCompare(b.role, "es") ||
    a.age - b.age ||
    a.name.localeCompare(b.name, "es")
  );
});
 
// admin: Marta, Ana
// user: Carlos, Luis

El operador || funciona bien aquí porque un comparator devuelve 0 cuando hay empate. Si el primer criterio devuelve 0, se evalúa el siguiente.

Prioridad personalizada

Muy usado para estados, severidades y kanban.

const tasks = [
  { title: "Deploy", status: "done" },
  { title: "Fix bug", status: "urgent" },
  { title: "Write docs", status: "todo" },
  { title: "Review PR", status: "in-progress" },
];
 
const statusOrder = {
  urgent: 0,
  "in-progress": 1,
  todo: 2,
  done: 3,
};
 
const sortedTasks = tasks.toSorted((a, b) => {
  return statusOrder[a.status] - statusOrder[b.status];
});
 
// urgent, in-progress, todo, done

Top N

Ordenar y quedarte con los primeros elementos es un patrón simple para rankings pequeños o medianos.

const players = [
  { name: "Ana", points: 120 },
  { name: "Luis", points: 90 },
  { name: "Marta", points: 150 },
  { name: "Carlos", points: 110 },
];
 
const topThree = players
  .toSorted((a, b) => b.points - a.points)
  .slice(0, 3);
 
// Marta, Ana, Carlos

Si el array es enorme y solo necesitas pocos elementos, ordenar todo puede ser más trabajo del necesario. Para la mayoría de interfaces normales, esta versión es suficiente y legible.

Deduplicar y ordenar

Patrón común para filtros, tags y selectores.

const tags = ["React", "CSS", "react", "JavaScript", "css"];
 
const uniqueSortedTags = [...new Set(tags.map((tag) => tag.toLowerCase()))].toSorted(
  (a, b) => a.localeCompare(b, "es"),
);
 
// ["css", "javascript", "react"]

Errores comunes

Usar sort sin comparator para números

[1, 100, 2].sort();
 
// [1, 100, 2]

Para números:

[1, 100, 2].sort((a, b) => a - b);

Devolver booleanos

numbers.sort((a, b) => a > b);

Un comparator debe devolver un número negativo, cero o positivo. Los booleanos pueden producir resultados inconsistentes.

numbers.sort((a, b) => a - b);

Mutar datos compartidos

const sortedUsers = users.sort((a, b) => a.name.localeCompare(b.name, "es"));

Si users viene de props, estado o una caché, estás modificando el array original.

const sortedUsers = users.toSorted((a, b) => {
  return a.name.localeCompare(b.name, "es");
});

Regla práctica

Usa toSorted por defecto cuando estés preparando datos para renderizar o derivando datos de estado. Usa sort cuando quieras ordenar el array original de forma explícita.