typescript

基础类型

let str: string = 'a'
let num: number = 1
let bool: boolean = false
let nu: null = null
let und: undefined = undefined

任意类型

let any: any = [1, 2, 3] // 接收所有数据类型

数组

let arr1: number[] = [1, 2, 3, 4]//数组的每一个成员都是number类型
let arr2: (string | number | boolean)[] = ['a', 'b', 100, false] //数据的成员可能存在某些类型
let arr3: Array<string> = ['a'] //类似 new Array()
let arr4: [string, number] = ['a', 2] // 元组写法，规定每一位都类型

对象

 // interface 接口 数据结构稍微复杂的时候可以用interface来定义
interface Iobj {
    // 表示 只读 
    readonly mes: string; 
    // ? 表示可有可无
    data?: {    
        list: { id: number, a: string }[];
        obj?: Iobj2
    };
    suc: boolean
}
interface Iobj2 {
    a: string
}
let obj: Iobj = {
    mes: '成功',
    data: {
        list: [{ id: 1, a: 'a' }, { id: 1, a: 'a' }],
        obj: { a: 'a' }
    },
    suc: true
}

函数

// 函数                                               //定义函数返回值时object
function fun(a: object, b?: number, c: string = '3'): object {
    return { a, b, c }
}
fun({ a: 1 })

                                                     // 没有返回值
function fun(a: object, b?: number, c: string = '3'): void {
    return { a, b, c }
}
fun({ a: 1 })


const fun2 = (a: number, b: number): number => {
    return a + b
}
完整写法
const fun2: (a: number, b: number) => number = (a: number, b: number): number => {
    return a + b
}

类

// public 公开的
// protected 受保护的 可以在子类访问
// private   私有 只能在当前类访问
class Person {
    public userName: string
    userAge: number
    constructor(name: string, age: number) {
        this.userName = name
        this.userAge = age
    }
    run(): number {
        return this.userAge
    }
}

class Child extends Person {
    ChildRun() {
        return this.userName
    }
}
let p1 = new Person('zhangsan', 28)
let c1 = new Child('lisi', 18)

抽象类

// 抽象类规定了所有继承自它的子类必须实现它的所规定的功能和相关操作，否则会报错
// 抽象类不能new
abstract class Person1 {
    abstract run(): number
}
class Child1 extends Person1 {
    run() { return 1 }
}

约束类

interface Ipo {
    userName: string;
    run(): number
}
interface Ipo2 {
    userAge: number
}
// 可以定义多个约束类，通过implements来关联
class Person2 implements Ipo, Ipo2 {
    run() { return 1 }
    userName: string
    userAge: number
}


interface Ipo {
    userName: string;
    run(): number
}

// 也可以通过继承到一个约束类再关联
interface Ipo2 extends Ipo{
    userAge: number
}
class Person2 implements Ipo2 {
    run() { return 1 }
    userName: string
    userAge: number
}

泛型

// 在定义函数、接口或类的时候，不预先指定类型，而在使用的时候再制定类型的一种特性

function add<T, U>(a: T, b: U): any {
    return a + b
}
add<number,string>(1, 'wo')


// 不存在 length 属性
// 解决1:接口泛型
interface leng{
    length:number
}
funciton Length<T extends leng>(str:T):any{
    return str.length
}
Length<string>('wo')


// 解决2:联合声明
funciton Length<T extends String | string[]>(str:T):any{
    return str.length
}
Length<string>('wo')
Length<string[]>(['a','b'])
Length<number[]>([1,2,3,4])



// object
interface Idata<T>{
    a:T;
    b:T;
    c:string;
}
let obj: Idata<number> = {
    a:1,
    b:2,
    c:'aaa'
}



// class类的泛型
class Name<T>{
    name: T
    constructor(name: T) {
        this.name = name
    }
}
let n = new Name<string>('wo')