Introducción
Instalación de TypeScript
Para instalar TypeScript de manera global:
npm install -g typescript
Compilar un archivo TypeScript
Compilar un archivo .ts
a .js
.
tsc archivo.ts
Iniciar un proyecto TypeScript
Inicializa un proyecto con un archivo tsconfig.json
para configurar el compilador.
tsc --init
Tipos
Definición de tipos básicos
TypeScript incluye una serie de tipos primitivos: number
, string
, boolean
, null
, undefined
, any
.
let edad: number = 25;
let nombre: string = "Luis";
let esEstudiante: boolean = true;
Arrays
Los arraus se tipan indicando el tipo seguido de []
.
let numeros: number[] = [1, 2, 3, 4];
let nombres: string[] = ["Luis", "María"];
Tuplas
Las tuplas permiten definir arraus con un número fijo de elementos de tipos específicos.
let persona: [string, number] = ["Luis", 25];
Enums
Los enumerados (enum
) permiten definir un conjunto de constantes con nombres.
enum Color { Rojo, Verde, Azul }
let colorFavorito: Color = Color.Azul;
Tipo any
any
desactiva el chequeo de tipos, permitiendo cualquier valor.
let valor: any = 5;
valor = "texto";
Tipos Unión
Permite definir variables que pueden ser de múltiples tipos.
let resultado: string | number = "Aprobado";
resultado = 85;
Tipos Null y Undefined
let valor: string | null | undefined;
Intersección de tipos
Los tipos de intersección combinan múltiples tipos en uno solo.
interface ConNombre {
nombre: string;
}
interface ConEdad {
edad: number;
}
type PersonaCompleta = ConNombre & ConEdad;
Tipos literales
Se pueden crear tipos literales con valores específicos.
type Colores = "Rojo" | "Verde" | "Azul";
let color: Colores = "Rojo";
Type Assertions
Las aserciones de tipo permiten decirle al compilador que trate un valor como un tipo específico.
let valor: any = "Hola mundo";
let longitud: number = (valor as string).length;
Funciones
Definir funciones con tipos
Las funciones en TypeScript pueden definir tipos para parámetros y el valor de retorno.
function sumar(a: number, b: number): number {
return a + b;
}
Parámetros opcionales y valores por defecto
Se pueden definir parámetros opcionales usando ?
y valores por defecto.
function saludar(nombre: string, saludo?: string): string {
return `${saludo || "Hola"}, ${nombre}`;
}
Funciones con tipo void
Una función que no devuelve nada usa el tipo void
.
function logMensaje(mensaje: string): void {
console.log(mensaje);
}
Funciones anónimas (arrow functions)
Arrow functions con tipos.
const multiplicar = (x: number, y: number): number => x * y;
Interfaces
Definición de interfaces
Una interface
permite definir la estructura de un objeto.
interface Persona {
nombre: string;
edad: number;
esEstudiante?: boolean;
}
const persona1: Persona = {
nombre: "Luis",
edad: 25
};
Interfaces para funciones
Las interfaces también pueden definir la estructura de una función.
interface Suma {
(a: number, b: number): number;
}
let miSuma: Suma = (x, y) => x + y;
Extender interfaces
Las interfaces pueden extenderse para heredar propiedades de otras.
interface Estudiante extends Persona {
matricula: number;
}
Clases y Programación Orientada a Objetos
Definición de clases
TypeScript soporta la programación orientada a objetos con clases, que incluyen propiedades y métodos.
class Persona {
nombre: string;
edad: number;
constructor(nombre: string, edad: number) {
this.nombre = nombre;
this.edad = edad;
}
saludar(): string {
return `Hola, me llamo ${this.nombre}`;
}
}
Modificadores de acceso
Los modificadores public
, private
, y protected
controlan la visibilidad de las propiedades y métodos.
class Estudiante {
public nombre: string;
private matricula: number;
constructor(nombre: string, matricula: number) {
this.nombre = nombre;
this.matricula = matricula;
}
obtenerMatricula(): number {
return this.matricula;
}
}
Herencia
Las clases pueden heredar de otras clases utilizando extends
.
class Profesor extends Persona {
especialidad: string;
constructor(nombre: string, edad: number, especialidad: string) {
super(nombre, edad);
this.especialidad = especialidad;
}
}
Clases abstractas
Las clases abstractas no pueden ser instanciadas directamente, solo pueden heredarse.
abstract class Animal {
abstract sonido(): void;
}
class Perro extends Animal {
sonido() {
console.log("Guau");
}
}
Generics
Definición de Generics
Los generics permiten escribir código reutilizable que funciona con múltiples tipos de datos.
function identidad<T>(arg: T): T {
return arg;
}
Generics en clases
Se pueden usar generics en clases para permitir diferentes tipos de propiedades.
class Caja<T> {
contenido: T;
constructor(contenido: T) {
this.contenido = contenido;
}
obtenerContenido(): T {
return this.contenido;
}
}
const cajaDeNumero = new Caja<number>(123);
Módulos y Namespaces
Importar y exportar módulos
Se puede dividir el código en varios archivos y usar export
e import
para compartir código entre ellos.
// archivoA.ts
export const PI = 3.14;
// archivoB.ts
import { PI } from './archivoA';
console.log(PI);
Namespaces
Los namespaces permiten agrupar código relacionado bajo un mismo nombre, útil para evitar conflictos de nombres.
namespace Geometria {
export function areaCirculo(radio: number): number {
return Math.PI * radio * radio;
}
}
console.log(Geometria.areaCirculo(5));
Decoradores
Decoradores de clases
Un decorador es una función especial que puede modificar el comportamiento de una clase o sus miembros.
function log(target: any) {
console.log(`Clase decorada: ${target.name}`);
}
@log
class MiClase {
constructor() {
console.log("Instancia creada");
}
}
Decoradores de métodos
Los decoradores de métodos permiten interceptar la ejecución de métodos.
function logLlamada(target: any, key: string, descriptor: PropertyDescriptor) {
const metodoOriginal = descriptor.value;
descriptor.value = function (...args: any[]) {
console.log(`Método llamado: ${key}`);
return metodoOriginal.apply(this, args);
};
}
class Calculadora {
@logLlamada
sumar(a: number, b: number): number {
return a + b;
}
}
Manejo de Promesas y Asíncronía
Funciones async/await
TypeScript soporta el manejo de promesas usando async
y await
para un código más limpio.
async function obtenerDatos(): Promise<string> {
return new Promise((resolve) => {
setTimeout(() => resolve("Datos obtenidos"), 1000);
});
}
async function mostrarDatos() {
const datos = await obtenerDatos();
console.log(datos);
}
Manejo de errores en async/await
El manejo de errores en funciones asíncronas se realiza con bloques try/catch
.
async function obtenerDatosConError() {
try {
const datos = await obtenerDatos();
console.log(datos);
} catch (error) {
console.error("Error al obtener los datos", error);
}
}
Configuración del tsconfig.json
Parámetros importantes en tsconfig.json
El archivo tsconfig.json
permite configurar las opciones de compilación de TypeScript.
{
"compilerOptions": {
"target": "es6", // Vers
ión de ECMAScript de salida
"module": "commonjs", // Sistema de módulos
"strict": true, // Activa todas las comprobaciones estrictas
"esModuleInterop": true, // Habilita la interoperabilidad con módulos ES6
"outDir": "./dist", // Directorio de salida
"rootDir": "./src" // Directorio de entrada
},
"include": ["src/**/*"], // Archivos incluidos en la compilación
"exclude": ["node_modules"] // Archivos excluidos de la compilación
}