TS笔记

基础类型

    let str: string = '123'
    let age: number = 123

数组定义-两种方式

// 第一种
let list: Array<number> = [1, 2, 3]
// 第二种
let list2: <number>[] = [1,2,3]
let num:Array<string | null> = []
interface List {
    age: number,
    readonly id: number,
    name: string,
}

对象

// 对象
interface Person {
    name: string,
    age: number,
    sex?: number,
    [propName: string]: any
}

let tom:Person = {
    name: 'tom',
    age: 18,
    hobby: 'play ball',
}
tom.isFood = true

函数

// 两种函数申明
type fn1  = (str: string) => boolean 
function fn0(str: string, s2?: number): void{}

interface addFn {// 接口定义
    (s1: number, s2:number): number
}
let fnc: addFn = (s1, s2) => s1 + s2
console.log(fnc(2, 5))

type AddFn = (s1: number, s2: number) => number // 类型别名定义
let addNumber: AddFn = (num1, num2) => num1 + num2
console.log(addNumber(1, 11))

function handleRes(str: string): string[] //函数重载
function handleRes(str: number): number
function handleRes(str: any): any {
    if (typeof str === 'string') {
        return str.split(',')
    } else {
        return str* 100
    }
}
console.log(handleRes('1,2,3'), handleRes(29))

高级类型

内置条件类型

//ReturnType<T> : 获取函数返回值类型
//InstanceType<T> : 返回类实例类型

function fn () { //ReturnType
    return { name: 'jack', age: 12 }
}
let fnx: ReturnType<typeof fn> = { name: '', age: 0 }

class C { //InstanceType
    name: string
}
let sss: InstanceType<typeof C> = new C()

typeof - 获取一个变量或者对象的类型

function getUser() {
  return {name: 'xxx', age: 10}
}
let fx: typeof getUser = () => {
    return {name:'', age: 0}
}

let obj = {
    name: 'jack',
    age: 12
}
let ss: typeof obj = {
    name: '',
    age: 0
}

Pick - 复合类型中，取出几个想要的类型的组合

interface Foo {
    name: string,
    age: number
    isMan: boolean
}
let man: Pick<Foo, 'name'> = {name: ''}

keyof - 获取类型所有的键，返回类型是联合类型

function Foo<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key]
}
Foo({age: 12}, 'age')

in - 可以枚举遍历类型

type Foo<T> = {
    [K in keyof T]: T[K]
}

let obj: Foo<object> = {
    age: 12,
    name: 'jaclk'
}