备案控制台
探索云世界
开发者社区 开发与运维 文章 正文

小结：近五十个常用 TypeScript类型工具 的声明、描述、用法示例

2024-01-29 126
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 小结：近五十个常用 TypeScript类型工具 的声明、描述、用法示例

TypeScript小结：近五十个常用TypeScript类型工具的声明、描述、用法示例

本文总结 TypeScript 中常用的类型工具。其中很多类型工具，在 TypeScript 中已经自带性地声明，可以直接使用。

1. 总览

类型工具 描述
Partial<T> 构造T的所有属性都设置为可选的类型。
Required<T> 构造T的所有属性都设置为required的类型。
Readonly<T> 构造T的所有属性都设置为readonly的类型。
Record<K, T> 用T类型的一组属性K构造一个类型。
Pick<T, K> 通过从T中选取属性集K来构造类型。
Omit<T, K> 通过从K中省略属性集K来构造类型。
Exclude<T, U> 通过从T中排除所有可赋给U的属性来构造类型。
Extract<T, U> 通过从T中提取所有可赋给U的属性来构造类型。
NonNullable<T> 通过从 T 中排除 null 和 undefined 来构造类型。
ReturnType<T> 构造一个由函数 T 的返回类型组成的类型。
Parameters<T> 构造一个元组类型，由函数 T 的参数类型组成。
ConstructorParameter<T> 构造一个元组类型，由构造函数t的参数类型组成。
ThisType<T> 构造一个表示函数中 this 类型的类型。
RequiredKeys<T> 构造一个由所需的 T 的键组成的类型。
Mutable<T> 构造 T 的所有属性都设置为可变的类型。
RequiredExcept<T, K> 构造T的所有属性都设置为 required 的类型，k中指定的属性除外。
ReadonlyExcept<T, K> 构造 T 的所有属性都设置为 readonly 的类型，K中指定的属性除外。
MutableExcept<T, K> 构造一个类型，其中 T 的所有属性都设置为可变，K 中指定的属性除外。
PickByValue<T, V> 通过选取值为 V 类型的 T 的属性来构造类型。
OmitByValue<T, V> 通过省略 T 的值为 V 类型的属性来构造类型。
Intersection<T, U> 构造一个由 T 和 U 中的所有属性组成的类型。
Diff<T, U> 构造一个类型，它包含T中但U中没有的所有属性。
Subtract<T, U> 构造一个类型，由T中但不在 T 和 U 的交集中的所有属性组成。
Overwrite<T, U> 构造一个由 T 和 U 的所有属性组成的类型，其中 U 的属性覆盖 T 的同名属性。
UnionToIntersection<T> 构造一个类型，该类型由 T 中所有类型的交集中的所有属性组成。
FunctionKeys 造一个由T的键组成的类型，这些键是函数。
NonFunctionKeys 构造一个由 T 的非函数键组成的类型。
PromiseType 构造一个由 Promise-like 类型 T 的已解析类型组成的类型。
DeepReadonly<T> 构造一个 T 的所有属性都递归设置为只读的类型。
DeepPartial<T> 递归地构造 T 的所有属性都设置为可选的类型。
ValueOf<T> 构造由 T 中所有值的并集组成的类型。
OptionalKeys<T> 构造一个由 T 的可选键组成的类型。
ReadonlyKeys<T> 构造一个由 T 的只读键组成的类型。
WritableKeys 构造一个由 T 的可写键组成的类型。
DeepRequired<T> 递归地构造 T 的所有属性都设置为 required 的类型。
DeepWritable<T> 构造 T 的所有属性都设置为可递归写的类型。
DeepNonNullable 构造一个类型，其中 T 的所有属性都递归地设置为 non-nullable。
Immutable<T> 构造 T 的所有属性都设置为不可变的类型。
Unionize 构造 T 中所有可能的性质排列的联合类型。
Exclusive<T, U> 通过从 T 中挑选所有不属于 T 或 U 的属性来构造类型。
Intersect<T, U> 通过从 T 中选取所有也在 U 中的属性来构造类型。
Assign<T, U> 通过从 T 和 U 中选取所有属性并将它们合并在一起来构造一个类型。
DeepMutable<T> 构造一个 T 的所有属性都设置为可变递归的类型。
Promisable<T> 构造一个 T 的所有属性都设置为 Promisable 的类型。
Awaited<T> 构造一个类型，将 T 的所有属性设置为 awaited 类型。
Brand<T, U> 通过用附加的 U 类型包装 T 来构造一个标称类型。
NonUndefined<T> 通过从 T 中选取所有未定义的属性来构造类型。

