日本综合一区二区|亚洲中文天堂综合|日韩欧美自拍一区|男女精品天堂一区|欧美自拍第6页亚洲成人精品一区|亚洲黄色天堂一区二区成人|超碰91偷拍第一页|日韩av夜夜嗨中文字幕|久久蜜综合视频官网|精美人妻一区二区三区

Readonly

作用：將Type所有屬性置為只讀。示例：

 
 
 

  
  
  
interface Todo { 
  
  
  
  title: string; 
  
  
  
} 
  
  
  
  
  
  
  
const todo: Readonly = { 
  
  
  
  title: "Delete inactive users", 
  
  
  
}; 
  
  
  
  
  
  
  
todo.title = "Hello"; // Cannot assign to 'title' because it is a read-only property. 
 
 
 

我們看看Readonly背后的實(shí)現(xiàn)：

 
 
 

  
  
  
/** 
  
  
  
 * Make all properties in T readonly 
  
  
  
 */ 
  
  
  
type Readonly = { 
  
  
  
    readonly [P in keyof T]: T[P]; 
  
  
  
}; 
 
 
 

這里有上面的知識(shí)鋪墊就比較好理解了，只需要知道映射類型支持修飾符readonly、?。

另外這里補(bǔ)充下readonly的含義跟JS的const不能修改的含義一樣，指的是不能重寫(重寫賦值)。

這個(gè)方法對(duì)于Object.freeze的定義非常適用：

 
 
 

  
  
  
function freeze(obj: Type): Readonly; 
 
 
 

Record

作用：構(gòu)建一個(gè)對(duì)象類型，該對(duì)象類型的key來(lái)自Keys，并且其key對(duì)應(yīng)的value是Type。所以這個(gè)方法非常適用于將一個(gè)類型的屬性映射到另外一個(gè)類型。

示例：

 
 
 

  
  
  
interface CatInfo { 
  
  
  
  age: number; 
  
  
  
  breed: string; 
  
  
  
} 
  
  
  
  
  
  
  
type CatName = "miffy" | "boris" | "mordred"; 
  
  
  
  
  
  
  
const cats: Record = { 
  
  
  
  miffy: { age: 10, breed: "Persian" }, 
  
  
  
  boris: { age: 5, breed: "Maine Coon" }, 
  
  
  
  mordred: { age: 16, breed: "British Shorthair" }, 
  
  
  
}; 
  
  
  
  
  
  
  
cats.boris; // (property) boris: CatInfo 
 
 
 

我們看看Record背后定義。

 
 
 

  
  
  
/** 
  
  
  
 * Construct a type with a set of properties K of type T 
  
  
  
 */ 
  
  
  
type Record = { 
  
  
  
    [P in K]: T; 
  
  
  
}; 
 
 
 

上面涉及的新的知識(shí)點(diǎn)：keyof any。

我們先看一段代碼：

 
 
 

  
  
  
type A = keyof any; 
  
  
  
 
  
  
  
type EqualA = string | number | symbol; // A其實(shí)等價(jià)于EqualA 
  
  
  
 
  
  
  
type Is = A extends EqualA ? true : false; 
  
  
  
 
  
  
  
const is: Is = false; // Type 'false' is not assignable to type 'true'. 
 
 
 

因此如果我們這樣使用就會(huì)提示報(bào)錯(cuò)了：

 
 
 

  
  
  
interface CatInfo { 
  
  
  
  age: number; 
  
  
  
  breed: string; 
  
  
  
} 
  
  
  
  
  
  
  
type CatName = "miffy" | "boris" | "mordred" | false; // false導(dǎo)致 
  
  
  
  
  
  
  
const cats: Record = { // Error: Type 'string | boolean' does not satisfy the constraint 'string | number | symbol'. Type 'boolean' is not assignable to type 'string | number | symbol'. 
  
  
  
  miffy: { age: 10, breed: "Persian" }, 
  
  
  
  boris: { age: 5, breed: "Maine Coon" }, 
  
  
  
  mordred: { age: 16, breed: "British Shorthair" }, 
  
  
  
}; 
 
 
 

Pick

Keys的類型有要求：string literal or union of string literals。

作用：構(gòu)建返回一個(gè)根據(jù)Keys從類型Type揀選所需的屬性的新類型。

代碼示例：

 
 
 

  
  
  
interface Todo { 
  
  
  
  title: string; 
  
  
  
  description: string; 
  
  
  
  completed: boolean; 
  
  
  
} 
  
  
  
  
  
  
  
type TodoPreview = Pick; 
  
  
  
  
  
  
  
const todo: TodoPreview = { // 只需要Keys: title and completed 
  
  
  
  title: "Clean room", 
  
  
  
  completed: false, 
  
  
  
}; 
  
  
  
  
  
  
  
todo; 
 
 
 

同樣我們看看其背后的實(shí)現(xiàn)：這里就沒(méi)有新的知識(shí)點(diǎn)了。

 
 
 

  
  
  
/** 
  
  
  
 * From T, pick a set of properties whose keys are in the union K 
  
  
  
 */ 
  
  
  
