Características de TypeScript
En comparación con JavaScript, TypeScript añade muchas características clave, especialmente mejoras en torno al sistema de tipos y la estructura del código.
Algunas características clave de TypeScript:
Comprobación estática de tipos: TypeScript comprueba en tiempo de compilación si los tipos del código coinciden, pudiendo detectar muchos errores potenciales. Incluso errores simples (como errores tipográficos o inconsistencias de tipos) pueden capturarse al escribir el código.
Inferencia de tipos: TypeScript puede inferir automáticamente el tipo de las variables. Por ejemplo, cuando declaras una variable y le asignas un valor, TypeScript infiere el tipo de la variable según esa asignación, sin necesidad de declarar el tipo explícitamente cada vez.
Interfaces y definiciones de tipos: TypeScript proporciona
interfaceytypepalabra clave, que te permite definir estructuras de datos complejas. Esto es muy importante para la colaboración de código y el intercambio de datos entre diferentes partes de un proyecto.Soporte de clases y módulos: TypeScript admite el concepto de clases (class) de la programación orientada a objetos, añadiendo constructores, herencia y modificadores de control de acceso (como
public、private、protected), y también es compatible con la especificación de módulos ES.Soporte de herramientas y editores: TypeScript cuenta con un buen soporte de editores, especialmente al integrarse con Visual Studio Code, ya que ofrece herramientas como sugerencias inteligentes, autocompletado y refactorización, lo que hace que el proceso de desarrollo sea más eficiente.
Compatibilidad con JavaScript: TypeScript es un superconjunto de JavaScript, lo que significa que todo código JavaScript válido es también código TypeScript válido. Esto permite que los proyectos JavaScript puedan migrarse gradualmente a TypeScript sin necesidad de reescribirlos por completo.
Las siguientes son las principales características que añade TypeScript:
1. Tipos estáticos
La mayor característica de TypeScript es la incorporación de un sistema de tipos estáticos. En TypeScript, los desarrolladores pueden declarar explícitamente los tipos de variables, parámetros y valores de retorno, lo que permite detectar muchos errores de tipos potenciales en tiempo de compilación. Los tipos comunes incluyennumber、string、boolean、array、tuple、enum, entre otros; además, también admite tipos personalizados.
let name: string = "Alice"; let age: number = 25;
2. Inferencia de tipos
TypeScript puede inferir automáticamente el tipo de las variables; incluso si no declaras explícitamente el tipo, TypeScript lo infiere según el contenido asignado a la variable, reduciendo así la cantidad de anotaciones de tipo necesarias en la mayoría de los casos.
let name = "Alice"; // 推断为 string
3. Interfaces
TypeScript proporciona interfaces, que permiten definir estructuras de objetos complejas. Las interfaces pueden definir propiedades y métodos, y también puedenimplementsimplementar la interfaz mediante la palabra clave, o medianteextendssu extensión, lo que facilita la definición de tipos de datos complejos.
interface Person {
name: string;
age: number;
greet(): void;
}
class Student implements Person {
constructor(public name: string, public age: number) {}
greet() {
console.log(`Hello, my name is ${this.name}`);
}
}
4. Alias de tipo (Type Aliases)
Alias de tipo (type) puede definir un alias corto para tipos complejos, lo que facilita la reutilización del código.
type StringOrNumber = string | number; let value: StringOrNumber = 42;
5. Enumeraciones (Enums)
TypeScript introduce el tipoenum, que se utiliza para definir un conjunto de constantes con nombre, mejorando la legibilidad del código. Las enumeraciones no tienen un equivalente directo en JavaScript.
enum Direction {
Up,
Down,
Left,
Right,
}
let dir: Direction = Direction.Up;
6. Tuplas (Tuples)
Las tuplas permiten definir arrays con un número fijo de elementos y tipos fijos. Son adecuadas para escenarios que requieren una estructura de datos fija, como coordenadas o valores de color RGB.
let point: [number, number] = [10, 20];
7. Modificadores de acceso (Access Modifiers)
TypeScript proporciona en las clases los modificadorespublic、privateyprotected, que permiten controlar la visibilidad de propiedades o métodos, favoreciendo un mejor encapsulamiento.
class Person {
private name: string;
protected age: number;
public constructor(name: string, age: number) {
this.name = name;
this.age = age;
}
}
8. Clases abstractas (Abstract Classes)
TypeScript admite clases abstractas; estas no pueden instanciarse directamente y deben ser implementadas por subclases. Las clases abstractas son adecuadas para definir jerarquías de clases con comportamiento común y métodos abstractos.
abstract class Animal {
abstract makeSound(): void;
}
class Dog extends Animal {
makeSound() {
console.log("Woof!");
}
}
9. Genéricos (Generics)
TypeScript admite genéricos, lo que permite utilizar tipos parametrizados en clases, interfaces y funciones, haciendo que el código pueda adaptarse a diferentes necesidades de tipos mientras se mantiene la seguridad de tipos.
function identity<T>(value: T): T {
return value;
}
let num = identity<number>(42);
10. Módulos y espacios de nombres
TypeScript proporciona un sistema de módulos basado en ES6, utilizandoimportyexportpara importar y exportar módulos. Además, TypeScript también admite espacios de nombres (Namespace), que se utilizan para organizar el código y evitar conflictos de nombres.
// math.ts
export function add(a: number, b: number): number {
return a + b;
}
// main.ts
import { add } from "./math";
console.log(add(2, 3));
11. Guardas de tipo (Type Guards)
TypeScript proporciona guardas de tipo, que permiten comprobar el tipo de una variable en el código y ayudan al compilador a inferir tipos más específicos. Esto es especialmente importante para los tipos unión.
function printId(id: string | number) {
if (typeof id === "string") {
console.log(id.toUpperCase());
} else {
console.log(id.toFixed(2));
}
}
12. Operadores de encadenamiento opcional y fusión de nulos
TypeScript añade el encadenamiento opcional de JavaScript (?.) y el operador de fusión de nulos (??), lo que simplifica el manejo en el código de los valores que pueden sernulloundefinednulos o indefinidos.
let user = { name: "Alice", address: { city: "Wonderland" } };
console.log(user?.address?.city); // 如果 address 存在则输出 city,否则返回 undefined
let value = null;
console.log(value ?? "default"); // 如果 value 为 null 或 undefined,则返回 "default"
13. Compatibilidad de tipos y tipos utilitarios
TypeScript proporciona algunos tipos utilitarios, comoPartial、Pick、Readonly、Record, etc. Estos tipos pueden ayudar a generar nuevos tipos y simplificar la definición de tipos.
interface Todo {
title: string;
description: string;
}
let partialTodo: Partial<Todo> = { title: "Learn TypeScript" }; // 可选属性
14. Comprobación de errores en tiempo de compilación
La comprobación de errores en tiempo de compilación que ofrece TypeScript puede detectar errores que no son fáciles de encontrar en JavaScript, como errores tipográficos o desajustes de tipos, lo que ayuda a mejorar la calidad del código.
15. Soporte de nuevas características de ES
TypeScript admite de antemano algunas características de ES que aún no están extendidas en todos los entornos, como decoradores (Decorators), iteradores asíncronos, etc., y puede compilarlas a versiones compatibles de JavaScript.
Gracias a estas características, TypeScript ofrece una capacidad de código más segura y más estructurada, lo que resulta especialmente ventajoso en proyectos grandes y en la colaboración entre múltiples desarrolladores.
Otras extensiones