2. 详解

2.1 Partial<T>

type Partial<T> = {
  [P in keyof T]?: T[P];
};

构造T的所有属性都设置为可选的类型。

示例：

interface User {
   name: string;
   age: number;
 }
 type PartialUser = Partial<User>;

PartialUser 相当于:

{
  name?: string | undefined;
  age?: number | undefined;
}

2.2 Required<T>

type Required<T> = {
  [P in keyof T]-?: T[P];
};

构造T的所有属性都设置为required的类型。

示例：

interface User {
  name?: string;
  age?: number;
}
type RequiredUser = Required<User>;

RequiredUser 相当于:

{
 name: string;
 age: number;
}

2.3 Readonly<T>

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

构造T的所有属性都设置为readonly的类型。

示例：

interface User {
  name: string;
  age: number;
}
type ReadonlyUser = Readonly<User>;

ReadonlyUser 相当于:

{
 readonly name: string;
 readonly age: number;
}

2.4 Record<K, T>

type Record<K extends keyof any, T> = {
  [P in K]: T;
};

用T类型的一组属性K构造一个类型。

示例：

type User = {
  name: string;
  age: number;
}
type UserRecord = Record<string, User>;

UserRecord 相当于:

{
  [x: string]: User;
}

2.5 Pick<T, K>

type Pick<T, K extends keyof T> = {
  [P in K]: T[P];
};
> 通过从T中选取属性集K来构造类型。
 示例：
 interface User {
   name: string;
   age: number;
   email: string;
 }
 type UserWithoutEmail = Pick<User, 'name' | 'age'>;

UserWithoutEmail 相当于:

{
   name: string;
   age: number;
 }

2.6 Omit<T, K>

type Omit<T, K extends keyof any> = Pick<T, Exclude<keyof T, K>>;

通过从K中省略属性集K来构造类型。

示例：

interface User {
  name: string;
  age: number;
  email: string;
}
type UserWithoutEmail = Omit<User, 'email'>;

UserWithoutEmail 相当于:

{
  name: string;
  age: number;
}

2.7 Exclude<T, U>

type Exclude<T, U> = T extends U ? never : T;

通过从T中排除所有可赋给U的属性来构造类型。

示例：

type User = {
  name: string;
  age: number;
  email: string | null;
}
type UserWithoutNullableEmail = Exclude<User, { email: null }>;

UserWithoutNullableEmail 相当于:

{
  name: string;
  age: number;
  email: string;
}

2.8 Extract<T, U>

type Extract<T, U> = T extends U ? T : never;

通过从T中提取所有可赋给U的属性来构造类型。

示例：

type User = {
  name: string;
  age: number;
  email: string | null;
}
type UserWithNullableEmail = Extract<User, { email: null }>;

UserWithNullableEmail 相当于:

{
  name: string;
  age: number;
  email: string | null;
}

2.9 NonNullable<T>

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

通过从 T 中排除 null 和 undefined 来构造类型。

示例：

type User = {
  name: string;
  age: number;
  email: string | null;
}
type UserWithNonNullEmail = {
  [K in keyof User]: NonNullable<User[K]>;
};

UserWithNonNullEmail 相当于:

{
  name: string;
  age: number;
  email: string;
}

2.10 ReturnType<T>

type ReturnType<T extends (...args: any[]) => any> = T extends (...args: any[]) => infer R ? R : any;

构造一个由函数 T 的返回类型组成的类型。

示例：

function getUser() {
  return {
    name: 'John',
    age: 30,
  };
}
type User = ReturnType<typeof getUser>;

User 相当于:

