typescript基础学习

//************************************基础类型************************************
//基础类型
let sty: string = '1'
let num: number = 1
let bool: boolean = false
//数组
let arr: (number | string)[] = [1, '2']
let arr2: Array<number | string | boolean> = [1, '1', false, 2, true, '2']
//元组
let tuple: [number, string] = [1, '1']
//对象
let obj: { sty1: string, num: number }
//函数
let fun = (x: number, y: number): number => { return }
//symbol
let sy1: symbol = Symbol()
//undefined null
let unf: undefined = undefined
let nul: null = null
// unf=1             不可将其他类型赋值给undefined和null类型
let sty2: string = null //可将undefined和null赋值给其他类型数据
let num2: number = undefined //可将undefined和null赋值给其他类型数据
//void
let noreturn = () => { } //当一个函数没有返回值时，通常其返回值会声明为 void 类型
//any任何类型
let x: any = 1
x = '1'
//never 永远不会有返回值类型
let err = () => {
    throw new Error('error')
}
//************************************枚举************************************
//枚举
//数字 (只有数字枚举成员才会有反向映射，字符串或其它值是没有的)
enum Role {
    rone1,
    rone2,
    rone3,
    rone4
}
//字符串
enum Str {
    str1 = '1',
    str2 = '2',
    str3 = '3',
    str4 = '4'
}
//枚举成员
enum Char {
    //const
    a,
    b = Char.a,
    c = 1 + 3,
    //computed
    d = Math.random()
}
//常量枚举(一般用于只需要对象的值)
const enum Month {
    jan,
    Feb,
    Mar
}
let month = [Month.jan, Month.Feb]

//枚举类型
enum E { a, b }
enum F { a = 2, b = 3 }
enum G { a = '1', b = '2' }
let e: E = 3
let e2: F = 3
//e === e2 不同枚举不能对比相等
let e3: E = 3
let e4: E = 3
//console.log(e3 === e4) true
let g1: G = G.a
let g2: G = G.b


//************************************接口************************************
// interface接口声明只存在于编译阶段，在编译后生成的 JS 代码中不包含任何接口代码
interface List {
    readonly id: number;//只读属性
    name: string;
    sex: string;
    age?: number, //可选属性
    [key: string]: unknown //定义未知属性
}
interface Result {
    data: List[]
}

function getList(result: Result) {
    result.data.forEach((item) => {
        console.log(item)
        if (item.age) {
            console.log(item.age)
        }
    });
}

let result = {
    data: [
        { id: 1, name: '小张', sex: '男', pid: 0 }
    ]
}
// 传递数据：
// getList(result) //{id:1,name:'小张',sex:'男',}

// 错误 直接传递数据：
// getList({data:[
//     {id:1,name:'小张',sex:'男',pid:1} //error：对象文字可以只指定已知属性，并且“pid”不在类型“List”中
// ]})

// 修改interface List后直接传递数据：
// getList({
//     data: [
//         { id: 1, name: '小张', sex: '男', pid: 1,age:25 }
//     ]
// })

//函数类型接口

let add: (a: number, b: string) => string

interface Add {
    (a: number, b: string): string
}
type Add2 = (a: number, b: string) => string
type Add3 = (a: number, b?: string) => string
//type 和 interface 的区别: 
//1. type关键字是声明类型别名的关键字 interface是定义一个接口类型
//2. type 能够表示非对象类型， 而 interface 则只能表示对象类型。
//3. interface可以继承其他的接口、类等对象类型， type 不支持继承。

//调用
let myNubmer: Add2 = (a, b) => b + a
//console.log(myNubmer(1, '张')) 张1

let myNubmer2: Add3 = (a, b = '李') => b + a
//console.log(myNubmer2(2)) 李2

//函数重载
function myFun(a: number, b: number): number
function myFun(a: string, b: string): string
function myFun(a: any, b: any): any {
    if (typeof a === 'number') {
        return a * b
    }
    if (typeof a === 'string') {
        return a + b
    }
}
// myFun(2,3)
// myFun('2','3')

// 接口封装
interface Lib {
    (): void,
    version: string,
    add(): void
}

function getlib() {
    let lib: Lib = (() => { }) as Lib
    lib.version = '1.0.0'
    return lib
}

let lib2 = getlib()
// console.log(lib2.version)