type Pick = { 
  
  
  
    [P in K]: T[P]; 
  
  
  
}; 
 
 
 

Omit

這里就不重復(fù)介紹，可以看我之前文章：TypeScript學(xué)習(xí)之Omit。

Exclude

作用：從Type中排除可以分配給ExcludedUnion的類型。

示例：

 
 
 

  
  
  
type T0 = Exclude<"a" | "b" | "c", "a">; // type T0 = "b" | "c" 
  
  
  
type T1 = Exclude<"a" | "b" | "c", "a" | "b">;  // type T1 = "c" 
  
  
  
type T2 = Exclude void), Function>; // type T2 = string | number 
 
 
 

我們看看Exclude背后的實(shí)現(xiàn)：

 
 
 

  
  
  
/** 
  
  
  
 * Exclude from T those types that are assignable to U 
  
  
  
 */ 
  
  
  
type Exclude = T extends U ? never : T; 
 
 
 

涉及知識(shí)點(diǎn)：

T extends U ? never : T這里的extends可與class的extends不是一回事，這里指的是條件類型。這里不做過(guò)多的擴(kuò)展，重點(diǎn)通過(guò)一個(gè)概念分布式條件類型來(lái)理解上面Exclude的寫法。

 
 
 

  
  
  
type A = 'a' | 'b' | 'c'; 
  
  
  
type B = 'a'; 
  
  
  
 
  
  
  
type C = Exclude; // 'b' | 'c'; 
  
  
  
 
  
  
  
// A extends B ? never : A 等價(jià)于 ('a' | 'b' | 'c') extends B ? never : ('a' | 'b' | 'c') 等價(jià)于如下 
  
  
  
type D = ('a' extends B ? never : 'a') | ('b' extends B ? never : 'b') | ('c' extends B ? never : 'c'); // 'b' | 'c'; 
 
 
 

Extract

作用：從Type中檢出可以分配給Union的類型。示例：

 
 
 

  
  
  
type T0 = Extract<"a" | "b" | "c", "a" | "f">; // type T0 = "a" 
  
  
  
type T1 = Extract void), Function>; // type T1 = () => void 
 
 
 

我們看看Extract背后的定義：

 
 
 

  
  
  
/** 
  
  
  
 * Extract from T those types that are assignable to U 
  
  
  
 */ 
  
  
  
type Extract = T extends U ? T : never; 
 
 
 

所有你闊以看到Extract就是跟Exclude取反的區(qū)別。

NonNullable

作用：排除類型Type中的null、undefined。

示例：

 
 
 

  
  
  
type T0 = NonNullable; // type T0 = string | number 
  
  
  
type T1 = NonNullable;// type T1 = string[] 
 
 
 

看看NonNullable的定義：

 
 
 

  
  
  
/** 
  
  
  
 * Exclude null and undefined from T 
  
  
  
 */ 
  
  
  
type NonNullable = T extends null | undefined ? never : T; 
 
 
 

我們可以看到其實(shí)還是上面分布式條件類型extends的運(yùn)用。

Parameters

作用：基于類型Type的參數(shù)構(gòu)建一個(gè)新的元組類型。示例：

 
 
 

  
  
  
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<(arg: T) => T>; // type T2 = [arg: unknown] 
  
  
  
type T3 = Parameters; 
  
  
  
      
  
  
  
// type T3 = [arg: { 
  
  
  
//     a: number; 
  
  
  
//     b: string; 
  
  
  
// }] 
  
  
  
type T4 = Parameters; // type T4 = unknown[] 
  
  
  
type T5 = Parameters; // type T5 = never 
  
  
  
type T6 = Parameters; // Type 'string' does not satisfy the constraint '(...args: any) => any'. type T6 = never 
  
  
  
type T7 = Parameters; 
  
  
  
// Type 'Function' does not satisfy the constraint '(...args: any) => any'. 
  
  
  
//   Type 'Function' provides no match for the signature '(...args: any): any'. 
  
  
  
      
  
  
  
// type T7 = never 
 
 
 

我們?cè)倏纯碢arameters背后實(shí)現(xiàn)。

 
 
 

  
  
  
/** 
  
  
  
 * Obtain the parameters of a function type in a tuple 
  
  
  
 */ 
  
  
  
type Parameters any> = T extends (...args: infer P) => any ? P : never; 
 
 
 

涉及知識(shí)點(diǎn)：

T extends (...args: any) => any定義了Parameters的泛型約束，兼容目前所有函數(shù)的類型定義。infer P：用于表示待推斷的函數(shù)參數(shù)。

T extends (...args: infer P) => any ? P : never：表示如果 T 能賦值給 (...args: infer P) => any，則結(jié)果是 (...args: infer P) => any類型中的參數(shù)為 P，否則返回為 never。

關(guān)于info更多學(xué)習(xí)推薦深入理解typescript-info。

ConstructorParameters

作用：從構(gòu)造函數(shù)類型 Type 的參數(shù)類型構(gòu)造元組或數(shù)組類型（如果 Type 不是函數(shù)，則為 never）。示例：

 
 
 

  
  
  
type T0 = ConstructorParameters; // type T0 = [message?: string] 
  
  
  
