Todo lo que necesitas saber sobre el estándar de JavaScript
ECMAScript es el estándar sobre el cual se basa JavaScript. Es una especificación de lenguaje de programación publicada por ECMA International (European Computer Manufacturers Association).
JavaScript es la implementación más popular de ECMAScript, pero no es la única. Otros lenguajes como ActionScript también implementan el estándar ECMAScript.
ECMAScript define:
Los navegadores implementan el motor JavaScript siguiendo esta especificación para garantizar que el código funcione de la misma manera en todos ellos.
Para utilizar ECMAScript en tus proyectos, simplemente escribe código JavaScript siguiendo las características disponibles en la versión que quieras usar.
Consideraciones importantes:
Para usar ECMAScript en un navegador, simplemente incluye un archivo JavaScript o escribe código dentro de etiquetas <script>:
<!DOCTYPE html>
<html>
<head>
<title>Mi página con ES6</title>
</head>
<body>
<script src="app.js"></script>
</body>
</html>Primera edición del estándar ECMAScript. Estableció las bases del lenguaje.
Pequeñas actualizaciones para alinear el estándar con el estándar ISO/IEC 16262.
Agregó expresiones regulares, manejo de excepciones (try/catch), más métodos para strings y arrays, y otras mejoras.
Nunca se lanzó oficialmente debido a desacuerdos sobre la dirección del lenguaje. Muchas de sus ideas se incorporaron más tarde en ES6.
Agregó "strict mode", métodos de array como forEach, map, filter, JSON nativo, y otras mejoras.
Pequeñas actualizaciones para alinear con la especificación ISO/IEC 16262:2011.
Una gran actualización que agregó clases, módulos, promesas, arrow functions, template strings, let/const, y muchas otras características.
Agregó el operador de exponenciación (**) y Array.prototype.includes.
Agregó async/await, Object.values/Object.entries, relleno de strings y otras características.
Agregó operadores rest/spread para objetos, iteración asíncrona, Promise.finally y otras mejoras.
Agregó Array.flat, Array.flatMap, Object.fromEntries, trimStart/trimEnd y otras características.
Agregó BigInt, operador de coalescencia nula (??), optional chaining (?.), Promise.allSettled y otras características.
Agregó String.replaceAll, operadores lógicos de asignación (&&=, ||=, ??=), Promise.any y otras mejoras.
Agregó campos privados en clases, métodos estáticos y privados, operador "in" para verificar propiedades privadas, at() para arrays/strings, y más.
Agregó métodos toSorted, toReversed, toSpliced, findLast y findLastIndex para arrays, y otras mejoras.
ES6 fue un cambio revolucionario que introdujo muchas características nuevas:
Las versiones posteriores a ES6 han sido más incrementales, agregando características específicas:
El modo estricto ayuda a capturar errores comunes y acciones inseguras:
"use strict";
x = 3.14; // Lanza un error porque x no está declarado
function withStrictMode() {
y = 3.14; // También lanza error
}Nuevos métodos para arrays como forEach, map, filter, reduce, etc.
var numbers = [1, 2, 3, 4, 5];
// forEach
numbers.forEach(function(num) {
console.log(num);
});
// map
var squares = numbers.map(function(num) {
return num * num;
});
// filter
var evens = numbers.filter(function(num) {
return num % 2 === 0;
});Sintaxis más concisa para funciones y manejo léxico de this.
// ES5
var multiply = function(a, b) {
return a * b;
};
// ES6
const multiply = (a, b) => a * b;
// Con this léxico
function Person() {
this.age = 0;
// ES5 necesitaba bind(this) o var self = this
setInterval(() => {
this.age++; // this se refiere al objeto Person
}, 1000);
}Interpolación de strings y strings multilínea.
const name = "Alice";
const age = 28;
// ES5
console.log("Hola " + name + ", tienes " + age + " años.");
// ES6
console.log(`Hola ${name}, tienes ${age} años.`);
// Multilínea
const message = `
Hola ${name},
Gracias por unirte a nuestro servicio.
Tu edad registrada es: ${age}.
Saludos,
El equipo
`;Nuevo operador para cálculos exponenciales.
// ES5
Math.pow(2, 3); // 8
// ES7
2 ** 3; // 8
// También funciona con asignación
let num = 2;
num **= 3; // num ahora es 8Método más legible para verificar si un array contiene un elemento.
const colors = ['red', 'green', 'blue'];
// ES5
if (colors.indexOf('green') !== -1) {
console.log('Tiene verde');
}
// ES7
if (colors.includes('green')) {
console.log('Tiene verde');
}Sintaxis más limpia para trabajar con promesas.
// ES6 con Promesas
function fetchData() {
return fetch('https://api.example.com/data')
.then(response => response.json())
.then(data => console.log(data))
.catch(error => console.error(error));
}
// ES8 con async/await
async function fetchData() {
try {
const response = await fetch('https://api.example.com/data');
const data = await response.json();
console.log(data);
} catch (error) {
console.error(error);
}
}Acceso seguro a propiedades anidadas sin errores si una intermedia es null/undefined.
const user = {
profile: {
name: "Alice",
address: {
city: "Madrid"
}
}
};
// ES5
const city = user && user.profile && user.profile.address && user.profile.address.city;
// ES2020
const city = user?.profile?.address?.city;Operador para valores por defecto que solo considera null/undefined (no otros falsy values).
// ES5
const value = settings.option || 'default';
// Problema: si option es 0 o '', igual usa 'default'
// ES2020
const value = settings.option ?? 'default';
// Solo usa 'default' si option es null o undefinedSintaxis para declarar miembros privados en clases usando #.
class Counter {
#count = 0; // Campo privado
#increment() { // Método privado
this.#count++;
}
get value() {
return this.#count;
}
tick() {
this.#increment();
}
}
const counter = new Counter();
counter.tick();
console.log(counter.value); // 1
console.log(counter.#count); // Error: campo privadoECMAScript es el estándar que impulsa JavaScript, y su evolución ha transformado el lenguaje de una herramienta simple para interactuar con páginas web a un lenguaje de programación completo y robusto.
Desde ES6 (2015), JavaScript ha experimentado una rápida evolución con nuevas características que mejoran la legibilidad, mantenibilidad y capacidad del código. Las versiones recientes siguen añadiendo funcionalidades útiles mientras mantienen la compatibilidad hacia atrás.
Para los desarrolladores, es importante:
El futuro de ECMAScript sigue brillante, con propuestas activas para nuevas características que continuarán mejorando el lenguaje en los próximos años.