¿Recuerdan cuando prometí que solo escribiría artículos ligeros y fáciles? Bueno… rompí esa promesa 😅 La semana pasada publiqué un artículo enorme sobre uno de los temas menos sexys que existen: aplicaciones legacy. Y a pesar de eso, al equipo editorial de DEV le gustó tanto que lo incluyeron en el Top 7 Posts de la Semana ❤️

Pero hoy sí toca algo más ligero. Y creo que es un tema que merece más atención.

Vivimos hablando de agentes de IA, y lo entiendo perfectamente porque es un campo fascinante. Pero a veces siento que olvidamos que los lenguajes de programación que usamos a diario también están evolucionando.

Yo paso la mayor parte de mis días escribiendo JavaScript (bueno… TypeScript, obviamente 😄). Y sí, el ecosistema ha madurado muchísimo en los últimos años. Ya no tenemos guerras interminables de React vs Angular. También superamos esa época donde todos amaban Redux un mes y seis meses después decidían que era un monstruo sobreingenierizado y lo removían de cada aplicación 😅.

Pero tanto el ecosistema como el estándar ECMAScript siguen evolucionando.

Después del legendario lanzamiento de ES6 en 2015, que cambió el desarrollo frontend para siempre, el comité TC39 adoptó un enfoque iterativo y comenzó a lanzar nuevas funcionalidades cada año.

Y lo mejor es que si usas navegadores o runtimes modernos, a menudo tienes acceso a estas características casi de inmediato.

Entonces, ¿qué nos trae ECMAScript 2026?

Ah, y para mantener las cosas entretenidas, todos los ejemplos de código están basados en el monólogo interno de gurús imaginarios de LinkedIn con opiniones muy firmes. Cualquier parecido con personas reales es, naturalmente, mera coincidencia 😇

“El estándar ECMAScript 2026 demuestra que JavaScript sigue vivo y evolucionando, con características que los desarrolladores hemos pedido durante años.”

1. Map.prototype.getOrInsert() — el upsert que siempre quisimos

MDN: Map.prototype.getOrInsert

Esta es una de esas funcionalidades que te hacen pensar: “Espera… ¿por qué no teníamos esto hace diez años?”

Imagina que estamos recolectando opiniones de gurús de LinkedIn. Hasta ahora, teníamos que hacer algo así:

const opiniones = new Map();

function agregarOpinion(tema, autor) {
  if (!opiniones.has(tema)) {
    opiniones.set(tema, []);
  }
  opiniones.get(tema).push(autor);
}

agregarOpinion("React ha muerto", "Ingeniero 10x");
agregarOpinion("React ha muerto", "Evangelista Principal de IA");

Funciona, pero tiene bastante boilerplate.

Con ES2026, todo es mucho más limpio:

const opiniones = new Map();

opiniones
  .getOrInsert("React ha muerto", [])
  .push("Ingeniero 10x");

opiniones
  .getOrInsert("React ha muerto", [])
  .push("Evangelista Principal de IA");

También tenemos una versión con cómputo diferido:

opiniones
  .getOrInsertComputed("Nadie escribe código limpio", () => [])
  .push("Purista de DDD");

Es perfecto para caching y para reducir el boilerplate. ¡Mucho más legible!

2. Iterator.concat() — combinando flujos de datos

MDN: Iterator.concat

Un iterador es básicamente un cursor que permite consumir datos elemento por elemento sin almacenar todo en memoria.

El año pasado recibimos Iterator Helpers con map(), filter() y compañía:

function* feedLinkedIn() {
  yield "Usa Rust para todo";
  yield "JavaScript fue un error";
  yield "El código limpio ha muerto";
  yield "Angular ha muerto";
}

const opinionesPolémicas =
  feedLinkedIn()
    .filter(post => post.includes("muerto"))
    .map(post => `🔥 ${post}`);

console.log([...opinionesPolémicas]);

Y ahora llega Iterator.concat(). Supongamos que los gurús del frontend y del backend tienen cada uno su propia fuente de sabiduría:

function* expertosFrontend() {
  yield "React ha muerto";
  yield "Nadie necesita Redux";
}

function* expertosBackend() {
  yield "Microservicios lo solucionan todo";
  yield "Los frontend no entienden de arquitectura";
}

const feed = Iterator.concat(
  expertosFrontend(),
  expertosBackend()
);

console.log([...feed]);

Estas características de iteradores no reciben ni de cerca la atención que merecen.

3. Array.fromAsync() — el equivalente asíncrono de Array.from()

MDN: Array.fromAsync

Diseñado principalmente para iteradores asíncronos. Imagina comentarios llegando uno por uno desde LinkedIn:

async function* comentariosEnojados() {
  yield "Esto pudo ser un formulario HTML simple";
  yield "Angular ha muerto";
  yield "React ha muerto";
  yield "JavaScript fue un error";
}