{
  name: string;
  age: number;
}

2.11 Parameters<T>

type Parameters<T extends (...args: any[]) => any> = T extends (...args: infer P) => any ? P : never;

构造一个元组类型，由函数 T 的参数类型组成。

示例：

function updateUser(name: string, age: number) {
  ...
}
type UpdateUserParams = Parameters<typeof updateUser>;

UpdateUserParams 相当于:

[string, number]

2.12 ConstructorParameter<T>

type ConstructorParameters<T extends new (...args: any[]) => any> = T extends new (...args: infer P) => any ? P : never;

构造一个元组类型，由构造函数t的参数类型组成。

示例：

class User {
  constructor(name: string, age: number) {
    ...
  }
}
type UserConstructorParams = ConstructorParameters<typeof User>;

UserConstructorParams 相当于:

[string, number]

2.13 ThisType<T>

type ThisType<T> = { [K in keyof T]: T[K] } & { new(...args: any[]): T };

构造一个表示函数中 this 类型的类型。

示例：

interface User {
  name: string;
  age: number;
  greet(this: User): void;
}
const user: User = {
  name: 'John',
  age: 30,
  greet() {
    console.log(`Hello, my name is ${this.name} and I am ${this.age} years old.`);
  },
};
user.greet(); logs "Hello, my name is John and I am 30 years old."

2.14 RequiredKeys<T>

type RequiredKeys<T> = {
  [K in keyof T]-?: {} extends Pick<T, K> ? never : K
}[keyof T];

构造一个由所需的 T 的键组成的类型。

示例：

interface User {
  name: string;
  age?: number;
  email?: string;
}
type RequiredUserKeys = RequiredKeys<User>;

RequiredUserKeys 相当于:

'name'

2.15 Mutable<T>

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

构造 T 的所有属性都设置为可变的类型。

示例：

interface User {
  readonly name: string;
  readonly age: number;
}
type MutableUser = Mutable<User>;

MutableUser 相当于:

{
  name: string;
  age: number;
}

2.16 RequiredExcept<T, K>

type RequiredExcept<T, K extends keyof T> = {
  [P in keyof T]-?: P extends K ? T[P] : NonNullable<T[P]>;
};

构造T的所有属性都设置为 required 的类型，k中指定的属性除外。

示例：

interface User {
  name?: string;
  age?: number;
  email?: string;
}
type RequiredUserExceptEmail = RequiredExcept<User, 'email'>;

RequiredUserExceptEmail 相当于:

{
  name: string;
  age: number;
  email?: string;
}

2.17 ReadonlyExcept<T, K>

type ReadonlyExcept<T, K extends keyof T> = {
  readonly [P in keyof T]-?: P extends K ? T[P] : T[P];
};

构造 T 的所有属性都设置为 readonly 的类型，K中指定的属性除外。

示例：

interface User {
  readonly name: string;
  readonly age: number;
  readonly email: string;
}
type MutableUserExceptEmail = ReadonlyExcept<User, 'email'>;

MutableUserExceptEmail 相当于:

{
  readonly name: string;
  readonly age: number;
  email: string;
}

2.18 MutableExcept<T, K>

type MutableExcept<T, K extends keyof T> = {
  -readonly [P in keyof T]-?: P extends K ? T[P] : T[P];
};

构造一个类型，其中 T 的所有属性都设置为可变，K 中指定的属性除外。

示例：

interface User {
  readonly name: string;
  readonly age: number;
  readonly email: string;
}
type MutableUserExceptEmail = MutableExcept<User, 'email'>;

MutableUserExceptEmail 相当于:

{
  name: string;
  age: number;
  email: string;
}

2.19 PickByValue<T, V>

type PickByValue<T, V> = Pick<T, { [P in keyof T]-?: T[P] extends V ? P : never }[keyof T]>;

通过选取值为 V 类型的 T 的属性来构造类型。

示例：

interface User {
  name: string;
  age: number;
  email: string | null;
}
type UserWithEmail = PickByValue<User, string>;

UserWithEmail 相当于:

{
  name: string;
  email: string | null;
}

