Historial de versiones de ECMAScript

La propuesta cuarta edición de ECMA-262 ( ECMAScript 4 o ES4 ) habría sido la primera actualización importante de ECMAScript desde la publicación de la tercera edición en 1999. La especificación (junto con una implementación de referencia) estaba originalmente prevista para completarse en octubre de 2008. ^{[ 16 ]} El primer borrador data de febrero de 1999. ^{[ 17 ]} El grupo de trabajo publicó una descripción general del lenguaje el 23 de octubre de 2007. ^{[ 18 ]}

En agosto de 2008, la propuesta de la cuarta edición de ECMAScript se había reducido a un proyecto con nombre en clave ECMAScript Harmony . Las características que se discutían para Harmony en ese momento incluían: ^{[ 19 ]}

• clases ,
• un sistema modular ,
• anotaciones de tipo opcionales y tipado estático , probablemente utilizando un sistema de tipos estructural ,
• generadores e iteradores ,
• asignación desestructurada y
• tipos de datos algebraicos .

La intención de estas características era, en parte, brindar un mejor soporte a la programación en entornos complejos y permitir sacrificar cierta capacidad dinámica del script para mejorar el rendimiento. Por ejemplo, Tamarin , la máquina virtual para ActionScript, desarrollada y de código abierto por Adobe, ofrece soporte para la compilación justo a tiempo (JIT) para ciertas clases de scripts.

Además de introducir nuevas características, se propuso corregir algunos errores de ES3 en la edición 4. ^{[ 20 ] [ 21 ]} Estas correcciones y otras, así como la compatibilidad con la codificación/decodificación JSON , se han incorporado a la especificación ECMAScript, 5.ª edición. ^{[ 22 ]}

El trabajo en la Edición 4 comenzó después de que se completó la especificación ES-CP (Compact Profile) y continuó durante aproximadamente 18 meses en los que se logró un lento progreso equilibrando la teoría de la especificación JavaScript 2 de Netscape con la experiencia de implementación de JScript .NET de Microsoft . Después de un tiempo, el enfoque cambió al estándar ECMAScript para XML (E4X). La actualización no ha estado exenta de controversia. A finales de 2007, un debate entre Eich, más tarde CTO de la Fundación Mozilla , y Chris Wilson, arquitecto de plataforma de Microsoft para Internet Explorer , se hizo público en varios blogs . Wilson advirtió que, dado que los cambios propuestos a ECMAScript lo hacían incompatible con versiones anteriores del lenguaje en algunos aspectos, la actualización equivalía a "romper la Web" ^{[ 23 ]} y que las partes interesadas que se oponían a los cambios estaban siendo "ocultas". ^{[ 24 ]} Eich respondió afirmando que Wilson parecía estar "repitiendo falsedades en blogs" y negó que hubiera un intento de suprimir la disidencia y desafió a los críticos a dar ejemplos específicos de incompatibilidad. ^{[ 25 ]} Señaló que Microsoft Silverlight y Adobe AIR se basan en C# y ActionScript 3 respectivamente, ambos más grandes y complejos que ECMAScript Edition 3. ^{[ 26 ]}

ECMAScript 4 introduce un sistema de tipado estricto. Por ejemplo, una función add()podría tener el siguiente aspecto: ^{[ 27 ]}

función agregar ( a : int , b : int ) : int { return a + b ; }

Se definieron los siguientes tipos primitivos: ^{[ 27 ]}

• Boolean
• Null
• Number
• Object
• String
• byte
• decimal
• double
• int
• uint
• void

Las variables podrían tener los siguientes modificadores:

• static: convierte una variable en una variable de clase
• prototype: agrega una variable al objeto prototipo de la clase, con un accesor get/set

A las clases se les asignaron los siguientes modificadores:

• dynamic: permite agregar propiedades a las instancias en tiempo de ejecución.
• final: no puede ser extendido por otras clases
• internal: visible solo para las referencias en el paquete actual
• public: visible para referencias a nivel global

Los constructores de clase se declararon con la functionpalabra clave (en lugar de constructor), y tomaron el nombre de la clase misma: ^{[ 27 ]}

clase X { variable privada valor : int ;función pública X ( i : int ) { valor = i ; } }

Los métodos getter y setter también se definieron con las palabras clave gety set: ^{[ 27 ]}

