TypeScript
 

Especificación del lenguaje

Versión 1.8
Enero , 2016

Microsoft pondrá a disposición esta Especificación bajo el Acuerdo de Especificación Final de la Open Web
Foundation Versión 1.0 ( " OWF 1.0 " ) a partir del 1 de octubre, 20 12. El OWF 1.0 está disponible
en http://www.openwebfoundation.org/legal/the- acuerdos owf-1-0 / owfa-1-0 .

TypeScript es una marca comercial de Microsoft Corporation.

 
Tabla de contenido
1 Introducción             
1.1 Declaraciones ambientales             
1.2 Tipos de funciones             
1.3 Tipos de objeto             
1.4 Subtipo estructural             
1.5 Mecanografía contextual             
1.6 clases             
1.7 Tipos de enumeración             
1.8 Sobrecarga en los parámetros de cadena             
1.9 Tipos genéricos y funciones             
1.10 espacios de nombres             
1.11 Módulos             
2 conceptos básicos             
2.1 Convenciones de gramática             
2.2 Nombres             
2.2.1 Palabras reservadas             
2.2.2 Nombres de propiedad             
2.2.3 Nombres de propiedades calculadas             
2.3 Declaraciones             
2.4 alcances             
3 tipos             
3.1 El cualquier tipo    any       
3.2 Tipos primitivos             
3.2.1 El tipo de número   number           
3.2.2 El tipo booleano     boolean         
3.2.3 El tipo de cadena      string       
3.2.4 El tipo de símbolo     simbol       
3.2.5 El tipo vacío      void        
3.2.6 El tipo nulo    null          
3.2.7 El tipo indefinido   undefined           
3.2.8 Tipos de enumeración     enum        
3.2.9 Tipos literales de cadena             
3.3 Tipos de objetos             
3.3.1 Referencias de tipo con nombre             
3.3.2 Tipos de matriz  array            
3.3.3 Tipos de tuplas        tuples      
3.3.4 Tipos de funciones             
3.3.5 Tipos de constructor             
3.3.6 Miembros             
3.4 Tipos de unión             
3.5 Tipos de intersección             
3.6 Parámetros de tipo             
3.6.1 Listas de parámetros de tipo             
3.6.2 Listas de argumentos de tipo             
3.6.3 Este tipo             
3.7 Tipos con nombre             
 3.8 Especificación de tipos             
3.8.1 Tipos predefinidos             
3.8.2 Referencias de tipo             
3.8.3 Literales de tipo de objeto             
3.8.4 Literales de tipo de matriz             
3.8.5 Literales tipo tupla             
3.8.6 Literales tipo unión             
3.8.7 Literales de tipo de intersección             
3.8.8 Literales de tipo de función             
3.8.9 Literales de tipo de constructor             
3.8.10 Consultas de tipo             
3.8.11 Referencias de este tipo             
3.9 Especificación de miembros             
3.9.1 Firmas de propiedad             
3.9.2 Firmas de llamadas             
3.9.3 Construir firmas             
3.9.4 Firmas de índice             
3.9.5 Firmas de métodos             
3.10 Alias tipo             
3.11 Relaciones de tipo             
3.11.1 Miembros aparentes             
3.11.2 Tipo e identidad del miembro             
3.11.3 Subtipos y supertipos             
3.11.4 Compatibilidad de asignación             
3.11.5 Exceso de propiedades             
3.11.6 Creación de instancias de firma contextual             
3.11.7 Inferencia de tipo             
3.11.8 Tipos recursivos             
3.12 Tipos ensanchados             
4 expresiones             
4.1 Valores y referencias             
4.2 La palabra clave this             
4.3 identificadores             
4.4 Literales             
4.5 Literales de objetos             
4.6 Literales de matriz             
4.7 Literales de plantilla             
4.8 Paréntesis             
4.9 La súper palabra clave    super keyword          
4.9.1 Super llamadas         super calls    
4.9.2 Super acceso a la propiedad   access          
4.10 Expresiones de funciones             
4.11 Funciones de flecha             
4.12 Expresiones de clase         class     
4.13 Acceso a la propiedad             
4.14 El nuevo operador             
4.15 Llamadas de función             
4.15.1 Resolución de sobrecarga    overload         
 4.15.2 Inferencia de argumento de tipo       inference      
4.15.3 Ambigüedades gramaticales             
4.16 Afirmaciones de tipo          assertions    
4.17 Expresiones JSX             
4.18 Operadores unarios          unary    
4.18.1 Los operadores ++ y -             
4.18.2 Los operadores +, - y ~             
4.18.3 El! operador             
4.18.4 El operador de eliminación   delete           
4.18.5 El operador vacío         void     
4.18.6 El tipo de operador     typeof         
4.19 Operadores binarios             
4.19.1 El *, /,%, -, <<, >>, >>>, &, ^ y | operadores             
4.19.2 El operador +             
4.19.3 Los operadores <,>, <=,> =, == ,! =, === y! ==             
4.19.4 La instancia del operador   instanceof           
4.19.5 El operador in             
4.19.6 El operador &&             
4.19.7 El || operador             
4.20 El operador condicional             
4.21 Operadores de asignación             
4.21.1 Asignación de desestructuración             
4.22 El operador de coma             
4.23 Expresiones de tipo contextual            contextually  
4.24 Guardias tipo           guards   
5 declaraciones             
5.1 bloques             
5.2 Declaraciones variables             
5.2.1 Declaraciones de variables simples              
5.2.2 Desestructuración de declaraciones de variables              
5.2.3 Tipo implícito impliied             
5.3 Declaraciones de Let y Const             
5.4 Declaraciones If, Do y While             
5.5 Para declaraciones   for          
5.6 Declaraciones for-in             
5.7 Declaraciones for-of             
5.8 Continuar declaraciones continue            
5.9 Declaraciones de ruptura    break         
5.10 Declaraciones de devolución return             
5.11 Con declaraciones      with       
5.12 Cambiar declaraciones  switch           
5.13 Declaraciones de lanzamiento throw             
5.14 Intentar declaraciones  try           
6 funciones             
6.1 Declaraciones de funciones             
6.2 Sobrecargas de funciones             
6.3 Implementaciones de funciones             
6.4 Declaraciones de parámetros de desestructuración              
 6.5 Funciones genéricas             
6.6 Generación de código             
6.7 Funciones del generador             
6.8 Funciones asincrónicas             
6.9 Funciones de protección de tipo             
7 interfaces             
7.1 Declaraciones de interfaz             
7.2 Fusión de declaraciones  merging            
7.3 Interfaces que amplían clases             
7.4 Verificaciones de tipo dinámico  checks           
8 clases             
8.1 Declaraciones de clase             
8.1.1 Especificación de patrimonio de clase heritage            
8.1.2 Cuerpo de clase  body           
8.2 Miembros             
8.2.1 Instancia y miembros estáticos             
8.2.2 Accesibilidad             
8.2.3 Herencia y anulación             
8.2.4 Tipos de clase             
8.2.5 Tipos de funciones de constructor             
8.3 Declaraciones del constructor             
8.3.1 Parámetros del constructor             
8.3.2 Super llamadas             
8.3.3 Constructores automáticos             
8.4 Declaraciones de miembros de la propiedad             
8.4.1 Declaraciones de variables miembro             
8.4.2 Declaraciones de funciones del miembro             
8.4.3 Declaraciones de acceso de miembros             
8.4.4 Declaraciones de propiedades dinámicas             
8.5 Declaraciones de miembros de índice             
8.6 Decoradores             
8.7 Generación de código             
8.7.1 Clases sin cláusulas extendidas             
8.7.2 Clases con cláusulas extendidas             
9 enumeraciones             
9.1 Declaraciones de enumeración             
9.2 Miembros de Enum             
9.3 Fusión de declaraciones             
9.4 Declaraciones de enumeración constante             
9.5 Generación de código             
10 espacios de nombres             
10.1 Declaraciones de espacio de nombres             
10.2 Cuerpo del espacio de nombres             
10.3 Declaraciones de alias de importación             
10.4 Declaraciones de exportación             
10.5 Fusión de declaraciones             
10.6 Generación de código             
11 Scripts y módulos             
11.1 Programas y archivos fuente             
11.1.1 Dependencias de archivos fuente             
11.2 Guiones             
11.3 Módulos             
11.3.1 Nombres de módulos             
11.3.2 Declaraciones de importación             
11.3.3 Importar declaraciones requeridas             
11.3.4 Declaraciones de exportación             
11.3.5 Asignaciones de exportación             
11.3.6 Módulos CommonJS             
11.3.7 Módulos AMD             
12 ambientes             
12.1 Declaraciones ambientales             
12.1.1 Declaraciones de variables ambientales             
12.1.2 Declaraciones de función ambiental             
12.1.3 Declaraciones de clase ambiental             
12.1.4 Declaraciones de enumeración ambiental             
12.1.5 Declaraciones de espacio de nombres ambientales             
12.2 Declaraciones de módulo ambiental             
Una gramática             
A.1 Tipos             
A.2 Expresiones             
A.3 Declaraciones             
A.4 Funciones             
A.5 Interfaces             
A.6 Clases             
A.7 Enums             
A.8 Espacios de nombres             
A.9 Scripts y módulos             
A.10 Ambientes             
 

 
 

1 Introducción        

Las aplicaciones de JavaScript , como el correo electrónico web , los mapas, la edición de documentos y las herramientas
de colaboración se están convirtiendo en una parte cada vez más importante de la informática
cotidiana. Diseñamos TypeScript para satisfacer las necesidades de los equipos de programación de JavaScript que crean y
mantienen grandes programas de JavaScript. TypeScript ayuda a los equipos de programación a definir interfaces entre
componentes de software y a obtener información sobre el comportamiento de las bibliotecas JavaScript
existentes. TypeScript también permite a los equipos reducir los conflictos de nombres al organizar su código en módulos
cargables dinámicamente. Mecanografiado ' s sistema de tipo opcional permite a los programadores de JavaScript para
utilizar herramientas de desarrollo altamente productivas y prácticas: comprobación estática, navegación basada en
símbolos, la finalización de instrucciones y el código de re-factoring.
TypeScript es un azúcar sintáctico para JavaScript. La sintaxis de TypeScript es un superconjunto de la sintaxis
de ECMAScript 2015 (ES2015 ). Cada programa de JavaScript también es un programa TypeScript. El compilador
de TypeScript solo realiza transformaciones locales de archivo en los programas de TypeScript y no reordena las variables
declaradas en TypeScript. Esto conduce a la salida de JavaScript que coincide estrechamente con la entrada
de TypeScript. TypeScript no transforma los nombres de las variables, lo que hace que la depuración directa de JavaScript
emitida sea manejable. TypeScript opcionalmente proporciona mapas de origen, lo que permite la depuración a nivel de
origen. Las herramientas de TypeScript suelen emitir JavaScript al guardar el archivo, preservando el ciclo de prueba,
edición y actualización comúnmente utilizado en el desarrollo de JavaScript.

La sintaxis de TypeScript incluye todas las características de ECMAScript 2015 , incluidas las clases y los módulos , y ofrece
la capacidad de traducir estas características en código compatible con ECMAScript 3 o 5.

Las clases permiten a los programadores expresar patrones comunes orientados a objetos de una manera estándar,
haciendo que características como la herencia sean más legibles e interoperables. Los módulos permiten a los
programadores organizar su código en componentes y evitar conflictos de
nombres. El compilador TypeScript proporciona opciones de generación de código de módulo que admiten la carga
estática o dinámica del contenido del módulo.

TypeScript también proporciona a los programadores de JavaScript un sistema de anotaciones de tipo opcionales. Estas

anotaciones de tipo son como los comentarios de JSDoc que se encuentran en el sistema Closure, pero en TypeScript se
integran directamente en la sintaxis del lenguaje. Esta integración hace que el código sea más legible y reduce el costo de
mantenimiento de sincronizar anotaciones de tipo con sus variables correspondientes.

El sistema de tipos TypeScript permite a los programadores expresar límites sobre las capacidades de los objetos
JavaScript y utilizar herramientas que imponen estos límites. Para minimizar el número de anotaciones necesarias para que
las herramientas sean útiles, el sistema de tipos TypeScript hace un uso extensivo de la inferencia de tipos. Por ejemplo, a
partir de la siguiente declaración, TypeScript inferirá que la variable ' i ' tiene el número de tipo.

var i = 0;

TypeScript inferirá de la siguiente definición de función que la función f tiene una cadena de tipo de retorno.

función f () { return " hola " ; }
    

Para beneficiarse de esta inferencia, un programador puede usar el servicio de lenguaje TypeScript. Por ejemplo, un editor
de código puede incorporar el servicio de lenguaje TypeScript y usar el servicio para encontrar los miembros de un objeto
de cadena como en la siguiente captura de pantalla.
En este ejemplo, el programador se beneficia de la inferencia de tipos sin proporcionar anotaciones de tipo. Sin embargo,
algunas herramientas beneficiosas requieren que el programador proporcione anotaciones de tipo. En TypeScript,
podemos expresar un requisito de parámetro como en el siguiente fragmento de código.

function f(s: string) {

return s;
}

f({}); // Error
f("hello"); // Ok

Esta anotación de tipo opcional en el parámetro ' s ' le permite al verificador de tipo TypeScript saber que el programador

espera que el parámetro ' s ' sea del tipo ' string ' . Dentro del cuerpo de la función ' f ' , las herramientas pueden suponer
que ' s ' es de tipo ' cadena ' y proporcionan verificación de tipo de operador y finalización de miembros de acuerdo con
esta suposición. Las herramientas también pueden indicar un error en la primera llamada a ' f ' , porque ' f ' espera una
cadena, no un objeto, como su parámetro. Para la función ' f ' , el compilador TypeScript emitirá el siguiente código
JavaScript:

function f(s) {
return s;
}

En la salida de JavaScript, todas las anotaciones de tipo se han borrado. En general, TypeScript borra toda la información
de tipo antes de emitir JavaScript.

1.1 Declaraciones ambientales        
Una declaración ambiental introduce una variable en un ámbito de TypeScript, pero tiene cero impacto en el programa
JavaScript emitido. Los programadores pueden usar declaraciones ambientales para decirle al compilador TypeScript que
algún otro componente proporcionará una variable. Por ejemplo, por defecto, el compilador TypeScript imprimirá un error
para el uso de variables indefinidas. Para agregar algunas de las variables comunes definidas por los navegadores,
un programador de TypeScript puede usar declaraciones ambientales. El siguiente ejemplo declara
el objeto ' documento ' proporcionado por los navegadores. Debido a que la declaración no especifica un tipo, se
infiere el tipo ' any ' . El tipo ' cualquiera ' significa que una herramienta no puede asumir nada sobre la forma o el
comportamiento del objeto del documento. Algunos de los ejemplos a continuación ilustrarán cómo los programadores
pueden usar tipos para caracterizar aún más el comportamiento esperado de un objeto.

declare var document;

document.title = "Hello"; // Ok because document has been declared

En el caso de ' documento ' , el compilador de TypeScript proporciona automáticamente una declaración, porque

TypeScript incluye de manera predeterminada un archivo ' lib.d.ts ' que proporciona declaraciones de interfaz para la
biblioteca JavaScript incorporada, así como para el Modelo de Objetos del Documento.

El compilador TypeScript no incluye por defecto una interfaz para jQuery, por lo que para usar jQuery, un programador
podría proporcionar una declaración como:

declare var $;

Sección 1.3 provee s un ejemplo más extenso de cómo un programador puede añadir información de tipo F o jQuery y
otras bibliotecas.
1.2 Tipos de funciones        
Las expresiones de función son una característica poderosa de JavaScript. Permiten a las definiciones de funciones para
crear cierres: funciones que capturan información del ámbito léxico que rodea la función ' definición s. Los cierres son
actualmente JavaScript ' única manera de hacer cumplir la encapsulación de datos s. Al capturar y utilizar variables de
entorno, un cierre puede retener información a la que no se puede acceder desde fuera del cierre. Los programadores de
JavaScript a menudo usan cierres para expresar controladores de eventos y otras devoluciones de llamada asíncronas, en
las que otro componente de software, como el DOM, volverá a llamar a JavaScript a través de una función de controlador.

Los tipos de función de TypeScript hacen posible que los programadores expresen la firma  esperada de una función. Una
firma de función es una secuencia de tipos de parámetros más un tipo de retorno. El siguiente ejemplo utiliza tipos de
función para expresar los requisitos de firma de devolución de llamada de un mecanismo de votación asíncrono.

function vote(candidate: string, callback: (result: string) => any) {

// ...
}

vote("BigPig",
function(result: string) {
if (result === "BigPig") {
// ...
}
}
);

En este ejemplo, el segundo parámetro para ' votar ' tiene el tipo de función

(result: string) => any

lo que significa que el segundo parámetro es una función que devuelve el tipo ' any ' que tiene un solo parámetro de
tipo ' string ' llamado ' result ' .

La Sección 3.9.2 proporciona información adicional sobre los tipos de funciones.

1.3         Tipos de objeto
Los programadores de TypeScript usan tipos de objetos  para declarar sus expectativas sobre el comportamiento de los
objetos . El siguiente código utiliza un literal de tipo de objeto  para especificar el tipo de retorno de la
función ' MakePoint ' .

var MakePoint: () => {

x: number; y: number;
};

Los programadores pueden dar nombres a los tipos de objetos; llamamos interfaces de  tipos de objetos con
nombre . Por ejemplo, en el siguiente código, una interfaz declara un campo obligatorio (name) y un campo opcional
(favoriteColor).

interface Friend {
name: string;
favoriteColor?: string;
}
 function add(friend: Friend) {
var name = friend.name;
}

add({ name: "Fred" }); // Ok

add({ favoriteColor: "blue" }); // Error, name required
add({ name: "Jill", favoriteColor: "green" }); // Ok

Los tipos de objetos TypeScript modelan la diversidad de comportamientos que puede exhibir un objeto JavaScript. Por

ejemplo, la biblioteca jQuery define un objeto, ' $ ' , que tiene métodos, como ’get’ (que envía un mensaje Ajax), y campos,
como ' browser ' (que proporciona información del proveedor del navegador). Sin embargo, los clientes jQuery también
pueden llamar a ' $ ' como una función. El comportamiento de esta función depende del tipo de parámetros pasados a la
función.

El siguiente fragmento de código captura un pequeño subconjunto del comportamiento de jQuery, lo suficiente como
para usar jQuery de una manera simple.

interface JQuery {
text(content: string);
}

interface JQueryStatic {
get(url: string, callback: (data: string) => any);
(query: string): JQuery;
}

declare var $: JQueryStatic;

$.get("http://mysite.org/divContent",
function (data: string) {
$("div").text(data);
}
);

La interfaz ' J Query Static ' hace referencia a otra interfaz: ' J Query ' . Esta interfaz representa una colección de uno o más
elementos DOM. La biblioteca j Query puede realizar muchas operaciones en dicha colección, pero en este ejemplo, el
cliente jQuery solo necesita saber que puede establecer el contenido de texto de cada elemento jQuery en una colección
pasando un anillo st al método ' text ' . La interfaz ' J Query Static ' también contiene un método, ’get’ , que realiza una
operación de obtención de Ajax en la URL proporcionada y hace los arreglos para invocar la devolución de llamada
proporcionada al recibir una respuesta.

Finalmente, la interfaz ' J Query Static ' contiene una firma de función desnuda

(query: string): JQuery;

La firma desnuda indica que las instancias de la interfaz son invocables. Este ejemplo ilustra que los tipos de
función TypeScript son solo casos especiales de tipos de objeto TypeScript. Específicamente, los tipos de función son los
tipos de objetos que contienen uno o más llamada firma s . Por esta razón, podemos escribir cualquier función ty pe como
un tipo de objeto literal. El siguiente ejemplo usa ambos formularios para describir el mismo tipo.

var f: { (): string; };

var sameType: () => string = f; // Ok
var nope: () => number = sameType; // Error: type mismatch
Mencionamos anteriormente que la función ' $ ' se comporta de manera diferente dependiendo del tipo de su
parámetro. Hasta ahora, nuestra escritura jQuery solo captura uno de estos comportamientos: devolver un objeto de
tipo ' J Query ' cuando se pasa una cadena. Para especificar múltiples comportamientos, TypeScript admite
la sobrecarga  de funciones en firmas en tipos de objetos. Por ejemplo, podemos agregar una firma de llamada adicional a
la interfaz ' J Query Static ' .

(ready: () => any): any;

Esta firma denota que se puede pasar una función como parámetro de la función ' $ ' . Cuando una función se pasa a ' $ ' ,
la biblioteca jQuery invocará esa función cuando un documento DOM esté listo. Debido a que TypeScript admite la
sobrecarga, las herramientas pueden usar TypeScript para mostrar todas las firmas de funciones disponibles con sus
sugerencias de documentación y proporcionar la documentación correcta una vez que una función ha sido llamada con
una firma particular.

Un cliente típico no necesitaría agregar ningún tipo de escritura adicional, sino que podría usar un tipo de escritura
proporcionado por la comunidad para descubrir (a través de la finalización de la declaración con sugerencias de
documentación) y verificar (a través de la comprobación estática) el uso correcto de la biblioteca, como en la siguiente
captura de pantalla.

La sección 3.3 proporciona información adicional sobre los tipos de objetos.

1.4 Subtipo estructural        
Los tipos de objetos se comparan estructuralmente.  Por ejemplo, en el fragmento de código a continuación,
la clase ' CPoint ' coincide con la interfaz ' Punto ' porque ' Punto C ' tiene todos los miembros requeridos
de ' Punto ' . Una clase puede declarar opcionalmente que implementa una interfaz, de modo que el compilador verificará
la declaración de compatibilidad estructural. El ejemplo también ilustra que un tipo de objeto puede coincidir con el tipo
inferido de un literal de objeto, siempre que el literal de objeto suministre todos los miembros requeridos.

interface Point {
x: number;
y: number;
}

function getX(p: Point) {

return p.x;
}
 class CPoint {
x: number;
y: number;
constructor(x: number, y: number) {
this.x = x;
this.y = y;
}
}

getX(new CPoint(0, 0)); // Ok, fields match

getX({ x: 0, y: 0, color: "red" }); // Extra fields Ok

getX({ x: 0 }); // Error: supplied parameter does not match

Consulte la sección 3.11 para obtener más información sobre comparaciones de tipos.

1.5 Mecanografía contextual        
Normalmente, la inferencia de tipos de TypeScript procede "de abajo hacia arriba " : desde las hojas de un árbol de
expresión hasta su raíz. En el siguiente ejemplo, TypeScript infiere ' número ' como el tipo de retorno de la
función ' mul ' al hacer fluir la información del tipo de abajo hacia arriba en la expresión de retorno.

function mul(a: number, b: number) {

return a * b;
}

Para las variables y parámetros sin una anotación de tipo o un valor predeterminado , mecanografiado infiere

tipo ' ninguna ' , asegurando que los compiladores no necesitan la información no local acerca de una función ' sitios de
llamadas s para inferir la función de ' tipo de retorno s. En general, este enfoque ascendente proporciona a los
programadores una intuición clara sobre el flujo de información de tipo.

Sin embargo, en algunos contextos limitados, la inferencia procede "de arriba abajo " del contexto de una
expresión. Cuando esto sucede, se llama tipificación contextual. La escritura contextual ayuda a las herramientas a
proporcionar información excelente cuando un programador está usando un tipo pero puede no conocer todos los
detalles del tipo. Por ejemplo, en el ejemplo de jQuery, arriba, el programador proporciona una expresión de función
como el segundo parámetro para el método ’get’. Durante el tipeo de esa expresión, las herramientas pueden suponer
que el tipo de expresión de la función es como se indica en la firma ’get’ y pueden proporcionar una plantilla que incluye
nombres y tipos de parámetros.

$.get("http://mysite.org/divContent",
function (data) {
$("div").text(data); // TypeScript infers data is a string
}
);

La tipificación contextual también es útil para escribir literales de objetos. A medida que el programador escribe el objeto
literal, el tipo contextual proporciona información que permite a las herramientas completar los nombres de los miembros
del objeto.

La sección 4.23 proporciona información adicional sobre expresiones contextualizadas.

1.6 clases        
La práctica de JavaScript tiene dos patrones de diseño muy comunes: el patrón de módulo y el patrón de clase. En
términos generales, el patrón del módulo usa cierres para ocultar nombres y encapsular datos privados, mientras que el
patrón de clase usa cadenas de prototipos para implementar muchas variaciones en los mecanismos de herencia
orientados a objetos. Las bibliotecas como ' prototype.js ' son típicas de esta práctica . Los espacios de nombres de
TypeScript son una formalización del patrón del módulo. (El término "patrón de módulo" es algo desafortunado ahora
que ECMAScript 2015 admite formalmente los módulos de una manera diferente de lo que prescribe el patrón de módulo.
Por esta razón, TypeScript utiliza el término "espacio de nombres" para su formalización del patrón de módulo).

Esta sección y la sección del espacio de nombres a continuación mostrarán cómo TypeScript emite JavaScript coherente e
idiomático al emitir código compatible con ECMAScript 3 o 5 para clases y espacios de nombres . El objetivo
de mecanografiado ' traducción s es emitir exactamente lo que un programador escriba la hora de implementar una clase
o espacio de nombres sin la ayuda de una herramienta. Esta sección también describirá cómo TypeScript infiere un tipo
para cada declaración de c lass. Nos ' Comenzaremos con una simple clase BankAccount.

class BankAccount {
balance = 0;
deposit(credit: number) {
this.balance += credit;
return this.balance;
}
}

Esta clase genera el siguiente código JavaScript.

var BankAccount = (function () {

function BankAccount() {
this.balance = 0;
}
BankAccount.prototype.deposit = function(credit) {
this.balance += credit;
return this.balance;
};
return BankAccount;
})();

Esta declaración de clase TypeScript crea una variable llamada ' BankAccount ' cuyo valor es la función constructora

para instancias ' BankAccount ' . Esta declaración también crea un tipo de instancia del mismo nombre. Si tuviéramos que
escribir este tipo como una interfaz, se vería así.

interface BankAccount {
balance: number;
deposit(credit: number): number;
}

Si escribiéramos la declaración del tipo de función para la variable constructora ' BankAccount ' , tendría la siguiente
forma.

var BankAccount: new() => BankAccount;

La firma de la función se prefija con la palabra clave ' nueva ' que indica que la ' BankAccount ' función de must ser
llamado como un constructor. Es posible que unas funciones de  tipos de tener ambas firmas llamadas y constructor. Por
ejemplo, el tipo de la Fecha incorporado en JavaScript objeto incluye ambos tipos de firmas.
Si queremos comenzar nuestra cuenta bancaria con un saldo inicial, podemos agregar a la clase ' BankAccount ' una
declaración de constructor.

class BankAccount {
balance: number;
constructor(initially: number) {
this.balance = initially;
}
deposit(credit: number) {
this.balance += credit;
return this.balance;
}
}

Esta versión de la clase ' BankAccount ' requiere que introduzcamos un parámetro constructor y luego lo asignemos

al campo ' balance ' . Para simplificar este caso común, TypeScript acepta la siguiente sintaxis abreviada.

class BankAccount {
constructor(public balance: number) {
}
deposit(credit: number) {
this.balance += credit;
return this.balance;
}
}

La palabra clave ' public ' denota que el parámetro constructor se debe retener como un campo. Público es

la accesibilidad predeterminada para los miembros de la clase, pero un programador también puede
especificar accesibilidad privada o protegida para un miembro de la clase. La accesibilidad es una construcción en tiempo
de diseño; se aplica durante la verificación de tipo estático, pero no implica ninguna ejecución de tiempo de ejecución.

Las clases de TypeScript también admiten herencia, como en el siguiente ejemplo.

class CheckingAccount extends BankAccount {

constructor(balance: number) {
super(balance);
}
writeCheck(debit: number) {
this.balance -= debit;
}
}

En este ejemplo, la clase ' CheckingAccount ' deriva  de la clase ' BankAccount ' . El constructor

de ' CheckingAccount ' llama al constructor de la clase ' BankAccount ' utilizando la palabra clave ' super ' . En el código
JavaScript emitido, el prototipo de ' CheckingAccount ' se encadenará al prototipo de ' BankAccount ' .

Las clases de TypeScript también pueden especificar miembros estáticos. Los miembros de la clase estática se convierten
en propiedades del constructor de la clase.

La Sección 8 proporciona información adicional sobre las clases.

1.7 Tipos de enumeración        
TypeScript permite a los programadores resumir un conjunto de constantes numéricas como un tipo de enum.  El siguiente
ejemplo crea un tipo de enumeración para representar operadores en una aplicación de calculadora.

const enum Operator {

ADD,
DIV,
MUL,
SUB
}

function compute(op: Operator, a: number, b: number) {

console.log("the operator is" + Operator[op]);
// ...
}

En este ejemplo, la función de cálculo registra el operador ' op ' usando una característica de tipos de enumeración:
mapeo inverso desde el valor de enumeración ( ' op ' ) a la cadena correspondiente a ese valor. Por ejemplo, la
declaración de ' Operador ' asigna automáticamente enteros, comenzando desde cero, a los miembros enumerados. La
Sección 9 describe cómo los programadores también pueden asignar explícitamente enteros a miembros de enumeración,
y pueden usar cualquier cadena para nombrar un miembro de enumeración.

Cuando las enumeraciones se declaran con la constante modifier, el compilador TypeScript emitirá para un miembro
enum una constante JavaScript correspondiente a ese miembro ' valor asignado s (anotado con un comentario). Esto
mejora el rendimiento en muchos motores de JavaScript.

Por ejemplo, la función ' calcular ' podría contener una declaración de cambio como la siguiente.

switch (op) {
case Operator.ADD:
// execute add
break;
case Operator.DIV:
// execute div
break;
// ...
}

Para esta declaración de cambio, el compilador generará el siguiente código.

switch (op) {
case 0 /* Operator.ADD */:
// execute add
break;
case 1 /* Operator.DIV */:
// execute div
break;
// ...
}

Las implementaciones de JavaScript pueden usar estas constantes explícitas para generar código eficiente para esta
declaración de cambio, por ejemplo, creando una tabla de salto indexada por valor de caso.

1.8 Sobrecarga en los parámetros de cadena        

Un objetivo importante de TypeScript es proporcionar tipos precisos y directos para los patrones de programación
JavaScript existentes. Para ese fin, TypeScript incluye tipos genéricos, discutidos en la siguiente sección, y sobrecarga en
los parámetros de cadena, el tema de esta sección.

Las interfaces de programación de JavaScript a menudo incluyen funciones cuyo comportamiento es discriminado por una
constante de cadena que se pasa a la función. El Modelo de Objetos del Documento hace un uso intensivo de este
patrón. Por ejemplo, la siguiente captura de pantalla muestra que
el método ' createElement ' del objeto ' document ' tiene múltiples firmas, algunas de las cuales identifican los tipos
devueltos cuando se pasan cadenas específicas al método.

El siguiente fragmento de código utiliza esta función. Debido a que se infiere que la variable ' span ' tiene el
tipo ' HTMLSpanElement ' , el código puede hacer referencia sin error estático a la propiedad ' isMultiline ' de ' span ' .

var span = document.createElement("span");

span.isMultiLine = false; // OK: HTMLSpanElement has isMultiline property

En la siguiente captura de pantalla, una herramienta de programación combina información de sobrecarga en parámetros
de cadena con tipeo contextual para inferir que el tipo de la variable ' e ' es ' MouseEvent ' y que, por lo tanto, ' e ' tiene
una propiedad ' clientX ' .

La Sección 3.9.2.4 proporciona detalles sobre cómo usar literales de cadena en firmas de funciones.

1.9 Tipos genéricos y funciones        

Al igual que la sobrecarga en los parámetros de cadena, los tipos genéricos  facilitan que TypeScript capture con precisión
el comportamiento de las bibliotecas de JavaScript. Debido a que permiten que la información de tipo fluya desde el
código del cliente, a través del código de la biblioteca y de regreso al código del cliente, los tipos genéricos pueden hacer
más que cualquier otra característica de TypeScript para admitir descripciones detalladas de API.

Para ilustrar esto, vamos a ' s echar un vistazo a parte de la interfaz de texto mecanografiado de la incorporada en el tipo
de matriz JavaScript. Puede encontrar esta interfaz en el archivo ' lib.d.ts ' que acompaña a una distribución TypeScript.

interface Array<T> {
reverse(): T[];
sort(compareFn?: (a: T, b: T) => number): T[];
// ...
}
 Las definiciones de interfaz, como la anterior, pueden tener uno o más parámetros de tipo  . En este caso,
la interfaz ' Array ' tiene un único parámetro, ' T ' , que define el tipo de elemento para la
matriz. El método ' inverso 'devuelve una matriz con el mismo tipo de elemento. El método de clasificación toma un
parámetro opcional, ' compareFn ' , cuyo tipo es una función que toma dos parámetros de tipo ' T ' y devuelve un
número. Finalmente, sort devuelve una matriz con el tipo de elemento ' T ' .

Las funciones también pueden tener parámetros genéricos. Por ejemplo, la interfaz de matriz contiene un método

de ' mapa ' , definido de la siguiente manera:

map<U>(func: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];

El método de mapa, invocado en una matriz ' a ' con el tipo de elemento ' T ' , aplicará la función ' func ' a cada elemento
de ' a ' , obteniendo un valor de tipo ' U ' .

El compilador TypeScript a menudo puede inferir parámetros de métodos genéricos, lo que hace innecesario que el
programador los proporcione explícitamente. En el siguiente ejemplo, el compilador deduce que el parámetro' U ' del
método de mapa tiene el tipo ' cadena ' , porque la función pasada al mapa devuelve una cadena.
 
function numberToString(a: number[]) {
var stringArray = a.map(v => v.toString());
return stringArray;
}

El compilador infiere en este ejemplo que la función ' numberToString ' devuelve una matriz de cadenas.

En TypeScript, las clases también pueden tener parámetros de tipo. El siguiente código declara una clase que implementa
una lista enlazada de elementos del tipo ' T ' . Este código ilustra cómo los programadores pueden restringir
los  parámetros de tipo para que se extiendan como tipo específico. En este caso, los elementos en la lista deben extender
el tipo ' NamedItem '. Esto permite que el programador implemente la función ' log ' , que registra el nombre del
elemento.

interface NamedItem {
name: string;
}

class List<T extends NamedItem> {

next: List<T> = null;

constructor(public item: T) {
}

insertAfter(item: T) {
var temp = this.next;
this.next = new List(item);
this.next.next = temp;
}

log() {
console.log(this.item.name);
}

// ...
}

La Sección 3.7 proporciona más información sobre los tipos genéricos.

1.10 Espacio de nombres s   
Las clases y las interfaces de apoyar el desarrollo de JavaScript a gran escala, proporcionando un mecanismo para
describir cómo utilizar un componente de software que se puede separar de Th en el componente ' aplicación
s. TypeScript impone la encapsulación  de la implementación en clases en tiempo de diseño (restringiendo el uso
de miembros privados y protegidos ), pero no puede imponer la encapsulación en tiempo de ejecución porque todas las
propiedades de los objetos son accesibles en tiempo de ejecución. Las versiones futuras de JavaScript pueden
proporcionar nombres privados  que permitirían la ejecución en tiempo de ejecución de miembros privados y protegidos .

En JavaScript, una forma muy común de imponer la encapsulación en tiempo de ejecución es utilizar el patrón del
módulo: encapsular campos privados y métodos utilizando variables de cierre. El patrón módulo es una forma natural
para proporcionar la estructura organizativa y las opciones de carga dinámica por sorteo ing un límite alrededor de un
software com ponente. El patrón del módulo también puede proporcionar la capacidad de introducir espacios de
nombres, evitando el uso del espacio de nombres global para la mayoría de los componentes de software.

El siguiente ejemplo ilustra el patrón del módulo de JavaScript.

(function(exports) {
var key = generateSecretKey();
function sendMessage(message) {
sendSecureMessage(message, key);
}
exports.sendMessage = sendMessage;
})(MessageModule);

Este ejemplo ilustra los dos elementos esenciales del patrón de módulo: un cierre de  módulo  y un objeto de  módulo.  El
cierre módulo es una función que encapsula el módulo de  aplicaciones, en este caso la variable 'key' y la
función ' sendMessage ' . El objeto del módulo contiene las variables y funciones exportadas del módulo. Los módulos
simples pueden crear y devolver el objeto del módulo. El módulo anterior toma el objeto del módulo como
parámetro, ' exporta ' y agrega la propiedad ' sendMessage ' al objeto del módulo. Este enfoque de aumento  simplifica la
carga dinámica de módulos y también admite la separación de código de módulo en múltiples archivos.

El ejemplo supone que un ámbito léxico externo define las

funciones ' generateSecretKey ' y ' sendSecureMessage ' ; también supone que el ámbito externo ha asignado el objeto
del módulo a la variable ' MessageModule ' .

Los espacios de nombres de TypeScript proporcionan un mecanismo para expresar sucintamente el patrón del

módulo. En TypeScript, los programadores pueden combinar el patrón del módulo con el patrón de la clase
anidando espacios de nombres y clases dentro de un espacio de nombres externo.

El siguiente ejemplo muestra la definición y el uso de un espacio de nombres simple.

namespace M {
var s = "hello";
export function f() {
return s;
}
}

M.f();
M.s; // Error, s is not exported

En este ejemplo, la variable ' s ' es una característica privada del espacio de nombres , pero la función ' f ' se exporta
desde el espacio de nombres y se puede acceder al código fuera del espacio de nombres . Si tuviéramos que describir el
efecto del espacio de nombres ' M ' en términos de interfaces y variables, escribiríamos
 interface M {
f(): string;
}

var M: M;

La interfaz ' M ' resume el comportamiento externamente visible del espacio de nombres ' M ' . En este ejemplo, podemos

utilizar el mismo nombre para la interfaz como para la variable inicializada porque en texto mecanografiado nombres de
tipos y nombres de variables no están en conflicto: cada ámbito léxico contiene un espacio de declaración de variables de
un espacio de declaración de tipo ND (ver s ección 2.3 para obtener más detalles).

El compilador de TypeScript emite el siguiente código JavaScript para el espacio de nombres:

var M;
(function(M) {
var s = "hello";
function f() {
return s;
}
M.f = f;
})(M || (M = {}));

En este caso, el compilador supone que el objeto de espacio de nombres reside en la variable global ' M ' , que puede o
no haberse inicializado en el objeto de espacio de nombres deseado .

1.11 Módulos   
TypeScript también admite módulos ECMAScript 2015 , que son archivos que contienen directivas
de importación  y exportación de  nivel superior . Para este tipo de módulo de la mecanografiado com piler puede emitir
tanto ECMAScript 2015 código compatible y hacia abajo a nivel de ECMAScript 3 o 5 código compatible para una variedad
de sistemas de módulo de carga, incluyendo CommonJS, asíncrono Módulo de Definición (AMD), y definición del módulo
universal (UMD )

2 conceptos básicos        

El resto de este documento es la especificación formal del texto mecanografiado lenguaje de programación y está

destinado a ser leído como un complemento de la ECMAScript 2015 Especificación del lenguaje ( en concreto, el estándar
ECMA-262 , 6  Edición ). Este documento describe la gramática sintáctica agregada por TypeScript junto con
ª 

el procesamiento en tiempo de compilación y la verificación de tipo realizada por el compilador TypeScript , pero solo

discute mínimamente el comportamiento en tiempo de ejecución de los programas, ya que está cubierto por la
especificación ECMAScript .

2.1         Convenios de gramática
La gramática sintáctica agregada por el lenguaje TypeScript se especifica a lo largo de este documento utilizando
las convenciones existentes y los nombres de producción de la gramática ECMAScript. En lugares
donde TypeScript aumenta una producción gramatical existente, se nota así. Por ejemplo:

Declaration: ( Modified )
…
InterfaceDeclaration
TypeAliasDeclaration
EnumDeclaration
La anotación ' (Modified)  ' indica que una producción gramatical existente está siendo reemplazada, y el ' ... '
hace referencia al contenido de la producción gramatical original.

Similar a la gramática ECMAScript, si la frase " [no hay LineTerminator aquí]  " aparece en el lado derecho de una
producción de la gramática sintáctica, indica que la producción no coincide si se produce un LineTerminator  en la
secuencia de entrada en el posición indicada

2.2 Nombres        
Un núcleo propósito de la mecanografiado compilador es rastrear las entidades nombradas en un programa y validar que
se utilizan según su significado designado. Los nombres en TypeScript se pueden escribir de varias maneras, según el
contexto. Específicamente, un nombre se puede escribir como

 un nombre identificador  ,
 un StringLiteral  en un nombre de propiedad,
 un NumericLiteral  en un nombre de propiedad, o
 un ComputedPropertyName  que denota un símbolo bien conocido ( 2.2.3 ) .

Por lo general , los nombres se escriben para ajustarse a la producción del identificador  , que es cualquier nombre
de identificador  que no es una palabra reservada.

2.2.1 Palabras reservadas        
Las siguientes palabras clave están reservadas y no se pueden usar como un Identificador:

break case catch class

const continue debugger default
delete do else enum
export extends false finally
for function if import
in instanceof new null
return super switch this
throw true try typeof
var void while with

Las siguientes palabras clave no se pueden utilizar como identificadores en el código de modo estricto, pero de lo
contrario no están restringidas:

implements interface let package

private protected public static
yield

Las siguientes palabras clave no se pueden usar como nombres de tipo definidos por el usuario, pero de lo contrario no
están restringidas :

any boolean number string

symbol

Las siguientes palabras clave tienen un significado especial en ciertos contextos, pero son identificadores válidos:

abstract as async await

constructor declare from get
is module namespace of
require set type
2.2.2         Nombres de propiedad
La producción de PropertyName a  partir de la gramática ECMAScript se reproduce a continuación:

PropertyName:
LiteralPropertyName
ComputedPropertyName

LiteralPropertyName:
IdentifierName
StringLiteral
NumericLiteral

ComputedPropertyName:
[ AssignmentExpression ]

Un nombre de propiedad puede ser cualquier identificador (incluida una palabra reservada), un literal de cadena, un
literal numérico o un nombre de propiedad calculado. Los literales de cadena se pueden usar para dar nombres de
propiedades que no son identificadores válidos, como nombres que contienen espacios en blanco. Los nombres de
propiedades literales numéricos son equivalentes a los nombres de propiedades literales de cadena con la representación
de cadena del literal numérico, tal como se define en la especificación ECMAScript.

2.2.3         Nombres de propiedades calculadas

ECMAScri pt 2015 permite literales y clases de objetos para declarar miembros con nombres de propiedad calculados. Un
nombre de propiedad calculada especifica una expresión que calcula el nombre de propiedad real en tiempo de
ejecución. Debido a que el nombre de la propiedad final no se conoce en tiempo de compilación, TypeScript solo puede
realizar comprobaciones limitadas para entidades declaradas con nombres de propiedad calculados . Sin embargo, un
subconjunto de nombres de propiedad calculados conocidos como símbolos conocidos  well-known symbols se puede
usar en cualquier lugar donde se espere un PropertyName  , incluidos los nombres de propiedad dentro de los tipos. Un
nombre de propiedad calculado es un símbolo bien conocido si tiene la forma

[ Symbol . xxx ]

En un símbolo bien conocido, el identificador a la derecha del punto debe denotar una propiedad del símbolo de tipo
primitivo en el tipo de la variable global ’Símbolo’, o de lo contrario se produce un error .

En un PropertyName  que especifica un ComputedPropertyName, se requiere que el nombre de la propiedad calculada

denote un símbolo bien conocido a menos que el nombre de la propiedad aparezca en una asignación de propiedad de
un objeto literal ( 4.5 ) o una declaración de miembro de propiedad en una clase no ambiental ( 8.4 )

A continuación se muestra un ejemplo de una interfaz que declara una propiedad con un nombre de símbolo conocido:

interface Iterable<T> {
[Symbol.iterator](): Iterator<T>;
}

TODO: Actualización para reflejar el tratamiento de  nombres de propiedades calculados con expresiones literales .

2.3         Declaraciones
Las declaraciones introducen el nombre s en su espacio de declaración  asociado s  . Un nombre debe ser único en su
espacio de declaración y puede denotar un valor  , un tipo  , o un espacio de nombres  , o alguna combinación de los
mismos . Efectivamente , un solo nombre puede tener hasta tres significados distintos . Por ejemplo:
 var X: string; // Value named X

type X = number; // Type named X

namespace X { // Namespace named X

type Y = string;
}

Un nombre que denota un valor tiene un tipo asociado (sección 3 ) y puede ser referenciado en
expresiones (sección 4.3 ) . Un nombre que denota un tipo puede usarse solo en una referencia de tipo o en el lado
derecho de un punto en una referencia de tipo ( 3.8.2 ) . Un nombre que denota un espacio de nombres se puede usar en
el lado izquierdo de un punto en una referencia de tipo.

Cuando se hace referencia a un nombre con múltiples significados, el contexto en el que se produce la referencia

determina el significado. Por ejemplo:

var n: X; // X references type

var s: X.Y = X; // First X references namespace, second X references value

En la primera línea, X hace referencia al tipo X porque ocurre en una posición de tipo. En la segunda línea, la primera X
hace referencia al espacio de nombres X porque aparece antes de un punto en un nombre de tipo, y la segunda X hace
referencia a la variable X porque aparece en una expresión.

Las declaraciones introducen los siguientes significados para el nombre que declaran:

 Una variable, parámetro, función, generador, variable miembro, miembro de la función, de acceso miembro,

o miembro de enum declaración introduce un significado de valor.
 Una interfaz, un alias de tipo o una declaración de parámetro de tipo introduce un significado de tipo.
 Una declaración de clase introduce un significado de valor (la función constructora) y en significado de tipo
(el tipo de clase ).
 Una declaración enum introduce un significado de valor (la instancia de enum ) y un significado de tipo (el tipo de
enumeración).
 Una declaración de espacio de nombres introduce un significado de espacio de nombres (el tipo y el contenedor
de espacio de nombres) y, si se instancia el espacio de nombres (sección 10.1 ), un significado de valor (la instancia
de espacio de nombres) .
 Una declaración de importación o exportación introduce los significados de la entidad importada o exportada.

A continuación se presentan algunos ejemplos de declaraciones que introducen múltiples significados para un nombre:

class C { // Value and type named C

x: string;
}

namespace N { // Value and namespace named N

export var x: string;
}

Los espacios de declaración existen de la siguiente manera:

 El espacio de nombres global, cada módulo y cada espacio de nombres declarado tiene un espacio de
declaración para sus entidades contenidas (ya sean locales o exportadas) .
 E ACH módulo tiene una DeCLARA espacio ción de sus entidades exportados . Todas las declaraciones de
exportación en el módulo contribuyen a este espacio de declaración.
  Cada espacio de nombres declarado tiene un espacio de declaración para sus entidades exportadas. Todas las
declaraciones de exportación en el espacio de nombres contribuyen a este espacio de declaración . Un espacio de
nombres del declarada espacio de declaración se comparte con otro espacio de nombres declarados s que tienen el
mismo contenedor raíz y el mismo cualificado na mí a partir de ese contenedor raíz .
 Cada declaración de clase tiene un espacio de declaración para miembros de instancia y parámetros de tipo , y
un espacio de declaración para miembros estáticos.
 Cada declaración de interfaz tiene un espacio de declaración para miembros y parámetros de tipo . Una
interfaz ' espacio de declaración s es compartida con otras interfaces que tienen el mismo contenedor raíz y el
mismo nombre calificado a partir de ese contenedor raíz .
 Cada declaración de enumeración tiene un espacio de declaración para sus miembros de enumeración. Una
enumeración ' s espacio de declaración se comparte con otras enumeraciones que tienen el mismo contenedor
raíz y el nam cualificado misma a partir de ese correo contenedor raíz .
 Cada declaración de alias de tipo tiene un espacio de declaración para sus parámetros de tipo.
 Cada función -como declaración (incluyendo declaraciones de funciones, constructor declaraciones , miembro
de la función declaraciones , declaraciones miembro de descriptor de acceso , las expresiones de función, y las
funciones de dirección ) tiene un espacio de declaración de los locales y los parámetros de tipo. Este espacio de
declaración incluye declaraciones de parámetros, todas las declaraciones locales de var y funciones ,
y declaraciones locales let, const, class, interface, type alias y enum que ocurren inmediatamente con en el cuerpo
de la función y no se anidan en bloques.
 Cada bloque de declaración tiene un espacio de declaración para las declaraciones locales let, const, class,
interface, ty pe alias y enum que ocurren inmediatamente dentro de ese bloque.
 Cada objeto literal tiene un espacio de declaración para sus propiedades.
 Cada tipo de objeto literal tiene un espacio de declaración para sus miembros.

Las declaraciones de nivel superior en un archivo fuente sin declaraciones de importación o exportación de nivel
superior pertenecen al espacio de nombres global  . Las declaraciones de nivel superior en un archivo fuente con una o
más declaraciones de importación o exportación de nivel superior pertenecen al módulo  representado por ese archivo
fuente.

El contenedor  de una entidad se define de la siguiente manera:

 El contenedor de una entidad declarada en una declaración de espacio de nombres es esa declaración de espacio

de nombres .
 El contenedor de una entidad declarada en un módulo es ese módulo.
 El contenedor de una entidad declarada en el espacio de nombres global es el espacio de nombres global .
 El contenedor de un módulo es el espacio de nombres global .

El contenedor  raíz  de una entidad se define de la siguiente manera:

 El contenedor raíz de una entidad no exportada es el contenedor de la entidad .

 La raíz de contenedores de una entidad exportada es la raíz de contenedores de la entidad ' s contenedor .

Intuitivamente, t él raíz contenedor de una entidad es el módulo más externa o cuerpo de espacio de nombres de dentro

de la cual la entidad es alcanzable.

Interfaces, enumeraciones y espacios de nombres son " Ende abierta d, " lo que significa que la interfaz ,

enumeración, y de espacio de nombres declaraciones con el mismo nombre cualificado en relación con una raíz común se
fusionan de forma automática. Para más detalles, consulte la sección s 7.2 , 9.3 y 10.5 .

Las instancias y los miembros estáticos en una clase están en espacios de declaración separados . Por lo tanto, se permite
lo siguiente:

clase C { x : número ; // Miembro de instancia static x : string;   // miembro estático }

             
    

2,4         Alcances
El alcance  de un nombre es la región del texto del programa dentro del cual es posible hacer referencia a la entidad
declarada por ese nombre sin calificación del nombre. El alcance de un nombre depende del contexto en el que se declara
el nombre. Los contextos se enumeran a continuación en orden de más externo a más interno:

 El alcance de un nombre declarado en el espacio de nombres global es el texto completo del programa.

 El alcance de un nombre declarado en un módulo es el archivo fuente de ese módulo.
 El alcance de un n nombre exportado declarado dentro de una declaración de espacio de nombres es el
cuerpo de esa declaración de espacio de nombres y cada declaración de espacio de nombres con la misma raíz y el
mismo nombre calificado relativo a esa raíz .
 El alcance de un nombre no exportado declarado dentro de una declaración de espacio de nombres es el cuerpo
de esa declaración de espacio de nombres .
 El alcance de un nombre de parámetro de tipo declarado en una declaración de clase o interfaz es que
la declaración completa, incluidas las restricciones, extiende la cláusula, implementa la cláusula y el cuerpo de
la declaración , pero no incluye las declaraciones de miembros estáticos.
 El alcance de un nombre de parámetro de tipo declarado en una declaración de alias de tipo es toda la
declaración de alias de tipo.
 El alcance de un nombre de miembro declarado en una declaración de enumeración es el cuerpo de
esa declaración y cada declaración de enumeración con la misma raíz y el mismo nombre calificado relativo a esa
raíz .
 El alcance de un parámetro de tipo nombre declarado en una llamada o la construcción de la firma es que toda
declaración de la firma, incluyendo las limitaciones, la lista de parámetros, y el tipo de retorno. Si la firma es parte de
la implementación de una función, el alcance incluye el cuerpo de la función.
 El alcance del nombre de un parámetro declarado en una llamada o firma de construcción es el resto de la
declaración de firma. Si la firma es parte de una declaración de tipo función con un cuerpo (incluida una declaración
de función, declaración de constructor, declaración de función de miembro, declaración de acceso de miembro,
expresión de función o función de flecha), el alcance incluye el cuerpo de esa declaración de tipo función .
 El alcance de una variable local o nombre de función declarada en cualquier parte del cuerpo de una declaración
de tipo función es el cuerpo de esa declaración de función probable .
 El alcance de una declaración local let, const, class, interface, type alias o enum declarada inmediatamente dentro
del cuerpo de una declaración de tipo función es el cuerpo de esa declaración de tipo función.
 El alcance de una declaración local let, const, class, interface, type alias o enum declarada inmediatamente dentro
de un bloque de declaración es el cuerpo de ese bloque de declaración.

Los ámbitos pueden superponerse, por ejemplo, mediante el anidamiento de espacios de nombres y funciones. Cuando
los alcances de dos nombre s solapamiento, el nombre con el más interno declaración tiene prioridad y el acceso
al exterior el nombre i s bien no es posible o sólo es posible por la calificación .

Cuando un identificador se resuelve como una Expresión primaria  (sección 4.3 ), solo se consideran los nombres en el
ámbito con un significado de valor y se ignoran otros nombres.

Cuando un identificador se resuelve como TypeName  (sección 3.8.2 ) , solo se consideran los nombres dentro del

alcance con un significado de tipo y se ignoran otros nombres.

Cuando un identificador se resuelve como un NameSpaceName  (sección 3.8.2 ) , sólo nombres en alcance con un

significado de espacio de nombres se consideran y OTH nombres er se ignoran.

TODO:  Incluye reglas específicas para la resolución de alias .

Tenga en cuenta que los miembros de la clase y la interfaz nunca están directamente dentro del alcance; solo se puede
acceder aplicando el operador de punto ( ' . ' ) A una clase o instancia de interfaz . Esto incluye también miembros de la
instancia actual en una función constructor o miembro, que se accede mediante la aplicación del operador de punto
a este .

Como implican las reglas anteriores, las entidades declaradas localmente en un espacio de nombres tienen un alcance
más cercano que las entidades exportadas declaradas en otras declaraciones de espacio de nombres para el
mismo espacio de nombres . Por ejemplo:

var x = 1 ; 
espacio de nombres M { export var x = 2 ;     console.log (x);     // 2 } espacio de nombres M {    
console.log (x);     // 2 } espacio de nombres M { var x = 3 ;     console.log (x);     // 3 }
    

    

1
 
 

3 Tipos
        

TypeScript agrega tipos estáticos opcionales a JavaScript. Tipos se utilizan para colocar restricción estática t s en entidades
de programas tales como func iones, variables y propiedades de modo que los compiladores y herramientas de desarrollo
pueden ofrecer una mejor verificación y asistencia durante el software de desarrollo . Mecanografiado ' s estática  en
tiempo de compilación tipo sys tem modelos de cerca la dinámica  del sistema de tipo de tiempo de ejecución de
JavaScript, lo que permite a los programadores para expresar con precisión las relaciones de tipo que se esperan de existir
cuando sus programas de gestión y hacer que esos supuestos previamente validados por
el mecanografiado compilador . Letra de imprenta ' análisis tipo s se produce completamente en tiempo de compilación y
añade ninguna sobrecarga de tiempo de ejecución para la ejecución del programa.

Todos los tipos en TypeScript son subtipos de un solo tipo superior llamado Cualquier tipo. La cualquier refere palabra
clave NCES este tipo. Cualquier tipo es el único que puede representar cualquier  valor de JavaScript sin
restricciones . Todos los demás tipos se clasifican como tipos primitivos  , tipos de objetos  , tipos de unión  , tipos de
intersección  , o parámetros de tipo  . Estos tipos introducen varias restricciones estáticas en sus valores.

Los tipos primitivos son el número, B ool ean, String, Símbolo, Vacío, Null, y U ndefined tipos junto con definidos por el
usuario tipos enum . El número , booleano , cadena , símbolo , y el vacío de palabras clave ref s rencia el número,
booleano, cadena , símbolo, y anular los tipos primitivos , respectivamente . El tipo de vacío existe únicamente para indicar
la ausencia de un valor, como en una función sin valor de retorno. No se posib le para hacer referencia de forma explícita
el Null y U ndefined tipos: sólo los valores  de esos tipos se puede hacer referencia , usin g los nulos y no
definidos Lite RAL .

Los tipos de objeto son todos los tipos de clase, interfaz, matriz, tupla, función y constructor . Los tipos de clase e interfaz
se introducen a través de declaraciones de clase e interfaz y se hace referencia por el nombre que se les da en sus
declaraciones. Los tipos de clase e interfaz pueden ser tipos genéricos  que tienen uno o más parámetros de tipo.
Los tipos de unión representan valores que tienen uno de varios tipos, y los tipos de intersección representan valores que
tienen simultáneamente más de un tipo .

Las declaraciones de clases, propiedades, funciones, variables y otras entidades del lenguaje asocian tipos con esas
entidades. El mecanismo por el cual se forma un tipo y se asocia con una entidad de lenguaje depende del tipo particular
de entidad. Por ejemplo, un espacio de nombres de declaración asocia el espacio de nombres con una n anónimo tipo
que contiene un conjunto de propiedades que corresponden a las variables exportadas y funciones en el espacio de
nombres , y una declaración de función asocia la función con un anónimo n tipo que contiene una firma de llamada
correspondiente a los parámetros y tipo de retorno de la función. Los tipos pueden asociarse con variables a través
de anotaciones de tipo  explícitas , como

var x: número ;

o mediante inferencia de tipo  implícita , como en

var x = 1 ;

que infiere que el tipo de ' x ' será el tipo primitivo Numérico porque ese es el tipo del valor utilizado para inicializar ' x ' .

3.1 El cualquier tipo        

El tipo A ny se usa para representar cualquier valor de JavaScript . Un valor del tipo Any admite las mismas
operaciones que un valor en JavaScript y se realiza una verificación de tipo estático mínimo para las operaciones en
cualquier valor . Específicamente, se puede acceder a las propiedades de cualquier nombre a través de un valor
Any y cualquier valor se puede llamar como funciones o constructores con cualquier lista de argumentos .

La cualquier refere palabra clave NCES la Cualquier tipo. En general, en lugares donde no se proporciona un tipo
explícitamente y TypeScript no puede inferir uno , se asume el tipo Any .

Any t ype es un supertipo de todos los tipos y se puede asignar a todos los tipos.

Algunos ejemplos:

var x : cualquiera ; // Tipo explícitamente var y;                  // Igual que y: any var z:

{a; segundo; };       // Igual que z: {a: any; b: cualquiera; }             

functio n f (x) {         // Igual que f (x: cualquier): void 

    console.log (x); 
}

3.2 Tipos primitivos        
Los primitivos tipos son el Número, B ool ean , S Tring , Símbolo, Vacío, Null, y U ndefined tipos y todos los tipos enum
definidos por el usuario.

3.2.1 El N umber T ipo        
El tipo primitivo Número corresponde al tipo primitivo JavaScript con un nombre similar y representa valores de coma
flotante IEEE 754 de formato de doble precisión de 64 bits.

El número clave palabra hace referencia a la N umber primitivo tipo y n literales Umeric puede ser usado para escribir
valores del número primitivo tipo.

Para fines de determinar las relaciones de tipo (sección 3.11 ) y acceder a las propiedades (sección 4.13 ) ,
el tipo primitivo Número se comporta como un tipo de objeto con los mismos vínculos apropiados que el tipo de interfaz
global ' Número ' .
Algunos ejemplos:

var x: número ; // Tipo explícitamente var y = 0 ; // Igual que y: número = 0 var z = 123.456 ; //

Igual que z: número = 123.456 var s = z.toFixed ( 2 ); // Propiedad de la interfaz numérica          
              
        
  

3.2.2 The Bool ean T ype        
El tipo primitivo booleano corresponde al tipo primitivo JavaScript con un nombre similar y representa valores lógicos que
son verdaderos o falsos.

La palabra clave booleana hace referencia al tipo primitivo booleano y los literales verdadero y falso hacen referencia

a los dos valores de verdad booleanos.

Para determinar las relaciones de tipo (sección 3.11 ) y acceder a las propiedades (sección 4.13 ) ,
el tipo primitivo booleano se comporta como un tipo de objeto con las mismas propiedades que el tipo de interfaz
global ' Boolean ' .

Algunos ejemplos:

var b: booleano ; // Tipo explícitamente var yes = true ;         // Igual que sí: boolean =

true var no = false ;         // Igual que no: boolean = false         

3.2.3 La cadena t ipo        

El tipo primitivo String corresponde al tipo primitivo JavaScript con un nombre similar y representa secuencias de
caracteres almacenados como unidades de código Unicode UTF-16.

La palabra clave s tring hace referencia al tipo primitivo de cadena y los literales de cadena se pueden usar para

escribir valores del tipo primitivo de cadena .

Para determinar las relaciones de tipo (sección 3.11 ) y acceder a las propiedades (sección 4.13 ) , el tipo primitivo String
se comporta como un tipo de objeto con las mismas propiedades que el tipo de interfaz global ' String ' .

Algunos ejemplos:

var s: cadena ; // Tipo explícitamente var empty = "" ; // Igual que empty: string = "" var abc

= ' abc ' ;        // Igual que abc: string = " abc " var c = abc.charAt ( 2 );  // Propiedad de la
interfaz de cadena          
         

3.2.4 El tipo de símbolo        

El tipo primitivo Símbolo corresponde al tipo primitivo JavaScript con un nombre similar y
representa tokens únicos que pueden usarse como claves para propiedades de objeto.

El símbolo keywor d hace referencia al tipo primitivo Símbolo . Valores de símbolo se obtienen usin g objeto global

'símbolo' que tiene un número de métodos y propiedades de un d puede invocarse como una función. En particular, el
objeto global 'Símbolo' define una serie de símbolos conocidos ( 2.2.3 ) que se pueden usar de manera similar a los
identificadores. Tenga en cuenta que el objeto 'Símbolo' solo está disponible en entornos ECMAScript 2015 .
Para determinar las relaciones de tipo (sección 3.11 ) y acceder a las propiedades (sección 4.13 ), el tipo primitivo Símbolo
se comporta como un tipo de objeto con las mismas propiedades que el tipo de interfaz global 'Símbolo '.

Algunos ejemplos:

var secretKey = Symbol (); var obj = {}; obj [secretKey ] = " mensaje secreto " ; // Use el símbolo

como clave de propiedad obj [Symbol.toStringTag] = "test" ; // Uso de símbolos conocidos 

  
  

3.2.5 El tipo vacío        

El V oid tipo , referenciado por el vacío de palabras clave, representa la ausencia de un valor y se utiliza como el tipo de
retorno de la función s sin valor de retorno.

Los únicos valores posibles para el tipo Void son nulos e indefinidos . El tipo Void es un subtipo del tipo Any y un
supertipo del tipo s nulo e indefinido , pero de lo contrario, Void no está relacionado con todos los demás tipos.

NOTA: Podríamos considerar no permitir declarar variables de tipo Void, ya que  no  tienen  ningún  propósito  útil  .  Sin
embargo, dado que Void está permitido como argumento de tipo para un tipo o  función  genérico  ,  no es posible rechazar
propiedades o parámetros de Void  .

3.2.6 El tipo nulo        

El tipo nulo se corresponde con el tipo primitivo JavaScript nombre similar y es del tipo de la nula literal.

El literal nulo hace referencia al único valor del tipo nulo. No es posible hacer referencia directa al tipo nulo en sí.

El tipo N ull es un subtipo de todos los tipos, más allá del tipo Indefinido . Esto significa s que NULL i s considerado un

VA valor de tapa para todos los tipos primitivos, tipos de objetos , tipos de unión, tipos de intersección, y los parámetros
de tipo, incluyendo incluso el número de Boole y primitivos tipos.

Algunos ejemplos:

var n: número = nulo ; // Las primitivas pueden ser nulas var x = null ;           // Igual que x: any
= null var e: Null;            // Error, lata ' t referencia de tipo Null   

3.2.7         El tipo indefinido

El tipo Indefinido corresponde al tipo primitivo JavaScript nombre similar y es el tipo de la indefinida li Teral.

T él indefinido literal denota el valor dado a todas las variables sin inicializar y es el único valor del tipo definido. No es
posible hacer referencia directa al tipo Indefinido en sí.

El tipo indefinido es un subtipo de todos los tipos. Esto significa que lo indefinido se considera un valor válido
para todos los tipos primitivos , tipos de objeto , tipos de unión, tipos de intersección y parámetros de tipo .

Algunos ejemplos:

var n: número ;          // Igual que n: número = indefinido 

var x = indefinido;      // Igual que x: any = undefined 
var e: Undefined;       // Error, lata ' t referencia de tipo Indefinido

3.2.8 Tipos de enumeración        
Los tipos de enumeración son distintos subtipos definidos por el usuario del tipo primitivo Número. Los tipos de
enumeración se declaran mediante declaraciones de enumeración (sección 9.1 ) y se hace referencia mediante referencias
de tipo (sección 3.8.2 ).

Los tipos de enumeración se pueden asignar al tipo primitivo Número y viceversa, pero los diferentes tipos de
enumeración no se pueden asignar entre sí.

3.2.9         Tipos literales de cadena

Las firmas especializadas (sección 3.9.2.4 ) permiten utilizar literales de cadena como tipos en anotaciones de tipo de
parámetro. Los tipos literales de cadena solo se permiten en ese contexto y en ningún otro lugar.

Todos los tipos literales de cadena son subtipos del tipo primitivo de cadena.

TODO: Actualización para reflejar  el soporte ampliado para los tipos literales de cadena .

3,3         Tipos de objeto
Los tipos de objetos se componen de propiedades, firmas de llamada, firmas de construcción y firmas de índice ,
denominadas colectivamente miembros.

Las referencias de tipo de clase e interfaz, los tipos de matriz , los tipos de tupla, los tipos de funciones y los tipos de
constructor se clasifican como tipos de objeto. Múltiples construcciones en el lenguaje TypeScript crean tipos de objetos ,
que incluyen:

 Literales de tipo de objeto (sección 3.8.3 ).

 Literales de tipo de matriz (sección 3.8.4 ).
 Tuples de tipo literales (sección 3.8.5 ).
 Literales de tipo de función (sección 3.8.8 ).
 Literales de tipo de constructor (sección 3.8.9 ).
 Literales de objeto (sección 4.5 ).
 Arreglos literales (sección 4.6 ).
 Expresiones de funciones (sección 4.10 ) y declaraciones de funciones ( 6.1 ).
 Tipos de función de constructor creados por declaraciones de clase (sección 8.2.5 ).
 Espacio de nombres tipos de instancias creadas por espacio de nombres declaraciones (sección 10.3 ).

3.3.1         Referencias de tipo con nombre

Las referencias de tipo (sección 3.8.2 ) a los tipos de clase e interfaz se clasifican como tipos de objeto. Las referencias de
tipo a clases genéricas y tipos de interfaz incluyen argumentos de tipo que se sustituyen por los parámetros de tipo de la
clase o interfaz para producir un tipo de objeto real.

3.3.2         Tipos de matriz
Los tipos de matriz  representan matrices de JavaScript con un tipo de elemento común. Los tipos de matriz son
referencias de tipo con nombre creadas a partir del tipo de interfaz genérico ' Array ' en el espacio de nombres global con
el tipo de elemento de matriz como argumento de tipo . Los literales de tipo matriz (sección 3.8.4 ) proporcionan una
notación abreviada para crear tales referencias.

La declaración de la interfaz ' Array ' incluye una propiedad ' length ' y una firma de índice numérico para el tipo de
elemento, junto con otros miembros:

interfaz Array <T> { 
    longitud: número ; 
    [x: número ]: T; // Otros miembros }
    
Los literales de matriz (sección 4.6 ) pueden usarse para crear valores de tipos de matriz. Por ejemplo

var a: cadena [] = [ " hola " , " mundo " ];

Se dice que un tipo es de tipo matriz  si es asignable (sección 3.11.4 ) al tipo any [] .

3.3.3         Tipos de tuplas
Los tipos de tupla  representan matrices de JavaScript con tipos de elementos individualmente rastreados . Los tipos de
tupla se escriben usando literales de tipo tupla (sección 3.8.5 ). Un tipo tupla combinan s un conjunto de propiedades
numéricamente nombradas con los miembros de un tipo de matriz . Específicamente, un tipo de tupla

[T0, T1, ..., Tn]

combina el conjunto de propiedades

{ 
    0: T0; 
    1: T1; 
    ... 
    n: Tn; 
}

con los miembros de un tipo de matriz cuyo tipo de elemento es el tipo de unión (sección 3.4 ) de los tipos de elementos
de tupla.

Los literales de matriz (sección 4.6 ) se pueden usar para crear valores de tipos de tupla. Por ejemplo :

var t: [ número , cadena ] = [ 3 , " tres " ]; 

var n = t [ 0 ];  // Tipo de n es el número 
var s = t [ 1 ];  // El tipo de s es string 
var i: number ; 
var x = t [i];  // Tipo de x es número | cuerda

Los tipos de tuplas con nombre se pueden crear declarando interfaces que se derivan de la matriz <T> e introducen
propiedades con nombre numérico. Por ejemplo:

La interfaz KeyValuePair <K, V> extiende la matriz <K | V> { 0 : K; 1 : V; }

var x: KeyValuePair < número , cadena > = [ 10 , "diez" ];

Un tipo se dice que es una tupla  tipo -como  si tiene una propiedad con el nombre de '0'.

3.3.4 Tipos de funciones        
Se dice que un tipo de  objeto que contiene una o más firmas de llamada es un tipo de función  . Los tipos de función se
pueden escribir utilizando literales de tipo de función (sección 3.8.8 ) o incluyendo firmas de llamada en literales de tipo
de objeto.

3.3.5 Tipos de constructor        
Se dice que un tipo de  objeto que contiene una o más firmas de construcción es un tipo de  constructor  . Los tipos de
constructor se pueden escribir utilizando literales de tipo de constructor (sección 3.8.9 ) o incluyendo firmas de
construcción en literales de tipo de objeto.

3.3.6         Miembros
Cada tipo de objeto está compuesto de cero o más de los siguientes tipos de miembros:
  Properties  , que definen los nombres de un d tipos de las propiedades de objeto s del tipo dado. Los nombres de
propiedad son únicos dentro de su tipo.
 Llame a las firmas  , las cuales definen las posibles listas de parámetros y volver tipo s asociados con la
aplicación operación de llamada s a objetar s del tipo dado.
 Construir  firmas  , que definen los posibles listas de parámetros y volver tipo s asociada con la aplicación de
t él nuevo operador de oponerse s del tipo dado.
 Firmas de índice  , que definen restricciones de tipo para propiedades en el tipo dado. Un tipo de objeto puede
tener como máximo una firma de índice de cadena y una firma de índice numérico.

Las propiedades son públicas  , privadas  o protegidas  y son obligatorias  u opcionales  :

 Las propiedades en una declaración de clase pueden designarse como públicas, privadas o protegidas , mientras

que las propiedades declaradas en otros contextos siempre se consideran públicas. Los miembros privados solo son
accesibles dentro de su clase de declaración , como se describe en la sección 8.2.2 , y las propiedades privadas solo
coinciden entre sí en las verificaciones de compatibilidad de subtipos y asignaciones , como se describe en la
sección 3.11 . Los miembros protegidos solo son accesibles dentro de su clase declarante y las clases derivadas
de ella, como se describe en la sección 8.2.2 , y las propiedades protegidas solo coinciden entre sí y anulan en las
verificaciones de compatibilidad de subtipos y asignaciones , como se describe en la sección 3.11 .
 Las propiedades en una declaración de interfaz o literal de tipo de objeto pueden designarse como obligatorias u
opcionales, mientras que las propiedades declaradas en otros contextos siempre se consideran obligatorias . Las
propiedades que son opcionales en el tipo de destino de una asignación pueden omitirse de los objetos de origen,
como se describe en la sección 3.11.4 .

Las firmas de llamada y construcción pueden ser especializadas  (sección 3.9.2.4 ) al incluir parámetros con tipos literales
de cadena. Las firmas especializadas se utilizan para expresar patrones donde los valores de cadena específicos para
algunos parámetros hacen que los tipos de otros parámetros o el resultado de la función se especialicen aún más.

3.4         Tipos de unión
Los tipos de unión  representan valores que pueden tener una de varias representaciones distintas . Un valor de una unión
tipo A  | B  es un valor que es ya sea  de tipo A  o tipo B  . Los tipos de unión se escriben usando literales de tipo de unión
(sección 3.8.6 ).

Un tipo de unión abarca un conjunto ordenado de tipos constituyentes . Si bien es generalmente cierto que A  | B  es
equivalente a B  | A  , el orden de los tipos constituyentes puede ser importante al determinar la llamada y construir firmas
del tipo de unión.

Los tipos de unión tienen las siguientes relaciones de subtipo:

 Un tipo de unión T  es un subtipo de un tipo T  si cada tipo en T  es un subtipo de T  .

 Un tipo T  es un subtipo de un tipo de unión T  si T  es un subtipo de cualquier tipo T  .

Del mismo modo, los tipos de unión tienen las siguientes relaciones de asignabilidad:

 Un tipo de unión T  es asignable a un tipo T  si cada tipo en U  es asignable a T  .

 Un tipo T  se puede asignar a un tipo de unión T  si T  es asignable a cualquier tipo de U  .

El || y los operadores condicionales (sección 4.19.7 y 4.20 ) pueden producir valores de tipos de unión, y los literales de
matriz (sección 4.6 ) pueden producir valores de matriz que tienen tipos de unión como sus tipos de elementos.

Los protectores de tipo (sección 4.24 ) pueden usarse para reducir un tipo de unión a un tipo más específico. En particular,
los protectores de tipo son útiles para limitar los valores de tipo de unión a valores de tipo no sindicalizados.

En el ejemplo
var x: cadena | número ; prueba 
var : boolean ; 
x = "hola" ;            // Ok 
x = 42 ;                 // Ok 
x = prueba;               // Error, booleano no asignable 
x = prueba? 5 : "cinco" ;  // Ok 
x = prueba? 0 : falso ;   // Error, número | booleano no culo ignable

es posible asignar a 'x' un valor de tipo cadena , número o la cadena tipo unión | número , pero no cualquier otro
tipo. Para acceder a un valor en 'x', se puede usar un protector de tipo para reducir primero el tipo de 'x'
a cadena o número :

var n = typeof x === "cadena" ? x.length: x;  // Tipo de n es numero

Para fines de acceso a la propiedad y llamadas a funciones , los miembros aparentes (sección 3.11.1 ) de un tipo de

unión son aquellos que están presentes en cada uno de sus tipos constituyentes, con tipos que son uniones de los
miembros aparentes respectivos en los tipos constituyentes . El siguiente ejemplo ilustra la fusión de tipos de miembros
que ocurre cuando se crean tipos de unión a partir de tipos de objeto.

interfaz A { 
    a: cadena ; 
    b: número ; 
}
interfaz B { 
    a: número ; 
    b: número ; 
    c: número ; 
}
var x: A | SEGUNDO; 
var a = xa;  // a tiene tipo cadena | número 
var b = xb;  // b tiene el número de tipo 
var c = xc;  // Error, no hay propiedad c en tipo de unión

Tenga en cuenta que 'xa' tiene un tipo de unión porque el tipo de 'a' es diferente en 'A' y 'B', mientras que 'xb'
simplemente tiene un número de tipo porque ese es el tipo de 'b' en 'A' y 'SEGUNDO'. También tenga en cuenta que no
existe la propiedad 'xc' porque solo 'B ' tiene una propiedad 'c'.

Cuando se usa como un tipo contextual (sección 4.23 ), un tipo de unión tiene aquellos miembros que están presentes en
cualquiera de sus tipos constituyentes, con tipos que son uniones de los miembros respectivos en los tipos
constituyentes. Específicamente, un tipo de unión utilizado como tipo contextual tiene los miembros aparentes definidos
en la sección 3.11.1 , excepto que un miembro particular solo necesita estar presente en uno o más tipos constituyentes
en lugar de todos los tipos constituyentes.

3.5         Tipos de intersección
Los  tipos de  intersección  representan valores que simultáneamente tienen múltiples tipos. Un valor de un tipo de
intersección A  y B  es un valor que es tanto  de tipo A  y tipo B  . Los tipos de intersección se escriben usando literales de
tipo intersección (sección 3.8.7 ).

Un tipo de intersección abarca un conjunto ordenado de tipos constituyentes. Si bien es generalmente cierto que A  y B  es
equivalente a B  y A  , el orden de los tipos constituyentes puede ser importante al determinar la llamada y construir firmas
del tipo de intersección.

Los tipos de intersección tienen las siguientes relaciones de subtipo:

 A n intersección tipo I  es un subtipo de un tipo T  si cualquier tipo I  es un subtipo de T  .

 Un tipo T  es un subtipo de una intersección tipo I  si T  es un subtipo de cada tipo en I  .
Del mismo modo, los tipos de intersección tienen las siguientes relaciones de asignabilidad:

 Un tipo de intersección que  se puede asignar a un tipo T  , si cualquier tipo en que  se puede asignar a T  .
 Un tipo T  es asignable a un tipo de intersección I  si T  es asignable a cada tipo en I  .

Para fines de acceso a la propiedad y llamadas a funciones , los miembros aparentes (sección 3.11.1 ) de un tipo de

intersección n son aquellos que están presentes en uno o más de sus tipos constituyentes, con tipos que
son intersecciones de los miembros aparentes respectivos en el tipos constituyentes Los siguientes ejemplos ilustran la
fusión de tipos de miembros que ocurre cuando se crean tipos de intersección a partir de tipos de objetos.

interfaz A {a: número } 
interfaz B {b: número }
var ab : A y B = {a: 1 , b: 1 }; 
var a: A = ab; // A y B asignables a A var b: B = ab; // A y B asignables a B  
 
interfaz X {p: A} 
interfaz Y {p: B}
var xy: X e Y = {p: ab }; // X e Y tiene la propiedad p de tipo A y B 
escriba F1 = (a : cadena , b: cadena ) => vacío ; 
tipo F2 = (a : número , b: número ) => vacío ;
var f: F1 y F2 = (a: cadena | número , b: cadena | número ) => {}; 
f ( "hola" , "mundo" ); // Ok f ( 1 , 2 ); // Ok f ( 1 , "prueba" ); // Error  
              
        

Los operadores de tipo unión e intersección se pueden aplicar a los parámetros de tipo. Esta capacidad se puede usar, por
ejemplo, para modelar funciones que combinan objetos:

función extender <T, U> (primero: T, segundo: U): T & U { // Extender primero con propiedades de
segundo }
    

var x = ext final ({a: "hola" }, {b: 42 }); 

var s = xa; 
var n = xb;

Es posible crear tipos de intersección para los cuales no son posibles valores distintos de nulo o indefinido. Por ejemplo,
las intersecciones de tipos primitivos como cadena y número se incluyen en esta categoría.

3.6 Parámetros de tipo        
Un parámetro de tipo representa un tipo real al que está vinculado el parámetro en una referencia de tipo genérico o una
llamada de función genérica. Los parámetros de tipo tienen restricciones que establecen límites superiores para sus
argumentos de tipo reales.

Dado que un parámetro de tipo representa una multitud de argumentos de tipo diferentes, los parámetros de tipo tienen
ciertas restricciones en comparación con otros tipos. En particular, un parámetro de tipo no puede usarse como una clase
base o interfaz.

3.6.1         Listas de parámetros de tipo

Las declaraciones de clase, interfaz, alias de tipo y función pueden incluir opcionalmente listas de parámetros de tipo
entre corchetes <y>. Los parámetros de tipo también están permitidos en las firmas de llamada de los literales de tipo de
objeto, función y constructor.

TypeParameters: 
< TypeParameterList  >     
 TypeParameterList: 
TypeParameter 
TypeParameterList  , TypeParameter     

TypeParameter: 
Binding  Identifier  Restricción    
opt

Restricción: 
extiende el tipo  

Los nombres de los parámetros de tipo deben ser únicos. Se produce un error en tiempo de compilación si dos o más
parámetros de tipo en la misma TypeParameterList  tienen el mismo nombre.

El alcance de un parámetro de tipo se extiende sobre toda la declaración con la que está asociada la lista de parámetros
de tipo, con la excepción de las declaraciones de miembros estáticos en las clases.

Un parámetro de tipo puede tener una restricción de  parámetro de tipo asociada que establece un límite superior para
los argumentos de tipo . Se puede hacer referencia a los parámetros de tipo en las restricciones de parámetros de tipo
dentro de la misma lista de parámetros de tipo, incluidas las declaraciones de restricciones que se producen a la izquierda
del parámetro de tipo.

La restricción base  de un parámetro de tipo T  se define de la siguiente manera:

 Si T  tiene ninguna restricción declarada, T  ' restricción de base s es el tipo de objeto vacío {} .
 Si T  ' restricción declarada s es un parámetro de tipo, T  ' restricción de base de s es la del tipo de parámetro.
 De lo contrario, T  ' restricción de base de s es T  ' restricción declarada s.

En el ejemplo

interfaz G <T, U extiende V, V extiende Función> {}

la restricción base de 'T' es el tipo de objeto vacío y la restricción base de 'U' y 'V' es 'Función' .

Para determinar las relaciones de tipo (sección 3.11 ), los parámetros de tipo parecen ser subtipos de su restricción
base. Del mismo modo, en los accesos a propiedades (sección 4.13 ), nuevas operaciones (sección 4.14 ) y llamadas a
funciones (sección 4.15 ), los parámetros de tipo parecen tener los miembros de su restricción base, pero no otros
miembros.

Es un error que un parámetro de tipo sea directa o indirectamente una restricción para sí mismo. Por ejemplo, las dos
declaraciones siguientes no son válidas:

interfaz A <T extiende T> {}
interfaz B <T extiende U, U extiende T> {}

3.6.2         Listas de argumentos de tipo

Una referencia de tipo (sección 3.8.2 ) a un tipo genérico debe incluir una lista de argumentos de tipo encerrados entre
corchetes angulares y separados por comas. De manera similar, una llamada (sección 4.15 ) a una función genérica puede
incluir explícitamente una lista de argumentos de tipo en lugar de depender de la inferencia de tipo.

TypeArguments: 
< TypeArgumentList  >     

TypeArgumentList: 
TypeArgument 
TypeArgumentList  , TypeArgument     
 Tipo  Argumento: 
Tipo

Los argumentos de tipo corresponden uno a uno con los parámetros de tipo del tipo genérico o función a la que se hace
referencia. Se requiere una lista de argumentos de tipo para especificar exactamente un argumento de tipo para cada
parámetro de tipo correspondiente, y cada argumento de tipo para un parámetro de tipo restringido es necesario
para satisfacer  la restricción de ese parámetro de tipo. Un argumento de tipo satisface una restricción de parámetro de
tipo si el argumento de tipo es asignable a (sección 3.11.4 ) el tipo de restricción una vez que los argumentos de tipo son
sustituidos por parámetros de tipo.

Dada la declaración

interfaz G <T , U extiende Función > {}

una referencia de tipo de la forma ' G <A, B > ' no establece requisitos en ' A ' pero requiere que ' B ' sea asignable
a ' Función ' .

El proceso de sustitución de argumentos de tipo por parámetros de tipo en un tipo genérico o firma genérica se conoce
como instanciación  del tipo genérico o firma. La creación de instancias de un tipo genérico o firma puede fallar si los
argumentos de tipo suministrados no satisfacen las limitaciones de sus parámetros de tipo correspondientes.

3.6.3         Esto- tipos
Cada clase e interfaz tiene este tipo  que representa el tipo real de instancias de la clase o interfaz dentro de la declaración
de la clase o interfaz . Se hace referencia a este tipo utilizando la palabra clave this en una posición de tipo. Dentro de
los métodos de instancia y los constructores de una clase, el tipo de expresión this (sección 4.2 ) es el tipo this de la
clase.

Las pestañas e interfaces C admiten la herencia y, por lo tanto, la instancia representada por esto en un método no es

necesariamente una instancia de la clase que lo contiene; de hecho, puede ser una instancia de una clase o interfaz
derivada. Para modelar esta relación, el tipo de clase o interfaz se clasifica como parámetro de tipo. A diferencia de otros
parámetros de tipo, no es posible pasar explícitamente un argumento de tipo para este tipo. En cambio, en una referencia
de tipo a una clase o tipo de interfaz, la referencia de tipo en sí  se pasa implícitamente como un argumento de tipo para
este tipo. Por ejemplo:

clase A { 
    foo () { 
        devuelve esto; 
    } 
}
la clase B extiende A { 
    bar () {         devuelve esto;     } } 

dejar b: B; 
let x = b.foo (). bar (); // El patrón fluido funciona, el tipo de x es B

En la declaración de b más arriba, el tipo de referencia B es en sí mismo pasa como un argumento de tipo para este tipo
de B . Por lo tanto, la r eferen tipo ced es una instanciación de la clase B , donde todas las ocurrencias del
tipo este se reemplazan con B , y por esa razón el foo método de B devuelve realmente B (en contraposición a A ).

El tipo de este de una clase o tipo de interfaz dada C  implícitamente tiene una restricción que consiste en una referencia
de tipo de C  con C  propios parámetros de tipo 's pasados como argumentos de tipo y con esa referencia de tipo pasado
como el tipo de argumento para el este de tipo .

3.7         Tipos con nombre

Las clases es , las interfaces s, las enumeraciones y los alias de tipo son tipos con nombre  que se introducen a través
de declaraciones c lass (sección 8.1 ) , declaraciones de interfaz (sección 7.1 ) , declaraciones de enumeración ( 9.1 ) y
declaraciones de alias de tipo (sección 3.10 ) . Las clases, las interfaces y los alias de tipo pueden tener parámetros de tipo
y luego se denominan tipos genéricos  . Por el contrario, los tipos con nombre sin parámetros de tipo se denominan tipos
no genéricos  .

Las declaraciones de interfaz solo introducen tipos con nombre, mientras que las declaraciones de clase introducen tipos
con nombre y  funciones de constructor que crean instancias de implementaciones de esos tipos con nombre . Los tipos
con nombre introducidas por las declaraciones de clases e interfaces tienen sólo pequeñas diferencias de clase
( ES puede ' t declarar miembros opcionales e interfaz s puede ' t declarar privadas o protegidas miembros) y se
encuentran en la mayoría de los contextos intercambiables. En particular, las declaraciones de clase con
solo miembros públicos introducen tipos con nombre que funcionan exactamente como los creados por las declaraciones
de interfaz.

Los tipos con nombre se referencian a través de referencias de tipo  (sección 3.8.2 ) que especifican un nombre de tipo y,
si corresponde, los argumentos de tipo que se sustituirán por los parámetros de tipo del tipo con nombre.

Los tipos con nombre no son técnicamente tipos, solo lo son las referencias  a tipos con nombre. Esta distinción es
particularmente e vident con tipos genéricos: tipos genéricos son " plantillas " de la que
múltiples reales  tipos pueden ser creadas por escrito referencias tipo que s upply escriben argumentos para sustituir en
lugar del tipo genérico de ' parámetros de tipo s. Este proceso de sustitución se conoce como instanciar  un tipo
genérico . O ólo una vez al tipo genérico se instancia Qué denotar un tipo real.

TypeScri pt tiene un sistema de tipo estructural y , por lo tanto, una instancia de un tipo genérico es indistinguible de una
expansión escrita manualmente equivalente . Por ejemplo, dada la declaración

Par de interfaz <T1, T2> {primero: T1; segundo: T2; }

la referencia de tipo

Par < cadena , entidad>

es indistinguible del tipo

{primero: cadena ; segundo: entidad; }

3.8         Especificando tipos
Los tipos se especifican haciendo referencia a su palabra clave o nombre, o escribiendo literales de tipo de objeto ,
literales de tipo de matriz, literales de tipo de tupla , literales de tipo de función , literales de tipo de constructor o
consultas de tipo .

Tipo: 
UnionOrIntersectionOr  PrimaryType 
FunctionType 
ConstructorType

UnionOrIntersectionOrPrimaryType: 
UnionType 
IntersectionOrPrimaryType

IntersectionOrPrimaryType: 
IntersectionType 
PrimaryType
 Tipo  primario  : 
ParenthesizedType 
PredefinedType 
TypeReference 
ObjectType 
ArrayType 
TupleType 
TypeQuery 
ThisType

ParenthesizedType: 
( Tipo  )     

Los paréntesis requieren una unión redonda, intersección, función o tipos de constructor cuando se usan como tipos de

elementos de matriz; una ronda unión, función , o co nstruc tipos tor en tipos de intersección; y una función redonda o
tipos de constructor en tipos de unión. Por ejemplo:

( cadena | número ) [] 
((x: cadena ) => cadena ) | ( (x: número ) => número ) 
(A | B) y (C | D)

Las diferentes formas de anotaciones de tipo se describen en las siguientes secciones.

3.8.1         Tipos predefinidos
Las palabras clave any , number , boolean , string , symbol y void hacen referencia al tipo Any y
los tipos primitivos Number, Boolean, String , Symbol y Void respectivamente.

PredefinedType: 
cualquier 
número 
boolean 
string 
symbol 
void

Las palabras clave de tipo predefinidas se guardan y no se pueden usar como nombres de tipos definidos por el usuario .

3.8.2         Referencias de tipo
Una referencia de tipo hace referencia a un tipo con nombre o parámetro de tipo a través de su nombre y, en el caso de
un tipo genérico, proporciona una lista de argumentos de tipo.

TypeReference: 
TypeName  [no LineTerminator aquí]  TypeArguments       
opt

TypeName: Nombre de  espacio de nombres de  referencia de 

identificador  . I  dentificador  Referencia
     

NamespaceName  : 
Identificador de  referencia 
NamespaceName  . I  dentificador  Referencia     

Una TypeReference  consta de un TypeName  que hace referencia a un tipo o parámetro de tipo con nombre. Una
referencia a un tipo genérico debe ir seguida de una lista de argumentos  de tipo  (sección 3.6.2 ).
Un TypeName  es un identificador único o una secuencia de identificadores separados por puntos. En un nombre de tipo,
todos los identificadores, excepto el último, se refieren a espacios de nombres y el último identificador se refiere a un tipo
con nombre.

La resolución de un TypeName que  consiste en un único identificador se describe en la sección 2.4 .

Resolución de un TypeName  de la forma N.  X  , donde N  es un NameSpaceName  y X  es un Id  entifier  de referencia  ,

procede por resolver primero el espacio de nombres nombre N  . Si la resolución de N  es exitosa y el conjunto de
miembros de exportación (secciones 10.4 y 11.3.4.4 ) del espacio de nombres resultante contiene un tipo con nombre X  ,
entonces NX se  refiere a ese miembro. De lo contrario, NX  no está definido.

La resolución de un Nombre  de espacio  de nombres que  consiste en un único identificador se describe en la

sección 2.4 . Los dentificadores declarados en declaraciones de espacios de nombres (sección 10.1 ) o declaraciones de
importación (secciones 10.3 , 11.3.2 y 11.3.3 ) pueden clasificarse como espacios de nombres.

Resolución de un NameSpaceName  de la forma NX  , donde N  es un NameSpaceName  y X  es un identificador  de

referencia  , procede por resolver primero el espacio de nombres nombre N  . Si la resolución de N  es exitosa y el conjunto
de miembros de exportación (secciones 10.4 y 11.3.4.4 ) del espacio de nombres resultante contiene un miembro
de espacio de nombres exportado X  , entonces NX se  refiere a ese miembro. De lo contrario, NX  no está definido.

Se requiere una referencia de tipo a un tipo genérico para especificar exactamente un argumento

de tipo para cada parámetro de tipo del tipo genérico referenciado , y cada argumento de tipo debe ser asignable
a (sección 3.11.4 ) la restricción del parámetro de tipo correspondiente o de lo contrario se produce un error . Un ejemplo:

interfaz A { a: cadena ; }
la interfaz B extiende A { b: cadena ; }
la interfaz C extiende B {c: cadena ; }
interfaz G <T, U se extiende B > {     x: T;     Yu; } 

var v1: G <A, C >; // Ok var v2: G <{a: string }, C>;   // Ok, equivalente a G <A, C> var v3: G < A,
A >; // Error, un argumento no válido para U var v4: G <G <A, B >, C >; // Ok var v 5:
G < cualquiera , cualquiera >; // Ok var v6: G < cualquiera >;                // Error, número
incorrecto de argumentos var v 7 : G ; // Error, sin argumentos               

               
         
           

                    

Un argumento de tipo es simplemente un Tipo  y puede ser en sí mismo una referencia de tipo a un tipo genérico, como
lo demuestra ' v4 ' en el ejemplo anterior.

Como se describe en la sección 3.7 , una referencia de tipo a un tipo genérico G  designa un tipo en el que todas las
apariciones de los parámetros de tipo de G se  han reemplazado con los argumentos de tipo reales suministrados en la
referencia de tipo. Por ejemplo, la declaración de ' v1 ' anterior es equivalente a:

var v1: { 
    x: {a: cadena ; } 
    y: { a: cadena ; b: cadena ; c: cadena }; }; 

3.8.3         Tipo de objeto Literales

Un literal de tipo de objeto define un tipo de objeto al especificar el conjunto de miembros que se consideran
estáticamente presentes en instancias del tipo. Los literales de tipo de objeto pueden recibir nombres mediante
declaraciones de interfaz, pero por lo demás son anónimos.
 ObjectType: 
{ TypeBody  }     
opt 

TypeBody: 
TypeMemberList  ;  TypeMemberList  ,     
opt  opt

  

TypeMemberList: 
TypeMember 
TypeMemberList  ; TypeMember  TypeMemberList  , TypeMember      
     

TypeMember: 
PropertySignature 
CallSignature 
ConstructSignature 
IndexSignature 
MethodSignature

Los miembros de un tipo de objeto literal se especifican como una combinación de firmas de propiedad, llamada,
construcción, índice y método. Los miembros del tipo de objeto se describen en la sección 3.9 .

3.8.4         Array Type Literals
Un literal de tipo de matriz se escribe como un tipo de elemento seguido de un corchete abierto y cerrado.

ArrayType:  Tipo 
primario  [sin LineTerminator aquí]  [ ]        

Un literal de tipo de matriz hace referencia a un tipo de matriz (sección 3.3.2 ) con el tipo de elemento dado. Un literal
de tipo de matriz es simplemente una notación abreviada para una referencia al tipo de interfaz genérico ' Array ' en
el espacio de nombres global con el tipo de elemento como argumento de tipo .

Cuando los tipos de unión, intersección, función o constructor se utilizan como tipos de elementos de matriz, deben
encerrarse entre paréntesis. Por ejemplo:

( cadena | número ) [] 
(() => cadena )) []

Alternativamente , el tipo de matriz s se puede escribir usando la notación ' Array <T> ' . Por ejemplo, los tipos anteriores
son equivalentes a

Array < cadena | número > 
matriz <() => cadena >

3.8.5         Tuple Type Literals
Un literal de tipo tupla se escribe como una secuencia de tipos de elementos, separados por comas y encerrados entre
corchetes.

TupleType: 
[ TupleElementTypes  ]     

TupleElementTypes: 
TupleElementType 
TupleElementTypes  , TupleElementType     
 TupleElementType: 
Type

Un tipo de tupla literal hace referencia a un tipo de tupla (sección 3.3.3 ).

3.8.6         Literales tipo unión

Un literal de tipo de unión se escribe como una secuencia de tipos separados por barras verticales.

UnionType: 
Union  OrIntersectionOrPrimary  Type  | IntersectionOrP  rimaryType     

Un tipo de unión e literal hace referencia a un tipo de unión (sección 3.4 ).

3.8.7         Tipo de intersección Literales

Un literal de tipo de intersección se escribe como una secuencia de tipos separados por símbolos de unión.

Tipo de  intersección  : 

IntersectionOrPrimaryType  & PrimaryType     

Un literal típico de intersección hace referencia a un tipo de intersección (sección 3.5 ).

3.8.8         Tipo de función Literales
Un literal de tipo de función especifica los parámetros de tipo, los parámetros regulares y el tipo de retorno de una firma
de llamada.

FunctionType: 
TypeParameters  ( ParameterList  ) => Tipo              
opt  opt 

Un literal de tipo de función es una forma abreviada de un tipo de objeto que contiene una sola firma de
llamada. Específicamente, un tipo de función literal de la forma

<T1, T2, ...> (p1, p2, ...) => R

es exactamente equivalente al tipo de objeto literal

{<T1, T2, ...> (p1, p2, ...): R}

Tenga en cuenta que los tipos de función con múltiples firmas de llamada o construcción no pueden escribirse como
literales de tipo de función, sino que deben escribirse como literales de tipo de objeto.

3.8.9         Constructor Tipo Literales
Un literal de tipo de constructor especifica los parámetros de tipo, los parámetros regulares y el tipo de retorno de una
firma de construcción.

ConstructorType: 
new TypeParameters  ( ParameterList  ) => Tipo                 
opt  opt 

Un literal de tipo de constructor es la abreviatura de un tipo de objeto que contiene una única firma de
construcción. Específicamente, un tipo de constructor literal de la forma

nuevo <T1, T2, ...> (p1, p2, ...) => R

es exactamente equivalente al tipo de objeto literal

{ nuevo <T1, T2, ...> (p1, p2, ...): R}

Tenga en cuenta que los tipos de constructor con múltiples firmas de construcción no pueden escribirse como literales de
tipo de constructor, sino que deben escribirse como literales de tipo de objeto.

3.8.10     Consultas de tipo
Una consulta de tipo obtiene el tipo de una expresión.

TypeQuery: 
typeof TypeQueryExpression  

TypeQueryExpression: 
Identificador de  referencia 
TypeQueryExpression  . IdentifierName     

Una consulta de tipo consiste en la palabra clave typeof seguida de una expresión. La expresión está restringida a un
solo identificador o una secuencia de identificadores separados por puntos. La expresión se procesa como una expresión
de identificación (sección 4.3 ) o expresión de acceso a la propiedad (sección 4.13 ) , cuyo tipo ampliado (sección 3.12 )
se convierte en el resultado. Al igual que otras construcciones de escritura estática , las consultas de escritura se borran
del código JavaScript generado y no agregan sobrecarga en tiempo de ejecución.

Las consultas de tipos son útiles para capturar tipos anónimos generados por diversas construcciones, como literales de
objetos, declaraciones de funciones y declaraciones de espacios de nombres . Por ejemplo:

var a = {x: 10, y: 20}; 

var b: typeof a;

Arriba, ' b ' es dar n el mismo tipo que ' a ' , es decir, {x: número; y: número; } .

Si una declaración incluye una anotación de tipo que hace referencia a la entidad que se declara a través de una ruta
circular de consultas de tipo o referencias de tipo que contienen consultas de tipo , el tipo resultante es Cualquier
tipo. Por ejemplo , a todas las siguientes variables se les asigna el tipo Cualquiera:

var c: typeof c; 
var d: typeof e; 
var e: typeof d; 
var f: Matriz < typeof f>;

Sin embargo, si una ruta circular de consultas de tipo incluye al menos un ObjectType  , FunctionType  o ConstructorType  ,

la construcción denota un tipo recursivo:

var g: {x: typeof g; }; var h: () => typeof h; 

Aquí, ' g ' y ' gx ' tienen el mismo tipo recursivo, y del mismo modo ' h ' y ' h () ' tienen el mismo tipo recursivo.

3.8.11 Referencias de este tipo    

La palabra clave this se usa para hacer referencia al tipo t his (sección 3.6.3 ) de una clase o interfaz.

ThisType: 
this
El significado de una ThisType  depende el más cercano de
cerramiento FunctionDeclaration  , FunctionExpression  , PropertyDefinition  , ClassElement  o TypeMember  , conocida como
la declaración de la raíz de la ThisType  , de la siguiente manera:

 Cuando la declaración raíz es un miembro de la instancia o un constructor de una clase , ThisType hace  referencia
al this-type de esa clase.
 Cuando la declaración de la raíz es un miembro de un tipo de interfaz, la ThisType  hace referencia al tipo este de
esa interfaz.
 De lo contrario, el ThisType  es un error.

Tenga en cuenta que para evitar ambigüedades no es posible hacer referencia a este tipo de una clase o interfaz en un
tipo de objeto anidado literal. En el ejemplo

interfaz ListItem { 
    getHead (): esto ; 
    getTail (): esto ; 
    getHeadAndTail (): {head: this , tail: this };  // Error 
}

las referencias de este en la última línea son erróneas porque sus declaraciones raíz no son miembros de una clase o
interfaz. La forma recomendada para hacer referencia a la presente de tipo de una clase externa o la interfaz en un tipo de
objeto literal es declarar un tipo genérico intermedio y pasar este como un argumento de tipo. Por ejemplo:

escriba HeadAndTail <T> = {head: T, tail: T};

interfaz ListItem { 
    getHead (): esto ; 
    getTail (): esto ; 
    getHeadAndTail (): HeadAndTail < this >; 
}

3.9         Especificando miembros
Los miembros de un tipo n objeto literal (sección 3.8.3 ) se especifican como una combinación de la propiedad, llamar,
construir, índice , y método de firmas.

3.9.1 Firmas de propiedad        
Una firma de propiedad declara el nombre y el tipo de un miembro de la propiedad.

PropertySignature: 
PropertyName  ?  Tipo Anotación       
opt  opt

TypeAnnotation 
:: Type  

El PropertyName  ( 2.2.2 ) de una firma de propiedad debe ser único dentro de su tipo contenedor y debe denotar un
símbolo bien conocido si es un nombre de propiedad calculado ( 2.2.3 ). Si el nombre de la propiedad va seguido de un
signo de interrogación, la propiedad es opcional. De lo contrario, se requiere la propiedad.

Si una firma de propiedad omite una TypeAnnotation  , se asume el tipo Any .

3.9.2         Firmas de llamadas
Una firma llamada define los parámetros de tipo, lista de parámetros , y tipo de retorno asociados con la aplicación de
una operación de llamada (sección 4.15 ) a una instancia del tipo que contiene. Un tipo puede sobrecargar  las
operaciones de llamadas definiendo múltiples firmas de llamadas diferentes.

CallSignature: 
TypeParameters  ( ParameterList  ) TypeAnnotation             
opt  opt  opt
Una firma de llamada que incluye TypeParameters  (sección 3.6.1 ) se denomina firma de llamada genérica  . Por el
contrario, una firma de llamada sin TypeParameters  se denomina firma de llamada no genérica.

Además de ser miembros de literales de tipo de objeto, las firmas de llamada se producen en firmas
de método ( sección 3.9.5 ), expresiones de función ( sección 4.10 ) y declaraciones de función ( sección 6.1 ).

Se dice que un tipo de  objeto que contiene firmas de llamada es un tipo de función  .

3.9.2.1 Parámetros de tipo        
Los parámetros de tipo (sección 3.6.1 ) en las firmas de llamada proporcionan un mecanismo para expresar las relaciones
de los parámetros y los tipos de retorno en las operaciones de llamada. Por ejemplo, una firma podría introducir un
parámetro de tipo y utilizarlo como tanto un tipo de parámetro y un tipo de retorno, en efecto que describe una función
que la de regreso s un valor o f del mismo tipo que su argumento.

T ipo parámetros pueden ser referenciados en los tipos de parámetros y el tipo de retorno anotaciones , pero no en las
limitaciones de los parámetros de tipo, de la firma llamada en la que se introducen .

Los argumentos de tipo (sección 3.6.2 ) para los parámetros de tipo de firma de llamada pueden especificarse
explícitamente en una operación de llamada o, cuando sea posible, inferirse (sección 4.15.2 ) de los tipos de argumentos
regulares en la llamada. Una instancia  de una firma de llamada genérica para un conjunto particular de argumentos de
tipo es la firma de llamada formada al reemplazar cada parámetro de tipo con su argumento de tipo correspondiente.

A continuación se muestran algunos ejemplos de firmas de llamada con parámetros de tipo .

Una función que toma un argumento de cualquier tipo, devolviendo un valor del mismo tipo:

<T> (x: T): T

Una función que toma dos valores del mismo tipo y devuelve una matriz de ese tipo:

<T> (x: T, y: T): T []

Una función que toma dos argumentos de diferentes tipos, devolviendo un objeto con
los vínculos apropiados ' x ' e ' y ' de esos tipos:

<T, U> (x: T, y: U): {x: T; Yu; }

Una función que toma una matriz de un tipo y un argumento de función, devuelve una matriz de otro tipo, donde el
argumento de la función toma un valor del primer tipo de elemento de matriz y devuelve un valor del segundo tipo de
elemento de matriz:

<T, U> (a: T [], f: (x: T) => U): U []

3.9.2.2 Lista de parámetros        
Una firma ' s lista de parámetros consta de cero o más exigidas parámetros, seguido de cero o más parámetros
opcionales, finalmente seguida por un parámetro resto opcional.

ParameterList: 
RequiredParameterList 
OpcionalParameterList 
RestParameter 
RequiredParameterList  , OpcionalParameterList  RequiredParameterList  , RestParameter  OpcionalParameterList  , 
RestParameter  RequiredParameterList  , OpcionalParameterList  , RestParameter      
       
      
           

RequiredParameterList: 
RequiredParameter 
RequiredParameterList  , RequiredParameter     

RequiredParameter: 
AccessibilityModifier  BindingI  dentifier  OrPattern  TypeAnnotation  Binding  Identifier  : StringLiteral      
opt  opt 

     

AccessibilityModifier  : 
público 
privado 
protegido

Binding  IdentifierOrPattern:  Identificador de 

enlace  BindingPattern

OpcionalParameterList: 
OpcionalParameter 
OpcionalParameterList  , OpcionalParameter     

Parámetro  opcional: 
AccessibilityModifier  BindingI  dentifier  OrPattern  ? Tipo
opt 

Anotación  Accesibilidad  Modificador  Enlace  I  dentificador  O  Tipo

optar  optar 

de  patrón  Anotación  Inicializador  ¿ Identificador de  enlace  ? : StringLiteral         

optar 

         
        

RestParameter: 
... BindingI  dentifier  TypeAnnotation       
opt

Una declaración de parámetro puede especificar un identificador o un patrón de enlace ( 5.2.2 ). Los identificadores
especificados en las declaraciones de parámetros y los patrones de enlace en una lista de parámetros deben ser únicos
dentro de esa lista de parámetros.

El tipo de un parámetro en una firma se determina de la siguiente manera:

 Si la declaración incluye una anotación de tipo, el parámetro es de ese tipo.

 De lo contrario, si la declaración incluye una expresión de inicializador (que se permite solo cuando la lista de
parámetros se produce junto con un cuerpo de función), el tipo de parámetro es la forma ampliada (sección 3.12 )
del tipo de la expresión de inicializador.
 De lo contrario, si la declaración especifica un patrón de enlace, el tipo de parámetro es el tipo implícito de ese
patrón de enlace (sección 5.2.3 ).
 De lo contrario, si el parámetro es un parámetro de reposo, el tipo de parámetro es cualquiera [] .
 De lo contrario, el tipo de parámetro es any .

Se permite que un parámetro incluya un modificador público , privado o protegido solo si aparece en la lista de

parámetros de una ConstructorImplementation  (sección 8.3.1 ) y solo si no especifica un BindingPattern  .

Una anotación de tipo para un parámetro rest debe denotar un tipo de matriz.

Cuando un tipo de parámetro anotado especifica un tipo literal de cadena , la firma que contiene es una firma
especializada (sección 3.9.2.4 ). Las firmas especializadas no están permitidas junto con un cuerpo de función, es decir,
las producciones de
gramática FunctionExpression  , FunctionImplementation  , MemberFunctionImplementation  y ConstructorImplementation  no
permiten parámetros con tipos de cadenas literales.

Un parámetro puede marcarse como opcional siguiendo su nombre o patrón de enlace con un signo de interrogación
( ? ) O incluyendo un inicializador. Los inicializadores (incluidas las propiedades de enlace o los inicializadores de
elementos) solo se permiten cuando la lista de parámetros se produce junto con un cuerpo de función, es decir, solo
en una producción de gramática
de FunctionExpression  , FunctionImplementation  , MemberFunctionImplementation  o ConstructorImplementation  .

TODO: La actualización para reflejar el  parámetro de enlace no puede ser opcional en la firma de implementación .

TODO: la actualización para reflejar  los parámetros necesarios admite inicializadores .

3.9.2.3 Tipo de devolución        
Si está presente, una llamada de la firma ' s tipo de retorno de anotación especifica el tipo del valor calculado y devuelto
por una operación llamada . Se utiliza una anotación de tipo de retorno nulo para indicar que una función no tiene valor
de retorno.

Cuando se produce una firma de llamada sin anotación de tipo de retorno en un contexto sin cuerpo de función,
se supone que el tipo de retorno es Cualquier tipo.

W gallina una firma llamada con ningún tipo de retorno anotación se produce en un contexto que tiene un cuerpo de la
función ( en concreto, una implementación de la función , una implementación de la función miembro, o un miembro de
acceso declaración ) , el tipo de retorno se infiere de la cuerpo de la función como se describe en sección 6.3 .

3.9.2.4 Firmas especializadas        
Cuando una anotación de tipo de parámetro especifica un tipo literal de cadena (sección 3.2.9 ), la firma que lo contiene
se considera una firma especializada. S pecialized firmas se utilizan para expresar patrones donde específicos valores de
cadena para algunos parámetros causan los tipos de otro parámetro s o el resultado de la función a ser más
especializada. Por ejemplo, la declaración

Documento de interfaz { 
    createElement (tagName: " div " ): HTMLDivElement; 
    createElement (tagName: " span " ): HTMLSpanElement; 
    createElement (tagName: " canvas " ): HTMLCanvasElement; 
    createElement (tagName: string ): HTMLElement; 
}

establece que las llamadas a ' createElement ' con los literales de cadena " div " , " span " y " canvas " devuelven valores de

tipo ' HTMLDivElement ' , ' HTMLSpanElement ' y ' HTMLCanvasElement ' respectivamente, y que las llamadas con todas
las demás expresiones de cadena devuelven valores de tipo ' HTMLElement ' .

Al escribir declaraciones sobrecargadas como la anterior, es importante enumerar la firma no especializada al final . Esto
se debe a que la resolución de sobrecarga (sección 4.15.1 ) procesa a los candidatos en orden de declaración y elige el
primero que coincida.

Cada especializada llamada o construir la firma en un tipo de objeto ha de ser asignables a al menos una no
especializado llamada o construir sig naturaleza en el mismo tipo de objeto (donde una firma llamada A  se
considera un ssignable a otra firma llamada B  si un tipo de objeto que contiene solo A  sería asignable a un tipo de objeto
que solo contiene B  ) . Por ejemplo, la propiedad ' createElement ' en el ejemplo anterior es de un tipo que contiene tres
firmas especializadas, todas las cuales son asignables a la firma no especializada en el tipo.

3.9.3 Construir firmas        
Una construcción de la firma define la lista de parámetros y de retorno tipo asociado con la aplicación de
º e nuevo operador (sección 4.14 ) a una instancia del tipo que contiene. Un tipo puede SOBRECA d nueva oper un ciones
definiendo varios constructos firmas con diferentes parámetros listas .

ConstructSignature: 
nuevo TypeParameters  ( ParameterList  ) TypeAnnotation                
opt  opt  opt

Los parámetros de tipo, la lista de parámetros y el tipo de retorno de una firma de construcción están sujetos a las mismas
reglas que una firma de llamada .

Se dice que un tipo que contiene firmas de construcción es un tipo de  constructor  .

3.9.4         Firmas de índice
Una firma de índice define una restricción de tipo para las propiedades en el tipo contenedor.

IndexSignature: 
[ BindingI  dentifier  : string ] TypeAnnotation  [ BindingI  dentifier  : number ] TypeAnnotation               
              

Hay dos tipos de firmas de índice:

 Las firmas de índice de cadena  , especificadas mediante una cadena de tipo de índice , definen restricciones de
tipo para todas las propiedades y firmas de índice numérico en el tipo que lo contiene. En concreto, en un tipo con
una firma de índice serie es de tipo T  , todas las propiedades y firmas índice numérico deben tener tipos que
son asignables a T  .
 Las firmas de índice numérico  , especificadas usando el número de tipo de índice , definen restricciones de tipo
para todas las propiedades con nombre numérico en el tipo que lo contiene. En concreto, en un tipo con una firma
índice numérico de tipo T  , todas las propiedades numéricamente nombrados deben tener tipos que son asignables
a T  .

Una propiedad con nombre numérico  es una propiedad cuyo nombre es un literal numérico válido. Específicamente, una
propiedad con un nombre N  para los que ToString (ToNumber ( N  )) es idéntica a N  , donde ToString y ToNumber son la
operación abstracta s se define en la especificación de ECMAScript.

Un tipo de objeto puede contener como máximo una firma de índice de cadena y una firma de índice numérico.

Las firmas de índice afectan la determinación del tipo que resulta de aplicar un acceso de propiedad de notación de
paréntesis a una instancia del tipo que lo contiene, como se describe en la sección 4.13 .

3.9.5         Método de firmas
La firma de un método es una forma abreviada de declarar una propiedad de un tipo de función.

Firma del  método  : 

PropertyName  ?  CallSignature     
opt 

Si PropertyName  es un nombre de propiedad calculado ( 2.2.3 ), debe especificar un símbolo conocido. Si

el PropertyName  va seguido de un signo de interrogación, la propiedad es opcional. De lo contrario, se requiere la
propiedad. Solo los literales e interfaces de tipo de objeto pueden declarar propiedades opcionales.

Una firma de método del formulario

f < T1, T2, ... > ( p1, p2, ... ): R

es equivalente a la declaración de propiedad

f : {< T 1, T2, ... > ( p1, p2, ... ): R }

Un tipo literal puede sobrecargar  un método declarando firmas de métodos múltiples con el mismo nombre pero con

diferentes listas de parámetros. Todas las sobrecargas deben ser necesarias (se omite el signo de interrogación) o todas
deben ser opcionales (se incluye el signo de interrogación). Un conjunto de firmas de método sobrecargadas corresponde
a una declaración de una sola propiedad con un tipo compuesto de un conjunto equivalente de firmas de
llamada. Específicamente

f < T1, T2, ... > ( p1, p2, ... ): R ; 

f < U1, U2, ... > ( q1, q2, ... ): S ; 
...

es equivalente a

f : { <T1, T2, ...> (p1, p2, ...): R;     <U1, U2, ...> (q1, q2, ...): S; ... } ;
    

    

En el siguiente ejemplo de un tipo de objeto

{ 
    func1 (x: número ): número ;         // Método de firma func2 : (x: número )
=> número ;     // F Tipo de unción literal     FUNC3 : {(x: número ): número };   // O tipo de objeto
literal }
    

las propiedades ' func1 ' , ' func2 ' , y ' FUNC3 ' son todos del mismo tipo, a saber, un tipo de objeto con una sola firma
llamada de tomar un número y devolver un número. Del mismo modo, en el tipo de objeto

{ 
    func4 (x: número ): número ; 
    func4 (s: cadena ): cadena ; 
    func5 : { 
        (x: número ): número ; 
        (s: cadena ): cadena ; 
    }; 
}

los Properti es ' func4 ' y ' Func5 ' son del mismo tipo, es decir, un tipo de objeto con dos firmas llamada que toma y
volviendo número y secuencia, respectivamente.

3.10    Alias de tipo
Un tipo de alias decla ración introduce un tipo alias  en el que contiene espacio de declaración .

TypeAliasDeclaration: 
type BindingI  dentifier  TypeParameters  = Type  ;              
opt 

Un alias de tipo sirve como un alias para el tipo especificado en la declaración de alias de tipo. A diferencia de una
declaración de interfaz , que siempre introduce un tipo de objeto con nombre , una declaración de alias de tipo
puede introducir un nombre para cualquier tipo de tipo , incluidos los tipos primitivos, de unión e intersección .
Un alias de tipo puede tener opcionalmente parámetros de tipo (sección 3.6.1 ) que sirven como marcadores de posición
para los tipos reales que se proporcionarán cuando se haga referencia al alias de tipo en las referencias de tipo. Un alias
de tipo con parámetros de tipo se denomina alias de tipo  genérico  . Los parámetros de tipo de una declaración de alias
de tipo genérico están dentro del alcance y pueden referenciarse en el Tipo con  alias .

Los alias de tipo se referencian utilizando referencias de tipo ( 3.8.2 ). Las referencias de tipo a los alias de tipo genérico
producen instancias del tipo con alias con los argumentos de tipo dados. Escribir una referencia a un alias de tipo no
genérico tiene exactamente el mismo efecto que escribir el tipo con alias , y escribir una referencia a un alias de tipo
genérico tiene exactamente el mismo efecto que escribir la instanciación resultante del tipo con alias.

El dentificador  BindingI  de una declaración de alias de tipo puede no ser uno de los nombres de tipo predefinidos
(sección 3.8.1 ).

Es un error que el tipo especificado en un alias de tipo dependa de ese alias de tipo. Los tipos tienen las
siguientes dependencias:

 Un alias de tipo depende directamente  del tipo que alias.

 Una referencia de tipo depende directamente  del tipo referenciado y de cada uno de los argumentos de tipo, si los
hay.
 Una unión o intersección tipo depende directamente de  cada uno de los tipos de constituyentes.
 Un tipo de matriz depende directamente de  su tipo de elemento.
 Un tipo de tupla depende directamente de  cada uno de sus tipos de elementos.
 Una consulta de tipo depende directamente  del tipo de la entidad referenciada.

Dada esta definición, el conjunto completo de tipos de los que depende un tipo es el cierre transitivo del directamente
depende de la  relación. Tenga en cuenta que los literales de tipo de objeto, los literales de tipo de función y los literales de
tipo de constructor no dependen de los tipos a los que se hace referencia en ellos y, por lo tanto, se les permite hacer
referencia circular a sí mismos a través de los tipos alias .

Algunos ejemplos de declaraciones de alias de tipo:

escriba StringOrNumber = string | número ; 
escriba Texto = cadena | {texto: cadena }; 
escriba NameLookup = Dictionary < string , Person>; 
type ObjectStatics = typeof Object; 
tipo de devolución de llamada <T> = (datos: T ) => vacío ; 
tipo Par <T> = [T, T] ; tipo Coordenadas = Par < número >; escriba Árbol <T> = T | {izquierda: árbol
<T>, derecha: árbol <T>}; 

Tipos de interfaz tienen muchas similitudes a teclear ali a ses para literales de tipo de objeto, pero dado que los tipos de
interfaz ofrecen más capacidades que son generalmente preferidos para escribir alias. Por ejemplo, el tipo de interfaz

Punto de interfaz { 
    x: número ; 
    y: número ; 
}

podría escribirse como el alias de tipo

tipo Punto = { 
    x: número ; 
    y: número ; 
};
Sin embargo, hacerlo significa que se pierden las siguientes capacidades:

 Una interfaz se puede nombrar en una cláusula de extensiones o implementos , pero un alias de tipo para un tipo
de objeto literal no .
 Una interfaz puede tener varias declaraciones fusionadas, pero un alias de tipo para un literal de tipo de objeto no
puede .

3.11    Relaciones de tipo
Los tipos en TypeScript tienen relaciones de compatibilidad de identidad, subtipo, supertipo y asignación como se define
en las siguientes secciones.

3.11.1     Miembros aparentes
Los miembros aparentes  de un tipo son los miembros observados en las relaciones de compatibilidad de subtipo,
supertipo y asignación, así como en la verificación de tipos de accesos a propiedades (sección 4.13 ), nuevasoperaciones
(sección 4.14 ) y llamadas a funciones (sección 4.15 ). Los un miembros pParent de un tipo se determinaron como sigue:

 Los miembros aparentes del tipo primitivo Number y todos los tipos de enumeración son los miembros aparentes
del tipo de interfaz global 'Number'.
 Los miembros aparentes del tipo primitivo Boolean son los miembros aparentes del tipo de
interfaz global 'Boo lean' .
 Los miembros aparentes del tipo String primitivo y todos los tipos literales de cadena son los miembros aparentes
del tipo de interfaz global 'String'.
 Los miembros aparentes de un parámetro de tipo son los miembros aparentes de la restricción (sección 3.6.1 ) de
ese parámetro de tipo.
 Los miembros aparentes de un tipo de objeto T  son la combinación de lo siguiente:
o Los declarados y / o los miembros heredados de T  .
o Las propiedades de la interfaz típ mundial e 'Objeto' que no se oculta b propiedades Y con el mismo
nombre en la camiseta  .
o Si T  tiene uno o más cal l o construir firmas, las propiedades del tipo de interfaz global 'Función' que no
se oculta por propiedades con el mismo nombre en la camiseta  .
 Los miembros aparentes de una unión tipo U  se determinan de la siguiente manera:
o Cuando todos los tipos constituyentes de U  tienen una n propiedad aparente llamada N  , U  tiene una
propiedad aparente llamada N  de un tipo de unión de los respectivos tipos de propiedad.
o Cuando todos los tipos constituyentes de U  tienen una firma de llamada aparente n con una lista de
parámetros P  , U  tiene una firma de llamada aparente con la lista de parámetros P  y un tipo de retorno que
es una unión de los tipos de retorno respectivos. Las firmas de llamada aparecen en el mismo orden que en
el primer tipo de componente.
o Cuando todos los tipos constituyentes de U  tienen una firma de construcción aparente n con una lista de
parámetros P  , U  tiene una firma de construcción aparente con la lista de parámetros P  y un tipo de
retorno que es una unión de los tipos de retorno respectivos. Las firmas de construcción aparecen en el
mismo orden que en el primer tipo de componente.
o Cuando todos los tipos constituyentes de U  tienen una firma de índice de cadena aparente n , U  tiene
una firma de índice de cadena aparente n de un tipo de unión de los tipos de firma de índice de cadena
respectivos.
o Cuando todos los tipos constituyentes de U  tienen una firma de índice numérico aparente, U  tiene una
firma de índice numérico aparente de un tipo de unión de los tipos de firma de índice numérico
respectivos.
 Los miembros aparentes de una intersección tipo I  se determinan de la siguiente manera:
o Cuando uno de los tipos más constituyentes de I  tiene una propiedad aparente llamada N  , tengo  una
propiedad aparente llamada N  de un tipo de intersección n de los tipos de propiedad respectivos.
o Cuando uno o más tipos constitutivos de I  tienen una firma llamada S  , I  tiene la aparente firma
llamada S  . Las firmas están clasificadas como una concatenación de las firmas de cada tipo de componente
en el orden de los tipos de constituyentes dentro de I  .
 o Cuando uno o más tipos constitutivos de I  tienen una firma constructo S  , I  tiene la aparente firma
constructo S  . Las firmas están clasificadas como una concatenación de las firmas de cada tipo de
componente en el orden de los tipos de constituyentes dentro de I  .
o Cuando uno o más tipos constituyentes de I  tienen una firma de índice de cadena aparente, tengo  una
firma de índice de cadena aparente de un tipo de intersección de los respectivos tipos de firma de índice de
cadena.
o Cuando uno o más tipos constituyentes de I  tienen una firma de índice numérico aparente, tengo  una
firma de índice numérico aparente de un tipo de intersección de los tipos de firma de índice numérico
respectivos.

Si un tipo no es uno de los anteriores, se considera que no tiene miembros aparentes.

En efecto, un tipo ' aparentes s miembros lo convierten en un subtipo de la ' Object ' o ' Función ' interfaz a menos que

el tipo definir s miembros que son incompatibles con las de la ' Object ' o ' Función ' interfaz que, por ejemplo, ocurre
si el tipo define una propiedad con el mismo nombre que una propiedad en la interfaz ' Objeto ' o ' Función ' pero con un
tipo que no es 'un subtipo de eso en la interfaz ' Objeto ' o ' Función ' .

Algunos ejemplos:

var o: Objeto = {x: 10 , y: 20 };         // Ok 

var f: Función = (x: número ) => x * x;   // Ok 
var err: Object = {toString: 0 };        // Error

El último trabajo es un error porque el objeto literal que tiene un ' toString ' método que ISN ' t compatible con el
de ' Objeto ' .

3.11.2     Tipo y miembro I dentity

Dos tipos se consideran idénticos  cuando

 ambos son de cualquier tipo,

 son del mismo tipo primitivo,
 que son el mismo parámetro de tipo,
 son tipos de unión con conjuntos idénticos de tipos constituyentes, o
 son tipos de intersección con conjuntos idénticos de tipos constituyentes, o
 son tipos de objeto con conjuntos idénticos de miembros .

Dos miembros se consideran idénticos cuando

 son propiedades públicas con nombres, opciones y tipos idénticos,

 son propiedades privadas o protegidas que se originan en la misma declaración y tienen tipos idénticos ,
 son firmas de llamada idénticas,
 son firmas de construcción idénticas, o
 son firmas de índice de tipo idéntico con tipos idénticos.

Dos firmas de llamada o construcción se consideran idénticas cuando tienen el mismo número de parámetros de tipo con
restricciones de parámetros de tipo idénticas y, después de sustituir el tipo Cualquiera por los parámetros de tipo
introducidos por las firmas, un número idéntico de parámetros con tipo idéntico (requerido, opcional o resto) y tipos, y
tipos de retorno idénticos.

Tenga en cuenta que, a excepción de los tipos primitivos y las clases con miembros privados o protegidos , es la
estructura, no el nombre, de los tipos lo que determina la identidad. Además, tenga en cuenta que los nombres de los
parámetros no son significativos al determinar la identidad de las firmas.
P rivado y protegidas Propert IES coinciden sólo si se originan en la misma declaración y tienen tipos idénticos. Dos tipos
distintos pueden contener propiedades que se originan en la misma declaración si los tipos son referencias
parametrizadas separadas a la misma clase genérica. En el ejemplo

clase C <T> { privado x: T; }

interfaz X { f (): cadena ; }
interfaz Y { f (): cadena ; }
var a: C <X>; 
var b: C <Y>;

las variables ' a ' y ' b ' son de tipos idénticos porque las dos referencias de tipo a ' C ' crean tipos con un miembro
privado ' x ' que origina s en la misma declaración, y porque los dos miembros privados ' x ' tienen tipos con conjuntos
idénticos de miembros una vez que se sustituyen los argumentos de tipo ' X ' e ' Y ' .

3.11.3     Subtipos y Supertipos
S  es un subtipo  de un tipo T  , y T  es un supertipo  de S  , si S  no tiene propiedades en exceso con respecto a T  ( 3.11.5 )
y uno de los siguientes es verdadero :

 S  y T  son tipos idénticos.

 T  es cualquier tipo.
 S  es el tipo indefinido.
 S  es el tipo nulo y T  no es el tipo indefinido .
 S  es un tipo de enumeración y T  es el tipo de número primitivo.
 S  es un tipo de cadena literal y T  es el tipo de cadena primitivo.
 S  es un tipo de unión y cada tipo constituyente de S  es un subtipo de T  .
 S  es un tipo de intersección y al menos un tipo de constituyente de S  es un subtipo de T  .
 T  es un tipo de unión y S  es un subtipo de al menos un tipo constituyente de T  .
 T  es un tipo de intersección y S  es un subtipo de cada tipo de constituyente de T  .
 S  es un parámetro de tipo y la restricción de S  es un subtipo de T  .
 S  es un tipo de objeto, un tipo de intersección, un tipo de enumeración o el tipo primitivo Número, Booleano o
Cadena , T  es un tipo de objeto y para cada miembro M  en T  , uno de los siguientes es verdadero:
o M  es una propiedad y S  tiene una propiedad aparente N  donde
 M  y N  tienen el mismo nombre,
 el tipo de N  es un subtipo del de M  ,
 si M  es una propiedad requerida, N  también es una propiedad requerida, y
 M  y N  son públicos, M  y N  son privados y se originan en la misma declaración , M  y N  están
protegidos y se originan en la misma declaración, o M  está protegido y N  se declara en una clase
derivada de la clase en cuál M  se declara.
o M  es una firma de llamada o construcción no especializada y S  tiene una firma de llamada o
construcción aparente N  donde , cuando M  y N  se instancian usando el tipo Any como argumento de tipo
para todos los parámetros de tipo declarados por M  y N  (si corresponde),
 las firmas son del mismo tipo (llamada o construcción),
 M  tiene un parámetro de reposo o el número de parámetros no opcionales en N  es menor o
igual que el número total de parámetros en M  ,
 para las posiciones de parámetros que están presentes en ambas firmas, cada tipo de parámetro
en N  es un subtipo o supertipo del tipo de parámetro correspondiente en M  , y
 el tipo de resultado de M  es nulo, o el tipo de resultado de N  es un subtipo de la de M  .
o M  es una firma de índice cadena de tipo U  , y U  es la Cualquier tipo o S  tiene una aparente firma de
índice de cadena de un tipo que es un subtipo de U  .
o M  es una firma índice numérico de tipo U  , y U  es la Cualquier tipo o S  tiene una aparente cadena o firma
índice numérico de un tipo que es un subtipo de U  .

Al comparar las firmas de llamada o construcción , los nombres de los parámetros se ignoran y los parámetros de
descanso corresponden a una expansión ilimitada de parámetros opcionales del tipo de elemento de parámetro de
descanso.
Tenga en cuenta que las firmas especializadas de llamada y construcción (sección 3.9.2.4 ) no son significativas al
determinar las relaciones de subtipo y supertipo.

También tenga en cuenta que los parámetros de tipo no se consideran tipos de objeto. Por lo tanto, los únicos subtipos
de un parámetro de tipo T  son T  sí mismo y otros parámetros de tipo que están restringidas directa o indirectamente a T  .

3.11.4     Compatibilidad de asignación
Se requieren tipos de b correo asignación compatibles en ciertas circunstancias, como expresión y tipos de variables en
instrucciones de asignación y los tipos de argumentos y parámetros en las llamadas a funciones.

S  es asignable a  un tipo T  , y T  es asignable desde  S  , si S  no tiene propiedades en exceso con respecto a T  ( 3.11.5 )
y uno de los siguientes es cierto:

 S  y T  son tipos idénticos .

 S  o T  es cualquier tipo.
 S  es el tipo indefinido.
 S  es el tipo nulo y T  no es el tipo indefinido .
 S  o T  es un tipo de enumeración y el otro es el número de tipo primitivo.
 S  es un tipo de cadena literal y T  es el tipo de cadena primitivo.
 S  es un tipo de unión y cada tipo constituyente de S  es asignable a T  .
 S  es un tipo de intersección y al menos un tipo de constituyente de S  es asignable a T  .
 T  es un tipo de unión y S  es asignable al menos a un tipo de constituyente de T  .
 T  es un tipo de intersección y S  es asignable a cada tipo de constituyente de T  .
 S  es un parámetro de tipo y la restricción de S  es asignable a T  .
 S  es un tipo de objeto, un tipo de intersección, un tipo n enum , o el número, Boolean, o una cadena de tipo
primitivo, T  es un tipo de objeto, y para cada miembro M  en T  , uno de los siguientes es verdadera:
o M  es una propiedad y S  tiene una propiedad aparente N  donde
 M  y N  tienen el mismo nombre,
 el tipo de N  es asignable al de M  ,
 si M  es una propiedad requerida, N  también es una propiedad requerida, y
 M  y N  son públicos, M  y N  son privados y se originan en la misma declaración, M  y N  están
protegidos y se originan en la misma declaración, o M  está protegido y N  se declara en una clase
derivada de la clase en la que Se declara M.
o M  es una propiedad opcional y S  tiene no aparente propiedad del mismo nombre que M  .
o M  es una firma de llamada o construcción no especializada y S  tiene una firma de llamada o
construcción aparente N  donde, cuando M  y N  se instancian usando el tipo Any como argumento de tipo
para todos los parámetros de tipo declarados por M  y N  (si corresponde),
 las firmas son del mismo tipo (llamada o construcción),
 M  tiene un parámetro de reposo o el número de parámetros no opcionales en N  es menor o
igual que el número total de parámetros en M  ,
 para las posiciones de parámetros que están presentes en ambas firmas, cada tipo de parámetro
en N  se puede asignar ao desde el tipo de parámetro correspondiente en M  , y
 el tipo de resultado de M  es nulo, o el tipo de resultado de N  es asignable a la de M  .
o M  es una firma de índice cadena de tipo U  , y U  es la Cualquier tipo o S  tiene una aparente firma de
índice de cadena de un tipo que es asignable a U  .
o M  es una firma índice numérico de tipo U  , y U  es la Cualquier tipo o S  tiene una aparente cadena o firma
índice numérico de un tipo que es asignable a U  .

Al comparar firmas de llamada o construcción, los nombres de los parámetros se ignoran y los parámetros de descanso
corresponden a una expansión ilimitada de parámetros opcionales del tipo de elemento de parámetro de descanso.

Tenga en cuenta que las firmas especializadas de llamada y construcción (sección 3.9.2.4 ) no son significativas al
determinar la compatibilidad de la asignación.

La compatibilidad de asignación y las reglas de subtipo difieren solo en eso

  Cualquier tipo es asignable a , pero no un subtipo de, todos los tipos,
 el número de tipo primitivo se puede asignar a, pero no es un subtipo de, todos los tipos de enumeración, y
 un tipo de objeto sin una propiedad particular se puede asignar a un tipo de objeto en el que esa propiedad es
opcional.

Las reglas de compatibilidad de asignación implican que, al asignar valores o pasar parámetros, las propiedades

opcionales deben estar presentes y ser de un tipo compatible , o no estar presentes en absoluto. Por ejemplo:

function foo (x: {id: number ; name ?: string; }) {}

foo ({id: 1234 });                 // Ok 
foo ({id: 1234 , nombre: " hola " });  // Ok foo ({id: 1234 , nombre: falso });    // Error, nombre del
tipo incorrecto foo ({nombre: " hola " });            // Error, se requiere id pero falta 

3.11.5     Exceso de propiedades
Las relaciones de compatibilidad de subtipo y asignación requieren que los tipos de origen no tengan propiedades en
exceso con respecto a los tipos de destino ir . El propósito de esta verificación es detectar propiedades en exceso o mal
escritas en literales de objeto.

Se considera que un tipo de fuente S  tiene propiedades en exceso con respecto a un tipo de destino T  si

 S  es un tipo literal de objeto nuevo , como se define a continuación , y

 S  tiene una o más propiedades que no se espera en T  .

Se dice que se espera una propiedad P  en un tipo T  si uno de los siguientes es verdadero:

 T  no es un tipo de objeto, unión o intersección.

 T  es un tipo de objeto y
o T  tiene una propiedad con el mismo nombre que P  ,
o T  tiene una cadena de caracteres o firma de índice numérico,
o T  no tiene propiedades, o
o T  es el tipo global 'Objeto'.
 T  es una unión o intersección tipo y P  se espera que en al menos uno de los tipos constitutivos de T  .

El tipo inferido para un objeto literal (como se describe en la sección 4.5 ) se considera un tipo literal de
objeto  fr  esh  . La frescura desaparece cuando se amplía un tipo literal de objeto ( 3.12 ) o es el tipo de la expresión en
una aserción de tipo ( 4.16 ).

Considere el siguiente ejemplo:

interfaz CompilerOptions { 
    estricto ?: booleano ; 
    sourcePath ?: cadena ; 
    targetPath ?: cadena ; 
}
opciones var : CompilerOptions = { 
    estricto: verdadero , 
    ruta de origen : "./src" ,  // Error, exceso o m propiedad 
    emitida targetpath : "./bin" // Error, propiedad excesiva o mal escrita } ;   

El tipo 'CompilerOptions' contiene solo propiedades opcionales, por lo que sin la comprobación de propiedad en
exceso, cualquier  objeto literal se podría asignar a la variable 'opciones' (porque una propiedad mal escrita solo se
consideraría una propiedad en exceso de un nombre diferente).

En los casos en que se espera un exceso de propiedades, se puede agregar una firma de índice al tipo de destino como un
indicador de intención:
interfaz InputElement { 
    nombre: cadena ; 
    visible ?: booleano ; 
    [x: cadena ]: cualquiera ;  // Permitir propiedades adicionales de cualquier tipo }          

dirección var : InputElement = { 
    nombre: "Dirección" , 
    visible: verdadero , 
    ayuda: "Ingrese la dirección aquí" ,  // Permitido debido a 
    acceso directo de firma de índice : "Alt-A" // Permitido debido a firma de índice };            

3.11.6     Creación de instancias de firma contextual

Durante la inferencia de argumentos de tipo en una llamada de función (sección 4.15.2 ), en ciertas circunstancias es
necesario instanciar una firma de llamada genérica de una expresión de argumento en el contexto de una firma de
llamada no genérica de un parámetro de modo que se puedan hacer más inferencias . Una firma de llamada
genérica A  se instancia en el contexto de la  firma de llamada no genérica B de la  siguiente manera:

 Usando el proceso descrito en 3.11.7 , inferencias para A  ' parámetros de tipo s se hacen de cada tipo de
parámetro en B  en el correspondiente tipo de parámetro en A  para aquellas posiciones de parámetros que están
presentes en ambos signatur es , donde los parámetros de descanso corresponden a una ilimitada expansión de
parámetros opcionales del tipo de elemento del parámetro rest.
 El argumento de tipo inferido para cada parámetro tipo es el tipo de unión del conjunto de inferencias hechas
para el th en el tipo de parámetro. Sin embargo, si el tipo de unión no satisface la restricción del parámetro de tipo,
el argumento de tipo inferido es en cambio la restricción.

3.11.7     Inferencia de tipo
En ciertos contextos, las inferencias para un conjunto dado de parámetros de tipo se hacen de  un tipo S  , en el
que esos parámetros de tipo no ocurren, a  otro tipo T  , en el que esos parámetros de tipo sí ocurren. Las inferencias
consisten en un conjunto de argumentos de tipo candidato recopilados para cada uno de los parámetros de tipo. El
proceso de inferencia relaciona recursivamente S  y T  para reunir tantas inferencias como sea posible:

 Si T  es uno de los parámetros de tipo para el que se están haciendo inferencias, S  se agrega al conjunto de
inferencias para ese parámetro de tipo.
 De lo contrario, si S  y T  son referencias al mismo tipo genérico, inferencias se hacen de cada argumento tipo
en S  para cada argumento tipo correspondiente en T  .
 De lo contrario, si S  y T  son tipos de tupla con el mismo número de elementos, inferencias se hacen de cada tipo
de elemento en S  para cada tipo de elemento correspondiente en T  .
 De lo contrario, si T  es una unión o intersección tipo :
o En primer lugar, inferencias están hechos de S  a cada tipo de constituyente en T  que
ISN ' t simplemente uno de los parámetro de tipo para el que se están haciendo inferencias s .
o Si el primer paso no produjo inferencias, entonces si T es un tipo de unión y exactamente un tipo
constituyente en T  es simplemente un parámetro de tipo para el cual se están haciendo inferencias, las
inferencias se hacen de S  a ese parámetro de tipo.
 De lo contrario, si S  es una unión o intersección tipo , inferencias se hacen de cada tipo de constituyente
en S  a T  .
 De lo contrario, si S  y T  son tipos de objeto, entonces para cada miembro M  en T  :
o Si M  es una propiedad y S  contiene una propiedad N  con el mismo nombre que M  , inferencias se hacen
con el tipo de N  al tipo de M  .
o Si M  es una firma de llamada y existe una firma de llamada correspondiente N  en S  , N  se instancia con el
tipo Any como argumento para cada parámetro de tipo (si lo hay) y se hacen inferencias de los tipos de
parámetros en N  a los tipos de parámetros correspondientes en M  para las posiciones que están presentes
en ambas firmas, y desde el tipo de retorno de N  para el tipo de retorno de M  .
o Si M  es una firma de construcción y existe una firma de construcción correspondiente N  en S  , N  se
instancia con el tipo Any como argumento para cada parámetro de tipo (si lo hay) y se hacen inferencias de
 los tipos de parámetros en N  a los tipos de parámetros correspondientes en M  para las posiciones que
están presentes en ambas firmas, y desde el tipo de retorno de N  para el tipo de retorno de M  .
o Si M  es una firma de índice cadena y S  contiene una firma de índice cadena de N  , inferencias se hacen
con el tipo de N  al tipo de M  .
o Si M  es una firma índice numérico y S  contiene un índice de firma numérica N  , inferencias se hacen con
el tipo de N  al tipo de M  .
o Si M  es una firma de índice numérico y S  contiene una firma de índice cadena de N  , inferencias se hacen
con el tipo de N  al tipo de M  .

Al comparar firmas de llamada o de construcción, las firmas en S  corresponden a firmas del mismo tipo en T por  pares en
orden de declaración. Si S  y T  tienen números diferentes de un tipo dado de firma, se ignoran las primeras  firmas
en exceso en el orden de declaración de la lista más larga.

TODO: Actualización para reflejar una  mejor inferencia de unión e intersección .

3.11.8 Tipos recursivos    
Las clases y las interfaces pueden referenciarse a sí mismas en su estructura interna, en efecto creando tipos recursivos
con anidamiento infinito. Por ejemplo, el tipo

interfaz A {siguiente: A; }

contiene una secuencia infinitamente anidada de propiedades ' siguientes ' . Tipos como este son perfectamente válidos
pero requieren un tratamiento especial al determinar las relaciones de tipo. Específicamente, al comparar los
tipos S  y T  para una relación dada (identidad, subtipo o asignabilidad), se asume que la relación en cuestión es verdadera
para cada ocurrencia anidada directa o indirectamente de la misma S  y la misma T  (donde lo mismo significa origen en la
misma declaración y, si corresponde, con argumentos de tipo idéntico ). Por ejemplo, considere la relación de identidad
entre ' A ' arriba y ' B ' abajo:

interfaz B {siguiente: C; }

interfaz C {siguiente: D; }
interfaz D {siguiente: B; }

Para determinar si ' A ' y ' B ' son idénticos, primero se comparan las propiedades ' siguientes ' del tipo ' A ' y ' C ' . Eso

lleva a comparar las propiedades ' siguientes ' del tipo ' A ' y ' D ' , lo que lleva a comparar
las propiedades ' siguientes ' del tipo ' A ' y ' B ' . Como ' A ' y ' B ' ya se están comparando, esta relación es verdadera por
definición. Eso a su vez hace que las otras comparaciones sean verdaderas y, por lo tanto, el resultado final es verdadero.

Cuando se utiliza esta misma técnica para comparar referencias de tipo genérico, dos referencias de tipo se consideran
iguales cuando se originan en la misma declaración y tienen argumentos de tipo idénticos.

En ciertas circunstancias, los tipos genéricos que se refieren directa o indirectamente a sí mismos de manera recursiva

pueden conducir a una serie infinita de instancias distintas . Por ejemplo, en el tipo

Lista de interfaz <T> { 
    datos: T; 
    siguiente: Lista < T>; 
    propietario: Lista <Lista <T>>; 
}

' Lista <T> ' tiene un miembro de ' propietario ' de tipo ' Lista < List < T > > ' , que tiene un miembro de ' propietario ' de

tipo ' Lista <Lista <List <T >> > ' , que tiene un miembro ' propietario ' del tipo ' Lista <Lista <Lista <Lista <T> >>> ' y así
sucesivamente , hasta el infinito. El establecimiento de relaciones de tipo se determinan estructuralmente, posiblemente la
exploración de los tipos de constituyentes de toda su profundidad, i n con el fin de determinar las relaciones tipo que
implica inf initely expansión tipos genéricos que puede ser necesario para que el compilador terminar la recursión en
algún momento con el supuesto de que no más lejos La exploración cambiará el resultado.
3.12    Tipos ensanchados
I n varias situaciones mecanografiado Deducir s tipos de contexto, aliviando la necesidad de que el programador
especificar explícitamente los tipos t sombrero parecen evidentes. Por ejemplo

nombre var = " Steve " ;

infiere que el tipo de ' nombre ' será el tipo primitivo S tring ya que ese es el tipo del valor utilizado para inicializarlo. Al
inferir el tipo de resultado de una variable, propiedad o función de una expresión, la forma ampliada del  tipo de origen
se utiliza como el tipo inferido del destino. La forma ampliada de un tipo es el tipo en el que todas las apariciones de
los tipos N ull y U ndefined se han reemplazado por el tipo any .

El siguiente ejemplo muestra los resultados de la ampliación de tipos para producir tipos de variables inferidas.

var a = nulo ;                 // var a: any 

va r b = undefined;            // var b: cualquier 
var c = {x: 0 , y: nulo }; // var c : {x: número, y: cualquiera } var d = [ nulo , indefinido];  // var
d : cualquiera []    

1
 
 

4 expresiones        

Este capítulo describe la manera en que TypeScript proporciona inferencia de tipos y verificación

de tipos para expresiones de JavaScript . Letra de imprenta ' análisis tipo s se produce completamente en tiempo de
compilación y no añade tiempo de ejecución arriba para evaluación de la expresión.

Las reglas de escritura de TypeScript definen un tipo para cada construcción de expresión. Por ejemplo, el tipo de litro al

123 es el tipo primitivo Numérico , y el tipo del objeto literal {a: 10, b: " hola " } i s {a: número; b: cadena ; } . Las secciones
de este capítulo describen estas reglas en detalle.

Además de la inferencia de tipos y la verificación de tipos, TypeScript aumenta las expresiones de JavaScript con las

siguientes construcciones:

 Parámetros opcionales y anotaciones de tipo de retorno en expresiones de funciones y funciones de flecha .

 Escriba argumentos en llamadas a funciones.
 Escribe aserciones.

A menos que se indique lo contrario en las siguientes secciones, las expresiones TypeScript y las expresiones

JavaScript generadas a partir de ellas son idénticas.

4.1         Valores y referencias
Las expresiones se clasifican como valores  o referencias  . Las referencias son el subconjunto de expresiones que se
permiten como destino de una asignación. Específicamente, las referencias son combinaciones
de i dentifiers (sección 4.3 ), paréntesis (sección 4.8 ), y la propiedad de un ccesses (sección 4.13 ). A ll otros constructos de
expresión descritos en este capítulo se clasifican como valores.
4.2 4.2         La esta palabra clave
El tipo de esto en una expresión depende de la ubicación en la que tiene lugar la referencia:

 En un constructor, instancia función miembro , ejemplo miembro de acceso , o ejemplo miembro inicializador

variables, esto es de la this- tipo (sección 3.6.3 ) de la clase que contiene .
 En una función miembro estática o un miembro miembro estático , el tipo de este es el tipo de función
constructora de la clase que lo contiene .
 En una declaración de función o una expresión de función, esta es de tipo Any.
 En el espacio de nombres global , este es de tipo Any.

En todos los demás contextos, es un error en tiempo de compilación hacer referencia a esto .

Tenga en cuenta que una función de la flecha (sección 4.11 ) no tiene este parámetro sino que preserva el este de su
contexto circundante.

4.3 4.3         Identificadores
Cuando una expresión es una referencia de  identificador  , la expresión se refiere al espacio de nombres ,
clase, enumeración, función, variable o parámetro más anidados con ese nombre cuyo alcance (sección 2.4 ) incluye la
ubicación de la referencia. El tipo de un tal expr esión es el tipo asociado con la entidad referenciada:

 Para un espacio de nombres , el tipo de objeto asociado con la instancia del espacio de nombres .
 Para una clase, el tipo de constructor asociado con el objeto de función de constructor.
 Para una enumeración, el tipo de objeto asociado con el objeto enumeración.
 Para una función, el tipo de función asociado con el objeto de función.
 Para una variable, el tipo de la variable.
 Para un parámetro, el tipo del parámetro.

Una expresión de identificador que hace referencia a una variable o parámetro se clasifica como referencia. Una expresión
de identificador que hace referencia a cualquier otro tipo de entidad se clasifica como un valor (y, por lo tanto, no puede
ser el objetivo de una asignación).

4.4 Literales        
Los literales se escriben de la siguiente manera:

 El tipo de la nula literal es el N ULL primitivo tipo.

 El tipo de los literales verdadero y falso es el tipo primitivo booleano .
 El tipo de literales numéricos es la N umber primitivo tipo .
 El tipo de literales de cadena es el tipo primitivo S tring .
 El tipo de literales de expresión regular es el tipo de interfaz global ' RegExp ' .

4.5 4.5         Literales de objeto

Los literales de objeto se extienden para admitir anotaciones de tipo en métodos y obtener y establecer accesores.

PropertyDefinition:  (Modificado)  IdentifierReference  CoverInitializedName  PropertyName  : AssignmentExpression  Prop

ertyName  CallSignature  { FunctionBody  } GetAccessor  SetAccessor  

      
            
 GetAccessor: 
get PropertyName  ( ) TypeAnnotation  { FunctionBody  }                    
opt 

SetAccessor: 
set PropertyName  ( BindingI  dentifier  OrPattern  TypeAnnotation  ) { FunctionBody  }                       
opt 

El tipo de un objeto literal es un tipo de objeto con el conjunto de propiedades especificadas por las asignaciones de
propiedades en el objeto literal. Un descriptor de acceso get and set puede especificar el mismo nombre de propiedad,
pero de lo contrario es un error especificar múltiples asignaciones de propiedad para la misma propiedad.

Una asignación de propiedad abreviada del formulario

apuntalar

es equivalente a

prop: prop

Asimismo, una asignación de propiedad del formulario

f (...) { ... }

es equivalente a

f : función (...) {...}

Cada asignación de propiedad en un objeto literal i s procesa como sigue:

 Si el objeto literal se escribe contextualmente y el tipo contextual contiene una propiedad con un nombre
coincidente, la asignación de propiedad se escribe contextualmente por el tipo de esa propiedad.
 De lo contrario, si el literal del objeto se escribe contextualmente, si el tipo contextual contiene una firma de
índice numérico, y si la asignación de propiedad especifica un nombre de propiedad numérico, la asignación de
propiedad se escribe contextualmente por el tipo de firma de índice numérico.
 De lo contrario, si el objeto literal se escribe contextualmente y el tipo contextual contiene una firma de índice de
cadena, la asignación de propiedad se escribe contextualmente por el tipo de firma de índice de cadena.
 De lo contrario, la asignación de propiedad se procesa sin un tipo contextual.

El tipo de propiedad introducida por una asignación de propiedad del formulario Nombre  : Expr  es el tipo de Expr  .

Una declaración get accessor se procesa de la misma manera que una declaración de función ordinaria (sección 6.1 ) sin
parámetros . Una declaración de conjunto de acceso se procesa de la misma manera que una declaración de función
ordinaria con un único parámetro y un tipo de retorno Anulado. Cuando se declara un descriptor de acceso get y set para
una propiedad :

 Si ambos accesos incluyen anotaciones de tipo, los tipos especificados deben ser idénticos.
 Si solo un descriptor de acceso incluye una anotación de tipo, el otro se comporta como si tuviera la misma
anotación de tipo.
 Si ninguno de los descriptores de acceso incluye una anotación de tipo, el tipo de retorno inferido del descriptor
de acceso get se convierte en el tipo de parámetro del descriptor de acceso establecido.

Si se declara un descriptor de acceso para una propiedad, el tipo de retorno del descriptor de acceso se convierte en el
tipo de la propiedad. Si solo se declara un conjunto de accesos para una propiedad, el tipo de parámetro (que puede ser
de tipo Cualquiera si no hay ninguna anotación de tipo) del conjunto de accesos se convierte en el tipo de la propiedad.
Cuando un literal de objeto se escribe contextualmente por un tipo que incluye una firma de índice de cadena , el tipo
resultante del literal de objeto incluye una firma de índice de cadena con el tipo de unión de los tipos de las propiedades
declaradas en el literal de objeto, o el tipo Indefinido si El objeto literal está vacío. Del mismo modo, cuando un literal de
objeto se escribe contextualmente por un tipo que incluye una firma de índice numérico, el tipo resultante del literal de
objeto incluye una firma de índice numérico con el tipo de unión de los tipos de las propiedades con nombre numérico
(sección 3.9.4 ) declaradas en el objeto literal, o el tipo Indefinido si el objeto literal no declara propiedades con nombre
numérico.

Si el PropertyName  de una asignación de propiedad es un nombre de propiedad calculado que no denota un símbolo
conocido ( 2.2.3 ), la construcción se considera una asignación de  propiedad dinámica  . Las siguientes reglas se aplican
a las asignaciones de propiedades dinámicas:

 Una asignación de propiedad dinámica no introduce una propiedad en el tipo del objeto literal.
 La expresión del nombre de propiedad de una asignación de propiedad dinámica debe ser del tipo Cualquiera o
del tipo primitivo Cadena, Número o Símbolo.
 El nombre asociado con una asignación de propiedad dinámica se considera un nombre de propiedad numérico
si la expresión del nombre de propiedad es de tipo Any o del tipo primitivo Number.

4.6         Array Literals
Una matriz literal

[ expr1, expr2, ..., exprN ]

denota un valor de un tipo de matriz (sección 3.3.2 ) o un tipo de tupla (sección 3.3.3 ) según el contexto.

Cada expresión de elemento en un literal de matriz no vacía se procesa de la siguiente manera:

 Si el literal de matriz no contiene elementos de propagación, y si el literal de matriz está tipeado

contextualmente (sección 4.23 ) por un tipo T  y T  tiene una propiedad con el nombre numérico N  , donde N  es
el índice de la expresión del elemento en el literal de matriz, la expresión del elemento se escribe contextualmente
por el tipo de esa propiedad .
 De lo contrario, si el literal de matriz se escribe contextualmente por un tipo T  con una firma de índice numérico,
la expresión del elemento se escribe contextualmente por el tipo de firma de índice numérico.
 De lo contrario, la expresión del elemento no se escribe contextualmente.

El tipo resultante de una expresión literal de matriz se determina de la siguiente manera:

 Si el literal de matriz está vacío, el tipo resultante es un tipo de matriz con el tipo de elemento Indefinido.
 De lo contrario, si el literal de matriz no contiene elementos de propagación y está tipeado contextualmente por
un tipo similar a una tupla (sección 3.3.3 ) , el tipo resultante es un tipo de tupla construido a partir de los tipos de
las expresiones del elemento.
 De lo contrario, si el literal de matriz no contiene elementos extendidos y es un patrón de asignación de matriz en
una asignación de desestructuración (sección 4.21.1 ), el tipo resultante es un tipo de tupla construido a partir de los
tipos de las expresiones de elementos.
 De lo contrario , el tipo resultante es un tipo de matriz con un tipo de elemento que es la unión de los tipos
de expresiones de elementos no extendidos y los tipos de firma de índice numérico de las expresiones de elementos
extendidos.

Un elemento de extensión debe especificar una expresión de una matriz -como tipo (sección 3.3.2 ) , o de lo contrario se

produce un error.

TODO: el compilador actualmente no admite la  aplicación del operador de propagación a una cadena (para
distribuir  los  caracteres  individuales  de una cadena en una matriz de cadenas  )  .  Esto eventualmente se permitirá, pero solo
cuando el  objetivo de generación de  código  sea ECMAScript 2015  o posterior  .
TODO: documento que propaga un  iterador  en una matriz literal  .

Las reglas anteriores significan que un literal de matriz siempre es de un tipo de matriz, a menos que esté contextualizado
por un tipo similar a una tupla . Por ejemplo

var a = [ 1 , 2 ];                          // número [] 

var b = [ " hola " , verdadero ];                 // ( string | boolean ) [] 
var c: [ número , string ] = [ 3 , " tres " ];  // [número, cadena]

Cuando el objetivo de salida es ECMAScript 3 o 5, los literales de matriz que contienen elementos extendidos se
reescriben para invocaciones del método concat . Por ejemplo, las tareas

var a = [ 2 , 3 , 4 ]; var b = [ 0 , 1 , ... a, 5 , 6 ]; 

son reescritos a

var a = [ 2 , 3 , 4 ]; var b = [ 0 , 1 ] .concat (a , [ 5 , 6 ]); 

4.7 Literales de plantilla        
TODO:  Literales de plantilla .

4.8         Paréntesis
Una expresión entre paréntesis

( expr )

tiene el mismo tipo y clasificación que la expresión contenida en sí misma. Específicamente, si la expresión contenida se

clasifica como referencia, también lo es la expresión entre paréntesis.

4.9 La súper palabra clave        

T él súper palabra clave puede ser utilizado en las expresiones para hacer referencia a propiedades de la clase base y el
constructor de la clase base.

4.9.1         Super llamadas
S uper llaman s consisten en la palabra clave súper seguido por una lista de argumentos entre paréntesis. Las súper
llamadas solo se permiten en constructores de clases derivadas , como se describe en la sección 8.3.2 .

Una llamada súper invoca al constructor de la clase base en el ejemplo al que hace referencia este . Una súper llamada se
procesa como una llamada de función (sección 4.15 ) utilizando las firmas de construcción del tipo de función
de constructor de clase base como el conjunto inicial de firmas candidatas para la resolución de sobrecarga. Los
argumentos de tipo no se pueden especificar explícitamente en una súper llamada. Si la clase base es una clase genérica,
los argumentos de tipo utilizados para procesar una súper llamada son siempre los especificados en
la cláusula extendidas que hace referencia a la clase base.

El tipo de una expresión de súper llamada es Void.

El código JavaScript generado para una súper llamada se especifica en la sección 8.7.2 .

4.9.2         Super acceso a la propiedad
Un s propiedad uper acceso consisten s de la palabra clave súper seguido de un punto y un
identificador. Súper propiedad de acceso es se utilizan para acceder a la clase base funciones miembro de clase
derivada es y están permitidos en contextos donde esta (sección 4.2 ) hace referencia a una clase derivada ejemplo o una
función de constructor de la clase derivada . Específicamente:

 En un constructor, la función de miembro de instancia, de acceso miembro de instancia , o miembro de instancia

inicializador variables donde esta hace referencia a una clase derivada ejemplo , un acceso a la propiedad
súper está permitida y debe especificar una función de miembro de instancia pública de la clase base.
 En una función miembro estática o un acceso miembro estático donde esto hace referencia al objeto de función
constructor de una clase derivada, se permite un acceso de super propiedad y debe especificar una función
miembro pública estática de la clase base.

S de propiedad uper de acceso es son no permitidos en otros contextos, y T no es posible acceder a otros tipos de
miembros de la clase base en un acceso a la propiedad de super. Tenga en cuenta que los accesos de súper propiedades
no están permitidos dentro de las expresiones de función anidadas en las construcciones anteriores porque esto es del
tipo Cualquiera en tales expresiones de función.

En el Super accesos se utilizan normalmente para acceder OVERRID funciones miembro de la clase base del den de
miembro de clase derivados funciones . Para un ejemplo de esto, vea la sección 8.4.2 .

El código JavaScript generado para un acceso de super propiedad se especifica en la sección 8.7.2 .

TODO:  sección de actualización para incluir  notación de corchetes en el acceso a la propiedad súper .

4.10    Expresiones de iones funcionales

Las expresiones de función se extienden desde JavaScript para incluir opcionalmente parámetros y anotaciones de tipo
de retorno .

FunctionExpression:  (Modificado)  de función BindingI  dentifier  optan  CallSignature  { FunctionBody  }  

              

Las descripciones de las declaraciones de funciones proporcionadas en el capítulo 6 se aplican también a las expresiones
de funciones, excepto que las expresiones de funciones no admiten sobrecarga.

El tipo de una expresión de función es un tipo de objeto que contiene un solo firma llamada con tipos de parámetros y de
retorno inferidos a partir de la expresión de función ' firma s y el cuerpo.

Cuando una expresión de función sin parámetros de tipo y sin anotaciones de tipo de parámetro se tipea contextualmente
(sección 4.23 ) mediante un tipo T  y se puede extraer una firma contextual S  de T  , la expresión de función se procesa
como si hubiera especificado explícitamente anotaciones de tipo de parámetro como existen en S  . Los parámetros se
corresponden por posición y no necesitan tener nombres coincidentes . Si la expresión de la función tiene menos
parámetros que S  , los parámetros adicionales en S  se ignoran. Si la expresión de función tiene más parámetros que S  , se
considera que todos los parámetros adicionales tienen el tipo Any.

Del mismo modo, cuando una expresión de función sin anotación de tipo de retorno se tipea contextualmente
(sección 4.23 ) por un tipo de función T  y se puede extraer una firma contextual S  de T  , las expresiones en declaraciones
de retorno contenidas (sección 5.10 ) se tipean contextualmente por el tipo de retorno de S  .

Una firma contextual S  se extrae de una función tipo T de la  siguiente manera:

 Si T  es un tipo de función con exactamente una firma de llamada, y si esa firma de llamada no es genérica, S  es
esa firma.
 Si T  es un tipo de unión, sea U  el conjunto de tipos de elementos en T  que tienen firmas de llamada. Si cada tipo
en U  tiene exactamente una firma de llamada y esa firma de llamada no es genérica, y si todas las firmas son
 idénticas ignorando los tipos de retorno, entonces S  es una firma con los mismos parámetros y una unión de los
tipos de retorno.
 De lo contrario, ninguna firma contextual se puede extraer de T  .

En el ejemplo

var f: (s: string ) => string = function ( s ) { return s.toLowerCase (); }; 

    

la expresión de la función se tipea contextualmente por el tipo de 'f', y dado que la expresión de la función no tiene
parámetros de tipo ni anotaciones de tipo, su información de tipo de parámetro se extrae del tipo contextual, infiriendo
así el tipo de 's' para ser la primitiva String tipo.

4.11    Flecha Función s
Las funciones de flecha se extienden desde JavaScript para incluir opcionalmente parámetros y anotaciones de tipo de
retorno.

ArrowFormalParameters:  (Modificado)  CallSignature  

Las descripciones de las declaraciones de funciones proporcionadas en el capítulo 6 se aplican también a las funciones de
flecha, excepto que las funciones de flecha no admiten sobrecarga.

El tipo de una función de flecha se determina de la misma manera que una expresión de función (sección 4.10 ). Del
mismo modo, los parámetros de una función de flecha y las declaraciones de retorno en el cuerpo de una función de
flecha se escriben contextualmente de la misma manera que para las expresiones de función.

Cuando una función de flecha con un cuerpo de expresión y no el tipo de retorno de anotación se contextualmente
mecanografiado (sección 4.23 ) por un tipo de función de T  y una firma contextual S  se puede extraer de T  , el cuerpo de
expresión se contextualmente tecleado por el tipo de retorno de S  .

Una expresión de función de flecha n de la forma

(...) => expr

es exactamente equivalente a

(...) => { return expr ; }

Además, expresiones de función de flecha de las formas

id => {...} 
id => expr

son exactamente equivalentes a

( id) => {...} 

( id) => expr

Por lo tanto, los siguientes ejemplos son todos equivalentes:

(x) => { return Math.sin (x); } 
(x) => Math.sin (x) 
x => { return Math.sin (x); } 
x => Math.sin (x)

Una expresión de función introduce un nuevo límite dinámico de esto , mientras que una expresión de función de
flecha conserva el presente de su contexto envolvente. Expresiones de función Flecha son particularmente útiles para la
escritura de devolución de llamada s, que de otro modo a menudo tienen un n indefinido o inesperado este .

En el ejemplo

clase Messenger { 
    mensaje = " Hola Mundo " ; 
    start () { 
        setTimeout (() => alert ( this .message), 3000 ); 
    } 
};
var messenger = nuevo Messenger (); 
messenger.start ();

el uso de una expresión de la función de devolución de llamada flecha hace que el tener el mismo presente como el que
rodea a ' inicio ' método . Escribiendo la devolución de llamada como un estándar de la función de la expresión se hace
necesario organizar manualmente el acceso a los alrededores de este , por ejemplo mediante la copia en una variable
local:

clase Messenger { 
    mensaje = " Hola Mundo " ; 
    start () { var _this = this ;         setTimeout ( function () {alert
(_this.message);}, 3000 );     } };
        

var messenger = nuevo Messenger (); 

messenger.start ();

El compilador de TypeScript aplica este tipo de transformación para reescribir expresiones de función de flecha

en iones expresos de función estándar .

Una construcción de la forma

< T > ( ... ) => { ... }

podría analizarse como una expresión de función de flecha con un parámetro de tipo o una aserción de tipo aplicada a
una función de flecha sin parámetro de tipo. Se resuelve como el primero, pero se pueden usar paréntesis para seleccionar
el segundo significado:

< T > (( ... ) => {...})

4.12 Expresiones de clase   
TODO:  Expresiones de clase de  documento  .

4.13    Acceso a la propiedad
Un acceso de propiedad utiliza notación de punto o notación de corchete. Una expresión de acceso a la propiedad
siempre se clasifica como referencia.
Un acceso a la propiedad de notación de puntos del formulario

objeto . nombre

donde object  es una expresión y n  ame  es un identificador (que incluye, posiblemente, una palabra reservada ) , se utiliza
para acceder a la propiedad con el nombre dado en el objeto dado . El acceso a la propiedad de notación de puntos se
procesa de la siguiente manera en tiempo de compilación:

 Si objeto  es de tipo A ny , cualquier n  AME  está permitido y el acceso a la propiedad es de tipo Cualquier.
 De lo contrario, si n  AME  denota un n accesible aparente propiedad (sección 3.11.1 ) en
el ensanchada tipo (sección 3.12 ) de objeto  , el acceso a la propiedad es del tipo de esa propiedad . Los miembros
públicos siempre son accesibles, pero los miembros privados y protegidos de una clase tienen accesibilidad
restringida, como se describe en 8.2.2 .
 De lo contrario, el acceso a la propiedad no es válido y se produce un error en tiempo de compilación.

Un acceso de propiedad de notación de corchete del formulario

objeto [ índice ]

donde objeto  e índice  son expresiones, se utiliza para acceder a la propiedad con el nombre calculado por la expresión de
índice en el objeto dado. El acceso a la propiedad de notación de corchetes se procesa de la siguiente manera en tiempo
de compilación:

 I f índice  es una cadena literal o un literal numérico y objeto  tiene un n aparente propiedad (sección 3.11.1 ) con el

nombre dado por que literal (convertido a la representación de cadena en el caso de un literal numérico), el acceso a
la propiedad es del tipo de esa propiedad.
 De lo contrario, si el objeto  tiene una firma de índice numérico aparente n y el índice  es de tipo Cualquiera, el tipo
Número primitivo o un tipo de enumeración, el acceso a la propiedad es del tipo de esa firma de índice.
 De lo contrario, si el objeto  tiene una firma de índice de cadena aparente n y el índice  es del tipo
Cualquiera, el tipo primitivo Cadena o Número , o un tipo de enumeración, el acceso a la propiedad es del tipo de
esa firma de índice.
 De lo contrario, si el índice  es del tipo Any, el tipo primitivo String o Number , o un tipo enum , el acceso a la
propiedad es del tipo Any.
 De lo contrario, el acceso a la propiedad no es válido y se produce un error en tiempo de compilación.

TODO:  Me  ndexing con  símbolos .

Las reglas anteriores significan que las propiedades están fuertemente tipadas cuando se accede mediante notación de
corchetes con la representación literal de su nombre. Por ejemplo:

var type = { 
    name: " boolean " , 
    primitive: true 
};
var s = tipo [ " nombre " ];       // string 
var b = type [ " primitivo " ]; // booleano 

Los tipos de tupla asignan nombres numéricos a cada uno de sus elementos y, por lo tanto, los elementos se escriben
fuertemente cuando se accede mediante la notación de corchetes con un literal numérico:

datos var : [cadena, número] = [ " cinco " , 5 ]; var s = datos [ 0 ];  // cadena var n = datos

[ 1 ];  // número 
4.14    El nuevo operador
Una nueva operación tiene una de las siguientes formas:

nueva C 
nueva C (...) 
nueva C <...> ( ... )

donde C  es una expresión. La primera forma es equivalente a proporcionar una lista de argumentos vacía. C  debe ser
del tipo A ny o de un tipo de objeto con una o más construcciones o firmas de llamada . La operación se procesa de la
siguiente manera en tiempo de compilación:

 Si C  es de tipo A ny , se permite cualquier lista de argumentos y el resultado de la operación es de tipo A ny .
 Si C  tiene una o más firmas de construcción aparentes (sección 3.11.1 ) , la expresión se procesa de la misma
manera que una llamada a función , pero usando las firmas de construcción como el conjunto inicial de firmas
candidatas para la resolución de sobrecarga. El tipo de resultado de la llamada de función se convierte en el tipo de
resultado de la operación.
 Si C  no tiene firmas de construcción aparentes, sino una o más firmas de llamada aparentes , la expresión se
procesa como una llamada a función. Se produce un error en tiempo de compilación si el resultado de la llamada a
la función no es Anulado. El tipo del resultado de la operación es A ny .

4.15    Llamadas de funciones
Las llamadas a funciones se extienden desde JavaScript para apoyar op argumentos de tipo cionales.

Argumentos:  (Modificado)  TypeArguments  ( ArgumentList  )  

opt  opt 

        

Una llamada a función toma una de las formas

func ( ...) 
func < ... > ( ... )

donde func  es una expresión de un tipo de función o de cualquier tipo . La expresión de función es seguida por una lista
de argumentos de tipo opcional (sección 3.6.2 ) y una lista de argumentos n .

Si func  es de tipo A ny , o de un tipo de objeto que no tiene firmas de llamada o construcción pero es un subtipo de la

interfaz de función , la llamada es una llamada de función sin tipo  . En una llamada a la función sin tipo n o de tipo
argumentos ar e permitida , expresiones de argumento puede ser de cualquier tipo y número , no se proporcionan para
los tipos de contexto expresiones de argumento, y el resultado es siempre de tipo A ny .

Si func  tiene firmas de llamada aparentes (sección 3.11.1 ), la llamada es una llamada de función

escrita  . TypeScript emplea la resolución de sobrecarga  en las llamadas a funciones escritas para admitir funciones
con múltiples firmas de llamadas. Además, puede realizar mecanografiado tipo de argumento inferencia  para
determinar de forma automática en argumentos de tipo genérico llamada a la función s .

4.15.1     Resolución de sobrecarga
El propósito de la resolución de sobrecarga en una llamada de función es asegurar que al menos una firma es
aplicable, para proporcionar tipos contextuales de los argumentos , y para determinar el nuevo tipo sultado de la llamada
a la función , que podría diferir entre las múltiples firmas aplicables . La resolución de sobrecarga no tiene impacto en el
comportamiento en tiempo de ejecución de una llamada de función. Desde JavaScript doesn ' sobrecarga de funciones de
soporte t, lo único que importa en tiempo de ejecución es el nombre de la función.

TODO: Describe el uso de los  tipos de función comodín  en la resolución de sobrecarga  .

El procesamiento en tiempo de compilación de una llamada de función escrita consta de los siguientes pasos:

  Primero, se construye una lista de firmas candidatas a partir de las firmas de llamada en el tipo de función en
orden de declaración. Para las clases e interfaces, se considera que las firmas heredadas siguen firmas declaradas
explícitamente en orden de cláusula extendida .
o Una firma no genérica es candidata cuando
 la llamada a la función no tiene argumentos de tipo , y
 la firma es aplicable con respecto a la lista de argumentos de la llamada a la función.
o Una firma genérica es un candidato en una llamada de función sin argumentos de tipo cuando
 La inferencia de tipos (sección 4.15.2 ) tiene éxito para cada parámetro de tipo ,
 una vez que los argumentos de tipo inferidos son sustituidos por sus parámetros de tipo
asociados, la firma es aplicable con respecto a la lista de argumentos de la llamada a la función.
o Una firma genérica es un candidato en una llamada de función con argumentos de tipo cuando
 La firma tiene el mismo número de parámetros de tipo que los proporcionados en la lista de
argumentos de tipo,
 los argumentos de tipo satisfacen sus restricciones, y
 una vez que los argumentos de tipo se sustituyen por sus parámetros de tipo asociados, la firma
es aplicable con respecto a la lista de argumentos de la llamada a la función.
 Si la lista de firmas candidatas está vacía, la llamada a la función es un error.
 De lo contrario, si la lista de candidatos contiene una o más firmas para las cuales el tipo de cada expresión de
argumento es un subtipo de cada tipo de parámetro correspondiente, el tipo de retorno de la primera de esas
firmas se convierte en el tipo de retorno de la llamada a la función.
 De lo contrario, el tipo de retorno de la primera firma en la lista de candidatos se convierte en el tipo de retorno
de la llamada a la función.

Se dice que una firma  es una firma  aplicable  con respecto a una lista de argumentos cuando

 el número de argumentos s no es menor que el número de parámetros requeridos,

 el número de argumentos no es mayor que el número de parámetros, y
 para cada expresión argumento e  y su parámetro correspondiente P,  cuando e  se tecleó
contextualmente (sección 4.23 ) por el tipo de P  , no hay errores sobrevienen y el tipo de e  es asignar capaz
de (sección 3.11.4 ) del tipo de P  .

TODO:  Operador extendido en llamadas a funciones  y esparciendo un  iterador  en una llamada a funciones  .

4.15.2     Inferencia de argumento de tipo

Dada una firma < T  , T  , ... , T  > ( p  : P  , p  : P  , ..., p  : P  ), donde cada tipo de parámetro P hace  referencia a cero o
1  2  n  1  1  2  2  m  m 

más del tipo parámetros T  , y una lista de argumentos ( e  , e  , ..., e  ), la tarea de inferencia de argumentos de tipo es
1  2  m 

encontrar un conjunto de argumentos de tipo A  ... A  para sustituir a T  ... T  modo que la lista de argumentos se
1  n  1  n de 

convierte en una firma aplicable.

TODO: Actualización de  inferencia de argumentos de tipo  y  reglas de  resolución de sobrecarga .

La inferencia de argumento de tipo produce un conjunto de tipos candidatos para cada parámetro de tipo. Dado un
parámetro de tipo T  y un conjunto de tipos candidatos, el argumento de tipo inferido real se determina de la siguiente
manera:

 Si el conjunto de tipos de argumentos candidatos está vacío, el argumento de tipo inferido de T  es T  ' restricción
s.
 De lo contrario, si al menos uno de los tipos candidatos es un supertipo de todos los otros tipos candidatos,
dejemos que C  denote la forma ampliada (sección 3.12 ) del primer tipo de candidato. Si C  satisface T  ' s limitación,
el argumento de tipo inferido de T  es C  . De lo contrario, el argumento de tipo inferido de T  es T  ' restricción s.
 De lo contrario, si no hay tipo de candidato es un supertipo de todos los otros tipos de candidatos , la inferencia
de tipos ha falla y ningún tipo argumento se infiere de T  .

Para calcular los tipos de candidatos , la lista de argumentos se procesa de la siguiente manera:
  Inicialmente, un ll tipo inferidos argumentos se consideran no fijado  con un conjunto vacío de tipos de
candidatos .
 Procediendo de izquierda a derecha, cada expresión argumento e  se inferencia escrito  por su correspondiente
tipo de parámetro P  , posiblemente causando algunos argumentos de tipo inferidos a convertirse fijo  , y las
inferencias de tipo candidato (sección 3.11.7 ) están hechos para no fijadas argumentos de tipo inferidos a partir del
tipo calculado para e  a P  .

El proceso de escribir inferencialmente una expresión e  por un tipo T  es el mismo que el de escribir
contextualmente e  por T  , con las siguientes excepciones:

 Cuando las expresiones contenidas en e  se tipearán contextualmente, se tipearán inferencialmente.

 Cuando una expresión de función se escribe inferencialmente ( sección 4.10 ) y un tipo asignado a un parámetro
en esa expresión hace referencia a parámetros de tipo para los que se hacen inferencias , los argumentos de tipo
inferido correspondientes se vuelven fijos  y no se hacen más inferencias candidatas para ellos.
 Si e  es una expresión de un tipo de función que contiene exactamente una firma de llamada genérica y ningún
otro miembro, y T  es un tipo de función con exactamente una firma de llamada no genérica y ningún otro
miembro , entonces cualquier inferencia hecha para los parámetros de tipo referenciados por parámetros
de T  ' firma llamada s se fijan  , y e  ' tipo s es cambiado a un tipo de función con e  ' firma llamada s instanciado en
el contexto de T  ' firma llamada s (sección 3.11.6 ).

Un ejemplo :

la función elige <T> (x: T, y: T): T { return Math.random () < 0.5 ? x: y; }

    

var x = elegir ( 10 , 20 ); // Ok, x de tipo número var y = elegir ( " Cinco " , 5 );  // Error     

En la primera llamada a ' elegir ' , se hacen dos inferencias de ' número ' a ' T ' , una para cada parámetro. Por lo
tanto, ' número ' se infiere para ' T ' y la llamada es equivalente a

var x = elige < número > ( 10 , 20 );

En la segunda llamada a ' elegir ' , se hace una inferencia del tipo ' cadena ' a ' T ' para el primer parámetro y se hace una
inferencia del tipo ' número ' a ' T ' para el segundo parámetro. Como ni ' string ' ni ' number ' son un supertipo del otro,
la inferencia de tipos falla . Eso a su vez significa que no hay firmas aplicables y que la llamada a la función es un error.

En el ejemplo

mapa de funciones <T, U> (a: T [], f: (x: T) => U): U [] { resultado var : U [] = []; for ( var i = 0 ;
i <a.length; i ++) result.push (f (a [i])); resultado de retorno ; }
    
    
    

nombres var = [ " Peter " , " Paul " , " Mary " ]; 
var lengths = map (nombres, s => s.length);

Las inferencias para ' T ' y ' U ' en la llamada a ' map ' se hacen de la siguiente manera: para el primer parámetro, las
inferencias se hacen del tipo ' string [] ' (el tipo de ' nombres ' ) al tipo ' T [] ' , infiriendo ' cadena ' para ' T ' . Para el
segundo parámetro, el tipeo inferencial de la expresión de flecha ' s => s.length ' hace que ' T ' se fije de manera que el
tipo inferido ' string ' pueda usarse para el parámetro ' s ' . El tipo de retorno de la expresión de flecha se puede
determinar, y las inferencias se hacen del tipo ' (s: cadena) => número ' al tipo ' (x: T) => U ' ,
deduciendo ' número ' para ' U ' . Por lo tanto, la llamada al ' mapa ' es equivalente a

var lengths = map < string , number > (nombres, s => s.length);

y el tipo resultante de ' longitudes ' es, por lo tanto, ' número [] ' .

En el ejemplo

función zip <S, T, U> (x: S [], y: T [], combinar: (x: S) => (y: T) => U): U [] { var len =
Math. max (longitud x, longitud y); resultado var : U [] = []; for ( var i = 0 ; i <len; i ++)
result.push (combine (x [i]) (y [i])); resultado de retorno ; }
    
    
    
    

nombres var = [ " Peter " , " Paul " , " Mary " ]; 
var edades = [ 7 , 9 , 12 ]; 
var pares = zip (nombres, edades, s => n => ({nombre: s, edad: n}));

inferencias para ' S ' , ' T ' y ' T ' en la llamada a ' zip ' se hacen como sigue: El uso de los dos
primeros parámetros, inferencias de ' cadena ' de ' S ' y ' número ' para ' T ' se hacen . Para el tercer parámetro, el tipeo
inferencial de la expresión de flecha externa hace que ' S ' se fije de manera que el tipo inferido ' string ' pueda usarse
para el parámetro ' s ' . Cuando una expresión de función se escribe inferencialmente , sus expresiones de retorno también
se escriben inferencialmente. Por lo tanto, la función de flecha interna se escribe inferencialmente, lo que hace que ' T ' se
fije de manera que el tipo inferido ' número ' pueda usarse para el parámetro ' n ' . Luego se puede determinar el tipo de
retorno de la función de flecha interna, que a su vez determina el tipo de retorno de la función devuelta desde la función
de flecha externa, y se hacen inferencias del tipo ' (s: cadena) => (n: número ) => {nombre: cadena; edad: número} ' al
tipo ' (x: S) => (y: T) => R ' , infiriendo ' {nombre: cadena; edad: número} ' para ' R ' . Por lo tanto, la llamada a ' zip ' es
equivalente a

var pares = zip < cadena , número , {nombre: cadena ; edad: número }> ( 

    nombres, edades, s => n => ({nombre: s, edad: n}));

y el tipo resultante de ' pares ' es por lo tanto ' {nombre: cadena; edad: número} [] ' .

4.15.3 Ambigüedades gramaticales    
La inclusión de argumentos de tipo en la Argumentos  de producción (sección 4.15 ) dan s lugar a ciertas ambigüedades en
la gramática para expresiones. Por ejemplo, la declaración

f (g <A, B> ( 7 ));

podría interpretarse como una llamada a ' f ' con dos argumentos, ' g <A ' y ' B> (7) ' . Alternativamente, podría
interpretarse como una llamada a ' f ' con un argumento, que es una llamada a una función genérica ' g ' con dos
argumentos de tipo y un argumento regular.

La ambigüedad gramatical se resuelve de la siguiente manera: en un contexto donde una posible interpretación de una
secuencia de tokens es una producción de Argumentos  , si la secuencia inicial de tokens forma
una producción TypeArguments  sintácticamente correcta y es seguida por un token ' ( ' , entonces la secuencia de tokens
se procesa una producción de Argumentos  , y cualquier otra interpretación posible se descarta, de lo contrario, la
secuencia de tokens no se considera una producción de Argumentos  .

Esta regla significa que la llamada a ' f ' anterior se interpreta como una llamada con un argumento, que es una llamada a
una función genérica ' g ' con dos argumentos de tipo y un argumento regular. Sin embargo, las declaraciones

f (g < A, B> 7 ); f (g <A, B> + ( 7 )); 

son tanto interpretarse como llamadas a ' f ' con dos argumentos.

4.16    Afirmaciones de tipo
TypeScript amplía la gramática de expresiones de JavaScript con la capacidad de afirmar un tipo para una expresión :

UnaryExpression:  (Modificado)  ... < Tipo  > UnaryExpression  

        

Una expresión de aserción de tipo consiste en un tipo encerrado en < y > seguido de una expresión unaria. Las

expresiones de aserción de tipo son puramente una construcción en tiempo de compilación. Las aserciones de tipo no
se  verifican en tiempo de ejecución y no tienen impacto en el JavaScript emitido ( y, por lo tanto, no tienen costo en
tiempo de ejecución) El tipo y el < y > adjunto simplemente se eliminan del código generado.

En un tipo afirmación expresión de la forma < T  > e  , e  se escribe contextualmente (sección 4.23 ) por T  y

t él resultante tipo de e  se requiere para ser asignable a T  , o T  se requiere para ser asignable a la forma ensanchada de el
tipo resultante de e  , o de lo contrario se produce un error en tiempo de compilación. El tipo del resultado es T  .

La aserción de tipos verifica la compatibilidad de la asignación en ambas direcciones. Por lo tanto, forma de afirmaciones

permiten conversiones de tipos que podrían  ser correctas, pero aren ' t sabe  que es correcta. En el ejemplo

Forma de clase {... }
clase Círculo extiende Forma { ...}
función createShape (kind: string ): Shape { if (kind === " circle " ) devuelve un nuevo Circle ();    
... }
    

var c ircle = <Círculo> createShape ( " círculo " );

las anotaciones de tipo indican que la ' createShape ' función puede  devolver un ' círculo ' (porque ' Círculo ' es un subtipo

de ' Forma ' ), pero ISN ' t sabe  hacerlo (porque su tipo de retorno es ' Forma ' ). Por lo tanto, se necesita una aserción de
tipo para tratar el resultado como un ' Círculo ' .

Como se mencionó anteriormente, las aserciones de tipo no se verifican en tiempo de ejecución y corresponde al
programador protegerse contra errores, por ejemplo, utilizando el operador instanceof :

var forma = createShape (shapeKind); 

if (shape instanceof Circle) { var circle = <Círculo> forma;     ... }
    

TODO: documento  como  operador .

4.17 Expresiones JSX   
TODO: documenta las  expresiones JSX .

4.18 Operadores unarios   
Las subsecciones que siguen especifican las reglas de procesamiento en tiempo de compilación de los operadores
unarios. En general, si el operando de un operador unario no cumple con los requisitos establecidos, se produce un error
en tiempo de compilación y el resultado de la operación se predetermina al tipo A ny en el procesamiento posterior.

4.18.1 Los operadores ++ y -    

Estos operadores, en prefijo o forma postfix, requieren que el IR operando a ser de ty pe Cualquier, la N umber tipo
primitivo , o un tipo de enumeración, y clasificado como una referencia (sección 4.1 ) . Ellos producen un resultado
de la N umber tipo primitivo .

4.18.2 El + , -, y ~ operador s    

La SE operador s permiten su operando a ser de cualquier tipo y producir un resultado de la N umber tipo primitivo .

El operador unario + convenientemente se puede utilizar para conve rt un valor de cualquier tipo para la N umber tipo
primitivo :

función getValue () {...}
var n = + getValue ();

El ejemplo anterior convierte el resultado de ' getValu e () ' a un número si ISN ' bronceado umber alrea dy. El tipo inferido
para ' n ' es el tipo primitivo N umber independientemente del tipo de retorno de ' getValue ' .

4.18.3 El! operador    
Los ! operador permite su operando a ser de cualquier tipo y produce un resultado de la booleana tipo primitivo .

¡Dos unarios ! operadores de secuencia se pueden usar convenientemente para convertir un valor de cualquier tipo
para la Boolean tipo primitivo :

función getValue () {...}
var b = !! getValue ();

El ejemplo anterior convierte el resultado de ' getValue () ' a un booleano si ISN ' ta Boolean ya. El tipo e inferido
para ' b ' es el tipo primitivo booleano independientemente del tipo de retorno de ' getValue ' .

4.18.4 El operador de eliminación    

El ' delete ' operador toma un operando de cualquier tipo y produce un resultado de la booleana tipo primitivo .

4.18.5 El operador vacío    

El operador ' vacío ' toma un operando de cualquier tipo y produce el valor ' indefinido ' . El tipo del resultado es el tipo
Indefinido ( 3.2.7 ).

4.18.6 El tipo de operador    

El ' typeof ' operador toma un operando de cualquier typ e y produce un valor de la S Tring tipo primitivo . En las
posiciones donde se espera un tipo, ' typeof ' también se puede usar en una consulta de tipo (sección 3.8.10 ) para
producir el tipo de una expresión.

var x = 5 ; 
var y = typeof x;  // Usar en una expresión 
var z: typeof x;   // Usar en una consulta de tipo

En el ejemplo anterior, ' x ' es del tipo ' número ' , ' y ' es del tipo ' cadena ' porque cuando se usa en una

expresión, ' typeof ' produce un valor de tipo cadena (en este caso, la cadena " número " ) y ' z ' es de
tipo ' número ' beca u se cuando se utiliza en una consulta de tipo, ' typeof ' ob tains del tipo de una expresión .

4.19 Operadores binarios   
Las subsecciones que siguen especifican las reglas de procesamiento en tiempo de compilación de los operadores
binarios . En general, si los operandos de un operador binario no cumplen los requisitos establecidos, se produce un error
en tiempo de compilación y el resultado de la operación se predetermina para escribir un ny en el procesamiento
posterior. Las tablas que resumen los proces de tiempo de compilación cantar reglas para operandos de la
A ny tipo , el booleano, número, y S Tring tipos primitivos , y todos los otros tipos (la O Ther de columna en las tablas) se
proporcionan.

4.19.1 El *, / , % , -, <<, >>, >>> , &, ^ y | operadores    

Los SE operadores requieren sus Operan ds ser o f Tipo Cualquiera, la N umber tipo primitivo , o un tipo de
enumeración . Los operandos de un tipo enum se tratan como si tuvieran el tipo primitivo Number . Si un operando es
el valor nulo o indefinido , se trata como si tuviera el tipo del otro operando. El resultado es siempre de
la N umber tipo primitivo .

  Una ny Booleano N umber S tring O Ther

Una ny N umber   N umber    

Booleano          

N umber N umber   N umber    

S tring          

O Ther          
 
TODO: Documente el  operador de exponenciación .

4.19.2 El operador +    

El binario + operador requiere dos operandos para ser de la N umber tipo primitivo o un tipo de enumeración , o al
menos una de las Operan ds a ser de tipo A ny o el S Tring tipo primitivo . Los operandos de un tipo enum se tratan como
si tuvieran el tipo primitivo Number. Si un operando es el valor nulo o indefinido , se trata como si tuviera el tipo del
otro operando . Si ambos operandos son de la N umber tipo primitivo , el resultado es de la N umber tipo primitivo . I f
en e o ambos operandos son de la Cadena de tipo primitivo , el resultado es de la S Tring tipo primitivo . De lo contrario ,
el resultado es de tipo A ny.

  Una ny Booleano N umber S tring O Ther

Una ny Una ny Una ny Una ny S tring Una ny

Booleano Una ny     S tring  

N umber Una ny   N umber S tring  

S tring S tring S tring S tring S tring S tring

O Ther Una ny     S tring  

 
Un valor de cualquier tipo puede convertir en el S Tring tipo primitivo mediante la adición de una cadena vacía:

función getValue () {...}
var s = getValue () + "" ;

El ejemplo anterior convierte el resultado de ' getVa lue () ' en una cadena si no es ' tas tring alrea dy'. El tipo inferido
para ' s ' es el tipo primitivo S tring independientemente del tipo de retorno de ' getValue ' .

4.19.3 Los operadores <,>, <=,> =, == ,! =, === y! ==    

Estos operadores requieren uno o ambos de los tipo de operando s de ser asignables a la otra. T l resultado
es siempre de la booleana tipo primitivo .

  Una ny Booleano N umber S tring O Ther

 Una ny Booleano Booleano Booleano Booleano Booleano

Booleano Booleano Booleano      

N umber Booleano   Booleano    

S tring Booleano     Booleano  

O Ther Booleano       Booleano

 

4.19.4 La instancia del operador    

El operador instanceof requiere que el operando izquierdo sea del tipo A ny, un tipo de objeto o un tipo de parámetro
de tipo , y el operando derecho sea del tipo A ny o un subtipo del tipo de interfaz ' Función ' . T l resultado
es siempre de la booleana tipo primitivo .

Tenga en cuenta que tipo de objeto s que contiene una o más solicitudes o construir firmas se subtipo
automáticamente s de la ' Función ' tipo de interfaz , como se describe en la sección 3.3 .

4.19.5 El operador in    

El operador in requiere que el operando le ft sea del tipo Any, el tipo primitivo S tring , o el tipo primitivo Number , y el
operando derecho sea del tipo A ny, un tipo de objeto o un tipo de parámetro de tipo . T l resultado
es siempre de la booleana tipo primitivo .

4.19.6 El operador &&    

El operador && permite que los operandos sean de cualquier tipo y produce un resultado del mismo tipo que el segundo
operando.

  Una ny Booleano N umber S tring O Ther

Una ny Una ny Booleano N umber S tring O Ther

Booleano Una ny Booleano N umber S tring O Ther

N umber Una ny Booleano N umber S tring O Ther

S tring Una ny Booleano N umber S tring O Ther

O Ther Una ny Booleano N umber S tring O Ther

 

4.19.7     El || operador
El || El operador permite que los operandos sean de cualquier tipo.

Si th e || la expresión se tipea contextualmente (sección 4.23 ) , los operandos se tipean continuamente por el mismo

tipo . De lo contrario , el operando izquierdo no se escribe contextualmente y el operando derecho se escribe
contextualmente por el tipo del operando izquierdo .

T que tipo de resultado es el tipo de unión de los dos tipos de operando.

  Una ny Booleano N umber S tring O Ther

Una ny Una ny Una ny Una ny Una ny Una ny

S
N
Booleano Una ny Booleano | segund B | O
| segundo
o
 N
N umber Una ny | segund N umber S | norte N | O
o
S
S tring Una ny | segund S | norte S tring S | O
o
O Ther Una ny B | O N | O S | O O Ther
 

4.20    El operador condicional

En una expresión condicional de la forma

prueba ? e xpr1: e xpr2

La expresión de prueba  puede ser de cualquier tipo.

Si la expresión condicional se escribe contextualmente (sección 4.23 ) , e  xpr1  y e  xpr2  se escriben simultáneamente por el
mismo tipo. De lo contrario, expr1  y expr2  no se escriben contextualmente.

El tipo del resultado es el tipo de unión de los tipos de expr1  y expr2  .

4.21 Operadores de asignación   
Una asignación del formulario

v = expr

r requiere que v  se clasifique como referencia (sección 4.1 ) o como patrón de asignación

(sección 4.21.1 ) . La expresión expr  se tipea contextualmente (sección 4.23 ) por el tipo de v  , y el tipo de expr  debe ser
asignable a (sección 3.11.4 ) el tipo de v  , o de lo contrario se produce un error en tiempo de compilación . El resultado
es un valor con el tipo de expr  .

Una asignación compuesta del formulario.

v ?? = expr

donde ?? = es uno de los operadores de asignación compuesta

* = / =% = + = - = << = >> = >>> = & = ^ = | =

está sujeta a los mismos requisitos , y produce un valor del mismo tipo , como la operación no compuesto
correspondiente. Además, una asignación compuesta requiere que v  se clasifique como referencia (sección 4.1 ) y que el
tipo de operación no compuesta se pueda asignar al tipo de v  . Tenga en cuenta que no se permite que v  sea un patrón
de asignación en una asignación compuesta.

4.21.1     Asignación de Desestructuración
Una asignación de desestructuración  es una operación de asignación en la que el operando de la izquierda
está estructurando un patrón de asignación como se define en la producción de AssignmentPattern  en
la especificación ECMAScript 2015 .
En una expresión de asignación desestructurante, el tipo de expresión de la derecha debe ser asignable al objetivo de
asignación de la izquierda. Una expresión de tipo S  se considera asignable a un objetivo de asignación V  si uno de los
siguientes es verdadero:

 V  es variable y S  es asignable al tipo de V  .

 V  es un patrón de asignación de objetos y, para cada propiedad de asignación P  en V  ,
o S  es el tipo Cualquiera, o
o S  tiene una propiedad aparente con el nombre de propiedad especificado en P  de un tipo que se puede
asignar al objetivo dado en P  , o
o P  especifica un nombre de propiedad numérico y S  tiene una firma de índice numérico de un tipo que se
puede asignar al objetivo dado en P  , o
o S  tiene una firma de índice de cadena de un tipo que es asignable a la diana dada en P  .
 V  es un patrón de asignación de matriz, S  es el tipo Cualquiera o un tipo de matriz (sección 3.3.2 ) y, para cada
elemento de asignación E  en V  ,
o S  es el tipo Cualquiera, o
o S  es un tipo similar a una tupla (sección 3.3.3 ) con una propiedad llamada N  de un tipo que se puede
asignar al objetivo dado en E  , donde N  es el índice numérico de E  en el patrón de asignación de matriz, o
o S  no es un tipo tupla-like y el numérico tipo de índice de la firma S  es asignable a la meta dada en E  .

TODO:  Actualización para especificar el comportamiento cuando el elemento de asignación E es un elemento de descanso .

En una propiedad o elemento de asignación que incluye un valor predeterminado, el tipo del valor predeterminado debe
ser asignable al objetivo dado en la propiedad o elemento de asignación.

Cuando el objetivo de salida es ECMAScript 2015 o superior, las asignaciones de variables de desestructuración
permanecen sin cambios en el código JavaScript emitido. Cuando el objetivo de salida es ECMAScript 3 o 5, las
asignaciones variables de desestructuración se reescriben en series de asignaciones simples. Por ejemplo, la tarea de
desestructuración

var x = 1 ; 
var y = 2 ; 
[x, y] = [y, x];

se reescribe en las asignaciones de variables simples

var x = 1 ; 
var y = 2 ; 
_a = [y, x], x = _a [ 0 ], y = _a [ 1 ]; 
var _a;

4.22 El operador de coma   

El operador de coma permite que los operandos sean de cualquier tipo y produce un resultado que es del mismo tipo que
el segundo operando.

4.23    Expresiones de tipo contextual
La verificación de tipos de una expresión se mejora en varios contextos al tener en cuenta el tipo de destino del valor
calculado por la expresión . En tales situaciones, se dice que la expresión está contextualizada  por el tipo de
destino . Una expresión se escribe contextualmente en las siguientes circunstancias:

 En una variable, parámetro, propiedad de enlace, elemento de enlace o declaración de miembro, una expresión de
inicializador se escribe contextualmente por
o t que tipo dado en el de declaración de tipo de anotación, en su caso, o de otro modo
 o para un parámetro, el tipo proporcionado por una firma contextual (sección 4.10 ) , si existe, o de lo
contrario
o el tipo implicado por el patrón de enlace en la declaración (sección 5.2.3 ) , si existe.
 I n el cuerpo de una función de declaración, la función de la expresión, función de la flecha , el método
de declaración , o de acceso Get declaración que tiene una anotación de tipo de retorno , el retorno
expresiones están contextualmente tecleado por el tipo dado en la anotación tipo de retorno.
 En el cuerpo de una expresión de función o función de flecha que no tiene una anotación de tipo de retorno, si la
expresión de función o la función de flecha está contextualizada por un tipo de función con exactamente una firma
de llamada , y si esa firma de llamada no es genérica , las expresiones de retorno son contextualizado por el tipo de
retorno de esa firma de llamada.
 En el cuerpo de una declaración de constructor , las expresiones de retorno se tipifican contextualmente por el
tipo de clase que lo contiene.
 En el cuerpo de un descriptor de acceso get sin anotación de tipo de retorno , si existe un descriptor
de acceso coincidente y ese descriptor de acceso tiene una anotación de tipo de parámetro, las expresiones de
retorno se contextualizan según el tipo dado en la anotación de tipo de parámetro del descriptor de acceso.
 En una llamada de función escrita , las expresiones de argumento se escriben contextualmente por sus
correspondientes tipos de parámetros.
 En un literal de objeto contextualizado , cada expresión de valor de propiedad se escribe contextualmente por
o El tipo de propiedad con un nombre coincidente en el tipo contextual, si lo hay, o de lo contrario
o para una propiedad con nombre numérico , el tipo de índice numérico del tipo contextual, si lo hay, o de
lo contrario
o el tipo de índice de cadena del tipo contextual, si lo hay.
 En una expresión literal de matriz contextualizada que no contiene elementos de propagación , una expresión de
elemento en el índice N  se escribe contextualmente por
o El tipo de propiedad con el nombre numérico N  en el tipo contextual, si lo hay, o de lo contrario
o El tipo de índice numérico del tipo contextual, si lo hay.
 En una expresión literal de matriz contextualizada que contiene uno o más elementos extendidos, una expresión
de elemento en el índice N  se escribe contextualmente por el tipo de índice numérico del tipo contextual, si lo hay.
 En una expresión entre paréntesis contextualizada , la expresión contenida se escribe contextualmente por el
mismo tipo.
 En una aserción de tipo , la expresión se escribe contextualmente por el tipo indicado.
 En un || expresión de operador, si la expresión se escribe contextualmente, los operandos
se escriben contextualmente por el mismo tipo. De lo contrario , la expresión derecha se escribe contextualmente
por el tipo de la expresión izquierda.
 En una expresión de operador condicional tipeada contextualmente , los operandos se tipean contextualmente
por el mismo tipo.
 En una expresión de asignación, la expresión de la mano derecha se escribe contextualmente por el tipo de la
expresión de la mano izquierda.

En el siguiente ejemplo

interfaz EventObject { 
    x: número ; 
    y: número ; 
}
interfaz EventHandlers { 
    mousedown ? : (event: EventObject) => void ; 
    mouseup ? : (event: EventObject) => void ; 
    mousemove ? : (event: EventObject) => void ; 
}
función setEventHandlers (controladores: EventHandlers) {...}
setEventHandlers ({ 
    mousedown: e => {startTracking (ex, ey);} , 
    mouseup: e => {endTracking ();} 
} ) ;
el objeto literal pasado a ' setEventHandlers ' se escribe contextualmente al tipo ' EventHandlers ' . Esto hace que las dos
asignaciones de propiedad que se escriban contextualmente a la sin nombre tipo de función ' (evento: EventObject) =>
vo ID ' , que a su vez hace que la ' e ' parámetro s en las expresiones de función flecha a ser escrito de forma automática
como ' EventObject ' .

4.24    Guardias tipo
Los protectores de tipo son patrones de expresión particulares que involucran
los operadores ' typeof ' e ' instanceof ' que hacen que los tipos de variables o parámetros se reduzcan  a tipos más
específicos. Por ejemplo , en el código siguiente, el conocimiento del tipo estático de ' x ' en combinación con
un ' typeof ' cheque hace que sea seguro para estrechar el tipo de ' x ' de cadena en la primera rama del ' si ' declaración y
el número de en la segunda rama de la declaración ' if ' .

función foo (x: número | cadena ) { if ( typeof x === " cadena " ) { return x.length;  // x tiene una

cadena de texto aquí     } else { return x + 1;     // x tiene un número de tipo aquí     } }
    
        

    
        

El tipo de una variable o parámetro se reduce en las siguientes situaciones:

 En la declaración de rama verdadera de una declaración ' if ' , el tipo de una variable o

parámetro se reduce  por una protección de tipo en la condición ' if ' cuando es verdadero  , siempre que ninguna
parte de la declaración 'if' contenga asignaciones a la variable o parámetro .
 En la declaración de rama falsa de una declaración ' if ' , el tipo de una variable o parámetro
se reduce  por un protector de tipo en la condición ' if ' cuando es falso  , siempre que ninguna parte de
la declaración 'if' contenga asignaciones a la variable o parámetro .
 En la expresión verdadera de una expresión condicional, el tipo de una variable o
parámetro se reduce  por un protector de tipo en la condición cuando es verdadero  , siempre que ninguna parte
de la expresión condicional contenga asignaciones a la variable o parámetro .
 En la expresión falsa de una expresión condicional, el tipo de una variable o
parámetro se reduce  por una protección de tipo en la condición cuando es  falso  , siempre que ninguna parte
de la expresión condicional contenga asignaciones a la variable o parámetro .
 En el operando derecho de una operación &&, el tipo de una variable o parámetro
se reduce  mediante una protección de tipo en el operando izquierdo cuando es verdadero  , siempre que ninguno de
los operandos contenga asignaciones a la variable o parámetro .
 En el operando derecho de a || En la operación, el tipo de una variable o parámetro
se reduce  mediante una protección de tipo en el operando izquierdo cuando es  falso  , siempre que ninguno de
los operandos contenga asignaciones a la variable o parámetro .

Un protector de tipo es simplemente una expresión que sigue un patrón particular. El proceso de reducir el tipo de una
variable x  por una protección de tipo cuando es verdadero  o falso  depende de la protección de tipo de la siguiente
manera:

 Un protector de tipo de la forma x instancia de C , donde x  no es del tipo Cualquiera, C  es de un subtipo

del tipo global ' Función ' , y C  tiene una propiedad llamada ' prototipo '
o cuando es verdadero  , reduce el tipo de x  al tipo de la propiedad ' prototipo ' en C  siempre que sea un
subtipo del tipo de x  , o, si el tipo de x  es un tipo de unión, elimina del tipo de x  todos los componentes
tipos que no son subtipos del tipo de la propiedad 'prototipo' en C  , o
o cuando es falso  , no tiene efecto sobre el tipo de x  .
  Un protector de tipo de la forma typeof x === s , donde s  es un literal de cadena con el
valor ' string ' , ' number ' o ' boolean ' ,
o cuando es verdadero  , se estrecha el tipo de x  para el tipo primitivo dado siempre que es un subtipo del
tipo de x  , o, si el tipo de x  es un tipo de unión, elimina con el tipo de x  todos los tipos de constituyentes
que no son subtipos del tipo primitivo dado, o
o cuando es falso  , elimina el tipo primitivo del tipo de x  .
 Un protector de tipo de la forma typeof x === s , donde s  es un literal de cadena con cualquier valor que no
sea ' string ' , ' number ' o ' boolean ' ,
o cuando es verdadero  , si x  es un tipo de unión, elimina del tipo de x  todos los tipos constituyentes que
son subtipos de la cadena, número o tipo primitivo booleano , o
o cuando es falso  , no tiene efecto sobre el tipo de x  .
 Un protector de tipo de la forma typeof x! == s , donde s  es un literal de cadena,
o cuando es verdadero  , reduce el tipo de x por tipo de x === s cuando  es falso  , o
o cuando es  falso  , reduce el tipo de x por typeof x === s cuando  es verdadero  .
 Un tipo de guardia de la forma ! expr
o cuando es verdadero  , reduce el tipo de x  por expr  cuando es falso  , o
o cuando es  falso  , reduce el tipo de x  por expr  cuando es verdadero  .
 Un protector de tipo de la forma expr1 && expr2
o cuando  verdadera  , se estrecha el tipo de x  b y expr  cuando es verdadero  y luego por expr  cuando es
1  2 

verdadero  , o
o cuando es falso  , reduce el tipo de x  a T  | T  , donde T  es el tipo de x  reducido por expr  cuando es
1  2  1  1 

falso  , y T  es el tipo de x  reducido por expr  cuando es verdadero  y luego por expr  cuando es falso  .
2  1  2 

 Un protector de tipo de la forma expr1 || expr2

o cuando es  verdadero  , reduce el tipo de x  a T  | T  , donde T  es el tipo de x  reducido por expr  cuando
1  2  1  1 

es  verdadero  , y T  es el tipo de x  reducido por expr  cuando es  falso  y luego por expr  cuando es
2  1  2 

verdadero  , o
o cuando  falsa  , se estrecha el tipo de x  b y expr  cuando  falsa  y luego por expr  cuando  falsa  .
1  2 

 Un protector de tipo de cualquier otra forma no tiene efecto sobre el tipo de x  .

En las reglas anteriores, cuando una operación de estrechamiento eliminaría todos los tipos constituyentes de un tipo de
unión, la operación no tiene efecto sobre el tipo de unión.

Tenga en cuenta que los protectores de tipo afectan solo a los tipos de variables y parámetros y no tienen efecto en los
miembros de los objetos, como las propiedades. También tenga en cuenta que es posible derrotar a un protector de tipo
llamando a una función que cambia el tipo de la variable protegida.

TODO: documenta  las funciones de protección de tipo definidas por el usuario .

En el ejemplo

function isLongString (obj: any ) { return typeof obj === "string" && obj.length> 100 ; }

    

el parámetro obj tiene una cadena de tipo en el operando derecho del operador &&.

En el ejemplo

función processValue ( value : number | ( () => number ) ) { var x = typeof value !

== " number " ? valor (): valor ; // Número de proceso en x }
    
    
el parámetro de valor tiene tipo () => número en la primera expresión condicional y número de tipo en la segunda
expresión condicional, y el tipo inferido de x es número .

En el ejemplo

función f (x: cadena | número | booleano ) { if ( typeof x === " string " || typeof x === " number " )

{ var y = x;  // El tipo de y es string | número     } más { var z = x;  // Tipo de z es booleano    
} }
    
        

    
        

el tipo de x es una cadena | numero | booleano en el operando izquierdo de || operador, número | booleano en el

operando derecho de || operador, cadena | número en la primera rama de la declaración if y booleano en la segunda
rama de la declaración if.

En el ejemplo

clase C { 
    datos: cadena | cadena [] ; 
    getData () { var data = this .data; volver typeof datos === "cadena" ? datos: data.join ( "" );    
} }
        
        

el tipo de datos variable es cadena en la primera expresión condicional y string [] en la segunda expresión
condicional, y t infirió tipo de getData es cadena . Tenga en cuenta que la propiedad de datos debe copiarse en una
variable local para que la protección de tipo tenga efecto.

En el ejemplo

clase NamedItem { 
    nombre: cadena ; 
}
function getName (obj: Object ) { return obj instanceof NamedItem? obj.name: " desconocido " ; }
    

el tipo de obj se estrecha a NamedItem en el primer cond i cional expresión, y el tipo inferido de la getNombre función
es la cadena .

1
 
 

5 declaraciones        
Este capítulo describe la comprobación de tipos estáticos que TypeScript proporciona para las declaraciones de
JavaScript . TypeScript en sí mismo no introduce ninguna nueva construcción de sentencias, pero extiende la gramática de
las declaraciones locales para incluir declaraciones de interfaz, alias de tipo y enumeración.

5.1 bloques        
Los bloques se extienden para incluir la interfaz local, el alias de tipo y las declaraciones de enumeración (las clases ya
están incluidas en la gramática ECMAScript 2015 ) .

Declaración:  (Modificado)  ... Tipo de  declaración de  interfaz  Declaración de  alias  Declaración de  enumeración  

Las declaraciones de clase local, interfaz, alias de tipo y enumeración tienen un alcance de bloque, similar a las
declaraciones let y const.

5.2         Declaraciones variables
Las declaraciones variables se extienden para incluir anotaciones de tipo opcionales.

Declaración  Variable:  (Modificado)  SimpleVariableDeclaration  DestructuringVariableDeclaration  

Una declaración variable es una declaración variable simple o una declaración variable desestructurante.

5.2.1 Declaraciones de variables simples        

Una declaración de variable simple  introduce una sola variable con nombre y opcionalmente le asigna un valor inicial.

SimpleVariableDeclaration: 
BindingI  dentifier  TypeAnnotation  Initializer       
opt  opt

El tipo T  de una variable introducida por una declaración de variable simple se determina de la siguiente manera:

 Si la declaración incluye una anotación de tipo, T  es ese tipo.

 De lo contrario, si la declaración incluye una expresión inicializador, T  es el ensanchada forma (sección 3.12 )
del tipo de la expresión inicializador.
 De lo contrario, T  es cualquier tipo.

Cuando una declaración de variable especifica tanto una anotación de tipo como una expresión de inicializador, se
requiere que el tipo de la expresión de inicializador sea asignable (sección 3.11.4 ) al tipo dado en la anotación de tipo.

Se permiten múltiples declaraciones para el mismo nombre de variable en el mismo espacio de declaración, siempre que
cada declaración asocie el mismo tipo con la variable.

Cuando una declaración de variable tiene una anotación de tipo, es un error que esa anotación de tipo utilice
el operador typeof para hacer referencia a la variable que se declara.

A continuación se presentan algunos ejemplos de declaraciones de variables simples y sus tipos asociados.

var a;                          // cualquier 
var b: número ;                  // número 
var c = 1 ;                      // número 
var d = {x: 1 , y: "hola" };   // {x: número; y: cadena; } 
var e: any = "prueba" ;            // alguna
Se permite lo siguiente porque todas las declaraciones de la variable única 'x' asocian el mismo tipo (Número) con 'x'.

var x = 1 ; 
var x: número ; 
if (x == 1 ) { var x = 2 ; }
    

En el siguiente ejemplo, las cinco variables son del mismo tipo e, ' {x: número; y: número; } ' .

Punto de interfaz {x: número ; y: número ; }
var a = {x: 0 , y: < número > indefinido}; 
var b: Punto = {x: 0 , y: indefinido}; 
var c = <Punto> {x: 0 , y: indefinido}; 
var d: {x: número ; y: número ; } = {x: 0 , y: indefinido}; 
var e = <{x: número ; y: número ; }> {x: 0 , y: indefinido};

5.2.2         Destrucción de declaraciones de variables

Una declaración de variable de desestructuración  introduce cero o más variables con nombre y las inicializa con valores
extraídos de las propiedades de un objeto o elementos de una matriz.

DestructuringVariableDeclaration: 
BindingPattern  TypeAnnotation  Initializer     
opt 

Cada b ncontrar p ROPIEDAD o e lement que especi FIES una i dentifier introduce una variable por ese nombre. El tipo de

la variable es la forma ampliada (sección 3.12 ) del tipo asociado con la propiedad o elemento de enlace , como se define
a continuación.

TODO:  Documento que desestructura un  iterador  en una matriz  .

El tipo T  asociado con una declaración de variable de desestructuración se determina de la siguiente manera:

 Si la declaración incluye una anotación de tipo, T  es ese tipo.

 De lo contrario, si la declaración incluye una expresión de inicializador, T  es el tipo de esa expresión de
inicializador.
 De lo contrario, T  es cualquier tipo.

El tipo T  asociado con una propiedad de enlace se determina de la siguiente manera:

 Sea S  el tipo asociado con la declaración de variable de desestructuración , la propiedad de enlace o el elemento
de enlace que contiene inmediatamente .
 Si S  es cualquier tipo:
o Si el b ncontrar p ROPIEDAD especifica un inicializador expresión , T  es el tipo de que
inicializador expresión .
o De lo contrario, T  es cualquier tipo.
 Sea P  el nombre de propiedad especificado en la propiedad de enlace.
 Si S  tiene una propiedad aparente con el nombre P  , T  es el tipo de esa propiedad.
 De lo contrario, si S  tiene una firma de índice numérico y P  es un nombre numérico , T  es el tipo de firma de
índice numérico.
 De lo contrario, si S  tiene una firma de índice de cadena, T  es el tipo de firma de índice de cadena.
 De lo contrario, no se asocia ningún tipo con la propiedad de enlace y se produce un error.

El tipo T  asociado con un elemento de enlace se determina de la siguiente manera:

 Sea S  el tipo asociado con la declaración de variable de desestructuración , la propiedad de enlace o el elemento
de enlace que contiene inmediatamente .
 Si S  es cualquier tipo:
 o Si el b ncontrar elemento especifica un inicializador expresión , T  es el tipo de que inicializador expresión .
o De lo contrario, T  es cualquier tipo.
 Si S  no es un tipo de tipo matriz (sección 3.3.2 ) , no se asocia ningún tipo con la propiedad de enlace y se
produce un error.
 Si el elemento de unión es un elemento de apoyo , T  es un tipo de matriz con un tipo de elemento E  , donde E  es
el tipo de la firma índice numérico de S  .
 De lo contrario, si S  es una tupla -como tipo (sección 3.3.3 ) :
o Sea N  el índice basado en cero del elemento de enlace en el patrón de enlace de la matriz.
o Si S  tiene una propiedad con el nombre numérico N  , T  es el tipo de esa propiedad.
o De lo contrario, no se asocia ningún tipo con el elemento de enlace y se produce un error.
 De lo contrario, si S  tiene una firma de índice numérico, T  es el tipo de firma de índice numérico.
 De lo contrario, no se asocia ningún tipo con el elemento de enlace y se produce un error.

Cuando una declaración de variable de desestructuración , una propiedad de enlace o un elemento de enlace

especifica una expresión de inicializador, el tipo de la expresión de inicializador debe poder asignarse a la forma ampliada
del tipo asociado con la declaración de variable de desestructuración, la propiedad de enlace o el elemento de enlace.

TODO: Actualice las reglas para reflejar una  mejor verificación de la desestructuración con inicializadores literales .

W gallina el objetivo de producción es ECMAScript 2015 o superior , a excepción de la eliminación de la anotación de tipo
opcional, desestructuración variables declaraciones permanecen sin cambios en el código JavaScript emitida.

Cuando el objetivo de salida es ECMAScript 3 o 5, las declaraciones de variables de desestructuración se reescriben en

declaraciones de variables simples. Por ejemplo, una declaración de desestructuración de objetos n del formulario

var {x , p : y , q : z = falso } = getSomeObject () ;

se reescribe a las declaraciones de variables simples

var _a = getSomeObject (), x = _a.x , y = _a . p , _b = _a. q , z = _b === nulo 0 ? falso : _b;

    
    
    
   

T él '_a' y variables temporales '' _b existen para asegurar la asignada expresión se evalúa sólo una vez , y la expresión
'vacío 0' simplemente denota el valor de JavaScript 'indefinido'.

Del mismo modo, una declaración de desestructuración de matriz n del formulario

var [x, y, z = 10 ] = getSomeArray ();

se reescribe a las declaraciones de variables simples

var _a = getSomeArray (), 

    x = _a [ 0 ], 
    y = _a [ 1 ], 
    _b = _a [ 2 ], z = _b === ¿ vacío 0 ? 10 : _b;
   

Combinando ambas formas de desestructuración, el ejemplo

var {x, p : [ y, z = 10 ] = getSomeArray ()} = getSomeObject ();

se reescribe a

var _a = getSomeObject (), 

    x = _a.x, 
    _b = _a.p, _c = _b = == nulo 0 ? getSomeArray (): _b,     y = _c [ 0 ],     _d = _c [ 1 ], z = _d
=== void 0 ? 10 : _d;
    

   

5.2.3         Tipo implícito
Una variable, parámetro, propiedad de enlace o declaración de elemento de enlace que especifica que un patrón de
enlace tiene un tipo implícito  que se determina de la siguiente manera:

 Si la declaración especifica un patrón de enlace de objeto, el tipo implícito es un tipo de objeto con un conjunto
de propiedades correspondientes a las declaraciones de propiedades de enlace especificadas . El tipo de cada
propiedad es el tipo implícito en su declaración de propiedad vinculante, y una propiedad es opcional cuando su
declaración de propiedad vinculante especifica una expresión inicializadora.
 Si la declaración especifica un patrón de enlace de matriz sin un elemento de descanso , el tipo implícito es un
tipo de tupla con elementos correspondientes a las declaraciones de elementos de enlace especificados . El tipo de
cada elemento es el tipo implícito en su declaración de elemento vinculante.
 Si la declaración especifica un patrón de enlace de matriz con un elemento de descanso, el tipo implícito es un
tipo de matriz con un tipo de elemento de Any.

El tipo implícito de una propiedad de enlace o declaración de elemento de enlace es

 el tipo de expresión inicializadora de la declaración, si la hay, o de lo contrario

 el tipo implícito del patrón de enlace especificado en la declaración, si existe, o de otra manera
 El tipo Cualquiera.

En el ejemplo

función f ({a, b = "hola" , c = 1 }) {...}

El tipo implícito del patrón de enlace en el parámetro de la función es '{a: any; b ?: cuerda; c ?: número; } '. Dado que el
parámetro no tiene anotaciones de tipo , este se convierte en el tipo del parámetro.

En el ejemplo

var [a, b, c] = [ 1 , "hola" , verdadero ];

la expresión de inicializador literal de matriz se escribe contextualmente por el tipo implícito del patrón de
enlace, específicamente el tipo de tupla '[cualquiera, cualquiera, cualquiera]'. Debido a que el tipo contextual es un tipo de
tupla, el tipo resultante del literal de matriz es el tipo de tupla '[número, cadena, booleano]', y la declaración de
desestructuración da así el número de tipo, cadena y booleano a a, b y c respectivamente.

5.3 Declaraciones de Let y Const        

Las declaraciones Let y const se amplían para incluir anotaciones de tipo opcionales.

Enlace léxico  :  (Modificado)  SimpleLexicalBinding  DestructuringLexicalBinding  

 Enlace Lexical  simple  : 
BindingI  dentificador  Tipo Anotación  Inicializador       
opt  opt

DestructuringLexicalBinding  : 
BindingPattern  TypeAnnotation  Initializer       
opt  opt

TODO: alcance del documento y tipos de  declaraciones let y const .

5.4 Declaraciones If, Do y While        

Las expresiones que controlan ' if ' , ' do ' y ' while ' pueden ser de cualquier tipo (y no solo de tipo booleano).

5.5 Para declaraciones        
Las declaraciones de variables en ' para ' declaración s se extienden en la misma forma que las declaraciones de variables
en los estados variables (sección 5.2 ).

5.6 Declaraciones for-in        
En una declaración ' for-in ' del formulario

para la declaración ( v en expr )

v  debe ser una expresión clasificada como una referencia de tipo Any o el tipo primitivo String, y expr  debe ser una
expresión de tipo Any, un tipo de objeto o un tipo de parámetro de tipo.

En una declaración ' for-in ' del formulario

para ( var v en expr ) s tatement

v  debe ser una declaración de variable sin una anotación de tipo que declare una variable de tipo Any , y expr  debe ser
una expresión de tipo Any, un tipo de objeto o un tipo de parámetro de tipo.

5.7 Declaraciones for-of        
TODO: documentar  declaraciones for-of .

5.8 Continuar declaraciones        
Se requiere que una instrucción ' continue ' esté anidada, directa o indirectamente (pero no cruzando los límites de la
función), con una instrucción de iteración ( ' do ' , ' while ' , ' for ' o ' for-in ' ). W uando un ' continuará ' declaración
incluye una etiqueta de destino, esa etiqueta de destino debe aparecer en el conjunto de etiquetas de una
envolvente (pero no cruzar los límites de la función) comunicado iteración.

5.9 Declaraciones de ruptura        
Un ' descanso ' se requiere una declaración para ser anidado, (cruce pero no límites de función), directa o indirectamente,
dentro de una iteración ( ' hacer ' , ' mientras que ' , ' para ' , o ' for-in ' ) o ' interruptor ' declaración . Cuando
una declaración de ' interrupción ' incluye una etiqueta de destino, esa etiqueta de destino debe aparecer en el conjunto
de etiquetas de una declaración de cierre (pero no cruzando límites de función).

5.10    Declaraciones de devolución
Es un error que ocurra una declaración ' return ' fuera del cuerpo de una función. Específicamente, las declaraciones
de ' retorno ' no están permitidas a nivel global o en los cuerpos de espacios de nombres .
Un ' r eturn ' declaración sin una expresión de retorno s el valor ' indefinido ' y está permitido en el cuerpo de cualquier
función, independientemente del tipo de retorno de la función.

Cuando una declaración de ' retorno ' incluye una expresión , si la función que contiene incluye una anotación de tipo de
retorno, la expresión de retorno se tipea contextualmente (sección 4.23 ) por ese tipo de retorno y debe ser de un tipo
que se pueda asignar al tipo de retorno. De lo contrario, si la función que contiene se escribe contextualmente por un
tipo T  , Expr  se escribe contextualmente por el tipo de retorno de T.

En una implementación de función sin una anotación de tipo de retorno, el tipo de retorno se infiere de las declaraciones
de ' retorno ' en el cuerpo de la función, como se describe en la sección 6.3 .

En el ejemplo

función f (): (x: cadena ) => número { return s => s.length; }

    

la expresión de flecha en la declaración ' return ' está contextualizada por el tipo de retorno de ' f ' , dando así el
tipo ' string ' a ' s ' .

5.11 Con declaraciones   
T se de la ' con ' comunicado a máquina de escribir es un error , como es el caso en ECMAScript 5 ' modo estricto
s . Además, dentro del cuerpo de un ' con ' declaración , mecanografiado considera cada identificador se producen en una
expresión (sección 4.3 ) para ser de la Cualquier tipo independientemente de su tipo declarado. Debido a que
la instrucción ' with ' pone un conjunto de identificadores estáticamente desconocidos en el alcance delante de los que
están conocidos estáticamente, no es posible asignar significativamente un tipo estático a ningún identificador.

5.12 Cambiar declaraciones   
En una declaración ' switch ' , cada expresión ' case ' debe ser de un tipo que se pueda asignar ao desde (sección 3.11.4 )
el tipo de la expresión ' switch ' .

5.13 Declaraciones de lanzamiento   
La expresión especificada en una declaración ' throw ' puede ser de cualquier tipo.

5.14 Intentar declaraciones   
T que la variable introducida por un ' captura ' cláusula de un ' probar ' declaración es siempre del tipo Any. No es posible
incluir una anotación de tipo en una cláusula ' catch ' .

1
 
 

6 6 Las funciones
        

Letra de imprenta se extiende JavaScript función s para incluir parámetros de tipo, parámetro y volver anotaciones de

tipo, sobrecargas, valores de parámetros por defecto, y descansar parámetros .
6.1         Declaraciones de funciones
Fu declaraciones nción se extienden para permitir el cuerpo de la función a ser omitidos en las declaraciones de
sobrecarga.

FunctionDeclaration:  (modificada)  función BindingI  dentifier  CallSignature  { FunctionBody  } función BindingI  dent

opt 

ifier  CallSignature  ;  

opt 

               
        

Una declaración de función  introduce un valor con nombre de un tipo de función en el espacio de declaración que
contiene . El BindingIdentifier  es opcional solamente cuando la declaración de la función se produce en una
exportación declaración predeterminado (sección 11.3.4.2 ).

Las declaraciones de funciones que especifican un cuerpo se denominan implementaciones de  funciones y las
declaraciones de funciones sin un cuerpo se denominan sobrecargas de funciones  . Es posible especificar
múltiples sobrecargas para la misma función (es decir, para el mismo nombre en el mismo espacio de declaración) ,
pero una función puede tener como máximo una implementación. Todas las declaraciones para la misma función deben
especificar el mismo conjunto de modificadores (es decir, la misma combinación
de declarar , exportar y predeterminado ).

Cuando una función tiene declaraciones de sobrecarga, las sobrecargas determinan las firmas de llamada del tipo dado al
objeto de función y la firma de implementación de la función (si la hay) debe ser asignable a ese tipo. De lo contrario, la
implementación de la función misma determina la firma de la llamada.

Cuando una función tiene sobrecargas y una implementación, las sobrecargas deben preceder a la implementación y
todas las declaraciones deben ser consecutivas sin elementos gramaticales intermedios.

6.2         Sobrecargas de funciones
Las sobrecargas de funciones permiten una especificación más precisa de los patrones de invocación soportados por una
función que la que es posible con una sola firma. El procesamiento en tiempo de compilación de una llamada a una
función sobrecargada elige la mejor sobrecarga candidata para los argumentos particulares y el tipo de retorno de esa
sobrecarga se convierte en el tipo de resultado de la expresión de llamada de función. Por lo tanto, el uso de
sobrecargas que es posible estáticamente describir la manera en que una función de ' tipo de retorno s varía en función
de sus argumentos. La resolución de sobrecarga en las llamadas a funciones se describe más adelante en la sección 4.15 .

Las sobrecargas de funciones son puramente una construcción en tiempo de compilación. No tienen impacto en el
JavaScript emitido y, por lo tanto, no tienen costo de tiempo de ejecución.

La lista de parámetros de una sobrecarga de funciones no puede especificar valores predeterminados para los
parámetros. En otras palabras, una sobrecarga puede usar solo el ? forma al especificar parámetros opcionales.

El siguiente es un ejemplo de una función con sobrecargas.

función attr (nombre: cadena ): cadena ; 
función attr (nombre: cadena , valor: cadena ): Accesor; 
función attr (mapa: cualquiera ): Accesor; 
la función attr (nameOrMap: ninguna , valor ? : string ): ninguna { si (nameOrMap && typeof nameOrMap
=== " string " ) { // manipulador cadena caso     } demás { // h andle mapa caso     } }
    
        

    
        
Tenga en cuenta que cada sobrecarga y la implementación final especifican el mismo identificador. El tipo de la variable
local ' attr ' introducida por esta declaración es

var attr: { 
    (nombre: cadena ): cadena ; 
    (nombre: cadena , valor: cadena ): Accesor; 
    (mapa: cualquiera ): Accesor; 
} ;

Tenga en cuenta que la firma de la implementación de la función real no está incluida en el tipo.

6.3         Implementaciones de funciones
Se dice que una implementación de función sin una anotación de tipo de retorno es una función tipada
implícitamente  . El tipo de retorno de una función implícita mecanografiado f  se infiere de su cuerpo de la función como
sigue:

 Si no hay declaraciones de retorno con expresiones en f  ' s cuerpo de la función, el tipo de retorno inferido es
Vacío.
 De lo contrario, si f  ' cuerpo de la función s referencia directamente f  o referencias funciones que a través de esta
misma referencia análisis tecleó cualquier implícitamente f  , el tipo de retorno inferida es cualquier.
 De lo contrario, si f  es una expresión de función contextualizada (sección 4.10 ), el tipo de retorno inferido es el
tipo de unión (sección 3.4 ) de los tipos de expresiones de declaración de retorno en el cuerpo de la función,
ignorando las declaraciones de retorno sin expresiones.
 De lo contrario, el tipo de retorno inferido es el primero de los tipos de expresiones de declaración de retorno en
el cuerpo de la función que es un supertipo (sección 3.11.3 ) de cada uno de los otros, ignorando las declaraciones
de retorno sin expresiones. Se produce un error en tiempo de compilación si ninguna expresión de declaración de
retorno tiene un tipo que sea un supertipo de cada una de las otras.

En el ejemplo

función f (x: número ) {     if (x <= 0 ) return x; devolver g (x); } 

    

función g (x: número ) { return f (x - 1 ); }

    

el tipo de retorno inferido para ' f ' y ' g ' es Cualquiera porque las funciones hacen referencia a sí mismas a través de un
ciclo sin anotaciones de tipo de retorno. Agregar un tipo de retorno explícito ' número ' a cualquiera de los dos rompe el
ciclo y hace que el tipo de retorno ' número ' se infiera para el otro.

Una función de tipo explícito de cuyo retorno Tipo de ISN ' t el Vacío tipo, el Cualquier tipo o un tipo de unión que
contiene el Vacío o cualquier tipo como constituyente debe tener al menos una instrucción de retorno en algún lugar de
su cuerpo. Una excepción a esta regla es si la implementación de la función consiste en una sola declaración ' throw ' .

El tipo de ' esto ' en la implementación de una función es Cualquier tipo .

En la firma de la implementación de una función, un parámetro puede marcarse como opcional siguiéndolo con un
inicializador. Cuando una declaración de parámetro incluye tanto una anotación de tipo como un inicializador, la
expresión de inicializador se tipea contextualmente (sección 4.23 ) por el tipo indicado y debe ser asignable al tipo
indicado, o de lo contrario se produce un error en tiempo de compilación. Cuando una declaración de parámetro no tiene
anotaciones de tipo pero incluye un inicializador, el tipo del parámetro es la forma ampliada (sección 3.12 ) del tipo de la
expresión del inicializador.
Las expresiones de inicialización se evalúan en el ámbito del cuerpo de la función, pero no se les permite hacer referencia
a variables locales y solo se les permite acceder a los parámetros que se declaran a la izquierda del parámetro que
inicializan , a menos que la referencia de parámetro ocurra en una expresión de función anidada .

Cuando el objetivo de salida es ECMAScript 3 o 5, para cada parámetro con un inicializador, se incluye una declaración
que sustituye el valor predeterminado por un argumento omitido en el JavaScript generado, como se describe en la
sección 6.6 . El ejemplo

función extraña (x: número , y = x * 2 , z = x + y) { return z; }

    

genera JavaScript que es equivalente a

función extraña (x, y, z) { if (y === void 0 ) { y = x * 2 ; } if ( z === void 0 ) { z = x +

y; } retorno z; }
    
    
    

En el ejemplo

var x = 1; 
función f (a = x) { var x = " hola " ; }
    

la variable local ' x ' está dentro del alcance en el inicializador de parámetros (ocultando así la ' x ' externa ), pero es un
error hacer referencia a ella porque siempre estará sin inicializar en el momento en que se evalúa el inicializador de
parámetros .

6.4 Declaraciones de parámetros de desestructuración        

Declaraciones de parámetros pueden especificar modelos de unión (sección 3.9.2.2 ) y luego se
llama desestructuración  parámetro  declaración  s  . Similar a una declaración de variable de desestructuración
(sección 5.2.2 ), una declaración de parámetro de desestructuración introduce cero o más locales nombrados y los
inicializa con valores extraídos de propiedades o elementos del objeto o matriz pasados como argumento para el
parámetro.

El tipo de local introducido en una declaración de parámetro de desestructuración se determina de la misma manera que
un local introducido mediante una declaración de variable de desestructuración, excepto que el tipo T  asociado con una
declaración de parámetro de desestructuración se determina de la siguiente manera:

 Si la declaración incluye una anotación de tipo, T  es ese tipo.

 Si la declaración se produce en una expresión de función para la cual está disponible una firma contextual
(sección 4.10 ), T  es el tipo obtenido de la firma contextual.
 De lo contrario, si la declaración incluye una expresión inicializadora, T  es la forma ampliada (sección 3.12 ) del
tipo de expresión inicializadora.
 De lo contrario, si la declaración especifica un patrón de enlace, T  es el tipo implícito de ese patrón de enlace
(sección 5.2.3 ).
 De lo contrario, si el parámetro es un parámetro de reposo, T  es cualquier [] .
 De lo contrario, T  es cualquiera .
Cuando el objetivo de salida es ECMAScript 2015 o superior, a excepción de eliminar la anotación de tipo opcional, las
declaraciones de parámetros de desestructuración permanecen sin cambios en el código JavaScript emitido. Cuando el
objetivo de salida es ECMAScript 3 o 5, desestructuración parámetro decl Preparativos se reescriben a
locales declaraciones de variables.

El ejemplo

función dibujar texto ({text = "" , ubicación: [x, y] = [ 0 , 0 ], negrita = falso }) { // Dibujar

texto } 
    

declara una función drawText que toma un solo parámetro del tipo

{texto ?: cadena ; ubicación ?: [ número , número ]; negrita: booleano ; }

Cuando el objetivo de salida es ECMAScript 3 o 5, la función se reescribe en

función dibujar texto ( _a) { var _b = _a.text, text = _b === void 0 ? "" : _b, _c = _a.l

ubicación , _d = _c === nulo 0 ? [ 0 , 0 ]: _c, x = _d [ 0 ], y = _d [ 1 ],         _e =
_a. negrita , negrita = _e === ¿ vacío 0 ? falso : _e; // Dibujar texto }
    
        
        
        
        
        

        
    

Las declaraciones de parámetros de desestructuración no permiten anotaciones de tipo en los patrones de enlace
individuales, ya que tales anotaciones entrarían en conflicto con el significado ya establecido de dos puntos en literales de
objeto. Las anotaciones de tipo deben escribirse en la declaración de parámetros de nivel superior. Por ejemplo

interfaz DrawTextInfo { 
    text ?: string ; 
    ubicación ?: [ número , número ]; 
    negrita: booleano ; 
}
función drawText ({texto, ubicación: [x, y], negrita}: DrawTextInfo) { // Dibujar texto }
    

6.5 Funciones genéricas        
La implementación de una función puede incluir parámetros de tipo en su firma (sección 3.9.2.1 ) y luego se
denomina función genérica  . Los parámetros de tipo proporcionan un mecanismo para expresar relaciones entre
parámetros y tipos de retorno en operaciones de llamada. Los parámetros de tipo no tienen representación en tiempo de
ejecución; son puramente una construcción en tiempo de compilación.

Los parámetros de tipo declarados en la firma de una implementación de función están dentro del alcance de la firma y
el cuerpo de esa implementación de función.

El siguiente es un ejemplo de una función genérica:

interfaz Comparable { localeCompare (otro: any ): número ; }
    

función comparar <T se extiende Comparable > (x: T, y: T): número { if (x == null) return y ==

null? 0 : -1 ; if (y == null) devuelve 1 ; volver x. localeCompare (y); }
    
    
    

Tenga en cuenta que las ' x ' y ' Y ' parámetros son conocidos por ser subtipos de los contras Traint ' Comparable ' y por lo
tanto tener un ' compareTo ' miembro. Esto se describe más adelante en la sección 3.6.1 .

Los argumentos de tipo de una llamada a una función genérica pueden especificarse explícitamente en una operación de
llamada o, cuando sea posible, inferirse (sección 4.15.2 ) de los tipos de argumentos regulares en la llamada. En el ejemplo

clase Persona { nombre: cadena;     localeCompare (other: Person) { return compare (this.name,

other.name);     } }
    

        

El argumento de tipo para ' comparar ' se infiere automáticamente que es el tipo de Cadena porque los dos argumentos
son cadenas.

6.6         Codigo de GENERACION
Una declaración de función genera código JavaScript que es equivalente a:

function <FunctionName> (<FunctionParameters>) { 
    <DefaultValueAssignments> 
    <FunctionStatements> 
}

Función  Nombre  es el nombre de la función (o nada en el caso de una expresión de función).

Función  Param  eter  s  es una lista separada por comas de la función de ' nombres de los parámetros s.

DefaultValueAssignments  es una secuencia de asignaciones de valor de propiedad predeterminadas, una para cada
parámetro con un valor predeterminado, en el orden en que se declaran, del formulario

if (<Parameter> === void 0 ) {<Parameter> = <Default>; }

donde Parámetro  es el nombre del parámetro y Predeterminado  es la expresión del valor predeterminado.

Declaraciones de  función  es el código generado para las declaraciones especificadas en el cuerpo de la función.

6.7 Funciones del generador        

TODO:  Funciones del generador de  documentos  .

6.8 Funciones asincrónicas        
TODO: documenta  funciones asincrónicas .
6.9 Funciones de protección de tipo        
TODO:  funciones de protección de tipo de  documento  , incluidos los  predicados de este tipo .

1
 
 

7 interfaces        

Las interfaces proporcionan la capacidad de nombrar y parametrizar tipos de objetos y componer los tipos de objetos
nombrados existentes en otros nuevos.

Las interfaces no tienen representación en tiempo de ejecución: son puramente una construcción en tiempo de
compilación. Las interfaces son particularmente útiles para documentar y validar la forma requerida de las propiedades,
los objetos pasados como parámetros y los objetos devueltos por las funciones.

Dado que TypeScript tiene un sistema de tipo estructural, un tipo de interfaz con un conjunto particular de miembros se
considera idéntico y puede ser sustituido por otro tipo de interfaz o tipo de objeto literal con un conjunto idéntico de
miembros (ver sección 3.11.2 ) .

Las declaraciones de clase pueden hacer referencia a interfaces en su cláusula de implementos para validar que
proporcionan una implementación de las interfaces.

7.1         Declaraciones de interfaz
Una declaración de interfaz declara un tipo de interfaz  .

InterfaceDeclaration: 
interfaz BindingI  dentifier  TypeParameters  InterfaceExtendsClause  ObjectType           
opt  opt 

InterfaceExtendsClause: 
extiende ClassOrInterfaceTypeList  

ClassOrInterfaceTypeList: 
ClassOrInterfaceType 
ClassOrInterfaceTypeList  , ClassOrInterfaceType     

ClassOrInterfaceType: 
TypeReference

Una declaración de interfaz  introduce un tipo con nombre (sección 3.7 ) en el espacio de declaración que lo
contiene. El dentificador  BindingI  de una declaración de interfaz puede no ser uno de los nombres de tipo predefinidos
(sección 3.8.1 ).

Opcionalmente, una interfaz puede tener parámetros de tipo (sección 3.6.1 ) que sirven como marcadores de posición
para los tipos reales que se proporcionarán cuando se hace referencia a la interfaz en referencias de tipo. Una interfaz con
parámetros de tipo se denomina interfaz genérica  . Los parámetros de tipo de una declaración de interfaz genérica están
dentro del alcance de toda la declaración y se pueden hacer referencia en el cuerpo InterfaceExtendsClause  y ObjectType  .

Una interfaz puede heredar de cero o más tipos  base  que se especifican en InterfaceExtendsClause  . Los tipos base deben
ser referencias de tipo a clases o tipos de interfaz.
Una interfaz tiene los miembros especificados en el ObjectType  de su declaración y además hereda todos los de base de
tipo a los miembros que aren ' t ocultos por declaraciones en el inte rface:

 Una declaración de propiedad oculta una propiedad de tipo base pública con el mismo nombre.

 Una declaración de firma de índice de cadena oculta una firma de índice de cadena de tipo base .
 Una declaración de firma de índice numérico oculta una firma de índice numérico de tipo base.

Las siguientes restricciones deben cumplirse mediante una declaración de interfaz o, de lo contrario, se produce un error
en tiempo de compilación :

 Una declaración de interfaz no puede, directa o indirectamente, especificar un tipo base que se origina en la
misma declaración. En otras palabras, una interfaz no puede, directa o indirectamente, ser un tipo base de sí misma,
independientemente de los argumentos de tipo.
 Una interfaz no puede declarar una propiedad con el mismo nombre que una propiedad privada o
protegida heredada .
 Las propiedades heredadas con el mismo nombre deben ser idénticas (sección 3.11.2 ).
 Todas las propiedades de la interfaz deben satisfacer las restricciones implícitas en las firmas de índice de la
interfaz como se especifica en la sección 3.9.4 .
 El (sección de este tipo 3.6.3 ) de la declarada interfaz debe ser asignable (sección 3.11.4 ) a cada una de las
referencias de tipo base.

Se permite que una interfaz herede miembros idénticos de múltiples tipos base y en ese caso solo contendrá una
aparición de cada miembro en particular .

A continuación se muestra un ejemplo de dos interfaces que contienen propiedades con el mismo nombre pero diferentes
tipos:

interfaz Mover {     move (): void ;     getStatus (): {velocidad: número ; }; } 

interfaz Shaker {     shake (): void ;     getStatus (): {frecuencia: número ; }; } 

Una interfaz que extiende ' Mover ' y ' Shaker ' debe declarar una nueva propiedad ' getStatus ' ya que de lo contrario

heredaría dos propiedades ' getStatus ' con diferentes tipos. La nueva propiedad ' getStatus ' debe declararse de modo
que el ' MoverShaker ' resultante sea un subtipo de ' Mover ' y ' Shaker ' :

la interfaz MoverShaker extiende Mover, Shaker { 
    getStatus (): {speed: number ; frecuencia: número ; }; 
}

Dado que los tipos de función y constructor son solo tipos de objeto que contienen firmas de llamada y construcción, las
interfaces se pueden usar para declarar tipos de función y constructor con nombre. Por ejemplo:

interfaz StringComparer {(a: cadena , b: cadena ): número ; }

Esto declara que el tipo ' StringComparer ' es un tipo de función que toma dos cadenas y devuelve un número.

7.2         Declaración de fusión
Las interfaces son " abiertas " y las declaraciones de interfaz con el mismo nombre calificado relativo a una raíz común
(como se define en la sección 2.3 ) contribuyen a una única interfaz.
Cuando una interfaz genérica tiene múltiples declaraciones, todas las declaraciones deben tener listas de parámetros de
tipo idénticos, es decir, nombres de parámetros de tipo idénticos con restricciones idénticas en el mismo orden.

En una interfaz con múltiples declaraciones, t que se extiende cláusulas se fusionan en un único conjunto de tipos de
base y de los cuerpos de las declaraciones de interfaz se fusionan en un solo tipo de objeto. La fusión de declaraciones
produce un orden de declaración que corresponde a anteponer  los miembros de cada declaración de interfaz ,
en el orden en que se escriben los miembros , a la lista combinada de miembros en el orden de las declaraciones de
interfaz. Por lo tanto, los miembros declarados en la última declaración de interfaz aparecerán primero en el orden de
declaración del tipo combinado.

Por ejemplo, una secuencia de declaraciones en este orden:

Documento de interfaz { 
    createElement (tagName: any ): Element; 
}
Documento de interfaz { 
    createElement (tagName: string ): HTMLElement; 
}
Documento de interfaz { 
    createElement (tagName: " div " ): HTMLDivElement; 
    createElement (tagName: " span " ): HTMLSpanElement; 
    createElement (tagName: " canvas " ): HTMLCanvasElement; 
}

es equivalente a la siguiente declaración única:

Documento de interfaz { 
    createElement (tagName: " div " ): HTMLDivElement; 
    createElement (tagName: " span " ): HTMLSpanElement; 
    createElement (tagName: " canvas " ): HTMLCanvasElement; 
    createElement (tagName: string ): HTMLElement; 
    createElement (tagName: any ): Elemento; 
}

Tenga en cuenta que los miembros de la última declaración de interfaz aparecen primero en la declaración
fusionada. También tenga en cuenta que se conserva el orden relativo de los miembros declarados en el mismo cuerpo de
interfaz.

TODO:  Clase de  documento  y fusión de declaración de interfaz .

7.3 Interfaces que amplían clases        

Cuando una interfaz n tipo se extiende una clase de tipo que hereda el miembro s de la clase pero no
sus implementaciones. Es como si la interfaz tuvo declarar d todos los miembros de la clase sin proporcionar una
implementación. Las interfaces heredan incluso los miembros privados y protegidos de una clase base. W gallina una clase
que contenga privados o protegidos miembros es el tipo de base de un tipo de interfaz, que tipo de interfaz sólo puede
ser implementado por esa clase o de una clase descendiente. Por ejemplo:

Control de clase { estado privado : cualquiera ; }
    

interfaz SelectableControl extiende Control { 
    select (): void ; 
}
El botón de clase extiende el control { 
    select () {} 
}
class TextBox extiende Control { 
    select () { } 
}
clase Imagen extiende Control { 
}
ubicación de clase { 
    select () {} 
}

En el anterior ejemplo, ' SelectableControl ' contiene todos los de los miembros de ' control ' , incluyendo la

privada ' estado ' propiedad. Dado que ' state ' es un miembro privado, solo es posible que los descendientes
de 'Control ' implementen ' SelectableControl ' . Esto se debe a que solo los
descendientes de ' Control ' tendrán un miembro privado ' estatal ' que se ordena en la misma declaración, que es un
requisito para que los miembros privados sean compatibles (sección 3.11 ).

Dentro de la clase ' Control ' es posible acceder al miembro privado ' estado ' a través de una instancia

de ' SelectableControl ' . Efectivamente, un ' Control seleccionable ' actúa como un ' Control ' que se sabe que tiene
unmétodo ' select ' . T él ' botón ' y ' TextBox ' clases son subtipos de ' SelectableControl ' (porque ambos heredar
de ' control ' y tienen una ' seleccione ' método) , pero la ' imagen ' y ' Ubicación ' clases no lo son.

7.4 Verificaciones de tipo dinámico        

TypeScript no proporciona un mecanismo directo para probar dinámicamente si un objeto implementa una interfaz
particular. En cambio, el código TypeScript puede usar la técnica de JavaScript para verificar si un conjunto apropiado
de miembros está presente en el objeto. Por ejemplo, dadas las declaraciones en la sección 7.1 , la siguiente es una
comprobación dinámica de la interfaz ' MoverShaker ' :

var obj: any = getSomeObject (); 

if (obj && obj.move && obj.shake && obj.getStatus) { var moverShaker = < MoverShaker> obj;     ... }
    

Si tal verificación se usa a menudo, se puede resumir en una función:

funciona comoMoverShaker (obj: any ): MoverShaker { return obj && obj.move && obj.shake &&

obj.getStatus? obj: nulo ; }
    

1
 
 

8 Clases
        

TypeScript amplía las clases de JavaScript para incluir parámetros de tipo, implementa cláusulas, modificadores de
accesibilidad, declaraciones de variables miembro y declaraciones de propiedades de parámetros en constructores.

TODO:  documentar las  clases abstractas .

8.1         Declaraciones de clase
Una declaración de clase declara un tipo de clase  y una función constructora  .

ClassDeclaration:  (Modificado)  clase BindingI  dentificador  TypeParameters  ClassHeritage  { ClassBody  }  

opt  opt 

                 

Una declaración de clase  introduce un tipo con nombre (el tipo de clase) y un valor con nombre (la función de constructor)
en el espacio de declaración que lo contiene. El tipo de clase se forma a partir de los miembros de instancia declarados en
el cuerpo de la clase y los miembros de instancia heredados de la clase base . La función de constructor recibe un tipo
anónimo formado por la declaración de constructor , las declaraciones de miembro estático en el cuerpo de la clase y los
miembros estáticos heredados de la clase base . La función constructora se inicializa y devuelve una instancia del tipo de
clase.

El dentificador  BindingI  de una declaración de clase puede no ser uno de los nombres de tipo predefinidos
(sección 3.8.1 ). El BindingIdentifier  es opcional solamente cuando la declaración de clase se produce en una
exportación de declaración por defecto (sección 11.3.4.2 ).

Opcionalmente, una clase puede tener parámetros de tipo (sección 3.6.1 ) que sirven como marcadores de posición para
los tipos reales que se proporcionarán cuando se hace referencia a la clase en referencias de tipo. Una clase con
parámetros de tipo se llama clase  genérica  . Los parámetros de tipo de una declaración de clase genérica están dentro
del alcance de la declaración completa y pueden ser referenciados en ClassHeritage  y ClassBody  .

El siguiente ejemplo introduce un tipo con nombre llamado ' Punto ' (el tipo de clase) y un valor con

nombre llamado ' Punto ' (la función del constructor) en el espacio de declaración que lo contiene .

class Point { constructor ( public x: number , public y: number ) {} public length ()
{ return Math.sqrt ( this .x * this .x + this .y * this .y); } origen estático = nuevo punto
( 0 , 0 ); }
    
    
    

El tipo con nombre 'Punto' es exactamente equivalente a

Punto de interfaz { x: número ;     y: número ;     longitud (): número ; }

    

T se denomina valor de 'Punto' es una función constructora cuyo tipo corresponde a la declaración

Punto var : { nuevo ( x: número , y: número ): Punto ;     punto de origen; } ;

    

El contexto en el que se hace referencia a una clase distingue entre el tipo de clase y la función constructora. Por ejemplo,
en la declaración de asignación

var p : Punto = nuevo punto ( 10 , 20 );
el identificador ' Punto ' en la anotación de tipo se refiere al tipo de clase , mientras que el identificador ' Punto ' en
la nueva expresión se refiere al objeto de función constructor.

8.1.1 Especificación de patrimonio de clase        

TODO:  Actualice esta sección para reflejar  expresiones en la clase extiende cláusulas .

La especificación de la herencia de una clase consiste en opcional se

extiende y implementa cláusulas. La cláusula extiende especifica la clase base de la clase y la cláusula
de implementos especifica un conjunto de interfaces para las cuales validar la clase proporciona una implementación.

ClassHeritage:  (Modificado)  ClassExtendsClause  ImplementsClause    

opt  opt

  

ClassExtendsClause: 
extiende ClassType   

ClassType  : 
TypeReference

ImplementsClause: 
implementa ClassOrInterfaceTypeList  

Una clase que incluye una cláusula extendida se llama clase derivada  , y la clase especificada en

la cláusula extendida se llama clase base  de la clase derivada. Cuando una especificación de herencia de clase omite
la cláusula extendidas , la clase no tiene una clase base. Sin embargo, como es el caso con cada tipo de objeto ,
las referencias de tipo (sección 3.3.1 ) a la clase parecerán tener los miembros del tipo de interfaz global llamado ' Objeto '
a menos que esos miembros estén ocultos por miembros con el mismo nombre en el clase.

Las siguientes restricciones deben ser satisfechas por la especificación de herencia de clase o, de lo contrario, se produce
un error en tiempo de compilación:

 Si está presente, la referencia de tipo especificada en la cláusula extend debe denotar un tipo de clase. Además,

la parte TypeName  de la referencia de tipo debe ser una referencia a la función de constructor de clase cuando se
evalúa como una expresión.
 Una declaración de clase no puede, directa o indirectamente, especificar una clase base que se origina en la
misma declaración. En otras palabras, una clase no puede, directa o indirectamente, ser una clase base de sí misma,
independientemente de los argumentos de tipo.
 El este tipo (sección 3.6.3 ) de la clase declarada debe ser un ssignable (sección 3.11.4 ) a la referencia de tipo de
base y cada una de las referencias citadas en la implementos cláusula.
 El tipo de función de constructor creado por la declaración de clase debe ser asignable al tipo de función de
constructor de clase base, ignorando las firmas de construcción.

El siguiente ejemplo ilustra una situación en la que se violaría la primera regla anterior:

clase A {a: número ; }
espacio de nombres Foo { var A = 1; la clase B extiende A {b: cadena ; } }
   
   

Cuando se evaluó como una expresión, la referencia de tipo ' A ' en el extiende cláusula doesn ' t referencia a la función
constructor de la clase de ' A ' (en lugar se hace referencia a la variable local ' A ' ).

La única situación en la que la dos última restricción es superior son violados es cuando una clase anula uno o más
miembros de la clase de base con nuevos miembros incompatibles.
Tenga en cuenta que debido a mecanografiado tiene un sistema de tipo estructural, una clase doesn ' t necesidad de
indicar explícitamente que implementa una interfaz es suficiente para que la clase contiene simplemente el conjunto
apropiado de instancia miembros. La cláusula implements de una clase proporciona un mecanismo para afirmar y validar
que la clase contiene los conjuntos apropiados de miembros de instancia , pero de lo contrario no tiene ningún efecto
sobre el tipo de clase.

8.1.2 Cuerpo de clase        
El cuerpo de la clase consta de cero o más declaraciones de constructor o miembro. Las declaraciones no están permitidas
en el cuerpo de una clase; deben colocarse en el constructor o en los miembros .

ClassElement:  (Modificado)  ConstructorDeclaration  Property  MemberDeclaration  IndexMemberDeclaration  

El cuerpo de la clase puede contener opcionalmente una única declaración de constructor . Las declaraciones de
constructor se describen en la sección 8.3 .

Las declaraciones de miembros se utilizan para declarar instancias y miembros estáticos de la clase. Las declaraciones de
miembros de propiedades se describen en la sección 8.4 y las declaraciones de miembros de índice se describen en la
sección 8.5 .

8.2 Miembros        
Los miembros de una clase consisten en los miembros introducidos a través de declaraciones de miembros en el cuerpo
de la clase y los miembros heredados de la clase base .

8.2.1 Instancia y miembros estáticos        

Los miembros son miembros de instancia  o miembros estáticos  .

Instancia m brasas son miembros de la clase tipo (sección 8.2.4 ) y su asociado este tipo . Dentro de los constructores, las
funciones de miembro de instancia y los accesores de miembro de instancia, el tipo de este es este tipo (sección 3.6.3 )
de la clase .

Los miembros estáticos se declaran utilizando el modificador estático y son miembros del tipo de función de
constructor (sección 8.2.5 ) . Dentro de las funciones miembro estáticas y accesos de miembros estáticos, el tipo
de este i es la función constructora típ correo .

No se puede hacer referencia a los parámetros de clase t en las declaraciones de miembros estáticos.

8.2.2         Accesibilidad
Las propiedades tienen acceso público  , privado  o protegido  . El valor predeterminado es la accesibilidad pública,
pero las declaraciones de los miembros de la propiedad pueden incluir
un modificador público , privado o protegido para especificar explícitamente la accesibilidad deseada.

Se puede acceder a los miembros de la propiedad pública en todas partes sin restricciones.

P rivate propiedad miembros sólo se puede acceder dentro del IR clase declarar . En concreto, un me privadas mber M
que  declaran en una clase C  se puede acceder solamente dentro del cuerpo de la clase de C  .

Solo se puede acceder a los miembros de propiedad protegidos dentro de la clase de declaración de IR y las clases
derivadas de la clase de declaración de IR , y se debe acceder a  un miembro de propiedad de instancia protegida a través
de  una instancia de la clase adjunta o una subclase de la misma . Específicamente, un miembro protegido M  declarado en
una clase C  puede accederse solamente dentro del cuerpo de la clase de C  o el cuerpo de la clase de una clase derivada
de C  . Además, cuando un miembro de instancia protegido M  se accede en un acceso a la propiedad E  . M  dentro del
cuerpo de una clase D  , se requiere que el tipo de E  sea D  o un tipo que directa o indirectamente tenga D  como tipo
base , independientemente de los argumentos de tipo.

La accesibilidad privada y protegida se aplica solo en tiempo de compilación y no sirve más que como una indicación de
intención  . Dado que JavaScript no proporciona ningún mecanismo para crear propiedades privadas y protegidas en un
objeto, no es posible aplicar los modificadores privados y protegidos en el código dinámico en tiempo de ejecución. Por
ejemplo, la accesibilidad privada y protegida puede ser derrotado por el cambio de un objeto ' tipo estático s a Cualquiera
y acceder al miembro de forma dinámica.

El siguiente ejemplo demuestra accesibilidad privada y protegida:

clase A { privado x: número ; protegido y: número ; estático f (a: A, b: B) {         ax = 1;  //

Ok         bx = 1;  // Ok         ay = 1;  // Ok         por = 1;  // Ok     } }
    
    
    

la clase B extiende A { estática f (a: A, b: B) {         ax = 1;  // Error, x solo accesible dentro de

A         bx = 1;  // Error, x solo accesible dentro de A         ay = 1;  // Error, se debe acceder a
y a través de la instancia de B         by = 1;  // Ok     } }
    

En la clase ' A ' , los accesos a ' x ' están permitidos porque ' x ' está declarado en ' A ' , y los accesos a ' y ' están
permitidos porque ambos tienen lugar a través de una instancia de ' A ' o un tipo derivado de ' A ' . En la clase de ' B ' ,
acceso a ' x ' no está permitido, y el primer acceso a ' y ' i S un error porque se lleva a cabo a través de una instancia
de ' A ' , que no se deriva de la clase envolvente ' B ' .

8.2.3         Herencia y anulación
Un derivado clase hereda  todos los miembros de su clase base que doesn ' t anulación  . La herencia significa que una
clase derivada contiene implícitamente todos los miembros no anulados de la clase base. O ólo pública y protegida la
propiedad miembro de s se puede anular.

Una propiedad miembro en una clase derivada se dice para anular una propiedad miembro en una clase base cuando la
clase derivada propiedad miembro tiene el mismo nombre y tipo (instancia o estática) como la clase
base propiedad miembro. El tipo de una imperiosa propiedad miembro debe ser asignable (sección 3.11.4 ) para el tipo de
la anulado propiedad miembro, o de lo contrario se produce un error de tiempo de compilación.

Las funciones de miembro de instancia de clase base pueden ser anuladas por funciones de miembro de instancia de clase
derivadas, pero no por otros tipos de miembros.

Las variables miembro y los accesos de la instancia de cl ass base pueden ser anulados por las variables y los accesos
miembros de la instancia de clase derivada , pero no por otros tipos de miembros.

Los miembros de propiedades estáticas de clase base pueden ser anulados por miembros

de propiedades estáticas derivadas de cualquier tipo siempre que los tipos sean compatibles, como se describió
anteriormente.
Se dice que un miembro índice en una clase derivada anula un miembro índice en una clase base cuando el miembro
índice de la clase derivada es del mismo tipo de índice (cadena o numérico) que el miembro índice de la clase base. El tipo
de miembro de índice anulado debe ser asignable (sección 3.11.4 ) al tipo de miembro de índice anulado, o de lo
contrario se produce un error en tiempo de compilación.

8.2.4         Tipos de clase
Una declaración de clase declara un nuevo tipo con nombre (sección 3.7 ) llamado tipo de clase. Dentro de las funciones
de constructor y miembro de instancia de una clase, el tipo de este es el this-type (sección 3.6.3 ) de ese tipo de
clase . El tipo de clase tiene los siguientes miembros:

 Una propiedad para cada declaración de variable de miembro de instancia en el cuerpo de la clase.

 Una propiedad de un tipo de función para cada declaración de función miembro de instancia en el cuerpo de la
clase.
 Una propiedad para cada declaración de accesor de miembro de instancia con nombre exclusivo en el cuerpo de
la clase.
 Una propiedad para cada parámetro de constructor declarado
con un modificador público , privado o protegido .
 Una firma de índice para cada declaración de miembro de índice de instancia en el cuerpo de la clase.
 Todos los miembros de propiedad o índice de instancia de clase básica que no se anulan en la clase.

Todos los miembros de propiedad de instancia (incluidos los que son privados o protegidos ) de una clase deben
satisfacer las restricciones implícitas por los miembros de índice de la clase como se especifica en la sección 3.9.4 .

En el ejemplo

clase A { public x: number ; public f () {} public g
(a: any ) { return undefined; } estático s: cadena ; }
    
    
    
    

la clase B extiende A { public y: number ; public g (b: boolean ) { return false; } }
    
    

el tipo de clase de ' A ' es equivalente a

interfaz A { 
    x: número ; 
    f: () => vacío ; 
    g: (a: cualquiera ) => cualquiera ; 
}

y el tipo de clase de ' B ' es equivalente a

interfaz B { 
    x: número ; 
    y: número ; 
    f: () => vacío ; 
    g: (b: boolean ) => boolean ; 
}

Tenga en cuenta que las declaraciones estáticas en una clase no contribuyen al tipo de clase; más bien, las declaraciones
estáticas introducen propiedades en el objeto de función del constructor. También tenga en cuenta que la declaración
de ' g ' en ' B ' anula el miembro heredado de ' A ' .
8.2.5         Tipos de funciones de constructor
El tipo de la función constructora introducida por una declaración de clase se denomina tipo de función constructora. El
tipo de función constructor tiene los siguientes miembros:

 Si la clase no contiene ninguna declaración de constructor y no tiene una clase base, una firma de construcción
única sin parámetros, que tiene los mismos parámetros de tipo que la clase (si existe) y que devuelve una
instanciación del tipo de clase con esos parámetros de tipo pasados como argumentos de tipo.
 Si la clase no contiene ninguna declaración de constructor y tiene una clase base , un conjunto de firmas de
construcción con los mismos parámetros que los del tipo de función del constructor de la clase base después de la
sustitución de los parámetros de tipo con los argumentos de tipo especificados en la referencia de tipo de clase de
base , todos tener los mismos parámetros de tipo que la clase (si existe) y devolver una instancia del tipo de clase
con esos parámetros de tipo pasados como argumentos de tipo .
 Si la clase contiene una declaración de constructor sin sobrecargas, una firma de construcción con la lista de
parámetros de la implementación del constructor , que tiene los mismos parámetros de tipo que la clase (si existe) y
devuelve una instanciación del tipo de clase con esos parámetros de tipo pasados como tipo argumentos .
 Si la clase contiene una declaración de constructor con sobrecargas, un conjunto de firmas de
construcciones con las listas de parámetros de las sobrecargas , todas con los mismos parámetros de tipo que la
clase (si existe) y devolviendo una instanciación del tipo de clase con esos parámetros de tipo pasados como Escribe
argumentos .
 Una propiedad para cada declaración de variable miembro estática en el cuerpo de la clase.
 Una propiedad de un tipo de función para cada declaración de función miembro estática en el cuerpo de la clase.
 Una propiedad para cada declaración de acceso de miembro estático con un nombre único en el cuerpo de la
clase.
 Una propiedad llamada ' prototipo ' , cuyo tipo es una instanciación del tipo de clase con el tipo Any suministrado
como argumento de tipo para cada parámetro de tipo.
 Todas las propiedades del tipo de función del constructor de la clase base que no se anulan en la clase.

Cada clase contiene automáticamente un miembro de propiedad estático llamado ' prototipo ' , cuyo tipo es la clase que
contiene con el tipo Any sustituido por cada parámetro de tipo.

El ejemplo

clase Par <T1, T2> { constructor ( public item1: T1, public item2: T2) {} }

    

class TwoArrays <T> extiende Par <T [], T []> {}

introduce dos tipos con nombre correspondientes a

Par de interfaz <T1, T2> { 

    item1: T1; 
    elemento2: T2; 
}
interfaz TwoArrays <T> { 
    item1: T []; 
    elemento2: T []; 
}

y dos funciones constructoras correspondientes a

var Par: { nuevo <T1, T2> (elemento1: T1, elemento2: T2): Par <T1, T2>; }
    

var TwoArrays: { new <T> (item1: T [], item2: T []): TwoArrays <T>; }

    
Tenga en cuenta que cada firma constructo en los tipos de función constructor tiene los mismos parámetros de tipo
como su clase y volver s una instancia de su clase con esos parámetros de tipo pasadas como argumentos de tipo . Tenga
en cuenta también que cuando una clase derivada doesn ' declarar t un constructor, forma de argumentos a partir de la
referencia de clase base están sustituidos antes de construir firmas se propagan desde el tipo de función constructor base
para el tipo de función constructor derivada.

8.3         Declaraciones de constructor
Una declaración de constructor declara la función de constructor de una clase.

ConstructorDeclaration: 
AccessibilityModifier  constructor ( ParameterList  ) { FunctionBody  } AccessibilityModifier  constructor ( 
opt  opt  opt 

ParameterList  ) ;                     
opt 

              

Declaraciones del constructor que especifican un cuerpo se llaman constructor  implementaciones  y declaraciones del
constructor sin un cuerpo que se llama constructor  sobrecargas  . Es posible especificar múltiples sobrecargas de
constructor en una clase, pero una clase puede tener como máximo una implementación de constructor. Todas
las declaraciones de constructor en una clase deben especificar el mismo conjunto de modificadores. Solo los
constructores públicos son compatibles y los constructores privados o protegidos producen un error.

En una clase sin declaración de constructor, se proporciona un constructor automático, como se describe en la
sección 8.3.3 .

Cuando una clase tiene sobrecargas de constructor, las sobrecargas determinan las firmas de construcción del tipo dado
al objeto de función de constructor, y la firma de implementación del constructor (si la hay) debe ser asignable a ese
tipo. De lo contrario, la propia implementación del constructor determina la firma de la construcción. Esto es exactamente
paralelo a la forma en que se procesan las sobrecargas en una declaración de función (sección 6.2 ).

Cuando una clase tiene sobrecargas de constructor y una implementación de constructor , las sobrecargas deben

preceder a la implementación y todas las declaraciones deben ser consecutivas sin elementos gramaticales intermedios.

El cuerpo de la función de un constructor puede contener declaraciones de retorno. Si las declaraciones de

retorno especifican expresiones, esas expresiones deben ser de tipos que son asignables a la de este tipo
(sección 3.6.3 ) de la clase .

Los parámetros de tipo de una clase genérica están dentro del alcance y son accesibles en una declaración de constructor.

8.3.1         Parámetros de constructor
Similar a las funciones, solo la implementación del constructor (y no las sobrecargas del constructor) puede
especificar expresiones de valor por defecto para parámetros opcionales. Es un error en tiempo de compilación que tales
expresiones de valor predeterminado hagan referencia a esto . Cuando el objetivo de salida es ECMAScript 3 o 5,
para cada parámetro con un valor predeterminado , se incluye una declaración que sustituye el valor predeterminado por
un argumento omitido en el JavaScript generado para la función de constructor.

Un parámetro de una ConstructorImplementation  puede tener como prefijo

un modificador público , privado o protegido . Esto se denomina declaración de propiedad de parámetro  y es una
forma abreviada de declarar una propiedad con el mismo nombre que el parámetro e inicializarla con el valor del
parámetro. Por ejemplo, la declaración

Clase Point { constructor ( public x: number , public y : number ) { // Constructor body     } }

    
        
es equivalente a escribir

Punto de clase { public x: number ; público y: número ; constructor (x: número , y: número ) { this .x

= x; esto .y = y; // Cuerpo del constructor     } }
    
    
    
        
        
        

Una declaración de propiedad de parámetro puede declarar una opción al parámetro (al incluir un signo de
interrogación o un valor predeterminado), pero la propiedad introducida por una declaración siempre se considera una
propiedad requerida (sección 3.3.6 ).

8.3.2         Super llamadas
S uper llamadas (sección 4.9.1 ) se utilizan para llamar al constructor de la clase base. Una súper llamada consiste en la
palabra clave súper seguida de una lista de argumentos encerrada entre paréntesis. Por ejemplo:

clase ColoredPoint extiende Point { constructor (x: número , y: número , color público : cadena )
{ super (x, y);     } }
    
        

Constructores de clases sin extiende cláusula no puede contener llamadas súper, mientras que c onstructors de

deriva d clase es debe contener al menos una llamada súper alguna parte de su cuerpo de la función. No se permiten
súper llamadas fuera de los constructores o en funciones locales dentro de los constructores.

La primera declaración en el cuerpo de un constructor debe  ser una súper llamada si se cumple lo siguiente:

 La clase que contiene es una clase derivada.

 El constructor declara las propiedades del parámetro o la clase que contiene declara las variables miembro de
la instancia con inicializadores.

En una súper llamada requerida, es un error en tiempo de compilación que las expresiones de argumento hagan
referencia a esto .

La inicialización de las propiedades de los parámetros y las variables miembro de la instancia con inicializadores se realiza

inmediatamente al comienzo del cuerpo del constructor si la clase no tiene una clase base , o inmediatamente después de
la súper llamada si la clase es una clase derivada .

8.3.3         Constructores automáticos
Si una clase omite una declaración de constructor, se proporciona un constructor automático  .

En una clase sin cláusula de extensión , el constructor automático no tiene parámetros y no realiza otra acción que

ejecutar los inicializadores de variables miembro de la instancia (sección 8.4.1 ) , si corresponde.

En una clase derivada , el constructor automático tiene la misma lista de parámetros (y posiblemente sobrecargas) que el

constructor de la clase base. El constructor provisto automáticamente primero reenvía la llamada al constructor de la clase
base usando una llamada equivalente a
BaseClass.apply ( esto , argumentos);

y luego ejecuta los inicializadores de variable de miembro de instancia , si los hay.

8.4         Declaraciones de miembros de propiedad

Propiedad m brasa declaración s puede ser miembro de declaración de variable s , miembro de declaración de la
función s , o miembro de acceso declaración s .

Property  MemberDeclaration: 
MemberVariableDeclaration 
MemberFunctionDeclar  ation 
MemberAccessorDeclaration

M declaraciones ascua sin estática modifi er se llaman declaraciones de miembros instancia. Las declaraciones de

miembro de propiedad de instancia declaran propiedades en el tipo de clase (sección 8.2.4 ) , y deben especificar nombres
que sean únicos entre todas las declaraciones de miembro de propiedad de instancia y propiedad de parámetro en la
clase que lo contiene, con la excepción de que las declaraciones de acceso y establecimiento de instancia pueden
emparejarse especifique el mismo nombre

Declaraciones de miembros con una estática modifi er se denominan declaraciones de miembros

estáticos. Las declaraciones de miembros de propiedades estáticas declaran propiedades en el tipo de función de
constructor (sección 8.2.5 ) y deben especificar nombres que sean únicos entre todas las declaraciones de miembros
de propiedades estáticas en la clase que contiene, con la excepción de que las declaraciones de acceso estático get y set
pueden especificar por pares mismo nombre.

Tenga en cuenta que los espacios de declaración de instancia y los miembros de propiedad estática están separados. Por
lo tanto, es posible tener miembros de instancias y propiedades estáticas con el mismo nombre.

A excepción de las anulaciones , como se describe en la sección 8.2.3 , es un error que una clase derivada declare
un miembro de propiedad con el mismo nombre y tipo (instancia o estática) que un miembro de clase base.

Cada clase contiene automáticamente un miembro de propiedad estático llamado ' prototipo ' , cuyo tipo es una

instanciación del tipo de clase con el tipo Any proporcionado como argumento de tipo para cada parámetro de tipo . Es
un error declarar explícitamente un miembro de propiedad estática con el nombre ' prototipo ' .

A continuación se muestra un ejemplo de una clase que contiene declaraciones de miembros de propiedad estática y de

instancia :

clase Punto { constructor ( público x: número , público y: número ) {} distancia     pública (p: Punto)

{ var dx = this .x - px; var dy = this .y - py; return Math .sqrt (dx * dx + dy * dy);    
} origen estático = nuevo punto ( 0 , 0 ); distancia estática (p1: Point, p2: Point)
{ return p1.distance (p2); } }
    

        
        
        

    
    

El tipo de clase ' Punto ' tiene los miembros:

Punto de interfaz { 
    x: número ; 
    y: número ; 
    distancia (p: punto); 
}

y la función constructora ' Punto ' tiene un tipo correspondiente a la declaración :

Punto var : { nuevo (x: número , y: número ): Punto;     punto de origen;     distancia (p1: Punto, p2:

Punto): número ; }
    

8.4.1         Declaraciones de variables de miembros

Una declaración de variable miembro declara una variable miembro n instancia o una variable miembro estática .

MemberVariableDeclaration: 
AccessibilityModifier  estática  PropertyName  TypeAnnotation  inicializador  ;              
optar  opt  opt  opt 

El tipo asociado con una declaración de variable miembro se determina de la misma manera que una declaración de
variable ordinaria (ver sección 5.2 ).

Una declaración de variable de miembro de instancia introduce un miembro en el tipo de clase y opcionalmente inicializa

una propiedad en instancias de la clase. Los inicializadores en las declaraciones de variables miembro de la instancia se
ejecutan una vez para cada nueva instancia de la clase y son equivalentes a las asignaciones a las propiedades de esta en
el constructor. En una expresión inicializadora para una variable miembro de instancia, esta es del tipo this
(sección 3.6.3 ) de la clase.

Una declaración de variable miembro estática introduce una propiedad en el tipo de función de constructor y
opcionalmente inicializa una propiedad en el objeto de función de constructor. Los inicializadores en las declaraciones de
variables miembro estáticas se ejecutan una vez cuando se carga el script o módulo que lo contiene .

Las expresiones de inicialización para las variables miembro de instancia se evalúan en el ámbito del cuerpo del
constructor de la clase, pero no se les permite hacer referencia a parámetros o variables locales del constructor. Esta
eficacia significa que las entidades del ámbito externo s con el mismo nombre que un parámetro constructor o una
variable local son inaccesibles en las expresiones de inicializador, por ejemplo, las variables miembro.

Como los inicializadores de variables miembro de instancia son equivalentes a las asignaciones a propiedades

de esto en el constructor, el ejemplo

clase Empleado { nombre público : cadena ; dirección pública : cadena ; público retirado
= falso ; gerente público : Empleado = nulo ; informes públicos : Empleado [] = []; }
    
    
    
    
    

es equivalente a

clase Empleado { nombre público : cadena ; dirección pública : cadena ; público retirado : booleano ; g
erente público : empleado; informes públicos : Empleado []; constructor () { this .retired
= false ; this .manager = null ; this .reports = [];     } }
    
    
    
    
    
    
        
        
        

8.4.2         Declaraciones de funciones del miembro

Una declaración de función miembro declara una función miembro de instancia o una función miembro estática.

MemberFunctionDeclaration: 
AccessibilityModifier  estática  PropertyName  CallSignature  { FunctionBody  } AccessibilityModifier 
optar  opt  optar  estátic
a  PropertyName  CallSignature  ;                  
opt 

           

Una declaración de la función miembro se procesa de la misma manera como una declaración de la función ordinaria
(sección 6 ), excepto que en una función miembro esta tiene un tipo conocido .

Todas las declaraciones para la misma función miembro deben especificar la misma accesibilidad (pública, privada o

protegida ) y tipo (instancia o estática).

Una declaración de función de miembro de instancia declara una propiedad en el tipo de clase y asigna un objeto de
función a una propiedad en el objeto prototipo de la clase. En el cuerpo de una declaración de función de miembro de
instancia , esta es del tipo de este (sección 3.6.3 ) de la clase .

Una declaración de función miembro estática declara una propiedad en el tipo de función de constructor y asigna un
objeto de función a una propiedad en el objeto de función de constructor. En el cuerpo de una declaración de función
miembro estática, el tipo de esta es el tipo de función constructor .

Una función miembro puede acceder a los miembros de cl as de la base anulados utilizando un acceso de súper
propiedad (sección 4.9.2 ) . Por ejemplo

class Point { constructor ( public x: número , public y: número ) {} public toString () { return " x

= " + this .x + " y = " + this .y;     } }
    
    
        

clase ColoredPoint extiende Point { constructor (x: número , y: número , color público : cadena )
{ super (x, y);     } public toString () { return super .toString () + " color = " + this .color;    
} }
    
        

    
        

En una función miembro estática, esto representa el objeto de función constructor en el que se invocó la función
miembro estático . Por lo tanto, una llamada a ' new this () ' en realidad puede invocar un constructor de clase derivado:
clase A { 
    a = 1 ; static create () { return new this ();     } }
    
        

la clase B se extiende A { 
    b = 2 ; 
}
var x = A.create ();  // nuevo A () 
var y = B.create ();  // nuevo B ()

Tenga en cuenta que mecanografiado doesn ' t requieren o verificar que las funciones del constructor derivados son
subtipos de funciones constructoras base. En otras palabras, cambiar la declaración de ' B ' a

la clase B extiende A { constructor ( público b: número ) { super (); } }

    
        
    

no provoca errores en el ejemplo, aunque la llamada al constructor de la ' crear ' la función doesn ' t especifica un
argumento (dando así el valor ' indefinido ' a ' B ' ).

8.4.3 Declaraciones de acceso de miembros        

Una declaración de acceso de miembro declara un acceso de miembro de instancia o un acceso de miembro estático.

MemberAccessorDeclaration: 
AccessibilityModifier  estática  GetAccessor  AccessibilityModifier 
optar  opt  optar  estática opt  SetAccessor      
     

Los accesos get y set se procesan de la misma manera que en un objeto literal (sección 4.5 ), excepto que un tipo
contextual nunca está disponible en una declaración de acceso miembro.

Los accesores para el mismo nombre de miembro deben especificar la misma accesibilidad .

Una declaración de accesor de miembro de instancia declara una propiedad en el tipo de clase y define una propiedad en
el objeto prototipo de la clase con un descriptor de acceso get o set. En el cuerpo de una declaración de acceso de
miembro de instancia, esto es del tipo de este (sección 3.6.3 ) de la clase .

Una declaración de acceso miembro estático declara una propiedad en el tipo de función de constructor y define una
propiedad en el objeto de función de constructor de la clase con un acceso get o set. En el cuerpo de una declaración de
acceso de miembro estático , el tipo de este es el tipo de función de constructor .

Los accesos get y set se emiten como llamadas a ' Object.defineProperty ' en el JavaScript generado , como se describe en
la sección 8.7.1 .

8.4.4 Declaraciones de propiedad dinámica        
Si el PropertyName  de una declaración de miembro de propiedad es un nombre de propiedad calculado que no denota
un símbolo conocido ( 2.2.3 ), la construcción se considera una declaración de  propiedad dinámica  . Las siguientes
reglas se aplican a las declaraciones de propiedades dinámicas:

 Una declaración de propiedad dinámica no introduce una propiedad en el tipo de clase o tipo de función de
constructor.
 La expresión del nombre de propiedad de una asignación de propiedad dinámica debe ser del tipo Cualquiera o
del tipo primitivo Cadena, Número o Símbolo.
  El nombre asociado con una declaración de propiedad dinámica se considera un nombre de propiedad numérico
si la expresión del nombre de la propiedad es de tipo Any o del tipo primitivo Number.

8.5         Índice de declaraciones de miembros

Una declaración de miembro de índice introduce una firma de índice (sección 3.9.4 ) en el tipo de clase.

IndexMemberDeclaration: 
IndexSignature  ;  

Las declaraciones de índice de miembros no tienen cuerpo y no pueden especificar un modificador de accesibilidad.

Una declaración de clase puede tener como máximo una declaración de miembro de índice de cadena y una declaración
de miembro de índice numérico. Todos los miembros de propiedad de instancia de una clase deben satisfacer las
restricciones implícitas por los miembros de índice de la clase como se especifica en la sección 3.9.4 .

No es posible declarar miembros de índice para el lado estático de una clase.

Tenga en cuenta que rara vez tiene sentido incluir una firma de índice de cadena en una clase porque restringe todas
las propiedades de instancia de la clase. Sin embargo, las firmas de índice numérico pueden ser útiles para controlar el
tipo de elemento cuando una clase se usa de forma ordenada .

8.6 Decoradores        
TODO:  decoradores de  documentos  .

8.7 Generación de código        
Cuando el objetivo de salida es ECMAScrip t 2015 o superior, los parámetros de tipo, implementa cláusulas, modificadores
de accesibilidad y declaraciones de variables miembro se eliminan en el código emitido, pero de lo contrario las
declaraciones de clase se emiten tal como están escritas. Cuando el objetivo de salida es ECMAScript 3 o 5, se realizan
reescrituras más completas, como se describe en esta sección.

8.7.1         Clase es sin cláusula extendida s
Una clase sin cláusula extiende genera JavaScript equivalente a lo siguiente:

var < ClassName > = ( function () { function < ClassName > ( < C onstructorParam eter s > )

{ <DefaultValueAssignments> < ParameterPropertyAssignments > < MemberVariableAssignments > < Constructo
rStatements >     } <MemberFunctionStatements> < Static VariableAssignments > return < ClassName > ; })
(); 
    
        
        
        
        

    
    
    

ClassName  es el nombre de la clase.

ConstructorParam  eter  s  es una lista separada por comas del constructor ' de parámetros na s mes .

DefaultValueAssignments  es una secuencia de asignaciones de valor de propiedad predeterminadas correspondientes a

las generadas para una declaración de función regular , como se describe en la sección 6.6 .
ParameterPropertyAssignments  es una secuencia de asignaciones, una para cada declaración de propiedad de
parámetro en el constructor , en el orden en que se declaran , de la forma

esta . < P aram eter Nombre > = < Param eter Nombre > ;

donde Param  eter  Nombre  es el nombre de una propiedad de parámetros.

MemberVariableAssignments  es una secuencia de tareas, una para cada instancia m brasa declaración de variables con un
inicializador, en el orden en que se declaran , de la forma

esta . < M brasa Nombre > = < InitializerExpression > ;

donde Nombre de  miembro  es el nombre de la variable miembro e InitializerExpression  es el código generado para la
expresión de inicializador.

ConstructorStatements  es el código generado para las declaraciones especificadas en el cuerpo del constructor.

Las  declaraciones de  funciones de  miembros  son una secuencia de declaraciones, una para cada declaración de función
de miembro o declaración de acceso de miembro , en el orden en que se declaran.

Una declaración de función miembro de n instancia genera una declaración del formulario

< ClassName > .prototype. < M emberName > = función ( < Func ción Param eter s > ) { 
    <DefaultValueAssignments> 
    < Func tionStatements> 
}

y la declaración de función miembro estática genera una declaración de la forma

<ClassName>. <MemberName> = function (<FunctionParameters>) { 

    <DefaultValueAssignments> 
    <FunctionStatements> 
}

donde MemberName  es el nombre de la miembro de la

función, y Func  ción  Param  eter  s  , DefaultValueAssignments  , y FunctionStatements  corresponden a los generados por
una función regular declarat ion, como se describe en la sección 6.6 .

Una declaración de acceso de miembro de instancia get o set , o un par de declaraciones de acceso de miembro

de instancia get y set con el mismo nombre, genera una declaración del formulario

Object.defineProperty ( < C lassName > .prototype, " < MemberName > " , { 
    get: function ( ) { 
        <GetAccessorStatements> },     set: function ( < ParameterName >) {        
< Set AccessorStatements>     } ,     enumerable: verdadero ,     configurable: verdadero };
    

y una declaración de acceso de miembro estático get o set, o un par de declaraciones de acceso de miembro estático get
o set con el mismo nombre, genera una declaración del formulario
Object.defineProperty (<ClassName>, " <MemberName> " , { 
    get: function () { 
        <GetAccessorStatements> 
    }, 
    set: function (<ParameterName>) { 
        <SetAccessorStatements> 
    }, 
    enumerable: true , 
    configurable: true 
};

donde MemberName  es el nombre del descriptor de acceso miembro, GetAccessorStatements  es el código generado

por las declaraciones en el get acessor ' cuerpo de la función s, ParameterName  es el nombre del parámetro de acceso
set, y SetAccessorStatements  es el código generado por las declaraciones en el acceso set ' cuerpo de la función
s. La propiedad ’get’ se incluye solo si se declara un descriptor de acceso get y la propiedad ' set ' se incluye solo si se
declara un descriptor de acceso.

StaticVariableAssignments  es una secuencia de declaraciones, una para cada declaración de variable de miembro estático
con un inicializador, en el orden en que se declaran, del formulario

<ClassName>. <MemberName> = <InitializerExpression>;

donde Member  Name  es el nombre de la variable estática, y InitializerExpression  es el código generado para la expresión
de inicializador.

8.7.2         Clase es con cláusula extendida s
Una clase con una cláusula amplia genera JavaScript equivalente a lo siguiente:

var <NombreClase> = ( función (_super) { 
    __extends (<classname>, _super); de función <NombreClase> (<ConstructorParameters>) {        
<DefaultValueAssignments>         <SuperCallStatement>         <ParameterPropertyAssignments>        
<MemberVariableAssignments>         <ConstructorStatements>     }     <MemberFunctionStatements>     <
StaticVariableAssignments> return <ClassName>; }) (<BaseClassName>);
    

    

Además, los ' __extends ' función a continuación se emite en el beginnin g del archivo fuente JavaScript. Copia todas las
propiedades del objeto de función de constructor base al objeto de función de constructor derivado (para heredar
miembros estáticos ), y establece apropiadamente la propiedad ' prototipo ' del objeto de función de constructor
derivado.

var __extends = this .__ extiende || función (d, b ) { para ( var p en b ) if (b.hasOwnProperty (p)) d

[p] = b [p ];     función f () { this .constructor = d ; } f .prototype = b.prototype;     d .prototype
= new f (); }
    

    
BaseClassName  es el nombre de clase especificado en la cláusula extend .

Si la clase no tiene un constructor declarado explícitamente , SuperCallStatement  toma la forma

_super.apply ( esto , argumentos);

De lo contrario , SuperCallStatement  está presente si se requiere que la función constructora comience con una súper
llamada, como se discutió en la sección 8.3.2 , y toma la forma

_super.call ( esto , <SuperCallArguments>)

donde SuperCallArguments  es la lista de argumentos especificada en la súper llamada. Tenga en cuenta que esta llamada

precede al código generado para el parámetro Propert IES y miembros de las variables con inicializadores . S uper
llamadas en otras partes del constructor generan un código similar, pero el código generado para tales llamadas
será parte de la sección ConstructorStatements  .

Un acceso de súper propiedad en el constructor, una función de miembro de instancia n o un descriptor de acceso de
miembro de instancia n genera JavaScript equivalente a

_súper. prototipo. < Nombre de propiedad >

donde la propiedad  Nombre  es el nombre de la base de referencia de clase propert y . Cuando el acceso a la

súper propiedad aparece en una llamada de función , el JavaScript generado es equivalente a

_super.prototype. < Nombre de propiedad > .call ( esto , <Argumentos>)

donde Argumentos es el código generado para la lista de argumentos especificada en la llamada a la función .

Un acceso de súper propiedad en una función miembro estática o un miembro miembro estático genera JavaScript
equivalente a

_super. <NombreDePropiedad>

donde Nombre de  propiedad  es el nombre de la propiedad de clase base referenciada . Cuando el acceso a la súper

propiedad aparece en una llamada de función, el JavaScript generado es equivalente a

_super. <PropertyName> .call ( esto , <Argumentos>)

donde Argumentos es el código generado para la lista de argumentos especificada en la llamada a la función.

1
 
 
9 9 Enumeraciones
        

Un tipo de enumeración es un subtipo distinto del tipo primitivo Número con un conjunto asociado de constantes con
nombre que definen los posibles valores del tipo de enumeración.

9.1         Declaraciones Enum
Un e num d eclaración declara un enum  tipo  y un objeto enum  .

EnumDeclaration: 
const  enum BindingI  dentifier  { EnumBody  }              
opt  opt 

Una declaración  Enum  introduce un tipo con nombre (el tipo enum) y un valor con nombre (el objeto enum) en el espacio
de declaración que lo contiene. El tipo de enumeración es un subtipo distinto del tipo primitivo Número. El objeto
enum es un valor de un tipo de objeto anónimo que contiene un conjunto de propiedades, todo el tipo enum, que
corresponde a los valores declarados para el tipo enum en el cuerpo de la declaración . El objeto enum ' s tipo
furthe rmore incluye una firma índice numérico con la firma ' [x: número]: cadena ' .

El dentificador  BindingI  de una declaración enum puede no ser uno de los nombres de tipo predefinidos (sección 3.8.1 ).

Cuando una declaración enum incluye un modificador const , se dice que es una declaración enum

constante . Los miembros de una enumeración constante declaración deben tener todos los valores constantes que se
pueden calcular en tiempo de compilación. Las declaraciones de enumeración constante se analizan en la sección 9.4 .

El ejemplo

Color de enumeración {Rojo, Verde, Azul}

declara un subtipo del tipo primitivo Número llamado ' Color ' e introduce una variable ' Color ' con un tipo que
corresponde a la declaración

Color var : { 
    [x: número ]: cadena ; 
    Color rojo; 
    Color verde; 
    Color azul; 
};

La firma del índice numérico refleja una " asignación inversa " que se genera automáticamente en cada objeto de
enumeración, como se describe en la sección 9.5 . La asignación inversa proporciona una forma conveniente de obtener la
representación de cadena de un valor enum. Por ejemplo

var c = Color. Rojo; 

console.log (Color [c]);  // Salidas " rojas "

9.2 Miembros de Enum        
El cuerpo de una declaración enum define cero o más miembros enum que son los valores nombrados del tipo
enum. Cada miembro enum tiene un valor numérico asociado del tipo primitivo introducido por la declaración enum.

EnumBody: 
EnumMemberList  ,    opt
 EnumMemberList: 
EnumMember 
EnumMemberList  , EnumMember     

EnumMember: 
PropertyName 
PropertyName     =   EnumValue

EnumValue: 
AssignmentExpression

El PropertyName  de un miembro enum no puede ser un nombre de propiedad calculado ( 2.2.3 ).

Miembros de enumeración o son constantes  miembros  o computados  miembros  . Los miembros constantes tienen
valores constantes conocidos que se sustituyen en lugar de referencias a los miembros en el código JavaScript
generado . Los miembros calculados tienen valores que se calculan en tiempo de ejecución y no se conocen en tiempo de
compilación. No se realiza ninguna sustitución por referencias a miembros calculados.

Un miembro de enumeración se clasifica de la siguiente manera:

 Si la declaración del miembro no especifica ningún valor, el miembro se considera un miembro de enumeración

constante. Si el miembro es el primer miembro en la declaración de enumeración , se le asigna el valor cero. De lo
contrario, se le asigna el valor del miembro inmediatamente anterior más uno, y se produce un error n
si el miembro inmediatamente anterior no es un miembro de enumeración constante.
 Si la declaración de miembro especifica un valor que se puede clasificar como una expresión de enumeración
constante (como se define a continuación), el miembro se considera un miembro de enumeración constante.
 De lo contrario, el miembro se considera un miembro de enumeración calculado.

El valor de enumeración e xpresiones debe ser del tipo Cualquiera, el tipo primitivo Número o el tipo de enumeración en

sí.

Una expresión de enumeración constante  es un subconjunto de la gramática de la expresión que se puede evaluar

completamente en tiempo de compilación. Una expresión n se considera una expresión de enumeración constante si es
una de las siguientes:

 Un literal numérico.
 Un identificador o acceso a la propiedad que denota un miembro previamente declarado en la misma declaración
de enumeración constante.
 Una expresión enum constante entre paréntesis.
 Un operador unario +, - o ~ aplicado a una expresión de enumeración constante.
 A +, -, *, /,%, << , >>, >>>, &, ^ o | operador aplicado a dos expresiones enum constantes.

En el ejemplo

Prueba de enumeración {     A,     B,     C = Math.floor (Math.random () * 1000 ),     D = 10 ,    

E } 

' A ' , ' B ' , ' D ' y ' E ' son miembros constantes con valores 0, 1, 10 y 11 respectivamente, y ' C ' es un miembro calculado.

En el ejemplo
Estilo de enumeración { 
    Ninguno = 0 , Negrita = 1 ,     Cursiva = 2 ,     Subrayado = 4 , Énfasis = Negrita | Cursiva,    
hipervínculo = negrita | Subrayado } 
    

    

Todos los miembros son miembros constantes. Tenga en cuenta que las declaraciones de miembros

de enumeración pueden hacer referencia a otros miembros de enumeración sin calificación . Además, debido a que las
enumeraciones son subtipos del tipo primitivo Número, los operadores numéricos, como el operador OR a nivel de bits,
se pueden utilizar para calcular los valores de enumeración.

9.3         Declaración de fusión
Las enumeraciones son " abiertas " y las declaraciones de enumeración con el mismo nombre calificado relativo a una raíz
común (como se define en la sección 2.3 ) definen un único tipo de enumeración y contribuyen a un único objeto
enumerativo.

ISN ' t posible que una declaración de enumeración para continuar la secuencia de numeración automática de otro, y
cuando un tipo de enumeración tiene múltiples declaraciones, sólo se permite una declaración de omitir un valor para el
primer miembro.

Cuando se fusionan las declaraciones enum, todas deben especificar un modificador const o todas no especificar
ningún modificador const .

9.4         Declaraciones de enumeración constante

Una declaración enum que especifica un modificador const es una declaración  enum constante  . En una declaración
de enumeración constante , todos los miembros deben tener valores constantes y es un error que una declaración de
miembro especifique una expresión que no está clasificada como una expresión de enumeración constante.

A diferencia de las declaraciones de enumeración regulares, las declaraciones de enumeración constantes se borran por
completo en el código JavaScript emitido . Por esta razón, es un error hacer referencia a un objeto de enumeración
constante en cualquier otro contexto que no sea un acceso de propiedad que selecciona uno de los miembros de la
enumeración. Por ejemplo:

const enum Comparación {     LessThan = -1 ,     EqualTo = 0 ,     GreaterThan = 1 } 

var x = Comparación.EqualTo;  // Ok , reemplazado por 0 en el código emitido 

var y = Comparación [ Comparison.EqualTo ]; // Error var z = Comparación; // Error  
 

Toda la declaración const enum se borra en el código JavaScript emitido . Por lo tanto, las únicas referencias permitidas al
objeto enum son aquellas que se reemplazan con un valor de miembro enum.

9.5         Codigo de GENERACION
Una declaración enum genera JavaScript equivalente a lo siguiente:

var < Nombre de enumeración > ; 
( función ( <EnumName> ) { 
    <EnumMemberAssignments> 
}) ( <EnumName> || (<EnumName> = {}) ) ;

Enum  Name  es el nombre de la enumeración.

EnumMember  Assignments  es una secuencia de asignaciones, una para cada miembro de la enumeración, en el orden en
que se declaran, de la forma

<EnumName> [<EnumName> [ " <MemberName> " ] = < Value>] = " <MemberName> " ;

donde Nombre del  miembro  es el nombre del miembro enum y Valor  es el valor constante asignado o el código
generado para la expresión del valor calculado .

Por ejemplo, el ejemplo de enumeración ' Color ' de la sección 9.1 genera el siguiente JavaScript:

Color var ; 
( función (Color) { 
    Color [Color [ " Rojo " ] = 0 ] = " Rojo " ; 
    Color [Color [ " Verde " ] = 1 ] = " Verde " ; 
    Color [Color [ " Azul " ] = 2 ] = " Azul " ; 
}) (Color || (Color = {} ) );

1
 
 

10 Espacio de nombres m
  

Los espacios de nombres proporcionan un mecanismo para organizar el código y las declaraciones en jerarquías de
contenedores con nombre. Los espacios de nombres tienen miembros nombrados que cada uno denota un valor, un tipo
o un espacio de nombres, o alguna combinación de los mismos , y esos miembros pueden ser locales o exportados . El
cuerpo de un espacio de nombres corresponde a una función que se ejecuta una vez, proporcionando así un mecanismo
para mantener el estado local con un aislamiento asegurado. Los espacios de nombres pueden considerarse como una
formalización del patrón de expresión de función invocada inmediatamente (IIFE).

10,1    Declaraciones de espacio de nombres

Una declaración de espacio de nombres introduce un nombre con un significado de espacio de nombres y , en el caso de
un espacio de nombres instanciado , un significado de valor en el espacio de declaración que contiene .

NamespaceDeclaration  : 
namespace IdentifierPath  { NamespaceBody  }           

IdentifierPath: 
Binding  Identifier 
IdentifierPath  . BindingI  dentificador     

Los espacios de nombres se declaran usando la palabra clave de espacio de nombres , pero para la compatibilidad con
versiones anteriores de TypeScript , también se puede usar una palabra clave de módulo .
Los espacios de nombres son instanciados  o no instanciados  . Un espacio de nombres no instanciado es un espacio de
nombres que contiene solo tipos de interfaz , alias de tipo y otro espacio de nombres no instanciado . Un
instanciado espacio de nombres es un espacio de nombres que doesn ' t cumplir con esta definición . En términos
intuitivos, un n instanciada espacio de nombres es uno para el que un espacio de nombres de ejemplo se crea , mientras
que un no instanciado- espacio de nombres es uno para el que no se genera ningún código.

Cuando un espacio de nombres identificador se hace referencia como un NameSpaceName  (sección 3.8.2 ) denota un

recipiente de espacio de nombres nombres y tipo , y cuando un espacio de nombres identificador se hace referencia
como un PrimaryExpression  (sección 4.3 ) que indica la singleton espacio de nombres ejemplo . Por ejemplo:

espacio de nombres M { interfaz de exportación P {x: número ; y: número ; } exportar var a = 1 ; }

    
    

var p: MP;             // M u sed como NameSpaceName 

var m = M;              // M u sed como PrimaryExpression 
var x1 = Ma;           // M u sed como PrimaryExpression 
var x2 = ma;           // Igual que Ma 
var q: mP;             // Error

Por encima , cuando ' M ' se utiliza como una PrimaryExpression  denota una instancia de objeto con un único miembro
de ' un ' y cuando ' M ' se utiliza como una NameSpaceName  denota un recipiente con un único miembro de tipo ' P ' . La
línea final en el ejemplo es un error porque ' m ' es una variable a la que no se puede hacer referencia en un nombre de
tipo.

Si la declaración de ' M ' anterior hubiera excluido la variable exportada ' a ' , ' M ' sería un espacio de nombres no

instanciado y sería un error hacer referencia a ' M ' como expresión primaria  .

Una declaración de espacio de nombres que especifica un IdentifierPath  con más de un identificador es equivalente a una
serie de declaraciones de espacio de nombres de identificador único necesarias donde todos menos el más externo se
exportan automáticamente. Por ejemplo:

espacio de nombres ABC { export var x = 1 ; }

    

corresponde a

espacio de nombres A { espacio de nombres de exportación B { espacio de nombres de exportación C

{ export var x = 1 ;         }     } }
    
        
            

La jerarquía formada por el espacio de nombres y los nombres de tipo con nombre refleja parcialmente la formada por
instancias y miembros de espacio de nombres. El ejemplo

espacio de nombres A { espacio de nombres de exportación B { clase de exportación C {}     } }

    
        
introduce un tipo con nombre con el nombre calificado 'ABC' y también introduce una función de constructor a la que se
puede acceder utilizando la expresión 'ABC'. Así, en el ejemplo

var c: ABC = nuevo ABC ();

las dos ocurrencias de 'ABC' de hecho se refieren a diferentes entidades. Es el contexto de las ocurrencias lo que
determina si 'ABC' se procesa como un nombre de tipo o una expresión.

10.2 Cuerpo del espacio de nombres   

El cuerpo de un espacio de nombres corresponde a una función que se ejecuta una vez para inicializar la instancia
del espacio de nombres .

NamespaceBody  : 
NamespaceElement  s  opt

NamespaceElement  s: 
NamespaceElement 
NamespaceElement  s  NamespaceElement  

NamespaceElement  : 
Declaración 
LexicalDeclaration 
FunctionDeclaration 
GeneratorDeclaration 
ClassDeclaration 
InterfaceDeclaration 
TypeAliasDeclaration 
EnumDeclaration 
NamespaceDeclaration 
AmbientDeclaration 
Import  Alias  Declaración 
Exportar  NamespaceElement

Exportar  NamespaceElement  : 
export VariableStatement  export LexicalDeclaration  export FunctionDeclaration  export GeneratorDeclaration  ex
port ClassDeclaration  export InterfaceDeclaration  export TypeAliasDeclaration  export EnumDeclaration  export 
NamespaceDeclaration  export AmbientDeclaration  export ImportA  lias  Declaración   
   
   
   
   
   
   
   
   
   
  

10,3    Declaraciones de alias de importación

Las declaraciones de alias de importación se utilizan para crear alias locales para entidades en otros espacios de nombres .

Importación  Alias  Declaración  : 

importación BindingI  dentifier  = EntityName  ;           
 EntityName: 
NamespaceName 
NamespaceName  . Referencia del  identificador     

Un EntityName que  consiste en un único identificador se resuelve como un Nombre  de espacio de nombres  y, por lo tanto,
se requiere que haga referencia a un espacio de nombres . El alias local resultante hace referencia al espacio de nombres
dado y se clasifica como un espacio de nombres .

Un EntityName que  consta de más de un identificador se resuelve como un Nombre  de espacio de nombres  seguido de un
identificador que nombra una entidad exportada en el espacio de nombres dado . El alias local resultante tiene todos los
significados de la entidad referenciada . (Hasta tres significados distintos son posibles para un nombre de entidad: valor ,
tipo y espacio de nombres ). En efecto, es como si la entidad importada se declarara localmente con el nombre de alias
local.

En el ejemplo

espacio de nombres A { interfaz de exportación X {s: cadena } exportar var X: X; }

    
    

espacio de nombres B { interfaz A {n: número } importar Y = A;    // Alias para

el espacio de nombres A import Z = AX; // Alias para tipo y valor AX var v: Z = Z ; }
    
    
      
    

dentro de ' B ' , ' Y ' es un alias solo para el espacio de nombres ' A ' y no la interfaz local ' A ' , mientras que ' Z ' es un

alias para todos los significados exportados de ' AX ' , lo que denota tanto un tipo de interfaz como Una variable .

Si la parte de NamespaceName  de un EntityName hace  referencia a un espacio de nombres instanciado , se requiere

que NamespaceName  haga referencia a la instancia de espacio de nombres cuando se evalúa como una expresión. En
el ejemplo

espacio de nombres A { interfaz de exportación X {s: cadena } }

    

espacio de nombres B { var A = 1; importar Y = A; }

    
    

' Y ' es un alias local para el espacio de nombres no instanciado ' A ' . Si la declaración de ' A ' se cambia de manera
que ' A ' se convierte en un espacio de nombres instanciado , por ejemplo, al incluir una declaración de variable en ' A ' , la
declaración de importación en ' B ' anterior sería un error porque la expresión ' A ' no ' t hacen referencia al espacio de
nombres ejemplo de espacio de nombres ' A ' .

Cuando una declaración de importación incluye un modificador de exportación , se exportan todos los significados del
alias local.

10,4    Declaraciones de exportación
Una declaración de exportación declara un miembro de espacio de nombres accesible externamente . Una declaración de
exportación es simplemente una declaración regular prefijada con la palabra clave exportar .

Los miembros del espacio de declaración de exportación de un espacio de nombres (sección 2.3 ) constituyen el conjunto
de miembros de exportación  del espacio de nombres . El tipo de instancia de  un espacio de nombres es un tipo de
objeto con una propiedad para cada miembro en el conjunto de miembros de exportación del espacio de nombres que
denota un valor.

Un miembro exportado depende de un conjunto (posiblemente vacío) de tipos con nombre (sección 3.7 ). Esos tipos
nombrados deben ser al menos tan accesibles como el miembro exportado , o de lo contrario se produce un error.

Los tipos nombrados de los que depende un miembro son los tipos nombrados que ocurren en el cierre transitivo de la
relación directamente depende  de la  definida de la siguiente manera:

 Una variable depende directamente del tipo  especificado en su anotación de tipo.

 Una función depende directamente de cada tipo  especificado en un parámetro o anotación de tipo de retorno.
 Una clase depende directamente de cada tipo  especificado como un parámetro de restricción tipo,
cada typereference  especificado como una clase base o interfaz implementada, y cada tipo  especificado en
una anotación constructor tipo de parámetro, público mem ber anotación tipo de variable, público miembro
de parámetro de función o tipo de retorno anotación, parámetro de acceso de miembro público o anotación de tipo
de retorno, o anotación de tipo de firma de índice.
 Una interfaz depende directamente de cada tipo  especificado como una restricción de tipo de
parámetro, cada typereference  especificado como una interfaz de base , y la ObjectType  especificado
como su cuerpo.
 Un espacio de nombres depende directamente de sus miembros exportados.
 Un Type  o ObjectType  depende directamente de cada TypeReference  que ocurre dentro del tipo en cualquier nivel
de anidamiento.
 Un typereference  depende directamente del tipo al que hace referencia y en cada tipo  especificado como un
argumento de tipo.

Se dice que un tipo T  con nombre que tiene un espacio de nombres raíz R  (sección 2.3 ) es al menos tan accesible
como  un miembro M  si

 R  es el espacio de nombres global o un módulo, o

 R  es un espacio de nombres en la matriz de espacio de nombres de cadena de M  .

En el ejemplo

interfaz A {x: cadena ; }
espacio de nombres M { interfaz de exportación B {x: A; } interfaz de exportación C {x: B; } función
de exportación foo (c: C) {…} }
    
    
    

la función ' foo ' depende de los tipos nombrados ' A ' , ' B ' y ' C ' . Para exportar ' foo ' es necesario exportar

también ' B ' y ' C ', ya que de lo contrario no serían al menos tan accesibles como ' foo ' . La ' A ' interfaz ya es al menos
tan accesible como ' foo ' , ya que t es declarada mediante una matriz de espacio de nombres de foo ' s espacio de
nombres .

10,5    Declaración de fusión
Los espacios de nombres son " abiertos " y las declaraciones de espacios de nombres con el mismo nombre calificado
relativo a una raíz común (como se define en la sección 2.3 ) contribuyen a un único espacio de nombres . Por ejemplo, las
siguientes dos declaraciones de un espacio de nombres ' externo ' podrían ubicarse en archivos de origen separados.

Archivo a.ts:

espacio de nombres externo { var local = 1 ;           // Variable local no exportada export var a =

local;    // external.a export namespace inner { export var x = 10 ;   // external.inner.x     } }
    
    
    
        

Archivo b.ts:

espacio de nombres externo { var local = 2 ;           // Variable local no exportada export var b =

local;    // external.b export namespace inner { export var y = 20 ;   // external.inner.y     } }
    
    
    
        

Suponiendo que los dos archivos fuente son parte del mismo programa, las dos declaraciones tendrán el espacio de
nombres global como su raíz común y, por lo tanto, contribuirán a la misma instancia de espacio de nombres , cuyo tipo
de instancia será:

{ 
    a: número ; 
    b: número ; 
    interno: { 
        x: número ; 
        y: número ; 
    }; 
}

La fusión de declaraciones no se aplica a los alias locales creados por las declaraciones de alias de importación . En otras

palabras, no es posible tener una declaración de alias de importación y una declaración de espacio de nombres para el
mismo nombre dentro del mismo cuerpo de espacio de nombres .

TODO: aclarar las reglas para la  resolución de alias .

La fusión de declaraciones también se extiende a las declaraciones de espacio de nombres con el mismo nombre

calificado relativo a una raíz común como una función, clase o declaración de enumeración :

 Al fusionar una función y un espacio de nombres , el tipo del objeto de función se fusiona con el tipo de instancia
del espacio de nombres . En efecto, las sobrecargas o la implementación de la función proporcionan las firmas de
llamada y los miembros exportados del espacio de nombres proporcionan las propiedades del tipo combinado.
 Al fusionar una clase y un espacio de nombres , el tipo del objeto de función constructor se combina con el tipo
de instancia del espacio de nombres . En efecto, las sobrecargas o la implementación del constructor de la
clase proporcionan las firmas de construcción , y los miembros estáticos de la clase y los miembros exportados
del espacio de nombres proporcionan las propiedades del tipo combinado. Es un error tener miembros de clase
estáticos y miembros de espacio de nombres exportados con el mismo nombre.
 Al fusionar una enumeración y un espacio de nombres , el tipo del objeto de enumeración se fusiona con el tipo
de instancia del espacio de nombres . En efecto, los miembros de la enumeración y los miembros exportados
del espacio de nombres proporcionan las propiedades del tipo combinado. Es un error tener miembros de
enumeración y miembros de espacio de nombres exportados con el mismo nombre.

Al fusionar una función no ambiental o una declaración de clase y una declaración de espacio de nombres no ambiental ,
la declaración de función o clase debe ubicarse antes de la declaración de espacio de nombres en el mismo archivo
fuente. Esto garantiza que la instancia de objeto compartido se cree como un objeto de función. (Si bien es posible
agregar propiedades a un objeto después de su creación, no es posible hacer que un objeto sea " invocable " después del
hecho).

El ejemplo

Punto de interfaz { 
    x: número ; 
    y: número ; 
}
punto de función (x: número , y: número ) : Punto { return {x: x, y: y}; }
    

punto de espacio de nombres { export var origin = point (0, 0); la función de exportación es igual a

(p1: Point, p2: Point) {         return p1.x == p2.x && p1.y == p2.y;     } }
    
    

var p1 = punto (0, 0); 

var p2 = point.origin; 
var b = punto.equals (p1, p2);

declara ' punto ' como un objeto de función con dos propiedades, ' origen ' e ' igual ' . Tenga en cuenta que la declaración

de espacio de nombres para ' punto ' se encuentra después de la declaración de función.

10.6 Generación de código   
Un espacio de nombres genera código JavaScript que es equivalente al siguiente:

var < Nombre del espacio de nombres >; 

( función (< NamespaceName >) { 
    < NamespaceStatements > 
}) (< NamespaceName > || (< NamespaceName > = {}));

donde NamespaceName  es el nombre del espacio de nombres y NamespaceStatements  es el código generado para las

declaraciones en el cuerpo del espacio de nombres . El parámetro de la función NamespaceName  puede tener como
prefijo uno o más caracteres de subrayado para garantizar que el nombre sea único dentro del cuerpo de la
función. Tenga en cuenta que todo el espacio de nombres se emite como una función anónima que se ejecuta
inmediatamente. Esto asegura que las variables locales estén en su propio entorno léxico aislado del contexto
circundante. También tenga en cuenta que la función generada doesn ' t crear y devolver un espacio de nombres
de ejemplo, sino que se extiende a la instancia existente (que puede haber sido creado en la función ca ll). Esto garantiza
que los espacios de nombres se puedan extender entre sí.

Una declaración de importación genera el código del formulario

var <Alias> = <EntityName>;

Este código se emite solo si se hace referencia a la entidad importada como PrimaryExpression  en algún lugar del cuerpo
del espacio de nombres de importación . Si se hace referencia a una entidad importada solo
como TypeName  o NamespaceName  , no se emite nada. Esto garantiza que los tipos declarados en un espacio de
nombres puedan ser referenciados a través de un alias de impo rt en otro espacio de nombres sin sobrecarga de tiempo
de ejecución .

Cuando se exporta una variable, todas las referencias a la variable en el cuerpo del espacio de nombres se reemplazan con

< Nombre del espacio de nombres >. <Nombre variable>

Esto promueve efectivamente que la variable sea una propiedad en la instancia del espacio de nombres y asegura que
todas las referencias a la variable se conviertan en referencias a la propiedad.

Cuando se exporta una función, clase, enumeración o espacio de nombres , al código generado para la entidad le sigue
una declaración de asignación del formulario

< NamespaceName >. <EntityName> = <EntityName>;

Esto copia una referencia a la entidad en una propiedad en la instancia del espacio de nombres .

1
 
 

11 S cripts y módulos  

TypeScript implementa la compatibilidad con los módulos ECMAScript 2015 y admite la generación de código

de nivel inferior dirigida a CommonJS, AMD y otros sistemas de módulos.

11,1    Programas y archivos fuente

Un programa  TypeScript consta de uno o más archivos de origen .

SourceFile: 
ImplementationSourceFile 
DeclarationSourceFile

ImplementationSourceFile: 
ImplementationScript 
ImplementationModule

DeclarationSourceFile: 
DeclarationScript 
DeclarationModule

Los archivos fuente con la extensión '.ts' son archivos fuente de implementación que  contienen declaraciones y
declaraciones, y los archivos fuente con la extensión '.d.ts' son archivos fuente de declaración que  contienen
declaraciones .

Los archivos fuente de declaración son un subconjunto estricto de archivos fuente de implementación y se utilizan para
declarar la información de tipo estático asociada con el código JavaScript existente de manera adjunta. Son
completamente opcionales, pero permiten que el compilador TypeScript y las herramientas proporcionen una mejor
verificación y asistencia al integrar el código JavaScript existente y las bibliotecas en una aplicación TypeScript.

Cuando un texto mecanografiado se compila el programa, todos los del programa ' s archivos de origen se procesan
juntos . Las declaraciones y declaraciones en diferentes archivos fuente pueden depender unas de otras, posiblemente de
manera circular. De manera predeterminada, se genera un archivo de salida de JavaScript para cada archivo fuente de
implementación en una compilación, pero no se genera salida de los archivos fuente de declaración.

11.1.1 Dependencias de archivos fuente    

El mecanografiado compilador determina automáticamente un archivo de fuente ' dependencias s e incluye aquellas
dependencias en el ser programa compi l ed. La determinación se realiza a partir de los " comentarios de referencia " y
las declaraciones de importación del módulo de la siguiente manera :

 Un comentario de la forma /// <reference path = " … " /> que ocurre antes del primer token en un archivo
fuente agrega una dependencia en el archivo fuente especificado en el argumento de ruta. La ruta se resuelve en
relación con el directorio del archivo fuente que lo contiene .
 Una declaración de importación de módulo que especifica un nombre de
módulo relativo (sección 11.3.1 ) resuelve el nombre relativo al directorio del archivo
fuente que lo contiene . Si existe un archivo fuente con la ruta resultante y la extensión de archivo ' .ts ' , ese archivo
se agrega como una dependencia. De lo contrario, si existe un archivo fuente con la ruta resultante y la extensión de
archivo ' .d.ts ' , ese archivo se agrega como una dependencia.
 Una declaración de importación de módulo que especifica un nombre de módulo de nivel
superior (sección 11.3.1 ) resuelve el nombre de una manera dependiente del host ( generalmente resolviendo el
nombre relativo a una raíz de espacio de nombre de módulo o buscando el nombre en una serie de directorios) . Si
un archivo fuente con extensión ' ts ' o ' .d.ts ' correspondientes a la referencia se encuentra , ese archivo se añade
como una dependencia.

A su vez, los archivos incluidos como dependencias tienen sus referencias analizadas de manera transitiva hasta que se
hayan determinado todas las dependencias.

11.2 Guiones   
Los archivos de origen que no contienen declaraciones de importación o exportación de módulos se clasifican
como scripts  . Las secuencias de comandos forman el espacio de nombres  global  único y las entidades declaradas en
las secuencias de comandos tienen alcance en todas partes en un programa.

ImplementationScript: 
ImplementationScriptElements  opt

ImplementationScriptElements: 
ImplementationScriptElement 
ImplementationScriptElements  ImplementationScriptElement  

ImplementationScriptElement: 
ImplementationElement 
AmbientModuleDeclaration

ImplementationElement: 
Statement 
LexicalDeclaration 
FunctionDeclaration 
GeneratorDeclaration 
ClassDeclaration 
InterfaceDeclaration 
TypeAliasDeclaration 
EnumDeclaration 
Namespace  Declaración 
AmbientDeclaration 
ImportAlias  Declaración

DeclarationScript: 
DeclarationScriptElements  opt
 DeclarationScriptElements: 
DeclarationScriptElement 
DeclarationScriptElements  DeclarationScriptElement  

DeclarationScriptElement: 
DeclarationElement 
AmbientModuleDeclaration

DeclarationElement: 
InterfaceDeclaration 
TypeAliasDeclaration 
Namespace  Declaración 
AmbientDeclaration 
ImportAlias  Declaración

El orden de inicialización de los scripts que componen el espacio de nombres global depende en última instancia del
orden en que se cargan los archivos JavaScript generados en tiempo de ejecución (que, por ejemplo, pueden controlarse
mediante etiquetas <script /> que hacen referencia al JavaScript generado archivos).

11,3    Módulos
Los archivos de origen que contienen al menos una declaración de importación o exportación de módulo se
consideran módulos  separados . Las entidades no exportadas declaradas en un módulo solo están dentro del alcance de
ese módulo , pero las entidades exportadas pueden importarse a otros módulos mediante declaraciones de importación.

ImplementationModule: 
ImplementationModuleElements  opt

ImplementationModuleElements: 
ImplementationModuleElement 
ImplementationModuleElements  ImplementationModuleElement  

ImplementationModuleElement: 
ImplementationElement 
ImportDeclaration 
ImportAlias  Declaración 
ImportRequireDeclaration 
ExportImplementationElement 
ExportDefaultImplementationElement 
Export  List  Declaración 
Exportación  Asignación

DeclarationModule: 
DeclarationModuleElements  opt

DeclaraciónMóduloElementos: 
DeclaraciónMóduloElemento 
DeclaraciónMóduloElementos  DeclaraciónMóduloElemento  

DeclarationModuleElement: 
DeclaraciónElemento 
ImportaciónDeclaración 
ImportaciónAlias  Declaración 
ExportaciónDeclaraciónElemento 
Exportación  predeterminada  DeclaraciónElemento 
 Exportar  lista  Declaración 
Exportar  asignación

El orden de inicialización de los módulos está determinado por el cargador de módulos que se utiliza y no está
especificado por el lenguaje TypeScript. Sin embargo, por lo general, los módulos que no dependen circularmente se
cargan e inicializan automáticamente en el orden correcto.

Los módulos se pueden declarar adicionalmente utilizando AmbientModuleDeclaration  s  en scripts de declaración que

especifican directamente los nombres de los módulos como literales de cadena. Esto se describe más adelante en la
sección 12.2 .

A continuación, se muestra un ejemplo de dos módulos escritos en archivos fuente separados :

// -------- main.ts -------- 

import {message} from " ./ log " ; mensaje ( " hola " ); 

// -------- log.ts -------- mensaje de función de 

exportación (s: cadena ) {     console.log (s); } 

La declaración de importación en el ' principal ' del módulo hace referencia a la ' log ' del módulo y la compilación de

la ' main.ts ' archivo hace que los ' registro Ts ' archivo para también ser compilado como parte del programa.

TypeScript admite múltiples patrones de generación de código JavaScript para módulos:

 CommonJS . Este formato es utilizado por marcos de servidores como node.js.

 AMD ( definición de módulo asíncrono ) . Este formato lo utilizan los cargadores de módulos asíncronos ,
como RequireJS .
 UMD ( definición del módulo universal) . Una variación del formato AMD que permite que los cargadores
CommonJS también carguen módulos.
 Sistema . Esta forma t i s utiliza para representar ECMAScript 2015 semántica con alta fidelidad en entornos de
nivel inferior.

El patrón de generación de código de módulo deseado se selecciona a través de una opción de compilador y no afecta
el código fuente de TypeScript . De hecho, es posible crear módulos que se puedan compilar para usarlos tanto en
el lado del servidor ( por ejemplo, usando node.js ) como en el lado del cliente (usando un cargador compatible con
AMD ) sin cambios en el código fuente de TypeScript .

11.3.1     Nombres de módulos
Los módulos son identificados y referenciados usando los nombres de los módulos. La siguiente definición se alinea con la
proporcionada en º e CommonJS Módulos 1.0 especificación .

 El nombre de un módulo es una cadena de términos delimitados por barras diagonales.

 M nombres ÓDULO pueden no tener las extensiones de nombre de archivo como " js " .
 M nombres ódulo pueden ser relativa o a p-nivel. Un nombre de módulo es relativo si el primer término
es " . " O " .. " .
 Los nombres de nivel superior se resuelven de la raíz del espacio de nombres del módulo conceptual.
 Los nombres relativos se resuelven en relación con el nombre del módulo en el que aparecen.

Para los propósitos de resolver referencias de módulos, TypeScript asocia una ruta de archivo con cada módulo. La ruta

del archivo es simplemente el camino del módulo ' archivo de origen s sin la extensión de archivo. Por
ejemplo, un módulo contenido en el archivo de fuente ' C: \ src \ lib \ io.ts ' tiene la ruta de archivo ' C: / src / lib / io ' y
un módulo contenido en el archivo de fuente ' C: \ src \ ui \ editor.d.ts ' tiene la ruta del archivo ' C: / src / ui / editor ' .

El nombre de un módulo en una declaración de importación se resuelve de la siguiente manera:

  Si el declaratio importación n especifica un pariente nombre del módulo , el nombre se resuelve en relación con el
directorio del módulo de referencia ' ruta del archivo s. El programa debe contener un módulo con la ruta del
archivo resultante o, de lo contrario, se produce un error. Por ejemplo, en un módulo con la ruta del archivo ' C: / src
/ ui / main ' , los nombres de los módulos ' ./editor ' y ' ../lib/io ' hacen referencia a los módulos con las rutas del
archivo ' C: / src / ui / editor ' y ' C: / src / lib / io ' .
 Si la declaración de importación especifica un nombre de módulo de nivel superior y el programa contiene
una declaración AmbientModuleDeclaration  (sección 12.2 ) con un literal de cadena que especifica ese nombre
exacto, entonces la declaración de importación hace referencia a ese módulo ambiental .
 Si la declaración de importación especifica un nivel superior nombre del módulo y el
programa contiene s sin AmbientModuleDeclaration  (sección 12.2 ) con un literal de cadena que especifica que el
nombre exacto, el nombre se resuelve de una manera dependiente de host (por ejemplo, teniendo en cuenta el
nombre en relación con un espacio de nombre de módulo raíz). Si no se puede encontrar un módulo coincidente, se
produce un error.

11.3.2     Declaraciones de Importación
Las declaraciones de importación se utilizan para importar entidades de otros módulos y proporcionar enlaces para ellas
en el módulo actual.

Una declaración de importación del formulario

importar * como m de "mod" ;

importa el módulo con el nombre dado y crea un enlace local para el módulo en sí . El enlace local se clasifica como un
valor (que representa la instancia del módulo) y un espacio de nombres (que representa un contenedor de tipos y
espacios de nombres).

Una declaración de importación del formulario

importar {x, y, z} desde "mod" ;

importa un módulo determinado y crea enlaces locales para una lista específica de miembros exportados del
módulo . Los nombres especificados deben hacer referencia a una entidad en el conjunto de miembros de
exportación ( 11.3.4.4 ) del módulo dado. Los enlaces locales tienen el mismo nombre s y clasificación s como las
entidades que representan a menos que las cláusulas se utilizan para que especifican diferentes nombres locales:

importar {x como a, y como b} desde "mod" ;

Una declaración de importación del formulario

importar d desde "mod" ;

es exactamente equivalente a la declaración de importación

importar {predeterminado como d} desde "mod" ;

Una declaración de importación del formulario

importar "mod" ;

importa el módulo dado sin crear enlaces locales (esto es útil solo si el módulo importado tiene efectos secundarios).
11.3.3     Importar requiere declaraciones
Me Mport requiero declarati complementos existen para mantener la compatibilidad con versiones anteriores de
mecanografiado.

Importación  Requerir  Declaración  : 

importación BindingI  dentifier  = requieren ( StringLiteral  ) ;                    

Una declaración de requerimiento de importación introduce un identificador local que hace referencia a un módulo

dado. El literal de cadena especificado en una declaración de requerimiento de importación se interpreta como un
nombre de módulo (sección 11.3.1 ). El identificador local introducido por la declaración se convierte en un alias para, y se
clasifica exactamente como, la entidad exportada desde el módulo referenciado. Específicamente, si el módulo al que se
hace referencia no contiene una asignación de exportación, el identificador se clasifica como un valor y un espacio de
nombres, y si el módulo al que se hace referencia contiene una asignación de exportación, el identificador se clasifica
exactamente como la entidad nombrada en la asignación de exportación.

Una importación requiere declaración del formulario

importar m = requerir ( "mod" );

i S equivalente a la ECMAScript 2015 declaración de importación

importar * como m de "mod" ;

siempre que el módulo al que se hace referencia no contenga ninguna asignación de exportación .

11.3.4 Declaraciones de exportación    
Una declaración de exportación declara uno o más miembros del módulo exportados. Los miembros exportados de un
módulo pueden importarse en otros módulos mediante declaraciones de importación ( 11.3.2 ).

11.3.4.1 Modificadores de exportación    
En el cuerpo de un módulo, una declaración puede exportar la entidad declarada al incluir un modificador
de exportación .

ExportImplementationElement: 
export VariableStatement  export LexicalDeclaration  export FunctionDeclaration  export GeneratorDeclaration  ex
port ClassDeclaration  export InterfaceDeclaration  export TypeAliasDeclaration  export EnumDeclaration  export 
NamespaceDeclaration  export AmbientDeclaration  export ImportAlias  Declaración   
   
   
   
   
   
   
   
   
   
  

ExportDeclarationElement: 
export InterfaceDeclaration  export TypeAliasDeclaration  export AmbientDeclaration  export ImportAlias  Declara
ción   
   
    
  

Además de introducir un nombre en el espacio de declaración local del módulo, una declaración exportada introduce el
mismo nombre con la misma clasificación en el espacio de declaración de exportación del módulo. Por ejemplo, la
declaración

punto de función de exportación (x: número , y: número ) { return {x , y }; } 

    

introduce un punto de nombre local y un punto de nombre exportado que hacen referencia a la función.

11.3.4.2 Exportar declaraciones predeterminadas    

Las declaraciones predeterminadas de exportación proporcionan una sintaxis abreviada para exportar una entidad
denominada predeterminada .

ExportDefaultImplementationElement: 
export default FunctionDeclaration  export default GeneratorDeclaration  export default ClassDeclaration  exp
ort default AssignmentExpression  ;      
      
      
        

ExportDefaultDeclarationElement: 
exportación predeterminada AmbientF  unctionDeclaration  exportación predeterminada AmbientC  lassDeclarati
on  export default IdentifierReference  ;      
      
        

Un ExportD  efaultImplementationElement  o ExportDefaultDeclarationElement  para una función, generador o

clase introduce un valor llamado default , y en el caso de una clase , un tipo llamado default , en el espacio de
declaración de exportación del módulo contenedor . La declaración puede especificar opcionalmente un nombre
local para la función, el generador o la clase exportados. Por ejemplo, la declaración

exportar punto de función predeterminado (x: número , y: número ) { return {x , y }; } 

    

introduce un punto de nombre local y un nombre de exportación predeterminado que hacen referencia a la función. La

declaración es efectivamente equivalente a

punto de función (x: número , y: número ) { return {x , y }; }

    

punto predeterminado de exportación ;

que de nuevo es equivalente a

punto de función (x: número , y: número ) { return {x , y }; }

    

exportar {punto por defecto};

Un ExportDefault  ImplementationElement  o ExportDefaultDeclarationElement  para una expresión que consta de un único

identificador debe nombrar una entidad declarada en el módulo actual o en el espacio de nombres global. La declaración
introduce una entidad denominada default , con la misma clasificación que la entidad referenciada, en el espacio de
declaración de exportación del módulo contenedor. Por ejemplo, las declaraciones

Punto de interfaz { 
    x: número ; 
    y: número ; 
}
Punto de función (x: número , y: número ): Punto { return {x, y}; }
    

punto predeterminado de exportación ;

introduzca un nombre de punto local y un nombre de exportación predeterminado , ambos con un valor y un significado

de tipo.

Un ExportDefault  ImplementationElement  para cualquier expresión que no sea un identificador único introduce un
valor denominado default en el espacio de declaración de exportación del módulo contenedor. Por ejemplo, la
declaración

exportar por defecto "hola" ;

introduce un valor exportado denominado predeterminado de tipo cadena.

11.3.4.3 Declaraciones de lista de exportación    

Una declaración de lista de exportación exporta una o más entidades del módulo actual o un módulo específico.

Declaración de  ExportList  : 

export * FromClause  ; export ExportClause  FromClause  ; export ExportClause  ;         
         
     

Una n ExportListDeclaration  sin FromClause  exporta entidades del módulo actual. En una declaración de la forma

exportar {x };

t él nombre de x debe hacer referencia a una entidad declarada en el módulo actual o en el espacio de nombres global, y
la declaración introduce una entidad con el mismo nombre y significar ing en el espacio declaración de exportación del
módulo que contiene.

Una n ExportListDeclaration  con una FromClause  reexporta entidades desde un módulo específico. En una declaración de
la forma

exportar {x} desde "mod" ;

El nombre x debe hacer referencia a una entidad en el conjunto de miembros de exportación del módulo especificado, y

la declaración introduce una entidad con el mismo nombre y significado en el espacio de declaración de exportación del
módulo contenedor. No se crean enlaces locales para x .

El ExportClause  de un ExportListDeclaration  puede especificar múltiples entidades y puede especificar opcionalmente

diferentes nombres que se utilizarán para las entidades exportados. Por ejemplo , la declaración

exportar {x, y como b, z como c};

introduce entidades nombradas x , b , y c en el espacio declaración de exportación del módulo que contiene con el
mismo significado que las entidades locales nombrados x , y , y z , respectivamente.
Una declaración ExportListDeclaration  que especifica * en lugar de una ExportClause  se denomina declaración estrella de
exportación  . Una declaración estrella de exportación reexporta todos los miembros de un módulo específico.

exportar * desde "mod" ;

Los miembros exportados explícitamente tienen prioridad sobre los miembros reexportados utilizando declaraciones de
estrellas de exportación, como se describe en la siguiente sección.

11.3.4.4 Conjunto de miembros de exportación    

El conjunto de miembros de exportación  de un módulo particular se determina partiendo de un conjunto vacío de
miembros E  y un conjunto vacío de los módulos de procesado P  , y luego procesar el módulo como se describe a
continuación para formar el conjunto completo de los miembros exportados en E  . El procesamiento de un
módulo M  consta de estos pasos:

 Añadir M  a P  .
 Añadir a E  de cada miembro en el espacio de declaración de exportación de M  con un nombre que no está ya
en E  .
 Para cada declaración de exportación estrellas en M  , en el orden de declaración, procesar el módulo de referencia
si no está ya en P  .

El tipo de instancia de  un módulo es un tipo de objeto con una propiedad para cada miembro en el conjunto de
miembros de exportación del módulo que denota un valor.

Si un módulo contiene una asignación de exportación , es un error que el módulo también contenga declaraciones de
exportación. Los dos tipos de exportaciones son mutuamente excluyentes.

11.3.5     Asignaciones de exportación
Existen asignaciones de exportación para compatibilidad con versiones anteriores de TypeScript. Una asignación de
exportación designa a un miembro del módulo como la entidad que se exportará en lugar del propio módulo .

ExportAssignment: 
export = Identificador de  referencia  ;        

Un módulo que contiene una asignación de exportación se puede importar utilizando una importación requiere
declaración ( 11.3.3 ), y el alias local en troduced por la importación requiere declaración a
continuación, adquiere todo significado s del identificador de llamada en la asignación de exportación.

Un módulo que contiene una asignación de exportación también se puede importar utilizando una declaración de
importación regular ( 11.3.2 ) siempre que la entidad a la que se hace referencia en la asignación de exportación se
declare como un espacio de nombres o como una variable con una anotación de tipo.

Suponga que el siguiente ejemplo reside en el archivo ' point.ts ' :

export = Point;
clase Point { constructor ( public x: número , public y: número ) {} origen estático = nuevo punto
( 0 , 0 ); }
    
    

Cuando se importa ' point.ts ' en otro módulo, el alias de importación hace referencia a la clase exportada y se puede usar
como un tipo y como una función de constructor:

import Pt = require ( " ./ point " );
var p1 = nuevo Pt ( 10 , 20 ); var p2 = Pt.origin; 
Tenga en cuenta que no es necesario que el alias de importación use el mismo nombre que la entidad exportada.

11.3.6     Módulos CommonJS
La definición de Módulos CommonJS especifica una metodología para escribir módulos JavaScript con privacidad
implícita, la capacidad de importar otros módulos y la capacidad de exportar miembros explícitamente. Un sistema
compatible con Common JS proporciona una función ' require ' que se puede usar para cargar de forma sincrónica
otros módulos para obtener su instancia de módulo único a n, así como una variable ' exportar ' a la que un módulo
puede agregar propiedades para definir su API externa.

El ejemplo ' main ' y ' log ' de la sección 11.3 anterior genera el siguiente código JavaScript cuando se compila para el

patrón de Módulos CommonJS:

Archivo main.js :

var log _1 = require ( " ./ log " ); 

log _1 .message ( " hola " );

Archivo log.js:

función de mensaje ( s) { 

    console.log (s); 
} 
exportaciones.message = mensaje;

Una declaración de importación de módulo se representa en el JavaScript generado como una variable inicializada por
una llamada a la función ' requerir ' proporcionada por el sistema de módulo ho st. Se emite una declaración de variable
y una llamada ' requerida ' para un módulo importado particular solo si el módulo importado , o un alias local
(sección 10.3 ) que hace referencia al módulo importado, se hace referencia como una Expresión primaria  en algún lugar
del cuerpo del módulo de importación. Si se hace referencia a un módulo importado solo
como NamespaceName  o TypeQueryExpression  , no se emite nada.

Un ejemplo:

Archivo geometry.ts :

interfaz de exportación Punto {x: número ; y: número };

punto de función de exportación (x: número , y: número ): Punto {     return {x, y} ; } 

Archivo game.ts :

importar * como g desde " ./ geometry " ; sea p = punto g ( 10 , 20 ); 

El ' juego ' módulo hace referencia a la importada ' geometría ' módulo en una expresión ( a través de sus alias ' g ' ) y

un ' requiere ' por lo tanto llamada está incluido en el JavaScript emitida:

var g = require ( " ./ geometry " ); 

var p = punto g ( 10 , 20 );

Si el módulo ' juego ' hubiera sido escrito solo para hacer referencia a ' geometría ' en una posición de tipo
importar * como g desde "./geometry" ; sea p: g.Point = {x: 10 , y: 20 }; 

el JavaScript emitido no tendría dependencia en el módulo ' geometría ' y simplemente sería

var p = {x: 10 , y: 20 };

11.3.7     Módulos AMD
La especificación de definición de módulo asíncrono (AMD ) amplía la especificación de módulos CommonJS con un
patrón para crear módulos cargables asincrónicamente con dependencias asociadas . Usando el patrón AMD ,
los módulos se emiten como llamadas a una función global ' definir ' que toma una matriz de dependencias, especificadas
como nombres de módulos, y una función de devolución de llamada que contiene el cuerpo del
módulo. El mundial ' definir ' la función i s proporcionada por incluyendo un cargador compatible con AMD en
la aplicación . El cargador arregla para cargar de forma asíncrona los módulos ' s dependencias y, al finalizar, llama a la
función de devolución de llamada que pasa resueltos módulo casos como argumentos en el orden en que se enumeran
en la matriz de dependencia.

El ejemplo " principal " y " registro " de arriba genera el siguiente código JavaScript cuando se compila para el patrón

AMD.

Archivo main.js:

definir ([ " requerir " , " exportaciones " , " ./ log " ], función (requerir, exportaciones, log _1 )

{ 
    log _1 .message ( " hola " ); 
}

Archivo log.js:

definir ([ " requerir " , " exportaciones " ], función (requiera, las exportaciones)

{ función mensaje (s) {         console.log (s);     }     exports.message = mensaje; }
    

Las especialidades dependientes de ' requerir ' y ' exportaciones ' siempre están presentes. Se agregan entradas

adicionales a la matriz de dependencias y a la lista de parámetros según sea necesario para representar
los módulos importados . De manera similar a la generación de código para los módulos CommonJS, se
genera una entrada de dependencia para un módulo importado particular solo si el módulo importado se referencia
como una Expresión primaria  en algún lugar del cuerpo del módulo de importación. Si se hace referencia a un módulo
importado solo como un Nombre de espacio de nombres  , no se genera dependencia para ese módulo.

1
 
 
12 ambientes  

Las declaraciones ambientales se utilizan para proporcionar escritura estática sobre el código JavaScript existente. Las
declaraciones ambientales difieren de las declaraciones regulares en que no se emite ningún código JavaScript para
ellas. En lugar de introducir nuevas variables, funciones, clases, enumeraciones o espacios de nombres , las declaraciones
ambientales proporcionan información de tipo para entidades que existen " ambientalmente " y se incluyen en un
programa por medios externos, por ejemplo, haciendo referencia a una biblioteca JavaScript en un <script / > etiqueta.

12,1    Declaraciones ambientales
Las declaraciones ambientales se escriben usando la palabra clave declare y pueden declarar variables, funciones, clases,
enumeraciones, espacios de nombres o módulos.

AmbientDeclaration: 
declare AmbientVariableDeclaration  declare AmbientFunctionDeclaration  declare AmbientClassDeclaration  dec
lare AmbientEnumDeclaration  declare Ambient  NamespaceDeclaration   
   
   
   
  

12.1.1 Declaraciones de variables ambientales    

Una declaración de variable ambiental introduce una variable en el espacio de declaración que lo contiene.

AmbientVariableDeclaration: 
var AmbientBindingList  ; deja AmbientBindingList  ; const AmbientBindingList  ;      
      
     

AmbientBindingList: 
AmbientBinding 
AmbientBindingList  , AmbientBinding     

AmbientBinding: 
BindingIdentifier  TypeAnnotation    opt

Una declaración de variable ambiental puede incluir opcionalmente una anotación de tipo. Si no hay ninguna anotación
de tipo, se supone que la variable tiene el tipo Any.

Una declaración de variable ambiental no permite que esté presente una expresión inicializadora.

12.1.2 Declaraciones de función ambiental    

Una declaración de función ambiental introduce una función en el espacio de declaración que lo contiene.

AmbientFunctionDeclaration: 
function BindingI  dentifier  CallSignature  ;        

Las funciones ambientales se pueden sobrecargar especificando múltiples declaraciones de funciones ambientales con el
mismo nombre, pero es un error declarar múltiples sobrecargas que se consideran idénticas (sección 3.11.2 ) o que solo
difieren en sus tipos de retorno.

Las declaraciones de funciones ambientales no pueden especificar los cuerpos de una función y no permiten valores de
parámetros predeterminados.

12.1.3 Declaraciones de clase ambiental    

Una declaración de clase ambiental declara un tipo de clase y una función constructora en el espacio de declaración que
lo contiene .

AmbientClassDeclaration: 
class BindingI  dentifier  TypeParameters  ClassHeritage  { AmbientClassBody  }                 
opt 

AmbientClassBody: 
AmbientClassBodyElements  opt

AmbientClassBodyElements: 
AmbientClassBodyElement 
AmbientClassBodyElements  AmbientClassBodyElement  

AmbientClassBodyElement: 
AmbientConstructorDeclaration 
Ambient  Property  MemberDeclaration 
IndexSignature

AmbientConstructorDeclaration: 
constructor ( ParameterList  ) ;           
opt 

Ambient  Propiedad  MemberDeclaration: 

AccessibilityModifier  estática  PropertyName  TypeAnnotation  ; AccessibilityModifier 
opt  opt  opt  optar  estática opt  PropertyN
ame  CallSignature  ;            
           

12.1.4 Declaraciones de enumeración ambiental    
Una n enumeración ambiental es gramaticalmente equivalente a una declaración de enumeración no ambiental.

AmbientEnumDeclaration: 
EnumDeclaration

Las declaraciones de enumeración ambiental difieren de las declaraciones de enumeración no ambiental de dos maneras:

 En la declaración de enumeración ambiental s , todos los valores especificados en las declaraciones de miembros
de enumeración se deben clasificar como expresiones de enumeración constantes.
 En las declaraciones de enumeración ambiental que no especifican ningún modificador constante , las
declaraciones de miembros de enumeración que omiten un valor se consideran miembros calculados (en lugar de
tener asignados valores de incremento automático).

Las declaraciones de enumeración ambiental se procesan de la misma manera que las declaraciones de enumeración no
ambientales.

12.1.5 Declaraciones de espacio de nombres ambientales    

Una declaración de espacio de nombres ambiental declara un espacio de nombres .

Ambient  NamespaceDeclaration  : 
nombre de espacio IdentifierPath  { Ambient  NamespaceBody  }           

Ambient  NamespaceBody  : 
Ambient  NamespaceElement  s  opt

Ambient  NamespaceElement  s: 

Ambient  NamespaceElement 
Ambient  NamespaceElement  s  Ambient  NamespaceElement  
 Ambiente  NamespaceElement  : 
exportación  AmbientVariableDeclaration  exportación  ambiente  léxico  Declaración  de
opt  opt 

exportación  AmbientFunctionDeclaration  exportación  AmbientClassDeclaration  exportación  InterfaceDecla

opt  opt  opt 

ration  exportación  AmbientEnumDeclaration  exportación  ambiente  NamespaceDeclaration  exportación  I

opt  opt  opt 

mportAlias  Declaración   
   
   
   
   
   
   
  

A excepción de ImportAlias  Declaración  s  , ambiente  NamespaceElement  s  siempre declarar entidades

exportado independientemente de si el y incluye la opción de exportación modificador.

12,2    Declaraciones de módulo ambiental
Una declaración de  módulo de ambiente  declara un módulo. Este tipo de declaración se permite solo en el nivel superior
en un archivo fuente que contribuye al espacio de nombres global (sección 11.1 ) . El StringLiteral  mu st especificar un
nivel superior nombre del módulo. No se permiten nombres de módulos relativos .

AmbientModuleDeclaration  : 
declare module StringLiteral  { DeclarationModule  }               

A n Importación  Requerir  Declaración  en un AmbientModuleDeclaration  puede hacer referencia a otros módulos sólo a

través de nombres de los módulos de nivel superior. No se permiten nombres de módulos relativos .

Si un ambiente declaración módulo incluye una asignación de exportación, es un error para cualquiera de las
declaraciones con en el módulo para especificar una exportación m odifier. Si una declaración de módulo ambiental no
contiene asignación de exportación, las entidades declaradas en el módulo se exportan independientemente de si sus
declaraciones incluyen el modificador de exportación opcional .

Los módulos ambientales son " abiertos " y las declaraciones de módulos ambientales con el mismo nombre literal de

cadena contribuyen a un solo módulo. Por ejemplo, los Follo ala dos declaraciones de un módulo de ' io ' podrían estar
ubicados en los archivos fuente separados.

declare module " io " { export function readFile (filename: string ): string ; } 
    

declare el módulo " io " { función de exportación writeFile (nombre de archivo: cadena ,

datos: cadena ): vacío ; } 
    

Esto tiene el mismo efecto que una sola declaración combinada:

declare module " io " { export function readFile (filename: string ): string ; función
de exportación writeFile (nombre de archivo: cadena , datos: cadena ): vacío ; } 
    
    

1
 
 

Una gramática       

Este apéndice contiene un resumen de la gramática encontrada en el documento principal. Como se describe en la

sección 2.1 , la gramática Letra de imprenta es un superconjunto de la gramática definida en
el ECMAScript 2015 Language Specification (specif camente, la Norma ECMA-262, 6  edición) y se enumeran en este
ª 

Apéndice O producciones ólo que son nuevas o modificada a partir de la Gramática ECMAScript.

A.1 Tipos      
TypeParameters: 
< TypeParameterList  >     

TypeParameterList: 
TypeParameter 
TypeParameterList  , TypeParameter     

Tipo Parámetro: 
BindingIdentifier  Restricción    
opt

Restricción: 
extiende el tipo  

TypeArguments: 
< TypeArgumentList  >     

TypeArgumentList: 
TypeArgument 
TypeArgumentList  , TypeArgument     

Tipo  Argumento: 
Tipo

Tipo: 
UnionOrIntersectionOrPrimaryType 
FunctionType 
ConstructorType

UnionOrIntersectionOrPrimaryType: 
UnionType 
IntersectionOrPrimaryType

IntersectionOrPrimaryType: 
IntersectionType 
PrimaryType

Tipo  primario  : 
ParenthesizedType 
PredefinedType 
TypeReference 
ObjectType 
ArrayType 
 TupleType 
TypeQuery 
ThisType

ParenthesizedType: 
( Tipo  )     

PredefinedType: 
cualquier 
número 
boolean 
string 
symbol 
void

TypeReference: 
TypeName  [no LineTerminator aquí]  TypeArguments       
opt

TypeName: 
IdentifierReference 
NamespaceName  . IdentificadorReferencia     

NamespaceName: 
IdentifierReference 
NamespaceName  . IdentificadorReferencia     

ObjectType: 
{ TypeBody  }     
opt 

TypeBody: 
TypeMemberList  ;  TypeMemberList  ,     
opt  opt

  

TypeMemberList: 
TypeMember 
TypeMemberList  ; TypeMember  TypeMemberList  , TypeMember      
     

TypeMember: 
PropertySignature 
CallSignature 
ConstructSignature 
IndexSignature 
MethodSignature

ArrayType: 
PrimaryType  [no LineTerminator aquí]  [ ]        

TupleType: 
[ TupleElementTypes  ]     

TupleElementTypes: 
TupleElementType 
TupleElementTypes  , TupleElementType     

TupleElementType: 
Type
UnionType: 
UnionOrIntersectionOrPrimaryType  | IntersectionOrPrimaryType     

IntersectionType: 
IntersectionOrPrimaryType  & PrimaryType     

FunctionType: 
TypeParameters  ( ParameterList  ) => Tipo              
opt  opt 

ConstructorType: 
new TypeParameters  ( ParameterList  ) => Tipo                 
opt  opt 

TypeQuery: 
typeof TypeQueryExpression  

TypeQueryExpression: 
IdentifierReference 
TypeQueryExpression  . IdentifierName     

ThisType: 
this

PropertySignature: 
PropertyName  ?  Tipo Anotación       
opt  opt

PropertyName: 
IdentifierName 
StringLiteral 
NumericLiteral

TypeAnnotation 
:: Type  

CallSignature: 
TypeParameters  ( ParameterList  ) TypeAnnotation             
opt  opt  opt

ParameterList: 
RequiredParameterList 
OpcionalParameterList 
RestParameter 
RequiredParameterList  , OpcionalParameterList  RequiredParameterList  , RestParameter  OpcionalParameterList  , 
RestParameter  RequiredParameterList  , OpcionalParameterList  , RestParameter      
      
      
           

RequiredParameterList: 
RequiredParameter 
RequiredParameterList  , RequiredParameter     

RequiredParameter: 
AccessibilityModifier  BindingIdentifierOrPattern  TypeAnnotation  BindingIdentifier  : StringLiteral      
opt  opt 

     

AccessibilityModifier: 
público 
privado 
protegido
 BindingIdentifierOrPattern: 
BindingIdentifier 
BindingPattern

OpcionalParameterList: 
OpcionalParameter 
OpcionalParameterList  , OpcionalParameter     

OpcionalParameter: 
AccessibilityModifier  BindingIdentifierOrPattern  ? TypeAnnotation  AccessibilityModifier  BindingIdentifierOrPat
opt  opt  opt 

tern  TypeAnnotation  Initializer  BindingIdentifier  ? : StringLiteral         

opt 

         
        

RestParameter: 
... BindingIdentifier  TypeAnnotation       
opt

ConstructSignature: 
nuevo TypeParameters  ( ParameterList  ) TypeAnnotation                
opt  opt  opt

IndexSignature: 
[ BindingIdentifier  : string ] TypeAnnotation  [ BindingIdentifier  : número ] TypeAnnotation               
              

MethodSignature: 
PropertyName  ?  CallSignature     
opt 

TypeAliasDeclaration: 
type BindingIdentifier  TypeParameters  = Type  ;              
opt 

A.2 Expresiones      
PropertyDefinition:  (Modificado)  IdentifierReference  CoverInitializedName  PropertyName  : AssignmentExpression  Prop
ertyName  CallSignature  { FunctionBody  } GetAccessor  SetAccessor  

      
            

GetAccessor: 
get PropertyName  ( ) TypeAnnotation  { FunctionBody  }                    
opt 

SetAccessor: 
set PropertyName  ( BindingIdentifierOrPattern  TypeAnnotation  ) { FunctionBody  }                       
opt 

FunctionExpression:  (Modificado)  función BindingIdentifier  CallSignature  { FunctionBody  }  

opt 

              

ArrowFormalParameters:  (Modificado)  CallSignature  

Argumentos:  (Modificado)  TypeArguments  ( ArgumentList  )  

opt  opt 

        
 UnaryExpression:  (Modificado)  ... < Tipo  > UnaryExpression  

        

A.3 Declaraciones      
Declaración:  (Modificado)  ... Tipo de  declaración de  interfaz  Declaración de  alias  Declaración de  enumeración  

Declaración  Variable:  (Modificado)  SimpleVariableDeclaration  DestructuringVariableDeclaration  

SimpleVariableDeclaration: 
BindingIdentifier  TypeAnnotation  Initializer       
opt  opt

DestructuringVariableDeclaration: 
BindingPattern  TypeAnnotation  Initializer     
opt 

Enlace léxico:  (Modificado)  SimpleLexicalBinding  DestructuringLexicalBinding  

SimpleLexicalBinding: 
BindingIdentifier  TypeAnnotation  Initializer       
opt  opt

DestructuringLexicalBinding: 
BindingPattern  TypeAnnotation  Initializer       
opt  opt

A.4 Funciones      
FunctionDeclaration:  (modificada)  función BindingIdentifier  CallSignature  { FunctionBody  } función BindingIdentifi
opt 

er  CallSignature  ;  

opt 

               
        

A.5 Interfaces      
InterfaceDeclaration: 
interfaz BindingIdentifier  TypeParameters  InterfaceExtendsClause  ObjectType           
opt  opt 

InterfaceExtendsClause: 
extiende ClassOrInterfaceTypeList  

ClassOrInterfaceTypeList: 
ClassOrInterfaceType 
ClassOrInterfaceTypeList  , ClassOrInterfaceType     

ClassOrInterfaceType: 
TypeReference

A.6 Clases      
ClassDeclaration:  clase (modificada)  BindingIdentifier  TypeParameters  ClassHeritage  { ClassBody  }  
opt  opt 

                 
 ClassHeritage:  (Modificado)  ClassExtendsClause  ImplementsClause    
opt  opt

  

ClassExtendsClause: 
extiende ClassType   

ClassType: 
TypeReference

ImplementsClause: 
implementa ClassOrInterfaceTypeList  

ClassElement:  (Modificado)  ConstructorDeclaration  PropertyMemberDeclaration  IndexMemberDeclaration  

ConstructorDeclaration: 
AccessibilityModifier  constructor ( ParameterList  ) { FunctionBody  } AccessibilityModifier  constructor ( 
opt  opt  opt 

ParameterList  ) ;                     
opt 

              

PropertyMemberDeclaration: 
MemberVariableDeclaration 
MemberFunctionDeclaration 
MemberAccessorDeclaration

MemberVariableDeclaration: 
AccessibilityModifier  estática  PropertyName  TypeAnnotation  inicializador  ;              
optar  opt  opt  opt 

MemberFunctionDeclaration: 
AccessibilityModifier  estática  PropertyName  CallSignature  { FunctionBody  } AccessibilityModifier 
optar  opt  optar  estátic
a  PropertyName  CallSignature  ;                  
opt 

           

MemberAccessorDeclaration: 
AccessibilityModifier  estática  GetAccessor  AccessibilityModifier 
optar  opt  optar  estática opt  SetAccessor      
     

IndexMemberDeclaration: 
IndexSignature  ;  

A.7 Enums      
EnumDeclaration: 
const  enum BindingIdentifier  { EnumBody  }              
opt  opt 

EnumBody: 
EnumMemberList  ,     opt

EnumMemberList: 
EnumMember 
EnumMemberList  , EnumMember     

EnumMember: 
PropertyName 
PropertyName     =   EnumValue
 EnumValue: 
AssignmentExpression

A.8 Espacios de nombres      
NamespaceDeclaration: 
namespace IdentifierPath  { NamespaceBody  }           

IdentifierPath: 
BindingIdentifier 
IdentifierPath  . BindingIdentifier     

NamespaceBody: 
NamespaceElements  opt

NamespaceElements: 
NamespaceElement 
NamespaceElements  NamespaceElement  

NamespaceElement: 
Declaración 
LexicalDeclaration 
FunctionDeclaration 
GeneratorDeclaration 
ClassDeclaration 
InterfaceDeclaration 
TypeAliasDeclaration 
EnumDeclaration 
NamespaceDeclaration 
AmbientDeclaration 
ImportAliasDeclaration 
ExportNamespaceElement

ExportNamespaceElement: 
export VariableStatement  export LexicalDeclaration  export FunctionDeclaration  export GeneratorDeclaration  ex
port ClassDeclaration  export InterfaceDeclaration  export TypeAliasDeclaration  export EnumDeclaration  export 
NamespaceDeclaration  export AmbientDeclaration  export ImportAliasDeclaration   
   
   
   
   
   
   
   
   
   
  

ImportAliasDeclaration: 
import BindingIdentifier  = EntityName  ;           

EntityName: 
NamespaceName 
NamespaceName  . IdentificadorReferencia     
A.9 Scripts y módulos      
SourceFile: 
ImplementationSourceFile 
DeclarationSourceFile

ImplementationSourceFile: 
ImplementationScript 
ImplementationModule

DeclarationSourceFile: 
DeclarationScript 
DeclarationModule

ImplementationScript: 
ImplementationScriptElements  opt

ImplementationScriptElements: 
ImplementationScriptElement 
ImplementationScriptElements  ImplementationScriptElement  

ImplementationScriptElement: 
ImplementationElement 
AmbientModuleDeclaration

ImplementationElement: 
Statement 
LexicalDeclaration 
FunctionDeclaration 
GeneratorDeclaration 
ClassDeclaration 
InterfaceDeclaration 
TypeAliasDeclaration 
EnumDeclaration 
NamespaceDeclaration 
AmbientDeclaration 
ImportAliasDeclaration

DeclarationScript: 
DeclarationScriptElements  opt

DeclarationScriptElements: 
DeclarationScriptElement 
DeclarationScriptElements  DeclarationScriptElement  

DeclarationScriptElement: 
DeclarationElement 
AmbientModuleDeclaration

DeclarationElement: 
InterfaceDeclaration 
TypeAliasDeclaration 
NamespaceDeclaration 
AmbientDeclaration 
ImportAliasDeclaration
ImplementationModule: 
ImplementationModuleElements  opt

ImplementationModuleElements: 
ImplementationModuleElement 
ImplementationModuleElements  ImplementationModuleElement  

ImplementationModuleElement: 
ImplementationElement 
ImportDeclaration 
ImportAliasDeclaration 
ImportRequireDeclaration 
ExportImplementationElement 
ExportDefaultImplementationElement 
ExportListDeclaration 
ExportAssignment

DeclarationModule: 
DeclarationModuleElements  opt

DeclaraciónMóduloElementos: 
DeclaraciónMóduloElemento 
DeclaraciónMóduloElementos  DeclaraciónMóduloElemento  

DeclarationModuleElement: 
DeclarationElement 
ImportDeclaration 
ImportAliasDeclaration 
ExportDeclarationElement 
ExportDefaultDeclarationElement 
ExportListDeclaration 
ExportAssignment

ImportRequireDeclaration: 
import BindingIdentifier  = require ( StringLiteral  ) ;                    

ExportImplementationElement: 
export VariableStatement  export LexicalDeclaration  export FunctionDeclaration  export GeneratorDeclaration  ex
port ClassDeclaration  export InterfaceDeclaration  export TypeAliasDeclaration  export EnumDeclaration  export 
NamespaceDeclaration  export AmbientDeclaration  export ImportAliasDeclaration   
   
   
   
   
   
   
   
   
   
  

ExportDeclarationElement: 
export InterfaceDeclaration  export TypeAliasDeclaration  export AmbientDeclaration  export ImportAliasDeclarat
ion   
   
    
  

ExportDefaultImplementationElement: 
export default FunctionDeclaration  export default GeneratorDeclaration  export default ClassDeclaration  exp
ort default AssignmentExpression  ;      
      
      
        

ExportDefaultDeclarationElement: 
export default AmbientFunctionDeclaration  export default AmbientClassDeclaration  export default Identifier
Reference  ;      
      
        

ExportListDeclaration: 
export * FromClause  ; export ExportClause  FromClause  ; export ExportClause  ;         
         
     

ExportAssignment: 
export = IdentifierReference  ;        

A.10 Ambientes  
AmbientDeclaration: 
declarar AmbientVariableDeclaration  declarar AmbientFunctionDeclaration  declarar AmbientClassDeclaration 
declarar AmbientEnumDeclaration  declarar AmbientNamespaceDeclaration   
   
   
   
  

AmbientVariableDeclaration: 
var AmbientBindingList  ; deja AmbientBindingList  ; const AmbientBindingList  ;      
      
     

AmbientBindingList: 
AmbientBinding 
AmbientBindingList  , AmbientBinding     

AmbientBinding: 
BindingIdentifier  TypeAnnotation     opt

AmbientFunctionDeclaration: 
function BindingIdentifier  CallSignature  ;        

AmbientClassDeclaration: 
clase BindingIdentifier  TypeParameters  ClassHeritage  { AmbientClassBody  }                 
opt 

AmbientClassBody: 
AmbientClassBodyElements  opt
 AmbientClassBodyElements: 
AmbientClassBodyElement 
AmbientClassBodyElements  AmbientClassBodyElement  

AmbientClassBodyElement: 
AmbientConstructorDeclaration 
AmbientPropertyMemberDeclaration 
IndexSignature

AmbientConstructorDeclaration: 
constructor ( ParameterList  ) ;           
opt 

AmbientPropertyMemberDeclaration: 
AccessibilityModifier  estática  PropertyName  TypeAnnotation  ; AccessibilityModifier 
optar  opt  opt  optar  estática opt  Property
Name  CallSignature  ;            
           

AmbientEnumDeclaration: 
EnumDeclaration

AmbientNamespaceDeclaration: 
namespace IdentifierPath  { AmbientNamespaceBody  }           

AmbientNamespaceBody: 
AmbientNamespaceElements  opt

AmbientNamespaceElements: 
AmbientNamespaceElement 
AmbientNamespaceElements  AmbientNamespaceElement  

AmbientNamespaceElement: 
export  AmbientVariableDeclaration  export  AmbientLexicalDeclaration  export  AmbientFunctionDeclaration  e
opt  opt  opt 

xport  AmbientClassDeclaration  export  InterfaceDeclaration  export  AmbientEnumDeclaration  export  Ambi

opt  opt  opt opt 

entNamespaceDeclaration  export  ImportAliasDeclaration   

opt 

   
   
   
   
   
   
  

AmbientModuleDeclaration: 
declare module StringLiteral  { DeclarationModule  }               

1