2.20 OmitByValue<T, V>

通过省略 T 的值为 V 类型的属性来构造类型。

示例：

interface User {
  name: string;
  age: number;
  email: string | null;
}
type UserWithoutEmail = OmitByValue<User, string | null>;

UserWithoutEmail 相当于:

{
  age: number;
}
type OmitByValue<T, V> = Pick<T, { [P in keyof T]-?: T[P] extends V ? never : P }[keyof T]>;

2.21 Intersection<T, U>

type Intersection<T, U> = Pick<T & U, keyof T & keyof U>;

构造一个由 T 和 U 中的所有属性组成的类型。

示例：

interface User {
  name: string;
  age: number;
}
interface Admin {
  name: string;
  age: number;
  role: string;
}
type UserAndAdmin = Intersection<User, Admin>;

UserAndAdmin 相当于:

{
  name: string;
  age: number;
}

2.22 Diff<T, U>

type Diff<T, U> = Pick<T, Exclude<keyof T, keyof U>>;

构造一个类型，它包含T中但U中没有的所有属性。

示例：

interface User {
  name: string;
  age: number;
}
interface Admin {
  name: string;
  age: number;
  role: string;
}
type UserWithoutAdmin = Diff<User, Admin>;

UserWithoutAdmin 相当于:

{
  name: string;
  age: number;
}

2.23 Subtract<T, U>

type Subtract<T, U> = Pick<T, Exclude<keyof T, keyof U>>;

构造一个类型，由T中但不在 T 和 U 的交集中的所有属性组成。

示例：

interface User {
  name: string;
  age: number;
  email: string;
}
interface Admin {
  name: string;
  age: number;
  role: string;
}
type UserWithoutCommon = Subtract<User, Admin>;

UserWithoutCommon 相当于:

{
  email: string;
}

2.24 Overwrite<T, U>

type Overwrite<T, U> = Pick<T, Exclude<keyof T, keyof U>> & U;

构造一个由 T 和 U 的所有属性组成的类型，其中 U 的属性覆盖 T 的同名属性。

示例：

interface User {
  name: string;
  age: number;
}
interface PartialUser {
  name?: string;
}
type UserWithPartial = Overwrite<User, PartialUser>;

UserWithPartial 相当于:

{
  name?: string;
  age: number;
}

2.25 UnionToIntersection<T>

type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;

构造一个类型，该类型由 T 中所有类型的交集中的所有属性组成。

示例：

interface User {
  name: string;
  age: number;
}
interface Admin {
  name: string;
  role: string;
}
type UserAndAdminIntersection = UnionToIntersection<User | Admin>;

UserAndAdminIntersection 相当于:

{
  name: string;
}

2.26 FunctionKeys

构造一个由T的键组成的类型，这些键是函数。

示例：

interface User {
  name: string;
  age: number;
  greet(): void;
}
type UserFunctionKeys = FunctionKeys<User>;

UserFunctionKeys 相当于:

'greet'
type FunctionKeys<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T];

2.27 NonFunctionKeys

type NonFunctionKeys<T> = { [K in keyof T]: T[K] extends Function ? never : K }[keyof T];

构造一个由 T 的非函数键组成的类型。

示例：

interface User {
  name: string;
  age: number;
  greet(): void;
}
type UserNonFunctionKeys = NonFunctionKeys<User>;

UserNonFunctionKeys 相当于:

'name' | 'age'

2.28 PromiseType

type PromiseType<T extends Promise<any>> = T extends Promise<infer U> ? U : never;

构造一个由 Promise-like 类型 T 的已解析类型组成的类型。

示例：

type User = {
  name: string;
  age: number;
};
type UserPromise = Promise<User>;
type UserResolved = PromiseType<UserPromise>;

UserResolved 相当于:

{
  name: string;
  age: number;
}

2.29 DeepReadonly<T>

type DeepReadonly<T> = {
  readonly [P in keyof T]: T[P] extends object ? DeepReadonly<T[P]> : T[P];
};

构造一个 T 的所有属性都递归设置为只读的类型。

示例：

interface User {
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}
type DeepReadonlyUser = DeepReadonly<User>;

