Sintaxis básica de TypeScript

Un programa TypeScript consta de las siguientes partes:

Módulos
Funciones
Variables
Sentencias y expresiones
Comentarios

Primer programa TypeScript

Podemos usar el siguiente programa TypeScript para imprimir "Hello World":

Código del archivo Ejemplo.ts:

const hello : string = "Hello World!" console.log(hello)

El código anterior primero se compila mediantetscel comando de compilación:

tsc Ejemplo.ts

Se obtiene el siguiente código js:

Código del archivo Ejemplo.js:

var hello = "Hello World!"; console.log(hello);

Finalmente, usamos el comando node para ejecutar este código js.

$ node Ejemplo.js
Hello World

Todo el proceso se muestra en la siguiente figura:

Podemos compilar varios archivos ts a la vez:

tsc file1.ts file2.ts file3.ts

Los parámetros de compilación comunes de tsc se muestran en la siguiente tabla:

N.º	Descripción del parámetro de compilación
1.	--help Mostrar información de ayuda
2.	--module Cargar módulos de extensión
3.	--target Establecer la versión de ECMA
4.	--declaration Generar adicionalmente un archivo con extensión .d.ts. tsc ts-hw.ts --declaration El comando anterior generará dos archivos: ts-hw.d.ts y ts-hw.js.
5.	--removeComments Eliminar los comentarios del archivo
6.	--out Compilar varios archivos y combinarlos en un archivo de salida
7.	--sourcemap Generar un archivo sourcemap (.map). Un sourcemap es un archivo de información que almacena la correspondencia de ubicaciones entre el código fuente y el código compilado.
8.	--module noImplicitAny Informar error cuando haya un tipo any implícito en expresiones y declaraciones
9.	--watch Ejecutar el compilador en modo de vigilancia. Vigilará los archivos de salida y los recompilará cuando cambien.

Palabras reservadas de TypeScript

Las palabras reservadas de TypeScript son las siguientes:

Palabra clave	Descripción
`abstract`	Se usa para definir clases abstractas o métodos abstractos.
`any`	Representa cualquier tipo y deshabilita la comprobación de tipos.
`as`	Afirmación de tipo, se usa para convertir un tipo a otro.
`await`	Se usa en funciones asíncronas para pausar la ejecución del código hasta que se resuelva la Promise.
`boolean`	Representa el tipo booleano.
`break`	Sale de un bucle o de una sentencia switch.
`case`	Se usa para las ramas de una sentencia switch.
`catch`	Se usa para capturar excepciones.
`class`	Se usa para definir clases.
`const`	Define variables constantes.
`continue`	Salta el bucle actual y continúa con la siguiente iteración.
`debugger`	Inicia el depurador y pausa la ejecución del código.
`declare`	Declara una variable o módulo, generalmente se usa en archivos de declaración de tipos.
`default`	Define la rama predeterminada de una sentencia switch.
`delete`	Elimina propiedades de objetos o elementos de un array.
`do`	Se usa para`do...while`bucles.
`else`	Define la parte else de una sentencia condicional.
`enum`	Define tipos de enumeración (enum).
`export`	Se usa para exportar variables, funciones o clases desde un módulo.
`extends`	Se usa para la herencia de clases; indica que una clase hereda de otra.
`false`	Valor booleano`false`。
`finally`	Define el`try...catch`bloque de código de ejecución final en la sentencia.
`for`	Se usa para`for`bucles.
`from`	Se usa en sentencias de importación de módulos para especificar el origen del módulo.
`function`	Define funciones.
`get`	Se usa para los métodos getter de un objeto.
`if`	Se usa para evaluar condiciones.
`implements`	Se usa para que una clase implemente una interfaz.
`import`	Se usa para importar contenido desde un módulo.
`in`	Se usa para comprobar si un objeto contiene una propiedad determinada, o para`for...in`bucles.
`infer`	Se usa para inferir tipos en tipos condicionales.
`instanceof`	Comprueba si un objeto es una instancia de una clase determinada.
`interface`	Se usa para definir interfaces.
`let`	Define variables con ámbito de bloque.
`module`	Define módulos (se usa en versiones anteriores de TypeScript).
`namespace`	Define espacios de nombres (se usa en versiones anteriores de TypeScript).
`new`	Crea una instancia de una clase.
`null`	Representa el valor nulo.
`number`	Representa el tipo numérico.
`object`	Representa tipos no primitivos.
`of`	Se usa para`for...of`bucles.
`package`	Se usa en el sistema de módulos para identificar paquetes.
`private`	Se usa como modificador de acceso de miembros de clase; indica privado.
`protected`	Se usa como modificador de acceso de miembros de clase; indica protegido.
`public`	Se usa como modificador de acceso de miembros de clase; indica público.
`readonly`	Indica propiedades de solo lectura.
`require`	Se usa para importar módulos CommonJS.
`return`	Sale de una función y puede devolver un valor.
`set`	Se usa para los métodos setter de un objeto.
`string`	Representa el tipo cadena (string).
`super`	Se usa para llamar a métodos o al constructor de la clase padre.
`switch`	Se usa en sentencias switch.
`symbol`	Representa el tipo symbol.
`this`	Referencia a la instancia de la clase u objeto actual.
`throw`	Lanza una excepción.
`try`	Se usa en sentencias de manejo de excepciones`try...catch`。
`true`	Valor booleano`true`。
`type`	Se usa para definir alias de tipos.
`typeof`	Obtiene el tipo de una variable o expresión.
`undefined`	Representa un valor indefinido.
`unique`	Se usa para`symbol`identificadores únicos de tipo.
`var`	Se usa para declarar variables (ya no se recomienda).
`void`	Representa un tipo sin valor de retorno.
`while`	Se usa para`while`bucles.
`with`	Se usa para crear un ámbito en el que se puede omitir la referencia al objeto (no se recomienda).
`yield`	Se usa en funciones generadoras para pausar y reanudar la ejecución del generador.