type T1 = ConstructorParameters; // type T1 = string[] 
  
  
  
type T2 = ConstructorParameters; // type T2 = [pattern: string | RegExp, flags?: string] 
  
  
  
type T3 = ConstructorParameters; // type T3 = unknown[] 
 
 
 

看看其ConstructorParameters定義：

 
 
 

  
  
  
/** 
  
  
  
 * Obtain the parameters of a constructor function type in a tuple 
  
  
  
 */ 
  
  
  
type ConstructorParameters any> = T extends abstract new (...args: infer P) => any ? P : never; 
 
 
 

ConstructorParameters跟Parameters的定義幾乎一樣，區(qū)別在于前者是表達(dá)構(gòu)造函數(shù)簽名的定義。

常見(jiàn)的構(gòu)造函數(shù)類型簽名有：基于Type或者Interface。

 
 
 

  
  
  
type SomeConstructor = { 
  
  
  
  new (s: string): SomeObject; 
  
  
  
}; 
  
  
  
function fn(ctor: SomeConstructor) { 
  
  
  
  return new ctor("hello"); 
  
  
  
} 
  
  
  
 
  
  
  
interface CallOrConstruct { 
  
  
  
  new (s: string): Date; 
  
  
  
  (n?: number): number; 
  
  
  
} 
 
 
 

ReturnType

作用：基于函數(shù)Type的返回值類型創(chuàng)建一個(gè)新類型。

示例：

 
 
 

  
  
  
declare function f1(): { a: number; b: string }; 
  
  
  
  
  
  
  
type T0 = ReturnType<() => string>; // type T0 = string 
  
  
  
type T4 = ReturnType; 
  
  
  
 
  
  
  
// type T4 = { 
  
  
  
//     a: number; 
  
  
  
//     b: string; 
  
  
  
// } 
 
 
 

源碼定義：

 
 
 

  
  
  
/** 
  
  
  
 * Obtain the return type of a function type 
  
  
  
 */ 
  
  
  
type ReturnType any> = T extends (...args: any) => infer R ? R : any; 
 
 
 

我們可以看到其原理跟前幾個(gè)差不多，區(qū)別在于infer推斷的位置不同。

InstanceType

作用：基于函數(shù)類型Type的constructor的類型構(gòu)造一個(gè)新類型。示例：

 
 
 

  
  
  
class C { 
  
  
  
  x = 0; 
  
  
  
  y = 0; 
  
  
  
} 
  
  
  
  
  
  
  
type T0 = InstanceType; // type T0 = C 
  
  
  
 
  
  
  
type T1 = InstanceType; // type T1 = any 
 
 
 

源碼定義：

 
 
 

  
  
  
/** 
  
  
  
 * Obtain the return type of a constructor function type 
  
  
  
 */ 
  
  
  
type InstanceType any> = T extends abstract new (...args: any) => infer R ? R : any; 
 
 
 

通過(guò)對(duì)比發(fā)現(xiàn)：InstanceType 與 ReturnType 的區(qū)別是它多了函數(shù)構(gòu)造簽名定義，與 ConstructorParameters 的區(qū)別是它推斷的不是參數(shù)類型，而是返回值類型。

ThisParameterType

作用：獲取函數(shù)類型Type中的this類型。如果沒(méi)有返回unknown。

 
 
 

  
  
  
function toHex(this: Number) { 
  
  
  
  return this.toString(16); 
  
  
  
} 
  
  
  
  
  
  
  
function numberToString(n: ThisParameterType) { // n: number 
  
  
  
  return toHex.apply(n); 
  
  
  
} 
 
 
 

源碼定義：

 
 
 

  
  
  
/** 
  
  
  
 * Extracts the type of the 'this' parameter of a function type, or 'unknown' if the function type has no 'this' parameter. 
  
  
  
 */ 
  
  
  
type ThisParameterType = T extends (this: infer U, ...args: any[]) => any ? U : unknown; 
 
 
 

如果想了解如何在函數(shù)中定義this，建議還是看官網(wǎng)。

OmitThisParameter

作用：移除函數(shù)類型Type中參數(shù)的this。

示例：

 
 
 

  
  
  
function toHex(this: Number) { 
  
  
  
  return this.toString(16); 
  
  
  
} 
  
  
  
  
  
  
  
const fiveToHex: OmitThisParameter = toHex.bind(5); // const fiveToHex: () => string 
  
  
  
  
  
  
  
console.log(fiveToHex()); 
 
 
 

源碼定義：

 
 
 

  
  
  
/** 
  
  
  
 * Removes the 'this' parameter from a function type. 
  
  
  
 */ 
  
  
  
type OmitThisParameter = unknown extends ThisParameterType ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T; 
 
 
 

unknown extends ThisParameterType：如果T函數(shù)參數(shù)中沒(méi)有this，則直接返回T。否則，T extends (...args: infer A) => infer R ? (...args: A) => R : T;，如果T是后者的子類型，那么返回新的函數(shù)，函數(shù)參數(shù)為推導(dǎo)的infer A，返回值為infer R。否則返回T。

ending

• 參考官網(wǎng)。