loading
function isString (s: unknown): boolean {
return typeof s === 'string'
}
function toUpperCase (x: unknown) {
if (isString(x)) {
x.toUpperCase() // × Error, Object is of type 'unknown'
}
}
const isString = (s: unknown): s is string => typeof val === 'string'
function toUpperCase (x: unknown) {
if (isString(x)) {
x.toUpperCase()
}
}
type T0 = ReturnType<() => string> // string
type T1 = ReturnType<(s: string) => void> // void
type T2 = ReturnType<<T>() => T> // unknown
// 元组转联合类型
type Flatten<T> = T extends Array<infer U> ? U : never
type T0 = [string, number]
type T1 = Flatten<T0> // string | number
// 1. 定义一个接口
interface Person {
name: string
age: number
}
type newPerson = keyof Person // 等于type PersonKeys = 'name' | 'age'
const x1: newPerson = 'name' // √
const x2: newPerson = 'age' // √
const x3: newPerson = 'height' // ×
// 一
interface Person {
name: string
age: number
}
const sem: Person = { name: 'semlinker', age: 30 }
type Sem = typeof sem // type Sem = Person
// 二
const kakuqo = {
name: 'kakuqo',
age: 30,
address: {
province: '广东'
}
}
type Kakuqo = typeof kakuqo
/*
type Kakuqo = {
name: string;
age: number;
address: {
province: string;
city: string;
};
}
*/
// 三
function toArray (x: number): Array<number> {
return [x]
}
type Func = typeof toArray // -> (x: number) => number[]
const COLORS = {
red: 'red',
blue: 'blue'
}
// 首先通过typeof操作符获取Colors变量的类型,然后通过keyof操作符获取该类型的所有键,
// 即字符串字面量联合类型 'red' | 'blue'
type Colors = keyof typeof COLORS
let color: Colors
color = 'red' // √
color = 'blue' // √
color = 'yellow' // × Type '"yellow"' is not assignable to type '"red" | "blue"'.
// 原始类型
interface Todo {
title: string
description: string
completed: boolean
}
// 如果我只想要name和age怎么办,最粗暴的就是直接再定义一个
interface TodoPreview {
title: 'Clean room',
completed: false,
}
// 弊端:在Todo发生改变的时候,TodoPreview 并不会跟着一起改变,所以应该这么写
interface TodoPreview extends Pick<Todo , 'title' | 'completed'>;
type MyPick<T, K extends keyof T> = {
[k in K]: T[k]
}
public readonly state = {
name: 'jsben',
};
state.name ='xiaoxing' // × 只读属性能修改
type MyReadonly<T> = {
readonly [p in keyof T]: T[p]
}
type PersonOptional = {
name: string
age: number
}
function test(parmas:PersonOptional)=>{}
test({name:'jsben'}) × // 缺失age属性
type newPersonOptional = Partial(PersonOptional)
// 等价于
type newPersonOptional = {
name?: string
age?: number
}
function test(parmas:newPersonOptional )=>{}
test({name:'jsben'}) √ // age属性为可选
type myPartial<T> = {
[K in keyof T]?: T[K]
}
Exclude<T,U>
type myTypes = 'name' | 'age' | 'height'
type someMyTypes = Exclude<myTypes, 'name'>
// 等于 type someMyTypes = 'age' | 'height'
type myExclude = <T,U> = T extends U ? never : T
const tuple = ['tesla', 'model 3'] as const
const result: TupleToObject<typeof tuple> // expected { tesla: 'tesla', 'model 3': 'model 3'}
type TupleToObject = <T extends readonly any[]> = {
[k in T[number]] : k
}
type arr1 = ['a', 'b', 'c']
type arr2 = [3, 2, 1]
type head1 = First<arr1> // expected to be 'a'
type head2 = First<arr2> // expected to be 3
type First = <T extends readonly any[]> = T['length'] extends 0 ? never : T[0]
type tesla = ['tesla', 'model 3']
type spaceX = ['FALCON 9', 'FALCON HEAVY', 'DRAGON']
type teslaLength = Length<tesla> // expected 2
type spaceXLength = Length<spaceX> // expected 3
type Length = <T extends readonly any[]> = T['length']
Promise<T>
type Awaited<R extends Promise<any>> = R extends Promise<infer T> ? T : R