TypeScript: Tipos intermedios y avanzados

TypeScript ofrece una robusta tipificación estática que permite escribir código más seguro y mantenible. Este módulo aborda los tipos de datos avanzados en TypeScript, incluyendo tipos condicionales, mapeados, de unión e intersección.

Tipos condicionales

Los tipos condicionales permiten definir tipos basados en una condición. La sintaxis básica es T extends U ? X : Y. Esto significa que si T extiende de U, el tipo resultante será X; en caso contrario, será Y.

type NonNullable<T> = T extends null | undefined ? never : T;

type T1 = NonNullable<string | null>; // string
type T2 = NonNullable<number | undefined>; // number

En el ejemplo anterior, NonNullable elimina null y undefined de T.

Tipos mapeados

Los tipos mapeados permiten crear nuevos tipos transformando propiedades de un tipo existente. Utilizan la sintaxis { [P in K]: T }, donde P es el nombre de la propiedad y K es un conjunto de claves.

type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

interface User {
    id: number;
    name: string;
}

type ReadonlyUser = Readonly<User>;
// ReadonlyUser es equivalente a:
// {
//     readonly id: number;
//     readonly name: string;
// }

En este ejemplo, Readonly transforma todas las propiedades de T en propiedades de solo lectura.

Tipos de unión e intersección

Los tipos de unión (|) permiten que una variable sea de uno de varios tipos. Por otro lado, los tipos de intersección (&) combinan múltiples tipos en uno solo.

type ID = string | number;
type User = {
    id: ID;
    name: string;
};

type Admin = User & {
    privileges: string[];
};

const admin: Admin = {
    id: 1,
    name: 'Alice',
    privileges: ['manage-users', 'edit-settings']
};

Aquí, ID puede ser un string o un number, mientras que Admin combina User con un conjunto adicional de privileges.

Tipos inferidos

TypeScript puede inferir tipos automáticamente, lo que facilita la escritura de código sin especificar explícitamente cada tipo.

const user = {
    id: 1,
    name: 'Alice'
};

function getUser(id: number) {
    return user;
}

const newUser = getUser(1);
// TypeScript infiere que newUser es de tipo { id: number; name: string; }

La inferencia de tipos ayuda a mantener el código limpio y legible.

Tipos utilitarios

TypeScript incluye varios tipos utilitarios en su biblioteca estándar, como Partial, Required, Readonly, Pick, Omit, entre otros.

interface User {
    id: number;
    name: string;
    email?: string;
}

type PartialUser = Partial<User>;
// PartialUser es equivalente a:
// {
//     id?: number;
//     name?: string;
//     email?: string;
// }

type RequiredUser = Required<User>;
// RequiredUser es equivalente a:
// {
//     id: number;
//     name: string;
//     email: string;
// }

Estos tipos utilitarios permiten realizar transformaciones comunes sin necesidad de definir nuevos tipos manualmente.