Tipos básicos y anotaciones

// Anotamos TODO de forma explícita: lo más directo cuando empiezas con tipos.

// Parámetros y retorno anotados a mano.
function winrate(victorias: number, partidas: number): number {
  return victorias / partidas;
}

// Igual: parámetro y retorno explícitos.
function formatearPorcentaje(ratio: number): string {
  return (ratio * 100).toFixed(1) + "%";
}

// Cada variable con su tipo escrito a mano.
const nombre: string = "Tracer";
const partidas: number = 120;
const victorias: number = 78;

// Array de números.
const porSemana: number[] = [12, 8, 15, 20];

// Lo dejamos como any para que "compile y ya": funciona, pero apaga la seguridad.
let datoExterno: any;

// reduce sobre el array de números.
const totalSemanas: number = porSemana.reduce(
  (suma: number, n: number) => suma + n,
  0,
);

// Pinta el resumen.
console.log(`Jugadora: ${nombre}`);
console.log(`Winrate: ${formatearPorcentaje(winrate(victorias, partidas))}`);
console.log(`Partidas últimas semanas: ${totalSemanas}`);

// Anotamos SOLO donde aporta —las firmas de las funciones— y dejamos que
// TypeScript infiera el resto. Menos ruido, mismo tipado.

// La firma es el contrato de la función: ahí sí anotamos params y retorno.
function winrate(victorias: number, partidas: number): number {
  return victorias / partidas;
}

function formatearPorcentaje(ratio: number): string {
  return (ratio * 100).toFixed(1) + "%";
}

// Inferidas: el valor inicial ya fija el tipo (string, number, number).
const nombre = "Tracer";
const partidas = 120;
const victorias = 78;

// El literal [12, 8, 15, 20] ya se infiere como number[]: no hace falta anotarlo.
const porSemana = [12, 8, 15, 20];

// Nada de any: si el dato es desconocido, unknown no miente diciendo que vale todo.
let datoExterno: unknown;

// suma y n se infieren como number a partir de porSemana.
const totalSemanas = porSemana.reduce((suma, n) => suma + n, 0);

// Pinta el resumen.
console.log(`Jugadora: ${nombre}`);
console.log(`Winrate: ${formatearPorcentaje(winrate(victorias, partidas))}`);
console.log(`Partidas últimas semanas: ${totalSemanas}`);

// Equilibrio senior: dejamos que TypeScript infiera los valores locales, pero
// anotamos las FIRMAS de las funciones como contrato explícito. Así, si alguien
// cambia sin querer lo que devuelve una función, el error salta AQUÍ, en la
// función, y no a tres llamadas de distancia.

// Contrato explícito: recibe dos number, devuelve number.
function winrate(victorias: number, partidas: number): number {
  return victorias / partidas;
}

// Contrato explícito: recibe number, devuelve string.
function formatearPorcentaje(ratio: number): string {
  return (ratio * 100).toFixed(1) + "%";
}

// Locales: inferidos. El valor inicial ya fija el tipo, anotarlos sería ruido.
const nombre = "Tracer";
const partidas = 120;
const victorias = 78;

// Inferido como number[].
const porSemana = [12, 8, 15, 20];

// Dato externo (de un formulario o una API): entra como unknown, nunca como any.
// any apagaría la red de seguridad justo donde más falta hace: en datos de fuera.
const datoExterno: unknown = 5;

// Y aquí está el porqué de unknown frente a any: para USARLO hay que comprobar su
// tipo antes. typeof estrecha datoExterno a number dentro del if; si llegara un
// texto o un null, el if no entraría y no lo sumaríamos a ciegas.
let partidasExtra = 0;
if (typeof datoExterno === "number") {
  // Dentro del if, datoExterno ya es number: sumarlo es seguro.
  partidasExtra = datoExterno;
}

// suma y n se infieren como number; le añadimos las partidas externas ya validadas.
const totalSemanas = porSemana.reduce((suma, n) => suma + n, 0) + partidasExtra;

// Pinta el resumen.
console.log(`Jugadora: ${nombre}`);
console.log(`Winrate: ${formatearPorcentaje(winrate(victorias, partidas))}`);
console.log(`Partidas últimas semanas: ${totalSemanas}`);