//************************************类************************************
class Dog {
    constructor(name: string) {
        this.name = name
    }
    public name: string //public公有属性 默认
    private getname() { //private为私有属性，只能在类中调用
        return this.name
    }
    protected pro() { } //protected保护属性，只能在类及其子类中访问
    readonly age: number = 2 // readonly只读属性
    static food: string = '罐头' //静态属性 只能类名访问
    static pro2() { }
}
console.log(Dog.prototype) //constructor:f getname:f
let dog = new Dog('小白')
console.log(dog) //name: "小白" 1.内部属性只在实例上 不在原型上

//继承
class Husky extends Dog {
    constructor(name: string, color: string, public sex: string) {
        super(name)//super=>父类constructor
        this.color = color
    }
    color: string
}
let dog2 = new Husky('旺财', 'black', '公')
// console.log(Husky.food) 静态属性可以被继承
//console.log(dog2) age: 2,color: "black",name: "旺财",sex: "公"

//抽象类 (不能被实例化)
abstract class Animal {
    name: string = '抽象'
    abstract eat(): void //抽象方法 继承类必须定义改方法
}

class Animal2 extends Animal {
    eat() {
        console.log('eat')
        return 1
    }
}
let animal = new Animal2()
animal.eat()
console.log(animal.name)

//链式调用
class workFlow {
    step1() {
        return this
    }
    step2() {
        return this
    }
    step3() {
        return this
    }
}

class myFlow extends workFlow {
    next1() {
        return this
    }
    next2() {
        return this
    }
}

new myFlow().next1().step1().next2().next2()

//************************************接口与类的关系************************************

//接口约束类
interface Human {
    name: string
    eat(): void
}

class Asin implements Human {
    name: '1'
    eat() {
        return '吃'
    }
}

interface Human2 extends Asin {
    //name: string
    //eat():string
}


// class Asin3 implements Human2{
//     name:'1'
//     eat(){
//         return '2344'
//     }
//     name2:1
// }

class Asin4 extends Asin implements Human2 {

}

//************************************泛型************************************
//泛型方法
function log<T>(value: T): T {
    console.log(value)
    return value
}
log<string[]>(['a', 'b'])
log<number>(1)

interface Log<T> {
    (value: T): T
}

let mylog: Log<number> = log
// mylog(1)

//泛型约束类
class Log1<T>{
    run(value: T) {
        return value
    }
}
let myLog1 = new Log1<string>()
myLog1.run('1')

//泛型约束
interface LogLength {
    length: number
}

function log3<T extends LogLength>(value: T) {
    console.log(value.length)
}
//************************************类型推断************************************
let ssa = 1 //类型推断number
//ssa = '1'  error:不能将类型“string”分配给类型“number”

//************************************高级类型************************************

//
interface DogInterface {
    run(): void
}
interface CatInterface {
    jump(): void
}
//交叉类型 取并集
let per: DogInterface & CatInterface = {
    run() { },
    jump() { }
}
//字面量联合类型
let g3: 1 | 2 | 3
g3 = 1

//
interface Reactangle {
    name: 'no1',
    size: number
}
interface Circle {
    name: 'no2',
    watch: number,
    height: number
}
interface Dircle {
    name: 'no3',
    are: number
}
type calculate = Circle | Reactangle | Dircle

function arer(value: calculate) {
    switch (value.name) {
        case 'no1':
            console.log(value.size * 2)
            return value.size * 2
        case 'no2':
            console.log(value.height * value.watch)
            return value.height * value.watch
        case 'no3':
            return value.are
        default:
            return ((e: never) => { throw new Error(e) })(value)
    }
}
// console.log(arer({name:'no1',size:5}))  10
// console.log(arer({name:'no3',are:5})) 5
//索引类型
let obj2 = {
    a: 1,
    b: 2,
    c: 3
}

function getValue(obj, keys) {
    return keys.map(key => obj[key])
}

// console.log(getValue(obj2, ['a', 'b']))
// console.log(getValue(obj2, ['a', 'b', 'd'])) [1, 2, undefined]

let obj3 = {
    a: 1,
    b: 2,
    c: 3
}

function getValue2<T,K extends keyof T>(obj:T, keys:K[]):T[K][] {
    return keys.map(key => obj[key])
}

//  console.log(getValue2(obj3, ['a', 'b', 'd'])) error: 不能将类型“"d"”分配给类型“"a" | "b" | "c"”

//条件类型
type TypeName<T> = 
        T extends string?"string":
        T extends number?"number":
        T extends boolean?"boolean":"object"

type T1 = TypeName<string>

//************************************为JS编写声明文件************************************
import modules from './module/index'
console.log(modules,'声明文件')