Ejemplo (3): haciendo las funciones de control de datos

Para manipular datos JSON con seguridad y claridad en TypeScript, lo primero que debemos hacer es definir tipos personalizados que representen la estructura de esos datos. Aunque TypeScript cuenta con un sistema de inferencia bastante potente que puede deducir tipos al importar un JSON, crear manualmente nuestras interfaces nos permite entender mejor el proceso y controlar con precisión cómo trabajamos con esos datos.

Empezamos definiendo una interfaz para representar un club. Esta interfaz incluye un nombre de tipo string, un código que puede ser string o null, y un país también como string. Así, tenemos una estructura clara para cada club dentro de nuestro sistema.

export interface Club {
  name: string;
  code: string | null;
  country: string;
}

Luego, definimos otra interfaz para agrupar estos clubes bajo un nombre general, que también es un string, y un array de clubes.

export interface Clubs {
  name: string;
  clubs: Club[];
}

Cuando pasamos a los resultados de partidos, la estructura es un poco más compleja. Tenemos un nombre general y un array de partidos, donde cada partido contiene información como la ronda, la fecha (como string), los dos equipos participantes y, opcionalmente, un marcador. Este marcador es un objeto que incluye un campo llamado ft, que es una tupla con dos números, representando el resultado final.

export interface Match {
  round: string;
  date: string;
  team1: string;
  team2: string;
  score?: {
    ft: [number, number];
  };
}

export interface Matches {
  name: string;
  matches: Match[];
}

Con estas interfaces definidas, podemos cargar nuestros archivos JSON y tiparlos adecuadamente. Por ejemplo, al importar clubs.json, lo tipamos como Clubs, y al importar results.json, como Matches. Es importante recordar que TypeScript no valida en tiempo de ejecución que los datos realmente coincidan con estos tipos; simplemente asume que son correctos. Por eso, si los datos no cumplen con la estructura esperada, el programa puede fallar en ejecución.

Para trabajar con estos datos, creamos funciones que nos permitan buscar información específica. Por ejemplo, una función getClub que recibe un código de equipo y devuelve el objeto Club correspondiente. Utilizamos el método find de los arrays para buscar el club cuyo código coincida con el proporcionado.

function getClub(code: string): Club {
  const club = clubs.clubs.find(club => club.code === code);
  if (!club) {
    throw new Error(`No existe este equipo: ${code}`);
  }
  return club;
}

Aquí, añadimos una comprobación para lanzar un error si no se encuentra ningún club con ese código, evitando así devolver un valor undefined que podría causar problemas más adelante.

De manera similar, para obtener un partido entre dos equipos, creamos una función que recibe los nombres de ambos equipos y busca en el array de partidos un encuentro que coincida con esos equipos. Si no se encuentra, también lanzamos un error.

function getMatch(eq1: string, eq2: string): Match {
  const match = results.matches.find(
    match => match.team1 === eq1 && match.team2 === eq2
  );
  if (!match) {
    throw new Error(`No existe este partido este año: ${eq1} vs ${eq2}`);
  }
  return match;
}

Aunque estas funciones son sencillas y utilizan programación funcional con métodos de arrays, debemos tener en cuenta que su rendimiento puede no ser óptimo para grandes volúmenes de datos, ya que la búsqueda es lineal. Para mejorar esto, podríamos considerar estructuras de datos más eficientes como mapas o tablas hash, pero para fines didácticos y simplicidad, esta aproximación es suficiente.

Finalmente, estas funciones pueden integrarse en un servidor web para responder a peticiones que soliciten información sobre equipos o partidos, proporcionando así una API sencilla y segura basada en tipos bien definidos.