@pansy/types v0.2.0

TypeScript >= 3.4

🏗 安装

# npm install
$ npm install @pansy/types --save

# yarn install
$ yarn add @pansy/types

🔨 使用

import { NonUndefined } from '@pansy/types';

type FooWithoutRainbow = NonUndefined<string | null | undefined>;
//=> string | null

目录

• 内置类型
  • Partial<T> 将T中所有的属性设为可选 v2.1
  • Readonly<T> 将T中所有的属性设为只读 v2.1
  • Pick<T,K> 从T中过滤出属性K v2.1
  • Record<T,K> 标记对象的 key value类型 v2.1
  • Exclude<T,U> 从T可分配给的类型中排除U v2.8
  • Extract<T,U> 从T可分配给的类型中提取U v2.8
  • NonNullable<T> 从T中排除null和undefined v2.8
  • ReturnType 获取函数类型T的返回类型 v2.8
  • InstanceType 获取构造函数类型T的实例类型 v2.8
  • Required<T> 将T中所有的属性设为必填
  • Parameters<T> 获取一个函数的所有参数类型 v3.6
  • ConstructorParameters<T> 获取构造函数的所有参数类型 v3.6
  • Omit<T,K> 通过从T选取所有属性然后删除K来构造类型 v3.5
  • Uppercase<S> 将字符串中的每个字符转换为大写 v4.1
  • Lowercase<S> 将字符串中的每个字符转换为小写 v4.1
  • Capitalize<S> -将字符串中的第一个字符转换为大写 v4.1
  • Uncapitalize<S> 将字符串中的第一个字符转换为小写 v4.1

Partial<T>

将T中所有的属性设为可选。

interface NodeConfig {
  appName: string;
  port: number;
}
// Expect: { appName?: string; port?: number; }
Partial<NodeConfig>;

⇧ 回到目录

Readonly<T>

将T中所有的属性设为只读。

interface NodeConfig {
  appName: string;
  port?: number;
}
// Expect: { readonly appName: string; readonly port?: number; }
Readonly<NodeConfig>;

⇧ 回到目录

Pick<T, K>

从 T 中过滤出属性 K。

interface NodeConfig {
  name: string;
  appName: string;
  port?: number;
}
// Expect: { name: string; }
Pick<NodeConfig, 'name'>;

⇧ 回到目录

Record<T,K>

标记对象的 key value类型。

// Expect: { [key: string]: number; }
Record<string, number>;

⇧ 回到目录

Exclude<T,U>

从T可分配给的类型中排除U。

// Expect: 'b' | 'd'
Exclude<"a" | "b" | "c" | "d", "a" | "c" | "f">;

⇧ 回到目录

Extract<T,U>

从T可分配给的类型中提取U。

// Expect: 'a' | 'c'
Extract<"a" | "b" | "c" | "d", "a" | "c" | "f">;

⇧ 回到目录

NonNullable<T>

从T中排除null和undefined。

// Expect: string
NonNullable<string | null | undefined>;

⇧ 回到目录

ReturnType<T>

获取函数类型T的返回类型。

// Expect: string
ReturnType<() => string>;

⇧ 回到目录

InstanceType<T>

获取构造函数类型T的实例类型。

class C {
  x = 0;
  y = 0;
}

// Expect: C
InstanceType<typeof C>;

⇧ 回到目录

Required<T>

将T中所有的属性设为必填。

interface NodeConfig {
  appName?: string;
  port?: number;
}
// Expect: { appName: string; port: number; }
Required<NodeConfig>;

⇧ 回到目录

Parameters<T>

获取一个函数的所有参数类型。

function shuffle(input: string, input1: number): void {}

// Expect: { input: string; input1: number; }
Parameters<typeof shuffle>;

⇧ 回到目录

ConstructorParameters<T>

获取构造函数的所有参数类型

class A {
  constructor(input: string, input1: number) {}
}

// Expect: { input: string; input1: number; }
ConstructorParameters<typeof A>;

⇧ 回到目录

Omit<T,K>

通过从T选取所有属性然后删除K来构造类型。

interface Animal {
		imageUrl: string;
		species: string;
		images: string[];
		paragraphs: string[];
}

// Expect: { images: string[]; paragraphs: string[]; }
Omit<Animal, 'imageUrl' | 'species'>;

⇧ 回到目录

Uppercase<S>

将字符串中的每个字符转换为大写

// Expect: 'HELLO'
Uppercase<'hello'>;

⇧ 回到目录

Lowercase<S>

将字符串中的每个字符转换为小写

// Expect: 'hello'
Uppercase<'HELLO'>;

⇧ 回到目录

Capitalize<S>

将字符串中的第一个字符转换为大写

// Expect: 'Hello'
Capitalize<'hello'>;

⇧ 回到目录

Uncapitalize<S>

将字符串中的第一个字符转换为小写

// Expect: 'hello'
Uncapitalize<'Hello'>;

⇧ 回到目录