DeepReadonlyUser 相当于:

{
  readonly name: string;
  readonly age: number;
  readonly address: {
    readonly street: string;
    readonly city: string;
  };
}

2.30 DeepPartial<T>

type DeepPartial<T> = {
  [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};

递归地构造 T 的所有属性都设置为可选的类型。

示例：

interface User {
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}
type DeepPartialUser = DeepPartial<User>;

DeepPartialUser 相当于:

{
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}

2.31 ValueOf<T>

type ValueOf<T> = T[keyof T];

构造由 T 中所有值的并集组成的类型。

示例：

type User = {
  id: number;
  name: string;
};
//
type UserValues = ValueOf<User>;

UserValues 相当于:

number | string

2.32 OptionalKeys<T>

type OptionalKeys<T> = { [K in keyof T]-?: {} extends Pick<T, K> ? K : never }[keyof T];

构造一个由 T 的可选键组成的类型。

示例：

interface User {
  id: number;
  name: string;
  age?: number;
}
type UserOptionalKeys = OptionalKeys<User>;

UserOptionalKeys 相当于:

'age'

2.33 ReadonlyKeys<T>

type ReadonlyKeys<T> = { [K in keyof T]-?: T[K] extends Readonly<T[K]> ? K : never }[keyof T];

构造一个由 T 的只读键组成的类型。

示例：

interface User {
  readonly id: number;
  name: string;
  age?: number;
}
type UserReadonlyKeys = ReadonlyKeys<User>;

UserReadonlyKeys 相当于:

'id'

2.34 WritableKeys

type WritableKeys<T> = { [K in keyof T]-?: T[K] extends Readonly<T[K]> ? never : K }[keyof T];

构造一个由 T 的可写键组成的类型。

示例：

interface User {
  readonly id: number;
  name: string;
  age?: number;
}
type UserWritableKeys = WritableKeys<User>;
UserWritableKeys 相当于:
'name' | 'age'

2.35 DeepRequired<T>

type DeepRequired<T> = {
  [P in keyof T]-?: T[P] extends object ? DeepRequired<T[P]> : T[P];
};

递归地构造 T 的所有属性都设置为 required 的类型。

示例：

interface User {
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}
type DeepRequiredUser = DeepRequired<User>;

DeepRequiredUser 相当于:

{
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}

2.36 DeepWritable<T>

type DeepWritable<T> = {
  -readonly [P in keyof T]-?: T[P] extends object ? DeepWritable<T[P]> : T[P];
};

构造 T 的所有属性都设置为可递归写的类型。

示例：

interface User {
  readonly name?: string;
  readonly age?: number;
  readonly address?: {
    readonly street?: string;
    readonly city?: string;
  };
}
type DeepWritableUser = DeepWritable<User>;

DeepWritableUser 相当于:

{
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}

2.37 DeepNonNullable

type DeepNonNullable<T> = {
  [P in keyof T]-?: NonNullable<T[P]> extends object ? DeepNonNullable<NonNullable<T[P]>> : NonNullable<T[P]>;
};

构造一个类型，其中 T 的所有属性都递归地设置为 non-nullable。

示例：

interface User {
  name?: string;
  age?: number | null;
  address?: {
    street?: string;
    city?: string | null;
  };
}
type DeepNonNullableUser = DeepNonNullable<User>;

DeepNonNullableUser 相当于:

{
  name: string;
  age: number;
  address: {
    street: string;
    city: string;
  };
}

2.38 Immutable<T>

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

构造 T 的所有属性都设置为不可变的类型。

示例：

interface User {
  name: string;
  age: number;
}
type ImmutableUser = Immutable<User>;

ImmutableUser 相当于:

{
  readonly name: string;
  readonly age: number;
}

2.39 Unionize

type Unionize<T> = T extends any ? (k: T) => void : never extends (k: infer U) => void ? U : never;

构造 T 中所有可能的性质排列的联合类型。

示例：

interface User {
  id: number;
  name: string;
  age: number;
}
type UserUnion = Unionize<User>;

UserUnion 相当于:

{
  id: number;
} | {
  id: number;
  name: string;
} | {
  id: number;
  age: number;
} | {
  id: number;
  name: string;
  age: number;
}

2.40 Exclusive<T, U>

type Exclusive<T, U> = (Diff<T, U> & U) | (Diff<U, T> & T);

通过从 T 中挑选所有不属于 T 或 U 的属性来构造类型。

示例：

interface User {
  id: number;
  name: string;
  age: number;
}
type UserWithNameOrEmail = Exclusive<User, { name: any; email: any }>;

UserWithNameOrEmail 相当于:

{
  id: number;
  name: string;
  age: number;
} | {
  id: number;
  email: any;
}

2.41 Intersect<T, U>

type Intersect<T, U> = Pick<T, Extract<keyof T, keyof U> & Extract<keyof U, keyof T>>;

通过从 T 中选取所有也在 U 中的属性来构造类型。

示例：

interface User {
  id: number;
  name: string;
  age: number;
}
type UserWithName = Intersect<User, { name: any }>;

UserWithName 相当于:

{
  name: string;
}

2.42 Assign<T, U>

type Assign<T, U> = T & U;

通过从 T 和 U 中选取所有属性并将它们合并在一起来构造一个类型。

示例：

interface User {
  id: number;
  name: string;
  age: number;
}
type UserWithEmail = Assign<User, { email: string }>;

UserWithEmail 相当于:

{
  id: number;
  name: string;
  age: number;
  email: string;
}

2.43 DeepMutable<T>

type DeepMutable<T> = {
  -readonly [P in keyof T]: T[P] extends object ? DeepMutable<T[P]> : T[P];
};

构造一个 T 的所有属性都设置为可变递归的类型。

示例：

interface User {
  readonly name?: string;
  readonly age?: number;
  readonly address?: {
    readonly street?: string;
    readonly city?: string;
  };
}
type DeepMutableUser = DeepMutable<User>;

DeepMutableUser 相当于:

{
  name?: string;
  age?: number;
  address?: {
    street?: string;
    city?: string;
  };
}

2.44 Promisable<T>

type Promisable<T> = {
  [P in keyof T]: Promise<T[P]>;
};

构造一个 T 的所有属性都设置为 Promisable 的类型。

示例：

interface User {
  name: string;
  age: number;
}
type PromisableUser = Promisable<User>;

PromisableUser 相当于:

{
  name: Promise<string>;
  age: Promise<number>;
}

2.45 Awaited<T>

type Awaited<T> = {
  [P in keyof T]: T[P] extends Promise<infer U> ? U : never;
};

构造一个类型，将 T 的所有属性设置为 awaited 类型。

示例：

interface User {
  name: Promise<string>;
  age: Promise<number>;
}
type AwaitedUser = Awaited<User>;

AwaitedUser 相当于:

{
  name: string;
  age: number;
}

2.46 Brand<T, U>

type Brand<T, U> = T & { __brand: U };

通过用附加的 U 类型包装 T 来构造一个标称类型。

示例：

type Email = Brand<string, 'email'>;
const email: Email = 'john.doe@example.com';

2.47 NonUndefined<T>

type NonUndefined<T> = T extends undefined ? never : T;

通过从 T 中选取所有未定义的属性来构造类型。

示例：

interface User {
  name?: string;
  age?: number;
}
type UserWithoutUndefined = NonUndefined<User>;

UserWithoutUndefined 相当于:

{
  name: string;
  age: number;
}
文章标签：
JavaScript
关键词：
TypeScript类型
TypeScript用法
TypeScript工具
TypeScript类型用法
jcLee95
目录
相关文章
雪碧有白泡泡
|
2月前
|
JavaScript 前端开发 安全
Apollo与TypeScript：强大类型检查在前端开发中的应用
Apollo与TypeScript：强大类型检查在前端开发中的应用
雪碧有白泡泡
40 0
1941623231718325
|
4天前
|
JavaScript 前端开发 编译器
TypeScript中的高级类型：联合类型、交叉类型与条件类型深入解析
【4月更文挑战第23天】探索TypeScript的高级类型。这些特性增强类型系统的灵活性，提升代码质量和维护性。
1941623231718325
4 0
w风雨无阻w
|
1月前
|
JavaScript 安全
TypeScript 中的高级类型转换技术：映射类型、条件类型和类型推断
TypeScript 中的高级类型转换技术：映射类型、条件类型和类型推断
w风雨无阻w
25 0
Boale_H
|
1月前
react+typescript给state和props定义指定类型
react+typescript给state和props定义指定类型
Boale_H
16 1
会敲代码的_TT
|
2月前
|
JavaScript 安全 索引
TypeScript泛型和类型体操
泛型和类型体操（Type Gymnastics）是 TypeScript 中高级类型系统的重要组成部分。它们提供了强大的工具和技巧，用于处理复杂的类型操作和转换。
会敲代码的_TT
78 0
会敲代码的_TT
|
2月前
|
JavaScript 安全 容器
Vue3 + setup + TypeScript: 构建现代、类型安全的Vue应用的关键技巧总结
当使用 setup 的时候，组件直接引入就可以了，不需要再自己手动注册
会敲代码的_TT
48 0
爱吃糖的范同学
|
3月前
|
JavaScript 前端开发 IDE
【TypeScript】带类型语法的JavaScript
【1月更文挑战第26天】【TypeScript】带类型语法的JavaScript
爱吃糖的范同学
38 0
iOS学霸
|
3月前
|
JavaScript 前端开发
TypeScript 联合类型
TypeScript 联合类型
iOS学霸
35 0
答神~
|
3月前
|
存储 JavaScript 前端开发
2020你应该知道的TypeScript学习路线【数组类型】
2020你应该知道的TypeScript学习路线【数组类型】
答神~
33 0
jcLee95
|
3月前
|
JavaScript 前端开发 编译器
Typescript 类型的常用知识与技能总结
Typescript 类型的常用知识与技能总结
jcLee95
15 0

热门文章

最新文章

  • 1
    设置WebStorm像VSCode一样每行代码结尾自动格式化加入“；”分号（JavaScript、TypeScript格式化）
  • 2
    vite+typescript从入门到实战(二）
  • 3
    TypeScript极速入门笔记1
  • 4
    【TypeScript入门】TypeScript入门篇——数据类型
  • 5
    TypeScript基础知识点
  • 6
    TypeScript基本数据类型详解
  • 7
    TypeScript和JavaScript有什么不同？
  • 8
    TypeScript中装饰器的概念与使用场景
  • 9
    TypeScript中模块路径解析与配置：深入剖析与最佳实践
  • 10
    TypeScript中的高级类型：联合类型、交叉类型与条件类型深入解析
  • 1
    TypeScript 中的高级类型转换技术：映射类型、条件类型和类型推断
    25
  • 2
    TypeScript 中类型转换的终极指南：从零到深入
    29
  • 3
    使用React、TypeScript和Ant Design构建现代化前端应用
    25
  • 4
    在Vue中使用TypeScript的常见问题有哪些？
    28
  • 5
    在Vue中使用TypeScript的优缺点是什么？
    15
  • 6
    在 Vue 中如何使用 TypeScript？
    15
  • 7
    LocalStorage/sessionStorage 封装 - 基于TypeScript
    21
  • 8
    react+typescript通过window.xxx挂载属性报错的解决方案
    34
  • 9
    从零开始搭建react+typescript+antd+redux+less+vw自适应项目
    49
  • 10
    react+typescript接入百度地图
    45

    • 相关课程

    更多
  • Python语言基础 - 语法入门

    • 相关电子书

    更多
  • 现代TypeScript高级教程
  • 编程语言如何演化—— 以 JS 的 private 为例
  • 编程语言如何演化-以JS的private为例

    • 相关实验场景

    更多
  • 对象和接口-2：常见用法
  • 对象和接口-1：对象类型
  • 函数类型-1：基本语法
  • 常见类型-2：数组和元组
  • 语言入门-2：基本类型
  • 语言入门-1：环境构建
    • 下一篇
    部署LAMP环境（Alibaba Cloud Linux 3）