JavaScript => Palabras clave reservadas

Introducción

Ciertas palabras, llamadas palabras clave , se tratan especialmente en JavaScript. Hay una gran cantidad de diferentes tipos de palabras clave, y han cambiado en diferentes versiones del idioma.

Palabras clave reservadas

JavaScript tiene una colección predefinida de palabras clave reservadas que no puede utilizar como variables, etiquetas o nombres de funciones.

ECMAScript 1

_{A - E}	_{E - R}	_{S - Z}
`break`	`export`	`super`
`case`	`extends`	`switch`
`catch`	`false`	`this`
`class`	`finally`	`throw`
`const`	`for`	`true`
`continue`	`function`	`try`
`debugger`	`if`	`typeof`
`default`	`import`	`var`
`delete`	`in`	`void`
`do`	`new`	`while`
`else`	`null`	`with`
`enum`	`return`

ECMAScript 2

Añadido 24 palabras clave reservadas adicionales. (Nuevas adiciones en negrita).

3 E4X

_{A - F}	_{F - P}	_{P - Z}
`abstract`	`final`	`public`
`boolean`	`finally`	`return`
`break`	`float`	`short`
`byte`	`for`	`static`
`case`	`function`	`super`
`catch`	`goto`	`switch`
`char`	`if`	`synchronized`
`class`	`implements`	`this`
`const`	`import`	`throw`
`continue`	`in`	`throws`
`debugger`	`instanceof`	`transient`
`default`	`int`	`true`
`delete`	`interface`	`try`
`do`	`long`	`typeof`
`double`	`native`	`var`
`else`	`new`	`void`
`enum`	`null`	`volatile`
`export`	`package`	`while`
`extends`	`private`	`with`
`false`	`protected`

ECMAScript 5 / 5.1

No hubo cambios desde el ECMAScript 3 .

ECMAScript 5 eliminado int , byte , char , goto , long , final , float , short , double , native , throws , boolean , abstract , volatile , transient , y synchronized ; Añadió let y yield .

_{A - F}	_{F - P}	_{P - Z}
`break`	`finally`	`public`
`case`	`for`	`return`
`catch`	`function`	`static`
`class`	`if`	`super`
`const`	`implements`	`switch`
`continue`	`import`	`this`
`debugger`	`in`	`throw`
`default`	`instanceof`	`true`
`delete`	`interface`	`try`
`do`	`let`	`typeof`
`else`	`new`	`var`
`enum`	`null`	`void`
`export`	`package`	`while`
`extends`	`private`	`with`
`false`	`protected`	`yield`

implements , let , private , public , interface , package , protected , static y el yield se rechazan solo en modo estricto .

eval y los arguments no son palabras reservadas, sino que actúan como tal en modo estricto .

ECMAScript 6 / ECMAScript 2015

_{A - E}	_{E - R}	_{S - Z}
`break`	`export`	`super`
`case`	`extends`	`switch`
`catch`	`finally`	`this`
`class`	`for`	`throw`
`const`	`function`	`try`
`continue`	`if`	`typeof`
`debugger`	`import`	`var`
`default`	`in`	`void`
`delete`	`instanceof`	`while`
`do`	`new`	`with`
`else`	`return`	`yield`

Futuras palabras clave reservadas

Lo siguiente está reservado como palabras clave futuras por la especificación ECMAScript. Actualmente no tienen una funcionalidad especial, pero podrían hacerlo en algún momento futuro, por lo que no se pueden usar como identificadores.


`enum`

Los siguientes solo están reservados cuando se encuentran en código de modo estricto:


`implements`	`package`	`public`
`interface`	`private`	`estática '
`let`	`protected`

Futuras palabras clave reservadas en estándares más antiguos

Las siguientes están reservadas como palabras clave futuras según las especificaciones anteriores de ECMAScript (ECMAScript 1 a 3).


`abstract`	`float`	`short`
`boolean`	`goto`	`synchronized`
`byte`	`instanceof`	`throws`
`char`	`int`	`transient`
`double`	`long`	`volatile`
`final`	`native`

Además, los literales nulo, verdadero y falso no se pueden usar como identificadores en ECMAScript.

De la Red de Desarrolladores de Mozilla .

Identificadores y nombres de identificadores

Con respecto a las palabras reservadas, hay una pequeña distinción entre los "Identificadores" utilizados para los gustos de los nombres de variables o funciones y los "Nombres de identificadores" permitidos como propiedades de los tipos de datos compuestos.

Por ejemplo, lo siguiente resultará en un error de sintaxis ilegal:

var break = true;

SyntaxError no capturado: rotura de token inesperada

Sin embargo, el nombre se considera válido como propiedad de un objeto (a partir de ECMAScript 5+):

var obj = {
    break: true
};
console.log(obj.break);

Para citar de esta respuesta :

De la especificación de lenguaje ECMAScript® 5.1 :

Sección 7.6
Los nombres de identificadores son tokens que se interpretan de acuerdo con la gramática que se proporciona en la sección "Identificadores" del capítulo 5 de la norma Unicode, con algunas pequeñas modificaciones. Un Identifier es un nombre de IdentifierName que no es ReservedWord (ver 7.6.1 ).

Sintaxis

Identifier ::
  IdentifierName but not ReservedWord

Por especificación, un ReservedWord es:

Sección 7.6.1
Una palabra reservada es un nombre de IdentifierName que no se puede usar como Identifier .
ReservedWord :: 
  Keyword
  FutureReservedWord
  NullLiteral
  BooleanLiteral

Esto incluye palabras clave, palabras clave futuras, null y literales booleanos. La lista completa de palabras clave se encuentra en las Secciones 7.6.1 y los literales en la Sección 7.8 .

Lo anterior (Sección 7.6) implica que IdentifierName s puede ser ReservedWord s, y de la especificación para inicializadores de objetos :

Sección 11.1.5

Sintaxis

ObjectLiteral :
  { }
  { PropertyNameAndValueList }
  { PropertyNameAndValueList , }

Donde PropertyName es, por especificación:

PropertyName :
  IdentifierName
  StringLiteral
  NumericLiteral

Como puede ver, un PropertyName puede ser un IdentifierName , permitiendo así que ReservedWord s sea PropertyName s. Eso nos dice de manera concluyente que, por especificación , se permite tener ReservedWord s como class y var como PropertyName s sin comillas, como literales de cadena o literales numéricos.

Para leer más, vea la Sección 7.6 - Nombres e identificadores de identificadores.

Nota: el resaltador de sintaxis en este ejemplo ha detectado la palabra reservada y aún la ha resaltado. Si bien el ejemplo es válido, los desarrolladores de Javascript pueden quedar atrapados por algunas herramientas de compilador / transpilador, linter y minifier que argumentan lo contrario.

Modified text is an extract of the original Stack Overflow Documentation

Licenciado bajo CC BY-SA 3.0

No afiliado a Stack Overflow

JavaScript
Palabras clave reservadas

Buscar..