const comentarios = await Array.fromAsync(
  comentariosEnojados()
);

¿Lo mejor? También funciona con promesas y permite mapear valores al vuelo:

const comentarios = await Array.fromAsync(
  comentariosEnojados(),
  opinion => opinion.toUpperCase()
);

4. Math.sumPrecise() — adiós a los errores de punto flotante

MDN: Math.sumPrecise

Resuelve un problema tan viejo como internet 😄. Como muchos saben, en JavaScript:

console.log(0.1 + 0.2);
// 0.30000000000000004

ES2026 introduce Math.sumPrecise(), que realiza sumas mucho más precisas evitando la acumulación de errores de redondeo:

const boostsProductividad = [
  0.1, // duchas frías
  0.2, // agentes de IA
  0.3, // journaling
  0.4, // despertarse a las 4 AM
];

console.log(Math.sumPrecise(boostsProductividad));

Para la mayoría de desarrolladores frontend no será necesario en el día a día. Pero si trabajas con finanzas, estadísticas, simulaciones o IA/ML, donde pequeños errores se acumulan por miles de operaciones, esto cambia las reglas del juego.

5. Error.isError() — detectando errores entre reinos

MDN: Error.isError

Hasta ahora, verificar si algo era realmente un Error se hacía así:

console.log(e instanceof Error);

Pero si el error se originaba en otro contexto (iframe, Web Worker, VM), instanceof podía fallar:

const cosaRara = window.frames[0].eval(
  "new Error('JavaScript fue un error.')"
);

console.log(cosaRara instanceof Error);
// false 😱

Ahora tenemos una solución nativa:

console.log(Error.isError(cosaRara));
// true ✅

“Error.isError resuelve de una vez por todas un dolor de cabeza que los autores de librerías JavaScript han sufrido durante años.”

6. Base64 nativo para Uint8Array

MDN: Uint8Array.toBase64

Antes, trabajar con binario y Base64 era engorroso:

const bytes = new Uint8Array(buffer);
const base64 = btoa(String.fromCharCode(...bytes));

Ahora es mucho más limpio:

const captura = await fetch("/prueba/react-ha-muerto.png");
const bytes = new Uint8Array(await captura.arrayBuffer());
const base64 = bytes.toBase64();

Mucho más fácil de entender seis meses después.

7. JSON.parse con acceso al texto fuente

MDN: JSON.parse Source Text Access

¿Alguna vez recibiste un JSON con un número gigante que perdía precisión?

const json = `{ "seguidores": 999999999999999999999999999999 }`;
const data = JSON.parse(json);
console.log(data.seguidores); // 😱 precisión perdida

Con ES2026, el callback reviver tiene acceso al texto fuente original:

const data = JSON.parse(json, (key, value, context) => {
  if (key === "seguidores") {
    return BigInt(context.source);
  }
  return value;
});

Bonus: Los grandes ausentes

Dos funcionalidades que esperaba ver en ES2026 pero se quedaron para 2027 (aunque navegadores y runtimes ya las están implementando):

Temporal API — el fin del sufrimiento con fechas

Si llevas suficiente tiempo en frontend, seguro has tenido al menos una experiencia traumática con fechas:

const ahora = Temporal.Now.instant();
const cumpleaños = Temporal.PlainDate.from("1987-07-23");
const reunion = Temporal.ZonedDateTime.from("2026-11-03T10:00:00[America/Lima]");

Temporal introduce tipos propios de fecha y hora que eliminan la ambigüedad de Date() de una vez por todas. Llegó a Stage 4, pero su año de publicación oficial es 2027.

Explicit Resource Management (using)

Una feature que los desarrolladores de C# y Python han disfrutado en silencio mientras el resto fingíamos que try/finally estaba perfectamente bien 😄

using webinar = createWebinarAgentesIA();
webinar.start();
// Al salir del ámbito, se llama automáticamente a webinar.close()

Para desarrolladores Node.js, autores de librerías y personas que trabajan con streams y archivos, esto es increíblemente útil.

Este artículo resultó ser mucho más trabajo del que esperaba originalmente 😅 Se suponía que sería corto y fácil, y terminé excavando entre propuestas de TC39, páginas de MDN, implementaciones de navegadores y tratando de averiguar si Temporal realmente había llegado a ES2026 o no.

Pero espero que haya valido la pena ❤️

¿Cuál funcionalidad te sorprendió más? ¿También estás esperando ansiosamente Temporal para liberarnos de todo el sufrimiento relacionado con fechas?

“ECMAScript 2026 nos recuerda que JavaScript no es solo el lenguaje del momento, sino un ecosistema en evolución constante que sigue mejorando la vida de los desarrolladores.”