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

Arrays

Los arrays 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 arrays 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;

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

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
}