ECMAScript

La versión actual de la página aún no ha sido revisada por colaboradores experimentados y puede diferir significativamente de la versión revisada el 15 de junio de 2022; las comprobaciones requieren 2 ediciones .
ECMAScript
clase de idioma Especificación para lenguajes de programación , lenguaje de programación funcional y lenguaje de programación multiparadigma
Apareció en junio de 1997
Autor Brendan Eich y Ecma Internacional
Desarrollador Brendan Eich
extensión de archivo .es[2]
Liberar ECMAScript 2022 [Spec 1]  (junio de 2022 ) (2022-06)
sistema de tipos pato
Dialectos JavaScript , JScript , ActionScript , JScript.NET , QtScript
sido influenciado Auto [1] , C , Esquema [1] , Perl [1] , Python , Java [1] , AWK [1]
influenciado Objetivo-J
Sitio web ecma-international.org _ 

ECMAScript es un lenguaje de programación sin E/S  integrable y extensible que se utiliza como base para construir otros lenguajes de secuencias de comandos [3] .

ECMAScript está estandarizado por la organización internacional ECMA en la especificación ECMA-262 . Extensiones de lenguaje: JavaScript , JScript y ActionScript .

Historia

El lenguaje se originó a partir de varias tecnologías, las más famosas de las cuales son los lenguajes JavaScript y JScript . El desarrollo de la primera revisión de la especificación comenzó en noviembre de 1996. La especificación fue adoptada en junio de 1997. Enviado a ISO/IEC JTC 1 para la aceptación de seguimiento rápido , sirvió como base para el estándar internacional ISO/IEC 16262 . En junio de 1998, la reunión general de ECMA adoptó la segunda edición de ECMA-262, correspondiente a ISO/IEC 16262. La tercera edición de la especificación difería de la anterior al introducir soporte para expresiones regulares, mejorar el soporte de cadenas, introducir nuevas estructuras de control , un mecanismo de excepción, formateo cuando se ingresa un número y algunos otros cambios[Especificación 2] .

Semántica y sintaxis

Tipos de datos

ECMAScript admite cinco tipos de datos primitivos :

El tipo de dato numérico en ECMAScript corresponde al formato de número de coma flotante de 64 bits definido por el estándar IEEE 754-2008 , excepto que los diversos valores Not-a-Number definidos en el estándar [4] se representan en ese idioma por el único valor especial NaN [Especificación 4] .

Los tipos de datos nulos e indefinidos se denominan informalmente tipos "triviales" por David Flanagan , ya que cada uno de ellos define solo un valor [5] .

El idioma también tiene un tipo de datos "compuesto" [5] :

Además de los seis tipos de datos enumerados, ECMAScript admite siete más que se utilizan exclusivamente para almacenar resultados intermedios de expresiones evaluadas:

La popularidad del lenguaje JavaScript y la no trivialidad del procesamiento de datos de diferentes tipos llevaron al despliegue de investigaciones académicas en el campo del análisis de tipos de datos ECMAScript, cuyo objetivo es crear un analizador de código completo que pueda usarse en el desarrollo integrado . ambientes [6] .

Instrucciones

Hay quince tipos diferentes de instrucciones en ECMAScript, que se enumeran en la siguiente tabla:

