Utility Types

TypeScript provee una serie de utilidades para facilitar transformaciones entre tipos. Estas utilidades se encuentran de forma global.

Partial<Type>

Construye un tipo con todas las propiedades de Type como opcionales. Esta utilidad retorna un tipo que representa todos los subelementos del tipo provisto.

interface Tarea {
    titulo: string
    descripcion: string
}

function actualizarTodo(tarea: Tarea, camposActualizar: Partial<Tarea>) {
    return { ...tarea, ...camposActualizar }
}

const tarea1: Tarea = {
    titulo: 'Organizar escritorio',
    descripcion: 'Limpiar, ordenar y destruir material vencido',
}

const tarea2 = actualizarTodo(tarea1, {
    descripcion: 'Tirar la basura',
})

Required<Type>

Construye un tipo en el cual existen todas las propiedades de Type en donde los elementos que la componen son todos requeridos. Es decir lo opuesto a Partial<Type>.

interface Props {
    a?: number
    b?: string
}

const obj: Props = { a: 5 }

const obj1: Required<Props> = { a: 100 }

Readonly<Type>

Construye un tipo con todas las propiedades de Type definidas como readonly, lo que quiere decir que las propiedades del nuevo tipo no pueden ser reasignadas.

interface Tarea {
    titulo: string
}

const tarea: Readonly<Tarea> = {
    titulo: 'Eliminar usuarios inactivos',
}

tarea.titulo = 'Hola!' // <- esta línea generará un error

Record<Keys,Type>

Construye un objeto cuyas propiedades son Keys (llaves) y cuyos valores son Type. Esta utilidad puede ser utilizada para mapear propiedades de un tipo a otro.

interface GatoInfo {
    edad: number
    color: string
}

type GatoNombre = 'bolita' | 'michi' | 'rayas'

const gatos: Record<GatoNombre, GatoInfo> = {
    bolita: { edad: 10, color: 'Rojo' },
    michi: { edad: 15, color: 'Negro' },
    rayas: { edad: 21, color: 'Amarilla' },
}

Pick<Type, Keys>

Construye un tipo eligiendo un grupo de propiedades a partir de Type.

interface Tarea {
    titulo: string
    descripcion: string
    completado: boolean
}

type TareaReducido = Pick<Tarea, 'titulo' | 'descripcion'>

const tarea: TareaReducido = {
    titulo: 'Limpiar Recamara',
    descripcion: 'Poner en orden todo lo que existe en la recamara',
}

Omit<Type, Keys>

Construye un tipo tomando las propiedades de Type removiendo las Keys especificadas.

interface Tarea {
    titulo: string
    descripcion: string
    completado: boolean
}

type TareaPreview = Omit<Tarea, 'titulo'>

const tarea: TareaPreview = {
    completado: true,
    descripcion: 'Aqui la descripción de la tarea',
    titulo: 'Este es el título', // <- esta línea generará un error
}

Exclude<Type,UnionDeExcluidos>

Construye un tipo excluyendo de Type el resultado de la unión.

type T0 = Exclude<'a' | 'b' | 'c', 'c'>

// type T0 = "a" | "b"

Extract<Type,Union>

Construye un tipo extrayendo de Type basado en el resultado de la unión.

type T0 = Extract<'a' | 'b' | 'c', 'a' | 'c'>

// type T0 = "a" | "c"

NonNullable

Construye un tipo excluyendo null y undefined de Type.

type T0 = NonNullable<string | number | undefined | null>

// type T0 = string | number

Parameters<Type>

Construye una tupla de tipos a partir de los tipos utilizados en los parámetros de una función de tipo Type.

declare function f1(arg: { a: number; b: string }): void

type T0 = Parameters<() => string>

// type T0 = []

type T1 = Parameters<(s: string) => void>

// type T1 = [s: string]

type T2 = Parameters<<T>(arg: T) => T>

// type T2 = [arg: unknown]

type T3 = Parameters<typeof f1>

// type T3 = [arg: { a: number; b: string; }]

type T4 = Parameters<any>

// type T4 = unknown[]

type T5 = Parameters<never>

// type T5 = never

type T6 = Parameters<string>

// type T6 = never

type T7 = Parameters<Function>

// type T7 = never

ConstructorParameters<Type>

Construye una tupla o arreglo de tipos a partir de los tipos provistos a la función del constructor.

type T0 = ConstructorParameters<ErrorConstructor>

// type T0 = [message?: string]

type T1 = ConstructorParameters<FunctionConstructor>

// type T1 = string[]

type T2 = ConstructorParameters<RegExpConstructor>

// type T2 = [pattern: string | RegExp, flags?: string]

type T3 = ConstructorParameters<any>

// type T3 = unknown[]

type T4 = ConstructorParameters<Function> // <- error

// Type 'Function' does not satisfy the constraint 'new (...args: any) => any'.

ReturnType<Type>

Construye un tipo en base al Type del valor de retorno de una función.

declare function f1(): { a: number; b: string }

type T0 = ReturnType<() => string>

// type T0 = string

type T1 = ReturnType<() => void>

// type T1 = void

InstanceType<Type>

Construye un tipo a partir del tipo de instancia de la función constructor en Type.

type T0 = InstanceType<typeof C>

// type T0 = C

type T1 = InstanceType<any>

// type T1 = any

type T2 = InstanceType<never>

// type T2 = never

ThisParameterType<Type>

Extrae el tipo del parámetro this del tipo de una función, o unknown si la función no tiene un parámetro this.

function toHex(this: number) {
    return this.toString(16)
}

function numeroToString(n: ThisParameterType<typeof toHex>) {
    return toHex.apply(n)
}

Intrinsic Manypulation Types (Manipuladores Intrínsecos)

Uppercase<Type>
Lowercase<Type>
Capitalize<Type>
Uncapitalize<Type>

🔥 UTILITY TYPES