Tipos Interfaces y Clases en TypeScript

En TypeScript, los tipos, interfaces y clases son herramientas fundamentales que ayudan a definir y organizar tu código de manera más estructurada y robusta. Vamos a ver cada uno de ellos en detalle.

Tipos en TypeScript

Los tipos en TypeScript definen la forma de los datos. TypeScript ofrece una variedad de tipos para ayudarte a describir la forma de los objetos que usarás en tu código.

Tipos Primitivos

Estos son similares a los tipos en JavaScript:

• number: Representa números, ya sean enteros o flotantes.
• string: Representa cadenas de texto.
• boolean: Representa valores verdaderos o falsos.
• null y undefined: Representan valores nulos y no definidos, respectivamente.

Tipos Compuestos

• Array<T> o T[]: Representa un array de elementos del tipo 'T'.
• Tuple: Representa un array de elementos con tipos predefinidos.

let tuple: [number, string] = [1, "hello"];

Tipos Especiales

• any: Representa cualquier tipo. Útil para cuando no se conoce el tipo de una variable con antelación.
• void: Usado típicamente para funciones que no devuelven un valor.
• never: Representa el tipo de valores que nunca ocurren. Por ejemplo, una función que nunca termina o que siempre va a saltar una exepción, nunca devolverá un valor, su tipo de retorno puede ser never. Es distinto de void, que indicaría que la función si termina de forma normal, pero no devuelve valor ninguno.
• union types: Permite que una variable tenga más de un tipo.

let value: string | number;

Tipos Personalizados

• type: Permite crear tipos personalizados.

  type Point = { x: number, y: number };
  let point: Point = { x: 10, y: 20 };

Interfaces en TypeScript

Las interfaces en TypeScript son una forma de definir la estructura de los objetos. Pueden describir la forma que debe tener un objeto, incluyendo sus propiedades y métodos.

Definición de una Interfaz

interface Person {
  name: string;
  age: number;
  greet(): void;
}

let person: Person = {
  name: "John",
  age: 30,
  greet() {
    console.log("Hello!");
  }
};

Extender Interfaces

Las interfaces pueden extenderse para crear nuevas interfaces basadas en otras existentes.

interface Employee extends Person {
  employeeId: number;
}

let employee: Employee = {
  name: "Jane",
  age: 25,
  greet() {
    console.log("Hello!");
  },
  employeeId: 1234
};

Clases en TypeScript

Las clases en TypeScript son una característica fundamental de la programación orientada a objetos. Definen la estructura y el comportamiento de los objetos que se crean a partir de ellas.

Definición de una Clase

class Animal {
  name: string;

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

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

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

Herencia

Las clases pueden extender otras clases, permitiendo reutilizar el código.

class Bird extends Animal {
  fly(distance: number) {
    console.log(`${this.name} flew ${distance} meters.`);
  }
}

let bird = new Bird("Eagle");
bird.move(10);
bird.fly(20);

Modificadores de Acceso

TypeScript introduce modificadores de acceso para controlar la visibilidad de las propiedades y métodos.

• public: Las propiedades y métodos son accesibles desde cualquier lugar. Si no ponemos modificador de acceso, este es el de defecto.
• private: Las propiedades y métodos solo son accesibles dentro de la clase.
• protected: Las propiedades y métodos son accesibles dentro de la clase y las clases derivadas.

class Person {
  public name: string;
  private age: number;
  protected address: string;

  constructor(name: string, age: number, address: string) {
    this.name = name;
    this.age = age;
    this.address = address;
  }
}

let john = new Person("John", 30, "123 Main St");
console.log(john.name); // Válido
// console.log(john.age); // Error: 'age' es privado
// console.log(john.address); // Error: 'address' es protegido