Tipos de instrucción definidos por la especificación del lenguaje [Especificación 7]
Nombre nombre original Breve información definitivo; [Especificación 8]
Bloquear inglés  bloquear {[<instrucciones>]} −
Declaración de variables inglés  DeclaraciónDeVariable var <lista de declaraciones de variables> +
Instrucción vacía inglés  VacíoDeclaración ; +
Expresión inglés  ExpresiónDeclaración [cadena a ∉ {{, función}] instrucción +
Condición inglés  SiDeclaración if (<инструкция>) <выражение>[ else <выражение>] −
Ciclo inglés  Declaración de iteración do <expresión> while (<sentencia>)

while (<sentencia>) <expresión>
for ([<sentencia antes del inicio>]; [<sentencia>]; [<sentencia>]) <expresión>
for (<declaración de variable>; [<sentencia>]; [<sentencia >]) <expresión>
for (<expresión-valor-l> en <sentencia>) <expresión>
for (<declaración de variable> en <sentencia>) <expresión>

+/− [~1]
Continuación inglés  ContinuarDeclaración continuar [<identificador>] +
Interrumpir inglés  BreakStatement romper [<identificador>] +
Devolver inglés  DevoluciónDeclaración devolver [<instrucción>] +
Combinación inglés  ConDeclaración with (<sentencia>) <expresión> −
Etiqueta inglés  EtiquetadoDeclaración <identificador>: <expresión> −
Elección inglés  SwitchStatement switch (<sentencia>) case <sentencia>: [<expresiones>][ case <sentencia>: [<expresiones>] ...] [predeterminado: [<expresiones>]] −
Lanzar una excepción inglés  TirarDeclaración lanzar <instrucción> +
intentar bloquear inglés  TryStatement intente <bloque> catch (<identificador>) <bloque>
intente <bloque> finalmente <bloque>
intente <bloque> catch (<identificador>) <bloque> finalmente <bloque> 		−
(nuevo [Spec 9] ) Depurador inglés  depurador depurador −
Autocompletar cadenas con punto y coma

A pesar del punto y coma obligatorio en los casos señalados en la cuarta columna, la especificación declara un mecanismo para autocompletar cadenas con punto y coma , lo que lleva al hecho de que si hay un salto de línea, la instrucción anterior al salto de línea puede equiparse con este signo [ Especificación 8] , que es objeto de críticas [7] .

Instrucciones que cambian de significado cuando se usa una nueva línea dentro de [Especificación 8]
  • Postfijo unario ++
  • postfijo unario --
  • Continuación
  • Interrumpir
  • Devolver
  • Lanzar una excepción

Un ejemplo de cómo cambiar el significado de una instrucción

volver { estado : "completo" };

Aquí, la línea resaltada contiene una instrucción válida para el idioma y, dado que sigue una nueva línea, se activa el mecanismo de autocompletado de líneas con punto y coma. En lugar de que la función que contiene el código anterior devuelva un objeto con la propiedad como valor status, devolverá undefined.

Aunque la forma literal de un objeto no es un bloque de código, los paréntesis uniformes pueden generar errores. El desarrollo o la adopción de un estándar de codificación adecuado puede reducir la probabilidad de que ocurran . La elección del estilo de sangría juega un papel . En particular, los estilos Allman y Whitesmith , así como el estilo Horstman y el estilo GNU para el código JavaScript, están en desuso en la mayoría de las pautas [8] en contraste con los estilos K&R , 1TBS , BSD KNF .

Error de autocompletar

Si la expresión escrita en la línea siguiente puede ser sintácticamente una continuación de la expresión de la línea anterior, el mecanismo de autocompletado de líneas con punto y coma no funciona [9] .

función () [ 'h1' , 'h2' ]. paraCada ( función ( t ) { handleTag ( t ) })

En este ejemplo, los corchetes de la segunda línea se interpretan como una referencia a un elemento de matriz devuelto por func(). La coma entre paréntesis se trata como el operador correspondiente que devuelve 'h2'. Así que el código se convierte a lo siguiente:

función ()[ 'h2' ]. forEach ( función ( t ) { handleTag ( t ); });

Es costumbre en los estándares de codificación requerir punto y coma incluso si la sintaxis del idioma permite omitirlos [Estándares de codificación 1] [Estándares de codificación 2] [Estándares de codificación 3] [Estándares de codificación 4] [Estándares de codificación 5] .

Bloques y alcance

Otra característica de ECMAScript en relación con otros lenguajes tipo C es que en este lenguaje los bloques no forman un alcance . Las variables declaradas en un bloque se aplican a toda la función que contiene el bloque [10] [11] .

En esta sección de código, la variable se vuelve a declarar en las líneas resaltadas:

función foo ( ) { varsum = 0 ; for ( var i = 0 ; i < 42 ; i += 2 ) { var tmp = i + 2 ; suma += i * tmp ; } para ( var i = 1 ; i < 42 ; i += 2 ) { suma += i * yo ; } alerta ( tmp ); suma devuelta ; _ } foo ();

Además, la variable tmp declarada dentro del primero de los bucles (línea 4) es legal para acceder desde fuera del bucle (línea 10) según la sintaxis del lenguaje.

Debido a la naturaleza del alcance y los bloques, se recomienda declarar variables al comienzo de las funciones para mantener la calidad del código fuente [10] [Estándares de codificación 1] [Estándares de codificación 4] .

Declaraciones de variables

Las variables se definen mediante palabras clave var, let, const. Al declarar una variable, se coloca en el ámbito correspondiente en el caso de una varfunción, y en el caso let, constde un bloque de código. Si una variable se declara fuera de las funciones, se coloca en el ámbito global. La creación de una variable ocurre cuando se recibe el control de la función con su declaración. O un programa si la variable es global. Cuando se crea una variable en ECMAScript, adquiere el valor undefined. Si una variable se declara con initialization , la inicialización no ocurre en el momento de crear la variable, sino cuando se ejecuta la línea con la instrucción var[Specification 10] .

Al descomentar la línea seleccionada, la pantalla no mostrará un número , sino undefined :

var a = 42 ; function foo () { alerta ( tipo de a ); // var a = 10; } foo ();

Cuando se crea una variable, adquiere la propiedad interna {DontDelete} y no se puede eliminar con el operador delete[Especificación 10] . La excepción son las variables declaradas en contexto eval[12] [Especificación 11] .

Muchas fuentes [13] [14] [15] [16] [17] [18] declaran la posibilidad de declarar implícitamente variables en ECMAScript cuando se asigna a un identificador válido que no es un argumento de función formal sin declarar primero con var. Sin embargo, en la terminología de la especificación del lenguaje, en este caso se crea una propiedad del objeto global, no una variable [12] [Especificación 10] .

Fijar en el estándar de codificación la necesidad de declarar variables antes de que se utilicen [Estándares de codificación 1] [Estándares de codificación 4] (o corregir la necesidad de usar espacios de nombres para todos los objetos globales [Estándares de codificación 2] ) evita errores sutiles, previniendo el peligro de interacción de variables con nombres idénticos en diferentes partes del código [19] .

Palabras clave y palabras reservadas

Las siguientes palabras son palabras clave en el idioma y no se pueden usar como identificadores [Spec 12] :

romper hacer instancia de tipo de caso más nuevo var atrapar finalmente volver vacío continuar para cambiar mientras función de depuración esto con por defecto si tirar eliminar al intentar

En comparación con la tercera edición de la especificación [Especificación 13] , la quinta edición agregó una palabra clave debuggercon la instrucción correspondiente.

Las siguientes palabras se utilizan como palabras clave en las extensiones propuestas y, por lo tanto, están reservadas para la capacidad de adaptar esas extensiones [Especificación 14] :

enumeración de clase se extiende super constante exportación importación

Cuando se usa el modo estricto, las siguientes palabras se tratan como reservadas para uso futuro [Spec 14] :

implementos dejar rendimiento público privado paquete de interfaz estático protegido

Por lo tanto, en comparación con la tercera edición de la especificación del idioma, la cantidad de palabras reservadas para uso futuro ha disminuido significativamente. Anteriormente había 31 [Especificación 15] , y se criticaba la presencia de un gran número de palabras clave y palabras reservadas, la mayoría de las cuales no se utilizan en el idioma [20] .

Operadores

ECMAScript tiene operadores que usan palabras clave como nombres y operadores que usan signos de puntuación como nombres .

Clasificación de operadores

En orden descendente de precedencia , los operadores de ECMAScript se pueden dividir en los siguientes grupos:

  • .(acceso a la propiedad), [](acceso a la propiedad), ()(llamada a función), new(creación de nuevo objeto),
  • ++(incremento), --(decremento), -(unario menos), +(unario más), ^(complemento bit a bit), !(complemento booleano), delete(eliminar propiedad), typeof(definir tipo de datos primitivo), void(devolver nulo),
  • *(multiplicar), /(dividir), %(resto de la división),
  • +(suma), -(resta), +(concatenación de cadenas),
  • <<(desplazamiento a la izquierda), >>(desplazamiento a la derecha con extensión de bit de signo), >>>(desplazamiento a la derecha con relleno de cero),
  • <(menor que), <=(menor que o igual a), >(mayor que), >=(mayor que o igual a), instanceof(prueba de tipo de objeto), in(prueba de propiedad),
  • ==(prueba de igualdad), !=(prueba de desigualdad), ===(prueba de identidad), !==(prueba de no identidad),
  • &( conjunción bit a bit ),
  • ^( suma bit a bit módulo 2 ),
  • |( disyunción bit a bit ),
  • &&(conjunción),
  • ||(disyunción),
  • ?:( operación condicional ternaria ),
  • =(asignación), *=, /=, +=, -=, <<=, >>=, >>>=, &=, ^=, |=(asignación con operación),
  • ,(cálculo múltiple) [21] .

Los operadores ++, --, -, +, ~, !, delete, typeof, void, ?:, =, *=, /=, +=, -=, <<=, >=, >>>=, &=, ^=, son |=asociativos por la derecha (es decir, son a op b op cequivalentes a a op (b op c)). Los operadores restantes de ECMAScript son asociativos a la izquierda [22] .

Por arity , los operadores de ECMAScript se dividen en los siguientes grupos:

  • unario ( delete, void, typeof, ++, --, -(menos unario), +(más unario), ^, !, new) [Especificación 16] ,
  • binario ( ., [], (), *, /, %, +(suma), -(resta), +(concatenación de cadenas), <<, >>, >>>, <, <=, >, >=, instanceof, in, ==, !=, ===, !==, &, ^, |, &&, ||, =, *=, /=, +=, -=, <<=, >=, >>>=, &=, ^=, |=, ,),
  • ternario ( ?:) [23] ,
  • operadores que no tienen un número fijo de operandos ( ()) [24] .

Según la posición del signo de la operación en relación con los operandos, los operadores de ECMAScript se dividen en los siguientes grupos:

  • prefijo (por ejemplo, new, ++(incremento de prefijo),
  • infijo (por ejemplo, +, -),
  • sufijo (por ejemplo, ++(incremento de sufijo), --(decremento de sufijo).

Los operadores también se clasifican por el tipo de operandos [25] y por la naturaleza de la acción realizada.

Características de las sentencias ECMAScript

No hay ningún operador en ECMAScript que le permita comprobar si una propiedad pertenece directamente a un objeto o se hereda. Esta comprobación se lleva a cabo mediante el hasOwnProperty(). Debido a que este método no es un operador, cualquier otra propiedad puede sobrescribirlo [26] .

El operador +es el único operador aritmético en el idioma que está sobrecargado para argumentos de cadena. Si al menos uno de los operandos es una cadena, +actúa como concatenador , de lo contrario, realiza la suma [27] [Especificación 17] .

A diferencia de los lenguajes donde void es un tipo de dato, en ECMAScript es un operador que devuelve un valor undefined[28] .

El operador ==verifica la igualdad de acuerdo con un algoritmo que consta de 10 pasos, lo que implica en algunos casos conversión de tipo [Especificación 18] , que, en última instancia, puede conducir a resultados no obvios [29] .

Un ejemplo de los resultados del trabajo ==(en todos los casos enumerados, el valor del operador ===con los mismos argumentos será false):

alerta ( "NaN" == NaN ); // alerta falsa ( NaN == NaN ); // alerta falsa ( verdadero == 1 ); // alerta verdadera ( verdadera == 42 ); // alerta falsa ( nulo == 0 ); // alerta falsa ( 0 == "" ); // alerta verdadera ( "" == 0 ); // alerta verdadera ( "falsa" == falso ); // alerta falsa ( falso == 0 ); // alerta verdadera ( indefinido == falso ); // alerta falsa ( null == false ); // alerta falsa ( indefinido == nulo ); // alerta verdadera ( " \t\r\n " == 0 ); // verdadero

Funciones

Las funciones en ECMAScript son objetos [30] [31] . El constructor con el que se crean es Function(). Las funciones, como cualquier otro objeto, se pueden almacenar en variables, objetos y matrices, se pueden pasar como argumentos a otras funciones y las funciones pueden devolverlas. Las funciones, como cualquier otro objeto, pueden tener propiedades. Una característica específica esencial de las funciones es que pueden llamarse [30] .

Definición de funciones

Hay dos tipos de funciones en ECMAScript:

  • funciones internas (por ejemplo, parseInt),
  • funciones definidas en el texto del programa.

Las funciones internas son objetos integrados (ver más abajo ), no necesariamente implementados en ECMAScript [Especificación 19] .

En el texto del programa, una función con nombre en ECMAScript se puede definir de una de las siguientes maneras:

// declaración de función function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } // definir una función usando una sentencia var sum2 = function ( arg1 , arg2 ) { return arg1 + arg2 ; }; // definir una función usando notación de objeto var sum3 = nueva función ( "arg1" , "arg2" , "return arg1 + arg2;" );

Este último método es el menos preferido, ya que de facto se trata de definir una función usando una expresión, pero al mismo tiempo genera una doble interpretación del código (una interpretación adicional ocurre cuando el código se pasa al constructor), que puede afectar negativamente al rendimiento [31] .

Los dos primeros métodos dan un efecto similar pero no idéntico. Para empeorar las cosas, la declaración utilizada al definir una función puede parecerse mucho a la declaración de una función: en primer lugar, la palabra clave functionpuede ir seguida de un identificador [Especificación 20] , en segundo lugar, el punto y coma puede omitirse debido al mecanismo de finalización de cadenas punto y coma. [Especificación 8] . Ejemplo:

// declaración de función function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } // definir una función usando una expresión var sum2 = function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } barra de funciones () { }; // usa la declaración de la función ( function bar (){}) // usa la instrucción apropiada

La diferencia más significativa entre definir una función mediante una declaración y definir una función mediante una expresión es que, en el primer caso, la creación de una variable y su asignación como el valor de la función se produce antes de que se ejecute el código al entrar en el contexto de ejecución. . En el segundo caso, la variable recibe el valor del inicializador cuando se ejecuta la instrucción de asignación. Cuando se crea una variable al entrar en un contexto de ejecución, se inicializa con el valor de undefined[Spec 21] [32] (consulte Declaraciones de variables para obtener más detalles ).

Un ejemplo que ilustra la diferencia en el orden de ejecución del código:

alerta ( suma ( 3 , 4 )); // 7: la variable sum ya se ha creado en el momento en que se ejecuta esta línea, y se le ha asignado la función sum ( arg1 , arg2 ) function sum ( arg1 , arg2 ) { return arg1 + arg2 ; } alerta ( suma2 ( 3 , 4 )); // error: la variable sum2 ya se ha creado cuando se ejecuta esta línea, pero se le ha asignado undefined var sum2 = función ( arg1 , arg2 ) { return arg1 + arg2 ; };

Las declaraciones de funciones no deben usarse dentro de construcciones condicionales [33] , aunque los navegadores Gecko manejarán esto intuitivamente a través del mecanismo implementado de funciones como instrucciones [34] .

Asignaciones de funciones

Dado que las funciones en ECMAScript son objetos, es decir, son de un tipo de datos de referencia , los identificadores de función son variables que almacenan una referencia a la función. Esto se puede ilustrar con el siguiente código:

var suma = función ( arg1 , arg2 ) { return arg1 + arg2 ; }; alerta ( suma ( 3 , 4 )); // 7 var suma2 = suma ; alerta ( suma2 ( 4 , 2 )); // 6 suma = nulo ; alerta ( suma2 ( 42 , 42 )); // 84

En la línea resaltada, debe prestar atención a la ausencia del operador de llamada de función ( ()) en el lado derecho de la asignación. Si en lugar de suma se indicara en esta línea sum(), a la variable suma2 no se le asignaría una función, sino el resultado de su llamada. Otra cosa que vale la pena señalar es que después de la asignación, sum2 no apunta a una copia de la función, sino a la misma función a la que apunta sum .

Sobrecarga de funciones

En ECMAScript , la sobrecarga de funciones no es una propiedad del lenguaje, pero su efecto se proporciona mediante el uso de otros mecanismos.

Un ejemplo que muestra la ausencia de sobrecarga de funciones:

función suma ( arg1 , arg2 ) { return arg1 + arg2 ; } función suma ( arg1 , arg2 , arg3 ) { return arg1 + arg2 + arg3 ; } alerta ( suma ( 3 , 4 )); // Alerta de NaN ( suma ( 3 , 4 , 5 )); // 12

Si se declaran varias funciones con el mismo nombre, las declaraciones posteriores sobrescriben las declaraciones anteriores [31] .

Sin embargo, el efecto de la sobrecarga de funciones es alcanzable.

1. Compruebe si no está definido. Para verificar si el argumento real se pasó a la función, puede verificar el argumento formal para la identidad del valor de undefined. Por ejemplo:

function sum ( arg1 , arg2 , arg3 ) { if ( arg3 !== indefinido ) { return arg1 + arg2 + arg3 ; } más { devuelve arg1 + arg2 ; } } alerta ( suma ( 3 , 4 )); // 7 alerta ( suma ( 3 , 4 , 5 )); // 12

2. Comprobación de tipo. Además, typeof, instanceof, constructorse puede utilizar para averiguar el tipo de argumentos reales y personalizar el comportamiento de la función en función de ellos.

function sum ( arg1 , arg2 , arg3 ) { switch ( typeof arg3 ) { caso "indefinido" : return arg1 + arg2 ; caso "número" : return arg1 + arg2 + arg3 ; predeterminado : devuelve arg1 + arg2 + " (" + arg3 + ")" ; } } alerta ( suma ( 3 , 4 )); // 7 alerta ( suma ( 3 , 4 , 5 )); // 12 alerta ( suma ( 3 , 4 , "!" )); // "7(!)"

3. Acceso a datos sobre argumentos. En las funciones de ECMAScript, puede acceder a los datos de los argumentos mediante el objeto arguments[Especificación 22] . En particular, le permite usar la indexación para acceder a argumentos específicos pasados ​​[31] [35] y una propiedad lengthque almacena la cantidad de argumentos realmente pasados, lo que puede ser útil cuando se aplica el paradigma de programación genérico .

función suma () { var res = 0 ; for ( var i = 0 ; i < argumentos . longitud ; i ++ ) { res += argumentos [ i ]; } devuelve res ; } alerta ( suma ( 3 , 4 )); // 7 alerta ( suma ( 3 , 4 , 5 )); // 12 alerta ( suma ( 3 , 4 , 5 , 7 , 9 )); // 28 Recursividad

Las funciones de ECMAScript se pueden llamar recursivamente. Cuando define una función usando una declaración sin especificar un identificador después de la palabra clave functiondentro de la función, puede referirse a ella usando la propiedad de destinatario del objeto arguments[Especificación 22] .

Un ejemplo de cálculo factorial recursivo:

var factorial = función ( paso , res ) { res = res || 1 ; if ( paso < 2 ) { return res ; } argumentos de retorno . destinatario ( paso - 1 , paso * res ); }; alerta ( factorial ( 5 )); // 120

Actualmente, ECMAScript no implementa la recursión de cola , que se utiliza para optimizar las llamadas recursivas [36] .

Devoluciones de llamada

En ECMAScript, una función es un objeto de primera clase y se puede pasar como argumento a otra función. Si al mismo tiempo se llama en la función a la que se pasa, entonces se llama función de devolución de llamada (o función de devolución de llamada ). Si la función pasada no tiene nombre, es una función de devolución de llamada anónima ( función de devolución de llamada anónima ) [37] . Las razones principales para usar funciones de devolución de llamada son:

  • evitando nombrar funciones cuando se opera con ellas (ayuda a reducir el número de variables globales) [37] ,
  • delegar una llamada de función a otra función (ayuda a aumentar la expresividad del código) [37] ,
  • aumento del rendimiento [37] ,
  • simplificación del manejo de eventos cortos [38] .

Un ejemplo de una función que devuelve la suma de los resultados de ejecutar la función pasada en los argumentos:

función sumOfResults ( devolución de llamada ) { var resultado = 0 ; for ( var i = 1 ; i < argumentos . longitud ; i ++ ) { resultado += devolución de llamada ( argumentos [ i ]); } devuelve el resultado ; } var cuadrado = función ( x ) { retorno x * x ; }; alerta ( sumOfResults ( cuadrado , 3 , 4 )); // 25 Cierres

Las funciones en ECMAScript tienen un alcance léxico inherente. Esto significa que el alcance se define en el momento en que se define la función (a diferencia del alcance dinámico, donde el alcance se define en el momento en que se llama a la función) [39] .

Cuando se declara una función, la secuencia de ámbitos de función anidados se almacena como parte del estado de la función. Es decir, durante la ejecución del programa, las funciones que tienen acceso a las variables locales de las funciones circundantes retienen dicho acceso durante la ejecución del programa [39] .

El mecanismo de cierre se puede utilizar para restringir la visibilidad de las variables en una sección independiente del programa para que no haya conflictos de nombres cuando se comparte con otro código. Para ello, el código se coloca en una función anónima, provista de un operador de llamada a función.

( función () { // Sección del programa cuyo acceso a las variables debe estar aislado del exterior. })();

En este caso, las funciones definidas en la sección del programa se anidan con respecto a la función anónima añadida, y es posible acceder a las variables locales de la función anónima (que eran globales antes de su introducción). Sin embargo, no se puede acceder a ellos desde fuera de la función anónima: se ignora el resultado de la ejecución de la función.

Los cierres se utilizan no solo para prohibir el acceso a una serie de variables, sino también para modificar dicho acceso. Esto se logra con funciones que devuelven otras funciones. Un ejemplo de una función de generador de números de serie:

var ID único = función () { id de var = 0 ; función de retorno () { id de retorno ++ ; }; }(); var aValue = ID único (); var otro valor = ID único ();

Mediante el uso de un cierre , sólo la función que se asignó a la variable uniqueId tiene acceso a la variable id .

Ejemplo de curri :

var multNumber = function ( arg ) { return function ( mul ) { return arg * mul ; }; }; var multiCinco = multiNúmero ( 5 ); alerta ( multFive ( 7 )); //35

Un ejemplo de creación de un objeto que le permite acceder a la propiedad exclusivamente utilizando sus métodos [40] :

var miObjeto = función () { var valor = 0 ; return { incremento : función ( inc ) { valor += tipo de inc === 'número' ? aum : 1 ; }, getValue : función ( ) { valor devuelto ; } } }(); alerta ( miObjeto . valor === indefinido ); // alerta verdadera ( myObject . getValue ()); // 0 miObjeto . incrementar ( 9 ) miObjeto . incremento ( 7 ) alerta ( myObject . getValue ()); // dieciséis

Usando este truco, puede usar un cierre para emular constantes [41] .

var getConstant = function () { var constantes = { UPPER_BOUND : 100 , LOWER_BOUND : - 100 }; función de retorno ( nombreConstante ) { constantes de retorno [ nombreConstante ]; }; }(); alerta ( getConstant ( "LOWER_BOUND" )); // -100

Expresiones regulares

La sintaxis y funcionalidad de las expresiones regulares en ECMAScript fue influenciada por Perl 5 [Spec 23] y permite dos tipos de sintaxis: literal y de objeto .

var literalWay = /patrón/banderas; var objectWay = new RegExp ( patrón , banderas );

En el primer caso, la plantilla ( pattern) y las banderas ( flags) se especifican explícitamente, sin signos sintácticos redundantes adicionales: las barras sirven como separadores . En el segundo caso, la plantilla y las banderas deben ser variables que contengan valores de cadena, o directamente valores de cadena. Se prefiere la notación literal porque no requiere el escape doble [ ~ 2] de metacaracteres de expresión regular, a diferencia de la forma de objeto [42] .

Los siguientes símbolos se pueden usar como banderas en ECMAScript:

Indicadores de expresiones regulares [42] [Spec 23]
Bandera Descripción
g g modo global: el patrón se aplica a todas las coincidencias en la cadena, la expresión regular no se detiene después de encontrar la primera coincidencia del patrón
i y mayúsculas y minúsculas - ignorando : al hacer coincidir, se ignoran las mayúsculas y minúsculas de los caracteres del patrón y las cadenas
m modo multilínea : una línea que contiene caracteres de nueva línea se trata como varias líneas separadas por caracteres de avance de línea; regex funciona en todas las líneas

Cada expresión regular es un objeto con las siguientes propiedades:

Propiedades de objeto de expresión regular de ECMAScript [42] [Especificación 23]
Propiedad Tipo de Descripción
global lógico muestra si la bandera está configuradag
ignoreCase lógico muestra si la bandera está configuradai
multiline lógico muestra si la bandera está configuradam
lastIndex numérico coincide con el número de posición en la cadena donde se encontró la coincidencia de patrón como resultado de la aplicación anterior de la expresión regular, o 0 si la expresión regular no se aplicó previamente
source cuerda cadena que coincide con el patrón de expresión regular

Además, se definen los siguientes métodos para expresiones regulares:

Métodos de objeto de expresión regular en ECMAScript [42] [Especificación 23]
Método tipo de devolución Descripción
exec(handledString) objeto (matriz) onull forma una matriz de subcadenas que coinciden con el patrón especificado , teniendo en cuenta las banderas establecidas . nullsi ninguna subcadena coincide con el patrón
test(handledString) lógico truesi hay una cadena que coincida con el patrón y de falselo contrario

Objetos

Implementación en el lenguaje

Los objetos ECMAScript son colecciones desordenadas de propiedades , cada una de las cuales tiene uno o más atributos que determinan cómo se puede usar la propiedad; por ejemplo, si el valor del atributo ReadOnly se establece en true , entonces cualquier intento de ejecutar el código ECMAScript para cambiar el el valor de esa propiedad fallará. Las propiedades son contenedores que encapsulan otros objetos, valores de tipos primitivos y métodos [Especificación 24] .

Atributos de propiedad de objeto de ECMAScript [Spec 25]
Nombre Descripción
solo lectura La propiedad es una propiedad de solo lectura. Un intento de cambiar el valor de esta propiedad, realizado en el programa, será inútil. En algunos casos, el valor de una propiedad con el conjunto de atributos ReadOnly cambia debido a las acciones del entorno de extensión del idioma, por lo que ReadOnly no debe entenderse como inmutable.
DontEnum Propiedad no enumerada por buclefor-in
No eliminar Se ignorarán los intentos de eliminar esta propiedad.
Interno La propiedad es interna. No tiene nombre y no se puede acceder con accesores . El acceso a estas propiedades está determinado por la implementación del lenguaje.

Los objetos ECMAScript se dividen en objetos básicos (nativos) y de extensión (host). Por base entendemos cualquier objeto que sea independiente del entorno relacionado con la extensión del lenguaje. Algunos de los objetos básicos están integrados : existen desde el principio de la ejecución del programa. Se pueden crear otros cuando el programa se está ejecutando. Los objetos de extensión los proporciona la extensión ECMAScript y, para ECMAScript, esto significa que forman parte del modelo de objetos del documento o del modelo de objetos del navegador [Especificación 3] .

Sintaxis

Las formas de objetos y literales se pueden usar para especificar objetos. La forma de objeto de especificar un objeto tiene una sintaxis similar a Java, pero, a diferencia de ella, los paréntesis en ECMAScript se requieren para usarse solo cuando se pasan argumentos a un constructor [43] . Las siguientes entradas son sintácticamente equivalentes:

varobj1 = nuevo Objeto ( ); var obj2 = nuevo objeto ; var obj3 = {};

Sin embargo, no se recomienda la segunda opción [43] . Douglas Crockford recomienda evitar también la primera opción, prefiriendo la forma literal, que considera una gran ventaja del lenguaje [44] .

La especificación del lenguaje opera con el concepto de propiedad de un objeto , llamando a un método una función utilizada como propiedad de un objeto [Especificación 3] .

Cada objeto en el lenguaje tiene las siguientes propiedades:

Propiedades de los objetos ECMAScript [43]
Nombre Breve descripción
constructor La función utilizada para crear el objeto (en los ejemplos anteriores es Object())
tiene propiedad propia (nombre de propiedad) Indica si la propiedad dada existe en el objeto (no en su prototipo )
esPrototipoDe(objeto) Determina si un objeto está en la cadena de prototipo del objeto de argumento
propiedadEsEnumerable(nombreDePropiedad) Indica si la propiedad con el nombre dado es enumerable en el ciclofor-in
Encadenar() Devuelve la representación de cadena del objeto.
valor de() Devuelve este valor . Si el objeto es el resultado de una llamada al constructor de un objeto de extensión , el valor valueOf()depende de la implementación [Spec 26] . A menudo, el valor de retorno es un valor de tipo primitivo correspondiente a un objeto. Como regla general, el resultado de este método es el mismo que el resultado de toString(). Los objetos creados con un constructor Date() son un excelente ejemplo donde los resultados de toString()y valueOf()no coinciden [43] .

Se accede a las propiedades del objeto mediante la notación de puntos y corchetes :

var obj = nuevo objeto (); alerta ( obj . constructor === obj [ "constructor" ]); // verdadero: use la notación de puntos y corchetes para acceder a la propiedad var foo = obj [ "toString" ]; // usando notación de paréntesis para almacenar la función en una variable var result = obj [ "toString" ](); // guardando el resultado de la llamada a la función en una alerta variable ( foo ()); // mostrando el resultado de llamar a la función almacenada en la alerta de pantalla ( resultado ); varboo = obj ._ _ a la cadena ; // similar a la notación de puntos var res = obj . a la cadena (); alerta ( abucheo ()); alerta ( res );

Las nuevas propiedades se pueden establecer dinámicamente.

varcountry = nuevo Objeto ( ); país [ "nombre" ] = "Rusia" ; // usa la notación de paréntesis country . añoFundación = 862 ; // usa la notación de puntos var país2 = { "nombre" : "Rusia" , "año de fundación" : 862 }; // usa la forma literal

Enfoques para la creación de objetos

La creación de objetos de la manera descrita en la sección anterior puede resultar poco práctica debido a la necesidad de duplicar el código [45] . Si el programa manipula una gran cantidad de objetos del mismo tipo, el desarrollador tiene la oportunidad de elegir una de las técnicas utilizadas en el lenguaje [45] :

fábrica de objetos una función que crea un objeto y lo devuelve como su valor, constructor una función que usa la palabra clave thispara formar las propiedades del objeto que crea usando el operador new, enfoque prototipo usar la propiedad prototypede una función para mostrar las propiedades generales de los objetos, enfoque mixto constructor-prototipo usar un constructor para establecer propiedades de objetos que no son métodos y un enfoque de prototipo para establecer métodos, método de prototipo dinámico concluir el código relacionado con la función de crear objetos basados ​​en el enfoque mixto constructor-prototipo en una sola función, asegurando que las propiedades del prototipo se asignen una vez, método constructor parásito usar newcon la función de fábrica de objetos.

No hay clases en el lenguaje , pero se pueden emular usando constructores. Un ejemplo de emulación de clases en ECMAScript:

function MyClass () { this . miValor1 = 1 ; esto _ miValor2 = 2 ; } mi clase prototipo _ myMethod = función () { devuelve esto . miValor1 * este . miValor2 ; } var mc = new MiClase (); mc _ miValor1 = mc . miValor2 * 2 ; var i = mc . miMetodo ();

Características de la herencia en ECMAScript

Para cada uno de los componentes del objeto, se puede considerar la herencia. Cuando se hereda la interfaz de un padre sin que el hijo use la funcionalidad del antepasado, se habla de herencia de la interfaz. Al heredar el estado, el objeto hijo hereda la estructura de datos del objeto antepasado. Al heredar funcionalidad, estamos hablando de herencia junto con la interfaz y el código de métodos. Por regla general, esto implica la necesidad de organizar la herencia de estado, lo que hace razonable combinar la herencia de estado y la herencia de funcionalidad en la herencia de implementación [46] .

Con respecto a ECMAScript, solo la herencia de interfaz no se aplica, ya que las funciones en el lenguaje no tienen firmas [45] .

Las posibilidades que ofrece el lenguaje para la organización de la herencia pueden juzgarse, por ejemplo, por la lista que da Stoyan Stefanov [47] de doce formas diferentes de organizar la herencia.

ECMAScript 6

La adopción de ES6 ha eliminado muchas clases de problemas de JavaScript [48] [49] [50] [51] .

Notas

  1. ↑ 1 2 3 4 5 _ Axel Rauschmayer. La naturaleza de JavaScript // JavaScript hablado . - Primera edición. - O'Reilly Media, 2014. - Pág. 41. - ISBN 978-1-449-36503-5 .
  2. ↑ Tipo de medio de secuencias de comandos - 2006.
  3. ↑ Zakas N. ECMAScript // JavaScript profesional para desarrolladores web. — 2ª ed. - EE. UU., Canadá: Wiley Publishing, Inc, 2009. - P. 3-7. - ISBN 978-0-470-22780-0 .
  4. ↑ Aiken A., Applegate M., Bailey D. y otros. 6.2. Operaciones con NaNs // Estándar IEEE para aritmética de punto flotante / Presidente Zuras D., Editor Cowlishaw M. - EE. UU., 2008. - P. 34. - ISBN 978-0-7381-5753-5 .
  5. ↑ 1 2David Flanagan. 3. Tipos de datos y valores // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  39 -66. — ISBN 5-93286-103-7 .
  6. ↑ Jensen S., Møller A., ​​​​Thiemann P. Type Analysis for JavaScript  //  Lecture Notes in Computer Science: Proceedings of Conf. / The 16th International Static Analysis Symposium (SAS 2009), Los Ángeles, EE. UU., 9 - 11 de agosto de 2009. - Springer Berlin / Heidelberg, 2009. - Vol. 5673 . - Pág. 238 - 255 . - ISBN 978-3-642-03236-3 .  (enlace no disponible)
  7. ↑ Crockford D.A.3. Inserción de punto y coma // JavaScript: las partes buenas. - 2008. - Pág. 102. - ISBN 978-0-596-51774-8 .
  8. ↑ Dra. Axel Rauschmayer. Sintaxis de JavaScript // JavaScript hablado . - Primera edición. - O'Reilly Media, 2014. - Pág. 378. - ISBN 978-1-449-36503-5 .
  9. ↑ Dra. Axel Rauschmayer. Sintaxis de JavaScript // JavaScript hablado . - Primera edición. - O'Reilly Media, 2014. - Pág. 41. - ISBN 978-1-449-36503-5 .
  10. ↑ 1 2 Crockford D.A.2. Alcance // JavaScript: Las partes buenas. - 2008. - Pág. 36. - ISBN 978-0-596-51774-8 .
  11. ↑ David Flanagan. 4.3.1. Sin ámbito de bloque // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  70 -71. — ISBN 5-93286-103-7 .
  12. ↑ 1 2 Soshnikov, Dmitry Sutilezas ECMA-262-3. Parte 2. Objeto de las variables. (27 de junio de 2009). Consultado el 6 de noviembre de 2009. Archivado desde el original el 18 de febrero de 2012.
  13. ↑ David Flanagan. 4.2. Declaración de variables // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  68 . — ISBN 5-93286-103-7 .
  14. ↑ Peter-Paul Koch. Declaración de variable implícita // ppk en JavaScript / Editor: Wendy Sharp. — 1ra ed. - New Riders Press, 2006. - 528 p. - ISBN 978-0-321-42330-6 .
  15. ↑ Zakas N. Variables // JavaScript profesional para desarrolladores web. — 2ª ed. - EE. UU., Canadá: Wiley Publishing, Inc, 2009. - P. 26, 27. - ISBN 978-0-470-22780-0 .
  16. ↑ Souders S. Usar variables locales // Sitios web aún más rápidos: prácticas recomendadas de rendimiento para desarrolladores web. — 1ra ed. - EE.UU.: O'Reilly Media, 2009. - Págs. 81-83. — ISBN 0596522304 .
  17. ↑ Easttom C. Declaración de variables // Javascript avanzado. — 3ra ed. - EE.UU.: Wordware Publishing, Inc, 2008. - 81 - 83 p. — ISBN 1-59822-033-0 .
  18. ↑ Keith J. Variables // DOM Scripting: diseño web con JavaScript y el modelo de objeto de documento. — 1ra ed. - EE.UU.: Wordware Publishing, Inc, 2005. - 18 - 20 p. — ISBN 1590595335 .
  19. ↑ Peter-Paul Koch. Capítulo 5 Núcleo. Sección D. Variables // ppk en JavaScript / Editor: Wendy Sharp. — 1ra ed. - New Riders Press, 2006. - 528 p. - ISBN 978-0-321-42330-6 .
  20. ↑ Crockford D.A.4. Palabras reservadas // JavaScript: Las partes buenas. - 2008. - 170 págs. - ISBN 978-0-596-51774-8 .
  21. ↑ David Flanagan. 5.2. Descripción general del operador // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  78 -79. — ISBN 5-93286-103-7 .
  22. ↑ David Flanagan. 5.2.4 Asociatividad de operadores // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  81 . — ISBN 5-93286-103-7 .
  23. ↑ David Flanagan. 5.2.1 Número de operandos // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  79 . — ISBN 5-93286-103-7 .
  24. ↑ David Flanagan. 5.10.8 Operador de llamada de función // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  98 . — ISBN 5-93286-103-7 .
  25. ↑ David Flanagan. 5.2.2 Tipo de operandos // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  80 . — ISBN 5-93286-103-7 .
  26. ↑ Crockford D.A.13. hasOwnProperty // JavaScript: Las partes buenas. - 2008. - Pág. 107. - ISBN 978-0-596-51774-8 .
  27. ↑ Crockford D.A.8. + // JavaScript: Las partes buenas. - 2008. - 170 págs. - ISBN 978-0-596-51774-8 .
  28. ↑ Crockford DB12. void // JavaScript: Las partes buenas. - 2008. - 170 págs. - ISBN 978-0-596-51774-8 .
  29. ↑ Crockford DB1. == // JavaScript: Las partes buenas. - 2008. - 170 págs. - ISBN 978-0-596-51774-8 .
  30. ↑ 1 2 Crockford D. 4.1. Objetos de función // JavaScript: las partes buenas. - 2008. - Pág. 26. - ISBN 978-0-596-51774-8 .
  31. ↑ 1 2 3 4 Zakas N. El tipo de función // JavaScript profesional para desarrolladores web. — 2ª ed. - EE. UU., Canadá: Wiley Publishing, Inc, 2009. - P. 122-130. - ISBN 978-0-470-22780-0 .
  32. ↑ Soshnikov, Dmitry Sutilezas ECMA-262-3. Parte 1. Contextos de ejecución. (26 de junio de 2009). Consultado el 12 de octubre de 2010. Archivado desde el original el 16 de octubre de 2010.
  33. ↑ Juriy "kangax" Zaytsev. Expresiones de funciones nombradas desmitificadas  (inglés)  (el enlace está caído) . — Un artículo que detalla la diferencia entre definir una función con una declaración y definir una función con una expresión. Consultado el 19 de octubre de 2009. Archivado desde el original el 19 de junio de 2009.
  34. ↑ Maian et al.. Definición condicional de una función  (inglés)  (enlace no disponible) . Funciones y ámbito de funciones . — Descripción de los detalles de implementación de funciones como expresiones en el contexto de declaraciones dentro de condiciones. Consultado el 19 de octubre de 2009. Archivado desde el original el 14 de octubre de 2008.
  35. ↑ Crockford D. 4.4. Argumentos // JavaScript: Las partes buenas. - 2008. - Pág. 31. - ISBN 978-0-596-51774-8 .
  36. ↑ Crockford D. 4.8. Recursión // JavaScript: Las partes buenas. - 2008. - Pág. 35. - ISBN 978-0-596-51774-8 .
  37. ↑ 1 2 3 4 Stefanov S. Funciones de devolución de llamada // JavaScript orientado a objetos: cree aplicaciones y bibliotecas de JavaScript escalables y reutilizables de alta calidad. — 1ra ed. - Packt Publishing, 2008. - P. 73, 74. - ISBN 184719414.
  38. ↑ Crockford D. 4.11. Devoluciones de llamada // JavaScript: las partes buenas. - 2008. - Pág. 40. - ISBN 978-0-596-51774-8 .
  39. ↑ 1 2David Flanagan. 8.8. Alcance y cierres de funciones // JavaScript. Guía detallada = JavaScript. La guía definitiva / Traducido por A. Kiselev. - 5ª ed. - San Petersburgo. : "Símbolo-Plus" , 2008. - S.  156 -163. — ISBN 5-93286-103-7 .
  40. ↑ Crockford D. 4.10. Cierre // JavaScript: Las partes buenas. - 2008. - 170 págs. - ISBN 978-0-596-51774-8 .
  41. ↑ Harmes R., Diaz D. Constants // Pro JavaScript™ Design Patterns. - USA: Apress, 2008. - P. 37, 38. - ISBN 1-59059-908-X .
  42. ↑ 1 2 3 4 Zakas N. The RegExp Type // JavaScript profesional para desarrolladores web. — 2ª ed. - EE. UU., Canadá: Wiley Publishing, Inc, 2009. - P. 115-122. - ISBN 978-0-470-22780-0 .
  43. ↑ 1 2 3 4 Zakas N. El tipo de objeto // JavaScript profesional para desarrolladores web. — 2ª ed. - EE. UU., Canadá: Wiley Publishing, Inc, 2009. - P. 40-41. - ISBN 978-0-470-22780-0 .
  44. ↑ Crockford D. JSON // JavaScript: Las partes buenas. - 2008. - Pág. 136. - ISBN 978-0-596-51774-8 .
  45. ↑ 1 2 3 Zakas N. 6. Programación orientada a objetos // JavaScript profesional para desarrolladores web. — 2ª ed. - EE. UU., Canadá: Wiley Publishing, Inc, 2009. - P. 151-182. - ISBN 978-0-470-22780-0 .
  46. ↑ Kuznetsov, Mikhail Herencia de implementación en sistemas de objetos distribuidos . Editorial "Sistemas Abiertos" (11 de diciembre de 2002). Consultado el 1 de noviembre de 2009. Archivado desde el original el 17 de febrero de 2010.
  47. ↑ Stefanov S. Capítulo 6. Herencia. Resumen // JavaScript orientado a objetos: cree aplicaciones y bibliotecas de JavaScript escalables y reutilizables de alta calidad. — 1ra ed. - Editorial Packt, 2008. - Pág. 194-198. — ISBN 184719414.
  48. ↑ ECMAScript6 . Consultado el 17 de marzo de 2017. Archivado desde el original el 20 de diciembre de 2016.
  49. ↑ Una introducción a los iteradores JS en ES6 . Consultado el 17 de marzo de 2017. Archivado desde el original el 10 de junio de 2017.
  50. ↑ ES6 Introducción . Consultado el 17 de marzo de 2017. Archivado desde el original el 20 de diciembre de 2016.
  51. ↑ Funciones de flecha de ES6 . Consultado el 17 de marzo de 2017. Archivado desde el original el 20 de diciembre de 2016.

Estándares ECMAScript

Especificaciones de ECMAScript

  1. ↑ Estándar ECMA-262. 13ª edición . ecma-international.org (junio de 2022).
  2. ↑ CT39. Breve historia // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. Copia archivada (enlace inaccesible) . Consultado el 8 de diciembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  3. ↑ 123 TC39._ _ _ 4.3. Definiciones // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 4. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  4. ↑ CT39. 8.5. El tipo de número // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 29. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  5. ↑ 1 2 3 4 TC39. 8. Tipos // Especificación del lenguaje ECMAScript . — 3ra ed. - 1999. - Pág. 24.
  6. ↑ 1 2 3 4 TC39. 8. Tipos // 3.ª edición, diciembre de 1999.pdf Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 28.  (enlace inaccesible)
  7. ↑ CT39. 12. Sentencias // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Págs. 86-97. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  8. ↑ 1 2 3 4 TC39. 7.9. Inserción automática de punto y coma // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Págs. 25-28. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  9. ↑ CT39. 12. Sentencias // Especificación del lenguaje ECMAScript . — 3ra ed. - 1999. - P. 61-71. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  10. ↑ 123 TC39._ _ _ 12.2. Declaración variable // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 87, 88. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  11. ↑ CT39. 10.2.2. Código de evaluación // 3.ª edición, diciembre de 1999.pdf Especificación del lenguaje ECMAScript . — 3ra ed. - 1999. - Pág. 39.  (enlace inaccesible)
  12. ↑ CT39. 7.6.1.1. Palabras clave // ​​Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 18. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  13. ↑ CT39. 7.5.2. Palabras clave // ​​3ª edición, diciembre de 1999.pdf Especificación del lenguaje ECMAScript . — 3ra ed. - 1999. - P. 13-14.  (enlace no disponible)
  14. ↑ 12 TC39 . 7.6.1. Palabras reservadas // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - P. 18, 19. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  15. ↑ CT39. 7.5.3. Futuras palabras reservadas // 3.ª edición, diciembre de 1999.pdf Especificación del lenguaje ECMAScript . — 3ra ed. - 1999. - Pág. 15.  (enlace inaccesible)
  16. ↑ CT39. 11.4. Operadores unarios // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 70-72. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  17. ↑ CT39. 11.6.1 El operador de suma (+) // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 74, 75. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  18. ↑ CT39. 11.9.3. El algoritmo de comparación de igualdad abstracta // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 80, 81. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  19. ↑ CT39. 4.3. Definiciones // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Págs. 4-7. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  20. ↑ CT39. 13 Definición de funciones // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 97, 98. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  21. ↑ CT39. 12.2 Declaración de variable // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 87, 88. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  22. ↑ 12 TC39 . 10.6. Objeto de argumentos // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Págs. 60-62. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  23. ↑ 1 2 3 4 TC39. 15.10. Objetos RegExp (expresión regular) // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Págs. 179-196. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  24. ↑ CT39. 4.2. Descripción general del lenguaje // Especificación del lenguaje ECMAScript . — 5ª ed. - 2009. - Pág. 2-4. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  25. ↑ CT39. 8.6.1. Atributos de propiedad // Especificación del lenguaje ECMAScript . — 3ra ed. - 1999. - P. 25, 26. Copia archivada (enlace inaccesible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 
  26. ↑ CT39. Propiedades del Objeto Objeto Prototipo // Especificación del Lenguaje ECMAScript . — 5ª ed. - 2009. - Págs. 114-116. Copia archivada (enlace no disponible) . Consultado el 11 de noviembre de 2009. Archivado desde el original el 12 de abril de 2015. 

Comentarios

  1. ↑ Solo para hacer mientras
  2. ↑ Una sola barra invertida escapa de los metacaracteres de cadena (por ejemplo, \t). Se utiliza una barra invertida doble para escapar de metacaracteres de expresiones regulares (por ejemplo, \\s)

Estándares de codificación de JavaScript

  1. ↑ 1 2 3 Crockford, Douglas Code Conventions para el lenguaje de programación JavaScript  . JavaScript de Douglas Crockford . Estándar de formato de código JavaScript de Douglas Crockford. Consultado el 5 de octubre de 2009. Archivado desde el original el 18 de febrero de 2012.
  2. ↑ 1 2 Convenciones de código  JavaScript . Marco web de eco . próxima aplicación, inc. — Un estándar de codificación de JavaScript adoptado para Echo Web Framework. Consultado el 5 de octubre de 2009. Archivado desde el original el 18 de febrero de 2012.
  3. ↑ Amaram, Rahul Convenciones de nomenclatura de Javascript , pautas de codificación y mejores prácticas  . Marco web de eco . — Estándar de formato de código JavaScript de Raoul Amaram. Consultado el 5 de octubre de 2009. Archivado desde el original el 18 de febrero de 2012.
  4. ↑ 1 2 3 Komenda, Klaus Pautas y estándares de codificación de JavaScript  . Sitio del desarrollador web austriaco Klaus Komend . — Estándar de formato de código JavaScript de Klaus Komend. Consultado el 5 de octubre de 2009. Archivado desde el original el 18 de febrero de 2012.
  5. ↑ Estilo de codificación de JavaScript  . gnomo. — El estándar de codificación JavaScript de GNOME. Fecha de acceso: 24 de diciembre de 2009. Archivado desde el original el 18 de febrero de 2012.

Enlaces

 ECMAScript
Dialectos
Motores
( comparación )
Marcos ,
bibliotecas
JavaScript
( comparar )
lado del cliente
lado del servidor
Bibliotecas
( lista )
  • SWFObjeto
  • SWFAddress
código de acciónPuroMVC
Múltiples
implementaciones
Gente
Otro
 Normas Internacionales Ecma