TypeSrcipt. Part 2

KeyOf

Оператор, который формирует литеральный тип из строк или чисел из типа

interface A { prop1: number; prop2: number; prop3: number; }

type B = keyof A; // B = 'prop1' | 'prop2' | 'prop3'

let b: B = 'prop1';

interface A { prop1: number; prop2: number; }

type B = { [K in keyof A]: any; };

const b: B = { prop1: 0, prop2: 1 };

Readonly, Readonly<T>

Оператор, который делает свойство типа только на чтение

Тип, который делает все свойства типа T только на чтение

interface A { readonly prop: number; }

type B = { readonly prop: number; };

type ReadonlyB = Readonly<B>;

class C { readonly prop = 0; }

const reaonlyD: ReadonlyArray<number> = [1, 2, 3];

const reaonlyE: readonly number[] = [10, 20, 30];

const reaonlyF: Readonly<number> = 10; // const reaonlyF = 10

const reaonlyF: Readonly<number> = 10; // const reaonlyF = 10

Partial<T>

Тип, который делает свойства типа T необязательными

interface A { AA: number; BB: number; CC: number; }

type B = Partial<A>; // interface B { AA?: number;… }

let b: B = { AA: 0 };

Omit<T, K>

Тип, который исключает из типа Т свойства

interface A { AA: number; BB: number; CC: number; }

type B = Omit<A, 'CC'>;

let b: B = { AA: 0, BB: 1 };

Pick<T, K>

Тип, который исключает из типа Т все свойства, кроме указанных

interface Todo { title: string; description: string; completed: boolean; }

type TodoPreview = Pick<Todo, 'title' | 'completed'>;

const todo: TodoPreview = { title: 'Clean room', completed: false };

Exclude<T, E>

Тип, который исключает значения из литеральных типов. Omit только для литеральных

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

type T1 = Exclude<'a' | 'b' | 'c', 'a' | 'b'>; // T1: 'c'

type T2 = Exclude<string | number | (() => void), Function>; // T2: string | number

Extract<T, E>

Тип, который исключает все значения литерального типов, кроме переданных. Pick только для литеральных

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

type T1 = Extract<'a' | 'b' | 'c', 'a' | 'b'>; // T1: 'a' | 'b'

type T2 = Extract<string | number | (() => void), Function>; // T2: () => void

NonNullable<T>

Тип, который не дает присваивать значения null и undefined

type T0 = NonNullable<string | number | undefined>; // T0 = string | number

type T1 = NonNullable<string[] | null | undefined>; // T1 = string[]

const t: T1 = null; // error. Type 'null' is not assignable to type 'string[]'

Parameters<T>

Тип, который формирует кортеж из входных параметров функции типа Т

type T0 = Parameters<() => string>; // type T0 = [];

const t0: T0 = []; const t0_2: T0 = [1, 2, 3]; // error. Type '[number, number, number]' is not assignable to type '[]'

type T1 = Parameters<(s: string) => void>; // T1 = [s: string]

const t1: T1 = ['str']; const t1_2: T1 = ['str1', 'str2']; // error. Type '[string, string]' is not assignable to type '[s: string]'

type T2 = Parameters<<T>(a: string, b: number) => boolean>; // T2 = [a: string, b: number]

const t2: T2 = ['atr', 2];

type T4 = Parameters<any>; // T4 = unknown[]

type T5 = Parameters<never>; // T5 = never

type T6 = Parameters<string>; // error

type T7 = Parameters<Function>; // error

Есть подобные тип:

ConstructorParameters<Type>
ReturnType<Type>
InstanceType<Type>
ThisParameterType<Type>
OmitThisParameter<Type>
ThisType<Type>

Record<U, T>

Тип, который формирует новый тип с полями из литерального типа U, где в свою очередь типы этих полей является типом T

interface ICat { age: number; breed: string; }

type CatName = 'BORIS' | 'MURKA' | 'KISS KISS';

const cats: Record<CatName, ICat> = { BORIS: { age: 10, breed: 'Persian' }, MURKA: { age: 5, breed: 'Maine Coon' }, ['KISS KISS']: { age: 16, breed: 'British Shorthair' } };

const objs: Record<'A' | 'B', { aa: boolean, bb: number }> = { A: { aa: true, bb: 1 }, B: { aa: false, bb: 2 } };

interface A { A: number; B: string; }

const objs: Record<keyof A, { aa: boolean, bb: number }> = {

A: { aa: true, bb: 1 },

B: { aa: false, bb: 2 }

};

Intrinsic String Manipulation Types

Встроенные типы манипуляций со строками

let upperText:Uppercase<string>;

upperText = "HELLO, WORLD"; upperText = "Hello, World"; // error. Type 'string' is not assignable to type 'Uppercase<string>'

let lowerText:Lowercase<string>; lowerText = "hello, world";

let capitalizeText:Capitalize<string>;

capitalizeText = "Hello, world";

let uncapitalizeText:Uncapitalize<string>;

uncapitalizeText = "hELLO, WORLD";