Espacios en blanco y saltos de línea

TypeScript ignora los espacios, tabulaciones y saltos de línea que aparecen en el programa.

Los espacios y tabulaciones se usan normalmente para indentar el código, haciéndolo más fácil de leer y entender.

TypeScript distingue entre mayúsculas y minúsculas

TypeScript distingue entre caracteres en mayúsculas y minúsculas.

El punto y coma es opcional

Cada línea de instrucciones es una sentencia; puedes usar o no el punto y coma. El punto y coma es opcional en TypeScript, pero se recomienda usarlo.

El siguiente código es válido:

console.log("Ejemplo")
console.log("Google");

Si las sentencias se escriben en la misma línea, es obligatorio usar puntos y comas para separarlas; de lo contrario, se producirá un error. Por ejemplo:

console.log("Ejemplo");console.log("Google");

Comentarios en TypeScript

Los comentarios son un buen hábito. Aunque muchos programadores odian los comentarios, se recomienda añadir explicaciones textuales a cada bloque de código.

Los comentarios pueden mejorar la legibilidad del programa.

Los comentarios pueden contener información sobre el programa, como el autor del código, descripciones de funciones, etc.

El compilador ignorará los comentarios.

TypeScript admite dos tipos de comentarios

Comentario de una sola línea ( // )− El texto después de // es contenido del comentario.
Comentario de varias líneas (/* */)− Este tipo de comentario puede abarcar varias líneas.

Ejemplo de comentario:

// Este es un comentario de una sola línea
 
/* 
 Este es un comentario de varias líneas 
 Este es un comentario de varias líneas 
 Este es un comentario de varias líneas 
*/

TypeScript y la programación orientada a objetos

La programación orientada a objetos es un método para comprender y abstraer el mundo real.

TypeScript es un lenguaje de programación orientado a objetos.

La programación orientada a objetos tiene principalmente dos conceptos: objetos y clases.

Objeto: Un objeto es una instancia de una clase (un objeto no es buscar una novia), tiene estado y comportamiento. Por ejemplo, un perro es un objeto; sus estados incluyen: color, nombre, raza; sus comportamientos incluyen: mover la cola, ladrar, comer, etc.
Clase: La clase es una plantilla que describe el comportamiento y el estado de un tipo de objetos.
Método: El método es el paso de implementación de las operaciones de la clase.

En la siguiente figura,girl、boyes la clase, y cada persona específica es un objeto de esa clase:

Ejemplo de programación orientada a objetos en TypeScript:

class Site { name():void { console.log("Ejemplo") } } var obj = new Site(); obj.name();

El ejemplo anterior define una clase Site, que tiene un método name(), el cual imprime la cadena Ejemplo en la terminal.

La palabra clave new crea un objeto de la clase, y ese objeto llama al método name().

El código JavaScript generado después de la compilación es el siguiente:

var Site = /** @class */ (function () { function Site() { } Site.prototype.name = function () { console.log("Ejemplo"); }; return Site; }()); var obj = new Site(); obj.name();

Al ejecutar el código JavaScript anterior, el resultado de salida es el siguiente:

Ejemplo

Otras extensiones

Fundamentos del sistema de tipos

Avanzado