Desarrollo con TypeScript

Tipado de interfaces

Uno de los conceptos clave de TypeScript son las interfaces. Las interfaces son una forma de definir contratos para objetos que especifican qué propiedades y métodos deben tener.

Veamos un ejemplo de código que muestra cómo usar interfaces en TypeScript:

interface Person {
  firstName: string;
  lastName: string;
  age: number;
  greet(): string;
}

const john: Person = {
  firstName: "John",
  lastName: "Doe",
  age: 32,
  greet: () => {
    return `Hello, my name is ${this.firstName} ${this.lastName}`;
  },
}

console.log(john.greet())
// Output: "Hello, my name is John Doe"

En este ejemplo, se define una interface Person con cuatro propiedades y un método. Luego, se crea una constante john que implementa la interface Person. Al imprimir en la consola el resultado del método greet, se puede ver que el objeto john cumple con los requisitos especificados por la interface Person.

Clases

Otro concepto importante de TypeScript son las clases. Las clases son una forma de crear objetos basados en una plantilla que especifique los atributos y métodos que deben tener.

Veamos un ejemplo de código que muestra cómo usar clases en TypeScript:

class Person {
  firstName: string;
  lastName: string;
  age: number;

  constructor(firstName: string, lastName: string, age: number) {
    this.firstName = firstName;
    this.lastName = lastName;
    this.age = age;
  }

  greet(): string {
    return `Hello, my name is ${this.firstName} ${this.lastName}`;
  }
}

const john = new Person("John", "Doe", 32);

En este ejemplo, se define una clase Person con tres propiedades y dos métodos (el constructor y el método greet). Luego, se crea una constante john que es una instancia de la clase Person.

Como verás la gran diferencia es que en el primer caso utilizamos interfaces para poder trabajar con objetos literales asegurando el tipado, en cambio luego al usar clases dependemos de crear la instancia de la manera tradicional.

Módulos

Continuando con el ejemplo de la clase Person, vamos a profundizar en los módulos de TypeScript y cómo podemos aplicarlos para mejorar la organización de nuestro código.

En TypeScript, un módulo es una forma de organizar el código en diferentes secciones lógicas. Cada módulo puede tener sus propias variables, funciones y clases, y pueden ser importadas y exportadas entre los demás módulos.

Para empezar, vamos a crear un nuevo módulo para almacenar las funciones relacionadas con la API de Github:

// github.ts
export function getUsernameFromGithub(person: Person): string {
  // código para realizar la consulta a la API de Github
}

Y luego, en la clase Person, podemos importar y utilizar la función del módulo anterior:

// person.ts
import { getUsernameFromGithub } from "./github";

class Person {
  name: string;
  location: string;

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

  getLocationGPS(): string {
    // código para calcular la posición GPS
  }

  getGithubUsername(): string {
    return getUsernameFromGithub(this);
  }
}

Al utilizar módulos, podemos mantener el código organizado y separar las responsabilidades en diferentes archivos. Además, podemos reutilizar código fácilmente en otros proyectos al importar y exportar los módulos necesarios.

En resumen, los módulos en TypeScript nos permiten organizar el código de manera más eficiente y mantener una estructura clara en proyectos de mayor envergadura. Al utilizar módulos, podemos mejorar la legibilidad y la mantenibilidad del código, y hacerlo más fácil de reutilizar en el futuro.