摘要：都支持嵌套寫法寫法寫法有趣的寫法常量的寫法與交叉數(shù)據(jù)類型用法獲取對象的屬性升級版用法這種的聯(lián)合類型可以使用來循環(huán)值只能為用法二和與字符串索引簽名進行交互。
interface type 都支持嵌套寫法
// interface 寫法
interface Ip {
name: string;
child?: Ip;
}
let child: Ip = {
name: "str",
child: {
name: "test"
}
};
// type 寫法
type Ip = {
name: string;
child?: Ip;
};
let child: Ip = {
name: "child",
child: {
name: "haha"
}
};
// 有趣的寫法
type LinkedList = T & { next: LinkedList }; // people = {name:"",next:{name:"",next:{...}}}
interface Person {
name: string;
}
var people: LinkedList;
var s = people.name;
var s = people.next.name;
var s = people.next.next.name;
var s = people.next.next.next.name;
常量的寫法 與 交叉數(shù)據(jù)類型
interface I {
name: "ccc";
}
interface P {
age: "bbb";
}
var a: I & P = {
name: "ccc",
age: "bbb"
};
keyof 用法
// 獲取對象的屬性
function pluck(o: T, names: K): T[K] {
return o[names];
}
// 升級版
function pluck1(o: T, names: K[]): T[K][] {
return names.map(item => o[item]);
}
// keyof用法
interface Personal {
name: string;
age: number;
}
//keyof Personal ==> "name" | "age" 這種的聯(lián)合類型 可以使用in來循環(huán)
let ppp: keyof Personal = "name";
let ppp1: keyof Personal = "age";
let ppp2: keyof Personal = "ss"; // error 值只能為 name | age
keyof 用法二
keyof 和 T[K]與字符串索引簽名進行交互。 如果你有一個帶有字符串索引簽名的類型，那么 keyof T 會是 string。 并且 T[string]為索引簽名的類型
interface Map1 {
[key: number]: T;
}
let pp: keyof Map1; // pp 類型為number
let pp4: Map1[0]; // 返回的類型是string
interface Map2 {
[key: string]: T;
}
let pp1: keyof Map1; // pp1 類型為string
let pp3: Map2["foo"]; // 返回的類型是number
keyof 用法 3 映射類型
// 通過這個類型生成一個只讀版本 in 內(nèi)部使用了for---in循環(huán)
interface PersonPartial {
name?: string;
age?: number;
}
// 使用
type ReadonlyPersonPartial = {
readonly [key in keyof PersonPartial]: PersonPartial[key]
}
let b: ReadonlyPersonPartial = {
name: "string",
age: 123
}
type Map2 = {
[key in keyof PersonPartial]?: T;
}
var a: Map2 = {
name: "123",
}
// 封裝一些通用的版本
type BeNull = {
[P in keyof T]:T[P] | null
}
type BeEmpty = {
[P in keyof T]?:T[P]
}
理解 extends in 相關(guān)的東西
interface a {
name: string;
age: number;
}
// T 相當于上面有 name | age
// [key in T] 循環(huán) name age ，每一個key就是name age 那么 a[name],a[age] j
type b = { [key in T]: a[key] };
let c: b<"name" | "age"> = {
name: "123",
age: 12
};
內(nèi)置的 pick record exclude的理解 慢慢來吧
// pick 的作用是傳入一個接口，返回接口里面特定的字段類型
type Pick = {
[P in K]: T[P];
};
interface b {
name: string,
age:number
}
let cc: Pick = {
name: "cc",
age:123
}
// 傳入屬性，生成一個接口 生成一個 name age 都是string的interface
type Record = {
[P in K]: T;
};
let mmm: Record<"name" | "age", string> = {
name: "ccc",
age:"20"
}
// 排除相同的 extends 可以理解為 T 可以賦值給 U 可以賦值返回never 否則 返回 T
type Exclude = T extends U ? never : T;
interface a {
name:string
}
interface b {
name: string,
age:number
}
interface c {
name: string,
age: number,
hobby:any
}
// 這兩個東西表示出來了 是分開來搞的 首先 a extends b => a b extends b=>never 所以返回的是 a
let nnn: Exclude // 返回 a
let nnnn: Exclude // 返回 never a extends a => never b extends a b可以賦值給a 返回never
let ccc: Exclude
let b: a extends b ? number : string // a 不能賦值給 b 所以返回了string b的類型就是string
let nnn:Exclude // 排除相同的過后 剩下的就是 ‘a(chǎn)ge’ "name"|"age" extends "name" 難道是 name extends name ， age extends name 分開來的 先這樣理解吧
type mm = "number" | "age";
type nn = "age"
let c: mm extends nn ? never : mm; // mm 不能賦值給 nn 所以返回值是 mm 并不是上面Exclude 返回的 age 這個可以理解為傳入泛型變量的時候ts 幫我們?nèi)パh(huán) extends(賦值了一下)
// 取出相同的
type Extract = T extends U ? T : never; // T 可以賦值給 U的話 表示的是T中的字段 U中肯定都存在 返回了 U。
文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址：http://systransis.cn/yun/104445.html