clase X { variable privada _valor : int ;función obtener valor () : int { return _valor ; }función establecer valor ( n : int ) : void { _valor = n ; } }var x : X = new X (); x . value = 10 ;

Las funciones podrían tener los siguientes modificadores:

• static: convierte la función en un rasgo de la clase, en lugar de una instancia (es decir, un método estático ).
• final: declara que una función no puede ser sobrescrita
• override: sobrescribe un método con el mismo nombre y firma.
• native: declara que una función es "definida por la implementación"

Se introdujeron las interfaces , que, al igual que las interfaces de Java , definen un contrato entre una instancia y el código que la consume. ^{[ 27 ]}

interface Saludos { function hello () : void ; function goodMorning () : void ; }class Greeter implements Greetings { public function hello () : void { print ( "Hola, mundo!" ); }public function goodMorning () : void { print ( "Buenos días, mundo!" ); } }var greeter : Greetings = new Greeter (); greeter.hello ( ) ;

ECMAScript 4 introdujo además paquetes, que actuaban como paquetes en Java o espacios de nombres en C++ y C# . Además, un "paquete sin nombre" actuaba básicamente como el espacio de nombres global, que era importado implícitamente por todos los demás paquetes (y dado por ). ^{[ 27 ]}package{/* ... */}

paquete org.wikipedia { public class Article extends WikiObject { // ... } }importar org.wikipedia.* ; // Agrega todos los símbolos de org.wikipedia al alcance import org.wiktionary.Language ; // Agrega el tipo "org.wiktionary.Language" al alcance

En este ejemplo, Articletiene un nombre completamente calificado de org.wikipedia.Article. Si bien ECMAScript moderno presenta módulos, los paquetes de ECMAScript 4 se comportaban más como un esquema de nombres global, similar a los de Java.

Los espacios de nombres también existían como una característica separada de los paquetes y actuaban como un calificador del nombre de la definición. ^{[ 27 ]}

paquete org.wikipedia.examples { public namespace English ; public namespace French ;​​​​public class BilingualGreeter { English function hello () : void { console . log ( "Hello, world!" ); }Función francesa hola () : void { consola . log ( "¡Buen día, el mundo!" ); } } }import org . wikipedia . examples . BilingualGreeter ;var greeter : BilingualGreeter = new BilingualGreeter (); use namespace English ; // agregar todos los identificadores de espacio de nombres de inglés al ámbitogreeter.hello (); // invoca la versión en inglés greeter.French :: hello ( ) ; // invoca la versión en francés

Yahoo, Microsoft, Google y otros disidentes de la cuarta edición formaron su propio subcomité para diseñar una actualización menos ambiciosa de ECMAScript 3, denominada provisionalmente ECMAScript 3.1. Esta edición se centraría en la seguridad y las actualizaciones de bibliotecas, con especial énfasis en la compatibilidad. Tras el debate público mencionado, los equipos de ECMAScript 3.1 y ECMAScript 4 llegaron a un acuerdo: ambas ediciones se desarrollarían en paralelo, con coordinación entre los equipos para garantizar que ECMAScript 3.1 siguiera siendo un subconjunto estricto de ECMAScript 4 tanto en semántica como en sintaxis.

Sin embargo, las diferentes filosofías en cada equipo dieron como resultado repetidas rupturas de la regla del subconjunto, y seguía siendo dudoso que los disidentes de ECMAScript 4 alguna vez apoyaran o implementaran ECMAScript 4 en el futuro. Después de más de un año desde el desacuerdo sobre el futuro de ECMAScript dentro del Comité Técnico 39 de Ecma, los dos equipos llegaron a un nuevo compromiso en julio de 2008: Brendan Eich anunció que Ecma TC39 centraría el trabajo en el proyecto ECMAScript 3.1 (más tarde renombrado como ECMAScript, 5.ª edición) con la plena colaboración de todas las partes, y los proveedores apuntarían a al menos dos implementaciones interoperables para principios de 2009. ^{[ 28 ] [ 29 ]} En abril de 2009, Ecma TC39 publicó el borrador "final" de la 5.ª edición y anunció que se esperaba que las pruebas de las implementaciones interoperables estuvieran completadas para mediados de julio. ^{[ 30 ]} El 3 de diciembre de 2009 se publicó la quinta edición de ECMA-262. ^{[ 31 ]}

Las adiciones incluyen JSON , String.trim()para eliminar fácilmente los espacios en blanco que rodean una cadena ( " example "a "example"), String.charAt()para devolver un solo carácter de una posición dada en una cadena, y Array.isArray(). Una coma después del último par de valores en un objeto ( var example = { "property1":"value1", "property2":"value2", }) tampoco causa ya un error de sintaxis. ^{[ 32 ]}

La sexta edición, ECMAScript 6 ( ES6 ) y posteriormente renombrada como ECMAScript 2015, se finalizó en junio de 2015. ^{[ 4 ] [ 33 ]} Esta actualización agrega una sintaxis nueva significativa para escribir aplicaciones complejas, incluyendo declaraciones de clase ( ), módulos ES6 como , pero los define semánticamente en los mismos términos que el modo estricto de ECMAScript 5. Otras características nuevas incluyen iteradores y bucles, generadores al estilo de Python , expresión de función flecha ( ), palabra clave para declaraciones locales, palabra clave para declaraciones locales constantes, datos binarios, matrices tipadas, nuevas colecciones (mapas, conjuntos y WeakMap), promesas , mejoras numéricas y matemáticas, reflexión, proxies (metaprogramación para objetos virtuales y envoltorios) y literales de plantilla usando comillas invertidas ( ) para cadenas de varias líneas sin caracteres de escape . ^{[ 34 ] [ 35 ]} La lista completa es extensa. ^{[ 36 ] [ 37 ]} Como la primera especificación "ECMAScript Harmony", también se la conoce como "ES6 Harmony".classFoo{...}import*asmoduleNamefrom"...";exportconstFoofor...of()=>{...}letconst`

La séptima edición, o ECMAScript 2016, se finalizó en junio de 2016. ^{[ 5 ]} Sus características incluyen el operador de exponenciación **para números, await, asyncpalabras clave para programación asíncrona (como preparación para ES2017) y la Array.prototype.includesfunción. ^{[ 5 ]} El operador de exponenciación es equivalente a Math.pow, pero proporciona una sintaxis más simple similar a lenguajes como Python, F#, Perl y Ruby. async/ awaitfue aclamado como una forma más fácil de usar promesas y desarrollar código asíncrono.

La octava edición, o ECMAScript 2017, se finalizó en junio de 2017. ^{[ 6 ]} Sus características incluyen las funciones y Object.valuespara la fácil manipulación de objetos, construcciones que utilizan generadores y promesas, y características adicionales para concurrencia y operaciones atómicas . También incluye . ^{[ 38 ] [ 6 ]}Object.entriesObject.getOwnPropertyDescriptorsasyncawaitString.prototype.padStart()

La novena edición, o ECMAScript 2018, se finalizó en junio de 2018. ^{[ 7 ]} Las nuevas características incluyen el operador de propagación y los parámetros rest ( ...) para literales de objeto, iteración asíncrona Promise.prototype.finallyy adiciones a RegExp. ^{[ 7 ]}

El operador de propagación permite copiar fácilmente las propiedades de los objetos, como se muestra a continuación.

sea ​​objeto = { a : 1 , b : 2 }let objectClone = Object.assign ( {}, object ) // antes de ES2018 let objectClone = {... object } // sintaxis ES2018let otherObject = { c : 3 , ... object } console . log ( otherObject ) // -> {c: 3, a: 1, b: 2}

La décima edición, o ECMAScript 2019, se publicó en junio de 2019. ^{[ 8 ]} Las características añadidas incluyen, pero no se limitan a, Array.prototype.flat, Array.prototype.flatMap, cambios en Array.sorty Object.fromEntries. ^{[ 8 ]}

Array.sortAhora se garantiza su estabilidad , lo que significa que los elementos con claves de ordenación iguales no cambiarán su orden relativo antes y después de la operación de ordenación. Array.prototype.flat(depth=1)Aplana una matriz a una profundidad especificada, lo que significa que todos los elementos de la submatriz (hasta la profundidad especificada) se concatenan recursivamente.

Otro cambio notable es que el llamado enlace catch se volvió opcional. ^{[ 39 ]}

La undécima edición, o ECMAScript 2020, se publicó en junio de 2020. ^{[ 9 ]} Además de nuevas funciones, esta versión introduce un BigInttipo primitivo para enteros de tamaño arbitrario, el operador de coalescencia nula y el objeto globalThis . ^{[ 9 ]}

Los BigInts se crean con el BigIntconstructor o con la sintaxis 10n, donde "n" se coloca después del literal numérico. Los BigInts permiten la representación y manipulación de enteros más allá de , mientras que los Numbers se representan mediante un valor IEEE 754Number.MAX_SAFE_INTEGER de doble precisión de 64 bits . Las funciones integradas en no son compatibles con BigInts; por ejemplo, la exponenciación de BigInts debe hacerse con el operador en lugar de .Math**Math.pow

El operador de coalescencia nula, ??, devuelve su operando del lado derecho cuando su lado izquierdo es nullo undefined. Esto contrasta con el ||operador , que devolvería "string"para todos los valores "falsos", como los que se muestran a continuación.

indefinido ?? "cadena" // -> "cadena" nulo ?? "cadena" // -> "cadena" falso ?? "cadena" // -> falso NaN ?? "cadena" // -> NaN

El encadenamiento opcional permite acceder a las propiedades anidadas de un objeto sin tener que realizar una comprobación AND en cada nivel. Un ejemplo es const zipcode = person?.address?.zipcode. Si alguna de las propiedades no está presente, zipcodeserá undefined.

La 12.ª edición, ECMAScript 2021, se publicó en junio de 2021. ^{[ 10 ]} Esta versión introduce el replaceAllmétodo para cadenas; Promise.any, un combinador de promesas que se cortocircuita cuando se cumple un valor de entrada; AggregateError, un nuevo tipo de error para representar múltiples errores a la vez; operadores de asignación lógica ( ??=, &&=, ||=); WeakRef, para referirse a un objeto de destino sin preservarlo de la recolección de basura, y FinalizationRegistry, para gestionar el registro y la anulación del registro de las operaciones de limpieza realizadas cuando los objetos de destino se recolectan como basura; separadores para literales numéricos ( 1_000); y Array.prototype.sortse hizo más preciso, reduciendo el número de casos que dan como resultado un orden de clasificación definido por la implementación.

La 13.ª edición, ECMAScript 2022, se publicó en junio de 2022. ^{[ 11 ]} Esta versión introduce el nivel superior await, que permite usar la palabra clave en el nivel superior de los módulos; nuevos elementos de clase: campos de instancia públicos y privados, campos estáticos públicos y privados, métodos de instancia privados y accesores, y métodos estáticos privados y accesores; bloques estáticos dentro de las clases, para realizar la inicialización de la evaluación por clase; la #x in objsintaxis, para comprobar la presencia de campos privados en los objetos; índices de coincidencia de expresiones regulares/d a través del indicador, que proporciona índices de inicio y fin para las subcadenas coincidentes; la causepropiedad en Errorlos objetos, que se puede usar para registrar una cadena causal en los errores; el atmétodo para Strings, Arrays y TypedArrays, que permite la indexación relativa; y Object.hasOwn, una alternativa conveniente a Object.prototype.hasOwnProperty.

La 14.ª edición, ECMAScript 2023, se publicó en junio de 2023. ^{[ 40 ]} Esta versión introduce los métodos toSorted, toReversed, with, findLast, y en y , así como el método en ; se agregó soporte para comentarios shebang al principio de los archivos para facilitar mejor los archivos ECMAScript ejecutables; y permitió el uso de la mayoría de los símbolos como claves en colecciones débiles.findLastIndexArray.prototypeTypedArray.prototypetoSplicedArray.prototype#!

La 15.ª edición, ECMAScript 2024, se publicó en junio de 2024. ^{[ 41 ]} Esta versión introduce los métodos estáticos Object.groupByy , varias operaciones de conjuntos en , y la bandera unicode para expresiones regulares.Map.groupByPromise.withResolversSet.prototype/v

Los métodos Object.groupByy Map.groupByagrupan una colección iterable utilizando el valor de retorno de una función de devolución de llamada proporcionada.

// datos de muestra const arr = [ { año : "2024" , id : 0 }, { año : "2023" , id : 1 }, { año : "2024" , id : 2 }, ];const obj = Object.groupBy ( arr , ( el ) => el.year ) ; console.log ( obj ) ; // { "2024": [{ year: "2024", id: 0 }, { year : "2024", id: 2 } ], "2023": [{ year: "2023", id: 1 }] }

Promise.withResolversProporciona una forma sencilla de obtener las funciones de resolución y rechazo de una promesa directamente sin tener que asignarlas en el constructor. ^{[ 42 ]}

// ES 2023 let resolve ; let reject ; let promise = new Promise (( res , rej ) => { resolve = res ; reject = rej ; });// ES 2024 const { resolve , reject , promise } = Promise . withResolvers ();

La /vbandera en expresiones regulares es simplemente una versión mejorada de la /ubandera, pero como realiza cambios incompatibles con versiones anteriores, tuvo que introducirse como una nueva bandera. ^{[ 43 ]}

La 16.ª edición de ECMAScript se publicó en 2025. ^{[ 44 ]} Añade lo siguiente:

• El Iteratorobjeto que puede encapsular iteradores como Arrayy proporciona una interfaz funcional con evaluación perezosa .
• Promise.try: llamar a un método que puede o no ser una promesa como si fuera una promesa
• Nuevos Setmétodos: Set.intersection, Set.difference, Set.symmetricDifference, Set.isSubsetOf, Set.isSupersetOf,Set.isDisjointFrom
• RegExp.escapeFunción para escapar una cadena de texto de modo que pueda concatenarse con un patrón de expresión regular.
• Importar archivos JSON directamente como módulos
• Float16Array junto con los métodos TypedArray relacionados.

ES.Next es un nombre dinámico que se refiere a la siguiente versión disponible en el momento de la redacción. Las características de ES.Next incluyen propuestas finalizadas (también conocidas como "propuestas de etapa 4"), tal como se enumeran en las propuestas finalizadas que no forman parte de una especificación ratificada. El comité de lenguaje sigue un modelo de "especificación viva", por lo que estos cambios forman parte del estándar y la ratificación es una formalidad. ^{[ 45 ]}

• Tal como se implementó en Netscape Navigator 2.0 antes de enviar la primera versión para su estandarización como Ecmascript: "Guía de creación de JavaScript" . Archivado del original el 13 de junio de 1997. Recuperado el 13 de octubre de 2023 .{{cite web}}: CS1 maint: bot: estado de la URL original desconocido ( enlace )

• ISO/IEC 22275:2018

• Especificación del lenguaje ECMA-262 ECMAScript
  • Primera edición, junio de 1997: PDF
  • 2.ª edición, agosto de 1998: PDF
  • 3.ª edición, diciembre de 1999: PDF
  • 3.ª edición (final), marzo de 2000: PDF
  • 4.ª edición (descripción general): PDF
  • 4.ª edición (borrador final): HTML , PDF
  • Quinta edición, diciembre de 2009: PDF
  • Edición 5.1, junio de 2011: HTML , PDF
  • 6.ª edición, junio de 2015 (Especificación del lenguaje ECMAScript 2015): HTML , PDF
  • 7.ª edición, junio de 2016 (Especificación del lenguaje ECMAScript 2016): HTML , PDF
  • 8.ª edición, junio de 2017 (Especificación del lenguaje ECMAScript 2017): HTML , PDF
  • 9.ª edición, junio de 2018 (Especificación del lenguaje ECMAScript 2018): HTML , PDF
  • Décima edición, junio de 2019 (Especificación del lenguaje ECMAScript 2019): HTML , PDF
  • 11.ª edición, junio de 2020 (Especificación del lenguaje ECMAScript 2020): HTML , PDF
  • 12.ª edición, junio de 2021 (Especificación del lenguaje ECMAScript 2021): HTML , PDF
  • 13.ª edición, junio de 2022 (Especificación del lenguaje ECMAScript 2022): HTML , PDF
  • 14.ª edición, junio de 2023 (Especificación del lenguaje ECMAScript 2023): HTML , PDF
  • 15.ª edición, junio de 2024 (Especificación del lenguaje ECMAScript 2024): HTML , PDF
• Especificación de componentes ECMAScript ECMA-290 (junio de 1999)
• ECMA-327 Perfil compacto de ECMAScript, 3.ª edición (junio de 2001)
• ECMA-357 Especificación de ECMAScript para XML (E4X) (junio de 2004)