TypeScript: Sintaxis

TypeScript es un superset tipado de JavaScript que se compila a JavaScript puro. La sintaxis de TypeScript introduce algunas características adicionales que permiten escribir código más robusto y mantenible. A continuación, se describen los aspectos fundamentales de la sintaxis de TypeScript.

Tipos básicos

TypeScript ofrece tipos básicos que ayudan a definir el tipo de datos que una variable puede almacenar.

let isDone: boolean = false;
let decimal: number = 6;
let color: string = "blue";
let list: number[] = [1, 2, 3];
let x: [string, number];
x = ["hello", 10];

Interfaces

Las interfaces en TypeScript permiten definir la estructura de un objeto. Esto es útil para asegurar que un objeto tenga ciertas propiedades y tipos.

interface Person {
    firstName: string;
    lastName: string;
    age: number;
}

function greet(person: Person) {
    return `Hello, ${person.firstName} ${person.lastName}`;
}

let user = { firstName: "Jane", lastName: "Doe", age: 25 };
console.log(greet(user));

Clases

TypeScript soporta el concepto de clases, similar a otros lenguajes orientados a objetos. Las clases pueden tener propiedades y métodos.

class Animal {
    private name: string;

    constructor(name: string) {
        this.name = name;
    }

    public move(distance: number): void {
        console.log(`${this.name} moved ${distance} meters.`);
    }
}

let dog = new Animal("Dog");
dog.move(10);

Funciones

Las funciones en TypeScript pueden tener tipos de retorno y tipos para sus parámetros. También es posible definir funciones anónimas y funciones de flecha.

function add(x: number, y: number): number {
    return x + y;
}

let myAdd = (x: number, y: number): number => x + y;

Tipos avanzados

TypeScript incluye tipos avanzados como uniones, intersecciones y tipos genéricos, que permiten escribir código más flexible.

// Uniones
let value: string | number;
value = "hello";
value = 42;

// Tipos genéricos
function identity<T>(arg: T): T {
    return arg;
}

let output = identity<string>("myString");

Módulos

TypeScript soporta el uso de módulos para organizar el código en diferentes archivos y reutilizar componentes.

// math.ts
export function add(x: number, y: number): number {
    return x + y;
}

// main.ts
import { add } from "./math";
console.log(add(5, 3));

Decoradores

Los decoradores son una característica experimental en TypeScript que permite añadir metadatos a las clases y sus miembros.

function readonly(target: any, propertyKey: string, descriptor: PropertyDescriptor) {
    descriptor.writable = false;
}

class Person {
    @readonly
    name: string = "Jane";

    constructor(name: string) {
        this.name = name;
    }
}