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

举报
jcLee95 发表于 2023/06/08 21:59:02 2023/06/08
【摘要】 TypeScript 小结:近五十个常用TypeScript类型工具的声明、描述、用法示例博文作者:李俊才(jcLee95):https://blog.csdn.net/qq_28550263?spm=1001.2101.3001.5343邮箱 :291148484@163.com本文地址:https://blog.csdn.net/qq_28550263/article/details/1...
TypeScript
小结:近五十个常用TypeScript类型工具的声明、描述、用法示例

博文作者李俊才(jcLee95)https://blog.csdn.net/qq_28550263?spm=1001.2101.3001.5343
邮箱 :291148484@163.com
本文地址https://blog.csdn.net/qq_28550263/article/details/130299891


@[TOC](

目 录

)


本文总结 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> 造一个由T的键组成的类型,这些键是函数。
NonFunctionKeys<T> 构造一个由 T 的非函数键组成的类型。
PromiseType<T> 构造一个由 Promise-like 类型 T 的已解析类型组成的类型。
DeepReadonly<T> 构造一个 T 的所有属性都递归设置为只读的类型。
DeepPartial<T> 递归地构造 T 的所有属性都设置为可选的类型。
ValueOf<T> 构造由 T 中所有值的并集组成的类型。
OptionalKeys<T> 构造一个由 T 的可选键组成的类型。
ReadonlyKeys<T> 构造一个由 T 的只读键组成的类型。
WritableKeys<T> 构造一个由 T 的可写键组成的类型。
DeepRequired<T> 递归地构造 T 的所有属性都设置为 required 的类型。
DeepWritable<T> 构造 T 的所有属性都设置为可递归写的类型。
DeepNonNullable<T> 构造一个类型,其中 T 的所有属性都递归地设置为 non-nullable。
Immutable<T> 构造 T 的所有属性都设置为不可变的类型。
Unionize<T> 构造 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>

构造一个由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<T>

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<T>

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<T>

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<T>

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<T>

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;
}
【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。