Por qué conviene distinguir entre JavaScript y ECMAScript
Cualquiera que lleve un tiempo programando para la web ha leído las dos palabras en la misma frase: “esto es de ES2022”, “esta función de JavaScript es nueva”, “el motor implementa ECMAScript”. Muchas personas las usan como sinónimos y en una conversación informal casi nunca pasa nada. Sin embargo, cuando toca decidir qué sintaxis usar en un proyecto, configurar un compilador, leer una tabla de compatibilidad o entender por qué una función existe en el navegador pero no en el servidor, saber qué es cada cosa ahorra horas de confusión.
En este tutorial vas a recorrer la relación entre ambos conceptos de forma práctica. Verás qué es una especificación y qué es una implementación, quién decide qué entra en el lenguaje, cómo se numeran las ediciones, qué papel juegan los motores y los entornos de ejecución, y cómo se traduce todo eso en decisiones concretas de tu código. También repasaremos el estado actual del estándar: la edición de 2026 (ES2026, la decimoséptima de ECMA-262) fue aprobada por Ecma en junio de 2026, y algunas de sus funciones ya pueden probarse hoy.
Si estás empezando, te recomiendo complementar esta lectura con el manual completo de JavaScript para principiantes actualizado a 2026. Si ya dominas lo básico y quieres ver sintaxis reciente en acción, te servirán los ejemplos de JavaScript moderno y conceptos clave.
Una especificación frente a un lenguaje que la cumple
La forma más sencilla de entender la diferencia es pensar en un documento y en un producto. ECMAScript es el documento: una especificación técnica que describe, con un nivel de detalle casi matemático, cómo debe comportarse un lenguaje de scripting de propósito general. Define la sintaxis, los tipos de datos, los operadores, las sentencias de control, los objetos incorporados como Array, Map, Promise o Date, y el modelo de ejecución. Ese documento se publica con el identificador ECMA-262.
JavaScript es el producto: el lenguaje que escribes y ejecutas. Cumple la especificación, pero además puede incluir cosas que el documento no describe. Por ejemplo, la especificación no menciona document, window, fetch ni localStorage, porque esas piezas pertenecen al navegador. Tampoco habla de require, process o el sistema de archivos, que son cosas de Node.js y de otros entornos de servidor.
Una analogía útil es la de un manual de ajedrez y las partidas que juegas. El manual fija cómo se mueve cada pieza y qué es un jaque mate. Las partidas son la realidad concreta, con jugadores distintos, relojes, tableros de madera o aplicaciones móviles. Nadie confunde el reglamento con una partida, pero ambos están íntimamente ligados: sin reglas compartidas, dos personas no podrían jugar entre sí.
Otra forma de verlo es con un enchufe. Un estándar de conectores permite que fabricantes diferentes produzcan aparatos que funcionan en cualquier toma compatible. ECMA-262 cumple ese papel para los motores de JavaScript: gracias a él, el mismo programa se ejecuta en distintos navegadores y plataformas sin reescribirlo.
Dicho de manera directa: todo código ECMAScript válido es JavaScript válido, pero no todo el código que funciona en un entorno concreto es ECMAScript puro. Observa el siguiente fragmento, que mezcla ambos mundos.
// Parte del estándar: funciona en cualquier motor conforme
const precios = [12.5, 8, 30];
const total = precios.reduce((acumulado, valor) => acumulado + valor, 0);
// Parte del entorno: depende de dónde se ejecute
console.log(`Total: ${total}`);
document.title = `Pedido de ${total} euros`;
Las dos primeras líneas dependen únicamente del lenguaje. console.log existe en casi todos los entornos pero no está definido en la especificación del lenguaje, y document solo existe en un navegador. Si ejecutas ese archivo en un servidor, la última línea falla con un error de referencia, aunque el código sea perfectamente válido desde el punto de vista del estándar.
De Netscape a ECMA-262: un repaso breve de la historia
JavaScript nació a mediados de los años noventa dentro de Netscape, con la idea de dar interactividad a las páginas del navegador. Su primera versión se escribió en muy pocos días y su nombre fue en buena parte una decisión comercial, aprovechando la popularidad de Java en aquella época, aunque los dos lenguajes no tienen relación técnica.
Cuando otros navegadores empezaron a implementar su propia variante, apareció el riesgo de fragmentación: cada fabricante podía hacer cambios incompatibles y obligar a quienes desarrollaban sitios web a escribir versiones distintas del mismo código. La respuesta fue llevar el lenguaje a un organismo de estandarización, Ecma International. En 1997 se publicó la primera edición de ECMA-262. Como “JavaScript” era una marca registrada, el estándar recibió otro nombre: ECMAScript.
Después de los primeros años hubo una etapa de estancamiento. La tercera edición llegó en 1999 y la cuarta se abandonó por desacuerdos sobre su alcance. La quinta, publicada en 2009, consolidó el modo estricto y añadió métodos de arrays como map, filter y forEach, además de JSON nativo. La sexta edición, en 2015, fue la gran renovación: clases, módulos, funciones flecha, let y const, plantillas de texto, promesas y mucho más.
Aquí aparece una confusión clásica. La sexta edición se conoció como ES6 durante su desarrollo, pero al adoptarse un ciclo de publicación anual se rebautizó con el año: ES2015. Es la misma edición con dos nombres. Desde entonces la convención es usar el año, de modo que ES2016, ES2017 y así sucesivamente designan publicaciones pequeñas y frecuentes en lugar de grandes saltos cada varios años.
Para situarte, esta es una tabla de referencia con hitos reconocibles de cada etapa.
ES3 1999 Expresiones regulares, try/catch
ES5 2009 Modo estricto, JSON, métodos de array
ES2015 2015 Clases, módulos, let/const, promesas, flechas
ES2017 2017 async/await
ES2020 2020 Encadenamiento opcional, BigInt, nullish
ES2022 2022 Campos de clase, await de nivel superior
ES2025 2025 Iterator helpers, métodos de Set, Promise.try
ES2026 2026 Edición 17 de ECMA-262, aprobada en junio de 2026
La tabla es un resumen orientativo: cada edición incluye más cambios de los que caben en una línea, y la especificación oficial es la referencia definitiva.
Quién decide qué entra: el comité TC39
Ecma International es la organización que publica el estándar, pero quien lo escribe y evoluciona es un comité técnico llamado TC39. En él participan personas delegadas de empresas que fabrican navegadores, proveedores de nube, compañías de software, universidades y especialistas invitados. Se reúnen varias veces al año y trabajan de forma abierta, con las propuestas y las actas disponibles públicamente en repositorios de código.
Que haya empresas con motores propios sentadas en la misma mesa tiene una consecuencia práctica muy buena: una función no llega al estándar si nadie está dispuesto a implementarla. Por eso el proceso exige implementaciones experimentales y pruebas antes de cerrar una propuesta.
Cada propuesta avanza por etapas numeradas. Los nombres de las etapas son estables desde hace años, aunque el comité ha añadido una fase intermedia para afinar los detalles finales.
Etapa 0 Idea inicial, aún sin compromiso del comité
Etapa 1 Problema definido, se explora una solución
Etapa 2 Borrador de texto de especificación
Etapa 2.7 Diseño aprobado, a falta de pruebas y validación
Etapa 3 Candidata: implementaciones y feedback
Etapa 4 Terminada: lista para la siguiente edición
Cuando una propuesta alcanza la etapa 4, el comité la considera terminada y se incorpora a la edición anual en preparación. Esa edición se congela a principios de año y la asamblea general de Ecma la aprueba en el mes de junio. Es lo que ocurrió con ES2026: las propuestas que llegaron a la etapa 4 hasta cierto momento quedaron dentro y las posteriores pasaron a la siguiente edición.
Hay un detalle que conviene recordar: que una función esté en etapa 3 no significa que la puedas usar mañana en producción, y que esté en etapa 4 tampoco garantiza que tu navegador o tu versión de Node.js ya la incluya. El estándar y las implementaciones avanzan a velocidades distintas, y por eso hace falta comprobar la compatibilidad antes de adoptar algo nuevo.
Motores, runtimes y entornos anfitriones
Para ejecutar JavaScript hace falta un programa que lea el código y lo convierta en acciones. Ese programa es el motor. Los motores más conocidos son V8, presente en los navegadores basados en Chromium y en Node.js; SpiderMonkey, el de Firefox; y JavaScriptCore, el de Safari. Hay también motores más pequeños pensados para dispositivos con pocos recursos o para incrustarse en otras aplicaciones.
Un motor implementa la especificación: entiende la sintaxis, gestiona la memoria, ejecuta el bucle de eventos y ofrece los objetos incorporados. Pero un motor por sí solo no puede dibujar una página ni abrir un archivo. Para eso necesita un entorno de ejecución, o runtime, que le preste capacidades adicionales mediante objetos anfitriones.
En un navegador, el runtime añade window, document, el DOM, fetch y los temporizadores. En Node.js, añade el módulo de archivos, la red, los procesos y el sistema de módulos. Otros runtimes como Deno o Bun toman un motor y construyen su propio conjunto de APIs encima. El caso más ilustrativo es V8: el mismo motor ejecuta código en Chrome y en el servidor, pero lo que puedes hacer en uno y en otro es muy distinto, porque cambia el runtime.
Un ejemplo práctico para comprobar en qué tipo de entorno estás.
const esNavegador = typeof window !== "undefined" && typeof document !== "undefined";
const esNode = typeof process !== "undefined" && process.versions?.node !== undefined;
if (esNavegador) {
console.log("Entorno: navegador con DOM");
} else if (esNode) {
console.log(`Entorno: Node.js ${process.versions.node}`);
} else {
console.log("Entorno: otro runtime o worker");
}
El operador typeof es seguro con identificadores no declarados, y el encadenamiento opcional evita errores cuando la propiedad no existe. Esa técnica sirve para escribir bibliotecas que funcionan en varios lugares.
Con esto debería quedar clara la separación en capas que se resume a continuación.
Tu código
└─ APIs del entorno (DOM, fetch, fs, timers)
└─ Motor (V8, SpiderMonkey, JavaScriptCore)
└─ Especificación ECMAScript (ECMA-262)
Cuando una funcionalidad falla, preguntarte en qué capa vive te orienta enseguida. Si Array.prototype.at no existe, el problema está en la versión del motor. Si fetch no está definido, es una cuestión del entorno. Si un error de sintaxis aparece en una construcción nueva, probablemente tu herramienta de análisis o tu motor es anterior a esa sintaxis.
Cómo leer los nombres: ES5, ES6, ES2015 y ESNext
Los nombres que circulan por internet generan bastante ruido. Estas son las equivalencias que necesitas para no perderte.
ES5 es la quinta edición, de 2009, y durante años fue el mínimo común que funcionaba en todos los navegadores. ES6 y ES2015 son la misma edición. A partir de ahí cada edición se llama por su año. ESNext no es una edición concreta: es un término genérico para referirse a lo que viene a continuación, incluyendo propuestas que aún no se han cerrado. Cuando una herramienta ofrece un objetivo “esnext”, suele querer decir que compilará con la sintaxis más reciente que conoce.
Existe además la costumbre de hablar de “JavaScript moderno” para referirse al conjunto de funciones que se consideran seguras en el panorama actual, que hoy abarca prácticamente todo lo publicado hasta hace pocos años. En la práctica, si tu público usa navegadores actualizados, puedes escribir código con sintaxis reciente sin transformarlo.
Una consecuencia de este esquema es que el número de edición dice poco por sí solo sobre si puedes usar una función. Lo importante es consultar la compatibilidad de esa función concreta en los motores que te interesan, porque la especificación fija lo que significa, no cuándo llega a cada plataforma.
Compatibilidad, polyfills y transpiladores
Entre que una función se aprueba y que llega a todos los usuarios pasa un tiempo. Para cerrar esa brecha existen dos técnicas con propósitos diferentes.
Un polyfill es código que añade en tiempo de ejecución una API que falta, escrita con las herramientas que el entorno sí tiene. Sirve para funciones nuevas que se pueden simular, como un método de un objeto incorporado. Un transpilador, en cambio, reescribe la sintaxis nueva a otra más antigua antes de ejecutar el código. Sirve para construcciones que el motor viejo ni siquiera sabría leer, como una clase o un operador nuevo, porque no se pueden añadir con una simple biblioteca.
Babel es la herramienta más conocida para transpilar. Si quieres ver cómo se configura con Node.js, tienes una guía detallada para configurar Babel en Node.js y usar JavaScript moderno en 2026. El siguiente ejemplo muestra el efecto de la transformación sobre una función con valores por defecto y encadenamiento opcional.
// Código escrito con sintaxis moderna
const obtenerCiudad = (usuario, respaldo = "Sin dato") =>
usuario?.direccion?.ciudad ?? respaldo;
// Resultado aproximado tras transpilar a un objetivo antiguo
var obtenerCiudad = function obtenerCiudad(usuario) {
var _usuario$direccion, _ref;
var respaldo = arguments.length > 1 && arguments[1] !== undefined
? arguments[1]
: "Sin dato";
return (_ref = usuario === null || usuario === void 0
? void 0
: (_usuario$direccion = usuario.direccion) === null || _usuario$direccion === void 0
? void 0
: _usuario$direccion.ciudad) !== null && _ref !== void 0
? _ref
: respaldo;
};
El segundo bloque es largo y poco legible, y por eso se genera automáticamente. Es una de las razones para no transpilar más de lo necesario: el código resultante pesa más y es más difícil de depurar. Hoy muchos proyectos definen una lista de navegadores soportados y dejan que la herramienta decida qué transformar, de modo que las funciones ya compatibles se queden intactas.
Una forma sensata de decidir qué hacer con una función nueva es seguir este orden de preguntas: si la sintaxis ya la entienden todos los motores que soportas, úsala tal cual; si solo es una API y puedes cargar un polyfill fiable, añádelo; si es sintaxis que no se puede simular, transpila o espera a que el soporte sea general.
Estado actual del estándar: ediciones recientes
El ciclo anual lleva ya más de una década y la cadencia se ha mantenido. Para situarte en el presente, conviene fijarse en las dos ediciones más cercanas.
ES2025 incorporó, entre otras cosas, los ayudantes de iteradores, nuevos métodos para conjuntos como union, intersection y difference, la función Promise.try, la importación de módulos JSON con atributos, RegExp.escape y el tipo Float16Array. Son cambios que hacen el código cotidiano más expresivo y que ya funcionan en motores actuales.
ES2026, la decimoséptima edición de ECMA-262, fue aprobada por la asamblea general de Ecma en junio de 2026. Dado que se trata de una publicación reciente, lo más sensato es comprobar la lista exacta en el repositorio oficial de propuestas terminadas y en el documento de la especificación, porque los resúmenes de terceros no siempre coinciden entre sí. Las funciones que aparecen de forma consistente en esos resúmenes son estas.
Array.fromAsync Crea un array a partir de un iterable asíncrono
Error.isError Comprueba si un valor es realmente un error
Math.sumPrecise Suma números con menos error de redondeo
Uint8Array en base64 y hex Conversión directa desde y hacia texto
Iterator.concat Encadena varios iteradores en uno
JSON.parse con texto fuente El reviver recibe el texto original
Map.getOrInsert (upsert) Obtiene o inserta un valor por defecto
Algunas fuentes mencionan también otras funciones en este grupo, y la diferencia suele deberse a que ciertas propuestas se aprobaron cerca del límite entre dos ediciones. Un ejemplo claro es la API Temporal para fechas y horas, junto con la gestión explícita de recursos con using: ambas alcanzaron la etapa 4, pero están previstas para la edición de 2027. Verifica siempre en la fuente oficial antes de afirmar en un proyecto que una función “es de ES2026”.
Las novedades de ES2026 con ejemplos
Veamos las funciones anteriores en código. Recuerda que el soporte varía: algunas ya están en las últimas versiones de Chrome, Firefox y Safari, y otras tardan más en llegar a Node.js. Prueba cada ejemplo en tu entorno antes de depender de él.
Suma con menos error de redondeo
Los números de coma flotante acumulan imprecisiones al sumar muchos valores decimales. Math.sumPrecise calcula el resultado como si la suma se hiciera con precisión infinita y redondea una sola vez al final.
const lecturas = [0.1, 0.2, 0.3];
const sumaClasica = lecturas.reduce((a, b) => a + b, 0);
const sumaExacta = Math.sumPrecise(lecturas);
console.log(sumaClasica);
console.log(sumaExacta);
0.6000000000000001
0.6
Es útil en estadísticas, métricas y cualquier cálculo donde el error se acumule. Recibe un iterable de números y no sustituye a los tipos decimales exactos para dinero, que siguen requiriendo enteros o bibliotecas especializadas.
Detectar errores de forma fiable
instanceof Error falla cuando el error viene de otro contexto de ejecución, como un iframe o un módulo cargado en otro realm. Error.isError resuelve ese caso sin depender de la cadena de prototipos.
function describirFallo(valor) {
if (Error.isError(valor)) {
return `Error detectado: ${valor.message}`;
}
return "El valor no es un error";
}
console.log(describirFallo(new RangeError("Fuera de rango")));
console.log(describirFallo({ message: "Parece un error" }));
Error detectado: Fuera de rango
El valor no es un error
El segundo caso muestra la ventaja: un objeto con la forma de un error no pasa la prueba, porque la comprobación se basa en la naturaleza interna del valor.
Colecciones asíncronas a un paso
Array.fromAsync hace para los iterables asíncronos lo que Array.from hace para los síncronos: espera a cada elemento y devuelve una promesa con el array completo.
async function* generarPaginas() {
for (let pagina = 1; pagina <= 3; pagina++) {
await new Promise((resolver) => setTimeout(resolver, 50));
yield `pagina-${pagina}`;
}
}
const paginas = await Array.fromAsync(generarPaginas());
console.log(paginas);
[ 'pagina-1', 'pagina-2', 'pagina-3' ]
Antes había que escribir un bucle for await con un array auxiliar. Ahora es una sola expresión, y además acepta una función de transformación como segundo argumento.
Insertar o recuperar en un mapa
El patrón “si no existe, créalo; luego léelo” es tan común que Map incorpora getOrInsert y getOrInsertComputed. El segundo solo ejecuta la función cuando falta la clave, lo que evita trabajo innecesario.
const sesionesPorUsuario = new Map();
function registrarSesion(usuario, idSesion) {
const lista = sesionesPorUsuario.getOrInsertComputed(usuario, () => []);
lista.push(idSesion);
}
registrarSesion("lucia", "a1");
registrarSesion("lucia", "b2");
registrarSesion("mateo", "c3");
console.log(sesionesPorUsuario);
Map(2) { 'lucia' => [ 'a1', 'b2' ], 'mateo' => [ 'c3' ] }
Sin esta función, el código equivalente necesita un has, un set y un get, con tres búsquedas en lugar de una intención clara.
Base64 y hexadecimal en bytes
Convertir datos binarios a texto y de vuelta era un territorio de utilidades improvisadas con btoa y atob, que además solo manejan cadenas. Ahora Uint8Array incorpora métodos propios.
const bytes = new Uint8Array([72, 111, 108, 97]);
console.log(bytes.toBase64());
console.log(bytes.toHex());
const recuperado = Uint8Array.fromBase64("SG9sYQ==");
console.log(recuperado);
SG9sYQ==
486f6c61
Uint8Array(4) [ 72, 111, 108, 97 ]
Es una mejora relevante para criptografía, protocolos binarios y almacenamiento de archivos pequeños, porque elimina la conversión intermedia a cadenas de caracteres.
Concatenar iteradores
Iterator.concat une varias fuentes iterables en un solo iterador perezoso. Combinado con los ayudantes de ES2025, permite procesar datos de varias colecciones sin crear arrays intermedios.
const pedidosNuevos = ["P-10", "P-11"];
const pedidosPendientes = new Set(["P-07", "P-08"]);
const todos = Iterator.concat(pedidosNuevos, pedidosPendientes);
const etiquetas = todos
.map((codigo) => `#${codigo}`)
.toArray();
console.log(etiquetas);
[ '#P-10', '#P-11', '#P-07', '#P-08' ]
Cada elemento se produce solo cuando se pide, así que si solo necesitas los primeros resultados, el resto no se calcula.
Acceder al texto original en JSON.parse
Cuando JSON.parse convierte un número muy grande a Number, pierde precisión. La novedad es que la función reviver recibe un tercer argumento con el texto original, y puedes usarlo para construir un BigInt exacto.
const texto = '{"identificador": 12345678901234567890}';
const datos = JSON.parse(texto, (clave, valor, contexto) => {
if (typeof valor === "number" && contexto?.source) {
return BigInt(contexto.source);
}
return valor;
});
console.log(datos.identificador);
12345678901234567890n
Es una solución elegante para identificadores de sistemas externos que emiten enteros fuera del rango seguro de los números de JavaScript.
Detectar qué función admite tu entorno
Mientras una función nueva no está disponible en todas partes, lo prudente es detectarla antes de usarla. Esta práctica se llama detección de características y es mucho más fiable que comprobar el nombre o la versión del navegador.
const soporte = {
sumaPrecisa: typeof Math.sumPrecise === "function",
esError: typeof Error.isError === "function",
desdeAsync: typeof Array.fromAsync === "function",
mapaUpsert: typeof Map.prototype.getOrInsert === "function",
base64: typeof Uint8Array.fromBase64 === "function",
};
console.table(soporte);
La salida cambia según el motor y su versión, y eso es justo lo que quieres averiguar. Para tomar decisiones sobre qué publicar, combina esta técnica con una tabla de compatibilidad pública y con el análisis de los navegadores que realmente usan tus visitantes.
Un patrón habitual es escribir una pequeña envoltura que use la función nativa cuando existe y recurra a una alternativa cuando no.
function sumarSeguro(numeros) {
if (typeof Math.sumPrecise === "function") {
return Math.sumPrecise(numeros);
}
return numeros.reduce((a, b) => a + b, 0);
}
console.log(sumarSeguro([1.5, 2.25, 3.75]));
7.5
Así el código sigue funcionando en motores más antiguos, aunque con la precisión clásica, y se beneficia de la mejora donde está disponible.
Errores comunes al hablar y al trabajar con ECMAScript
Hay confusiones que se repiten una y otra vez, y conocerlas te evita malentendidos en equipos y entrevistas.
El primer error es creer que JavaScript es una versión de ECMAScript o al revés. Una versión de ECMAScript es una edición del estándar; JavaScript es un lenguaje que lo implementa. El segundo error es dar por hecho que la edición más nueva ya funciona en cualquier sitio. El estándar solo dice qué debe ocurrir; la implementación llega más tarde y de forma desigual.
El tercer error es atribuir a ECMAScript cosas del entorno. Cuando alguien afirma que “JavaScript puede leer archivos”, en realidad se refiere a Node.js u otro runtime, no al lenguaje. El cuarto error es mezclar los nombres de ediciones: hablar de ES7 y de ES2016 como si fueran distintos, o buscar una “ES8” cuando la convención ya usa el año.
Un quinto error, muy frecuente en proyectos de empresa, es transpilar siempre hacia el objetivo más antiguo posible. Eso aumenta el tamaño del paquete, ralentiza la carga y complica la depuración sin aportar beneficio si tu público usa navegadores modernos. El sexto es adoptar propuestas en etapa 2 o 3 en producción mediante plugins experimentales: la sintaxis o la semántica pueden cambiar antes de cerrarse, y tendrás que reescribir código más adelante.
Por último, evita copiar fragmentos de un resumen de terceros sin comprobar la edición real. Como se ha visto con ES2026, las listas pueden diferir. Contrasta con la propuesta original o con el documento de la especificación.
Buenas prácticas para mantenerte al día sin perder el rumbo
Seguir el ritmo del lenguaje no exige leer cada acta del comité. Basta con un hábito sencillo y constante. Revisa una vez al año la lista de propuestas terminadas y fíjate en las que resuelvan un problema que tengas. Prueba las funciones nuevas en un proyecto pequeño antes de llevarlas a un producto.
Define de forma explícita qué navegadores y versiones de Node.js soportas, y guárdalo en la configuración del proyecto. Con esa lista, tus herramientas pueden decidir qué transformar y tu equipo sabe qué puede usar. Añade comprobaciones automáticas en la integración continua, de modo que una función no soportada falle en el análisis estático y no en el navegador de una persona usuaria.
Prefiere la detección de características a la detección de versiones, y documenta las dependencias de funciones recientes en el código con un comentario breve que indique por qué es necesaria la alternativa. Cuando elimines un polyfill porque el soporte ya es general, hazlo en un cambio aislado para poder revertirlo con facilidad.
Y mantén una distinción mental constante: pregúntate si algo es del lenguaje, del motor o del entorno. Con esa pregunta se resuelve la mayoría de las dudas de compatibilidad, y te permite buscar la documentación adecuada, ya sea la especificación, la referencia del navegador o el manual del runtime.
Aplicación práctica: un módulo que se adapta al entorno
Para cerrar el recorrido técnico, juntemos varias ideas en un módulo pequeño. Imagina una utilidad que procesa lotes de eventos y que quieres que funcione tanto en navegadores como en servidor, aprovechando funciones nuevas cuando estén disponibles.
// utilidades-lote.js
const tieneFromAsync = typeof Array.fromAsync === "function";
const tieneConcat = typeof Iterator !== "undefined" && typeof Iterator.concat === "function";
export async function recolectar(fuente) {
if (tieneFromAsync) {
return Array.fromAsync(fuente);
}
const resultado = [];
for await (const elemento of fuente) {
resultado.push(elemento);
}
return resultado;
}
export function unir(...colecciones) {
if (tieneConcat) {
return Iterator.concat(...colecciones).toArray();
}
return colecciones.flatMap((coleccion) => [...coleccion]);
}
export function totalDecimal(valores) {
return typeof Math.sumPrecise === "function"
? Math.sumPrecise(valores)
: valores.reduce((a, b) => a + b, 0);
}
Cada función declara una vía moderna y una de respaldo. El código que llama no necesita saber en qué motor corre, y cuando el soporte sea general bastará con borrar las ramas alternativas. Este patrón es el que mejor encaja con la manera en que ECMAScript evoluciona: despacio, de forma compatible hacia atrás y con transiciones graduales.
Si el módulo se ejecuta en un entorno que no sea el esperado, lo mejor es probarlo con varios motores. Puedes lanzar la misma prueba en Node.js y en un navegador y comparar los resultados. Las diferencias señalan funciones que aún no están disponibles y te indican dónde conviene mantener el respaldo.
Preguntas frecuentes de entrevistas y equipos
Estas son las preguntas que más se repiten cuando se habla de este tema, con respuestas que puedes adaptar.
Quien pregunta “¿cuál es la diferencia entre JavaScript y ECMAScript?” espera oír que uno es la especificación y el otro una implementación con extras del entorno. Si preguntan “¿qué es ES6?”, la respuesta es la edición de 2015, también llamada ES2015. Si preguntan “¿qué es el TC39?”, es el comité técnico que desarrolla el estándar y gestiona el proceso de propuestas por etapas.
Otra pregunta habitual es si V8 es JavaScript. No lo es: es un motor que ejecuta JavaScript. Y la pregunta sobre si Node.js es un lenguaje tiene la misma respuesta: es un entorno de ejecución construido sobre un motor. También puede salir la duda de si el código transpilado es “otra versión” de JavaScript. Es el mismo lenguaje, pero con una sintaxis equivalente de una edición anterior.
Por último, cuando alguien cuestione cómo saber si una función se puede usar, responde con el método: consulta la propuesta y su etapa, comprueba la compatibilidad en los motores objetivo, detecta la característica en tiempo de ejecución y define una alternativa para los entornos antiguos.
Conclusiones
ECMAScript es el estándar que define el lenguaje y JavaScript es su implementación más conocida, enriquecida con las APIs de cada entorno. Esa separación explica por qué el mismo código se comporta igual en distintos motores mientras que los objetos de navegador o de servidor no son intercambiables.
El comité TC39 decide la evolución del estándar mediante un proceso por etapas, y cada año la asamblea de Ecma publica una nueva edición. La de 2026, la decimoséptima, se aprobó en junio de ese año y trae mejoras prácticas como una suma de decimales más precisa, una detección fiable de errores, la conversión de bytes a base64 y el acceso al texto original en el análisis de JSON. Otras funciones muy esperadas, como Temporal, están previstas para ediciones posteriores.
Para trabajar con tranquilidad, apóyate en la detección de características, en una lista clara de entornos soportados y en herramientas que transformen solo lo necesario. Verifica siempre en la fuente oficial qué incluye cada edición, y recuerda que una función aprobada no está disponible en todos los motores a la vez. Con ese criterio, el estándar deja de ser un documento lejano y se convierte en una guía para decidir qué escribir hoy y qué esperar mañana.
