Tipos en TypeScript: string, number, boolean y más

Los tipos de TypeScript describen qué clase de valor puede contener una variable. Escribes el tipo después de dos puntos, let name: string, y el compilador rechaza cualquier código que meta ahí un valor del tipo equivocado. Los tipos básicos son los siete primitivos de JavaScript más los tipos objeto para arrays y objetos.

let title: string = "TypeScript";
let version: number = 7;
let isStrict: boolean = true;
let big: bigint = 9007199254740993n;
let id: symbol = Symbol("id");
let nothing: null = null;
let notSet: undefined = undefined;

let scores: number[] = [90, 72, 85];
let user: { name: string; age: number } = { name: "Ada", age: 36 };

console.log(title, version, isStrict, big, id);
console.log(nothing, notSet);
console.log(scores, user);

Las anotaciones se comprueban en tiempo de compilación y después se eliminan. El programa que se ejecuta es JavaScript normal.

Los tipos primitivos

Los nombres de los tipos van en minúsculas. typeof en tiempo de ejecución devuelve las mismas palabras para la mayoría, así que typeof x === "number" es la forma de comprobar el tipo primitivo de un valor mientras el programa se ejecuta.

Anotaciones de tipo

Una anotación es : Type después de una variable, de un parámetro o de la lista de parámetros de una función. Los parámetros son donde más importan, porque TypeScript no puede adivinar qué pasará quien llame a la función.

function describe(name: string, age: number, admin: boolean): string {
    return `${name} (${age})${admin ? " [admin]" : ""}`;
}

let label: string = describe("Ada", 36, true);
console.log(label); // Ada (36) [admin]

// Without an annotation, TypeScript infers the type from the value:
let count = 10; // count: number
count = count + 1;
console.log(count); // 11

Cuando una variable se inicializa en la misma línea, la anotación suele sobrar: let count = 10 ya tiene tipo number. Las reglas para omitir tipos están en la página de inferencia de tipos.

Un tipo incorrecto es un error de compilación

Asigna un valor del tipo equivocado y el compilador se detiene antes de ejecutar nada:

// This does not compile: a string is not a number.
let port: number = 8080;
port = "3000";
console.log(port);

El compilador muestra:

index.ts(3,1): error TS2322: Type 'string' is not assignable to type 'number'.

La solución es convertir el valor, port = Number("3000"), o cambiar la anotación si la variable de verdad debe guardar texto.

number: no existe un tipo entero

JavaScript guarda todos los números como valores de coma flotante de 64 bits, así que TypeScript tiene un único tipo number. Los enteros son exactos hasta Number.MAX_SAFE_INTEGER (2 ** 53 - 1). A partir de ahí, usa bigint.

let price: number = 19.99;
let quantity: number = 3; // also number: no int type

console.log(Number.isInteger(quantity)); // true
console.log(Number.isInteger(price));    // false
console.log(Math.trunc(7 / 2));          // 3 (integer division)
console.log(0.1 + 0.2);                  // 0.30000000000000004

console.log(Number.MAX_SAFE_INTEGER);     // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 2); // 9007199254740992 (wrong)

let exact: bigint = 9007199254740991n + 2n;
console.log(exact); // 9007199254740993n

// @ts-expect-error: bigint and number cannot be mixed
const mixed = () => exact + 1;
console.log(exact + BigInt(1), Number(exact)); // 9007199254740994n 9007199254740992

bigint y number no se mezclan: exact + 1 es un error de compilación (TS2365: Operator '+' cannot be applied to types 'bigint' and '1'., donde '1' es el tipo literal del 1) y, si llegara a ejecutarse, también un TypeError en tiempo de ejecución. Convierte uno de los lados de forma explícita con BigInt(1) o Number(exact), sabiendo que Number redondea los valores que superan el rango seguro.

Si quieres un tipo que solo acepte números enteros, TypeScript no puede expresarlo para valores arbitrarios. Valida con Number.isInteger en el punto donde el valor entra en tu programa.

boolean

boolean tiene exactamente dos valores, true y false. Los valores que solo son truthy (1, "yes") no son booleanos, así que conviértelos con Boolean(x) o x !== 0.

let loggedIn: boolean = false;
const items: string[] = ["a", "b"];

const hasItems: boolean = items.length > 0;
const hasName: boolean = Boolean("Ada");

console.log(loggedIn, hasItems, hasName); // false true true

null y undefined

Con strict activado (el valor por defecto desde TypeScript 6.0), null y undefined son tipos separados y no forman parte de string, number ni de ningún otro tipo. Una variable que puede estar vacía lo indica con una unión:

let nickname: string | undefined;
console.log(nickname); // undefined

nickname = "Ace";
console.log(nickname.toUpperCase()); // ACE

let middleName: string | null = null;
console.log(middleName ?? "(none)"); // (none)

Leer una propiedad de un valor que podría ser undefined es un error de compilación hasta que lo compruebas. La página de null y undefined explica las comprobaciones, ?. y ??.

Arrays y objetos de un vistazo

Todo lo que no es primitivo es un tipo objeto. Las tres formas que encontrarás primero:

let tags: string[] = ["ts", "js"];               // array of strings
let point: { x: number; y: number } = { x: 1, y: 2 }; // object with two number properties
let greet: (name: string) => string = (n) => `hi ${n}`; // function type

Cada una tiene su propia página: arrays, tuplas (arrays de longitud fija), tipos objeto y tipos de función.

string, number, boolean frente a String, Number, Boolean

Los nombres con mayúscula son los tipos de los objetos envoltorio de JavaScript (new String("x")), no de los valores normales. Anota con los nombres en minúscula.

// This does not compile: String (the wrapper) is not string (the primitive).
const wrapped: String = "text";
const plain: string = wrapped;
console.log(plain);

index.ts(3,7): error TS2322: Type 'String' is not assignable to type 'string'.
  'string' is a primitive, but 'String' is a wrapper object. Prefer using 'string' when possible.

Cambia String por string en la primera línea y el bloque se ejecuta. Lo mismo vale para Number, Boolean, Symbol y BigInt. (Object es un caso distinto: acepta casi cualquier valor, primitivos incluidos; consulta los tipos objeto).

Otros tipos integrados

Hay algunos tipos más que aparecen pronto. Cada uno tiene su propia página.