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

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 = "Juan";
let esEstudiante: boolean = true;

Arrays

Los arraus se tipan indicando el tipo seguido de [].

let numeros: number[] = [1, 2, 3, 4];
let nombres: string[] = ["Juan", "María"];

Tuplas

Las tuplas permiten definir arraus con un número fijo de elementos de tipos específicos.

let persona: [string, number] = ["Juan", 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;

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;

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: "Juan",
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;
}

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");
}
}

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);

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 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;
}
}

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);
}
}

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
}