TypeScript

unkonw只能作为任意类型的父类 不能作为任意类型的子类

一般使用

// object  表示一个js对象
let a: object
a = {}
a = function() {
}

// {} 用来指定对象中可以包含哪些属性
// 语法：{属性名：属性值，属性名：属性值}
// 在属性名后边加上? 表示属性是可选的
let b:{name:string,age?:number}
b = {name:'小明',age:12}

// [proName:string]:any 表示任意类型的属性
let c: {name:string,[proName:string]:any}
c = {name:'小红',age:12,gender:'女'}


// 设置函数结构的类型声明
// 语法 ：(形参：类型,形参：类型...) => 返回值

let d :(a:number,b:number) => number;
d = function(n1:number,n2:number):number{
    return 12
}

// 数组的类型声明
// 类型[]   Array<类型>
// string[]  表示字符串数组
let e:string[]
e = ['a','c']

// number[] 表示数值数组
let f: number[]
let g:Array<number>
f=[1,2,3]


// 元组,元祖 就是固定长度的数组
// 语法：[类型，类型，类型]

let h:[string,number]
h = ['sss',123]


// enum枚举   选择限制

enum Gender{
    Male,
    Female
}

let i:{name:string,gender:Gender}
i = {
    name:'小玲',
    gender:Gender.Male  //将选择限制在一个对象中
}

// &表示同时
let j: {name:string}&{age:number}
j = {name:'孙伟',age:123}


// 类型的别名
type myType = 1 | 2 | 3 | 4 | 5;
let k: myType;
let l: myType
let m: myType

k = 1

abstract 抽象类

// 以abstract开头的类是抽象类
// 抽象类与其他类区别不大   只是不能用来创建对象
// 抽象类 就是专门用来被继承的类
// 抽象类中可以添加抽象方法

abstract class Animal{
    name:string;
    constructor(name:string){
        this.name = name
    }
    //定义一个抽象方法
    // 抽象方法使用abstract开头 没有方法体
    //抽象方法只能定义在抽象类中   子类必须对抽象方法进行重写
    abstract sayHello():void;
}

class Dog extends Animal{
    sayHello(){
        console.log('汪汪');
    }

    play(){
        console.log('玩骨头');
              
    }
}
const dog = new Dog('小黄')
console.log(dog);

interface 接口

      // 描述一个对象的类型
        type myType = {
            name: string,
            age: number
        }

        // 接口用来定义一个类结构  用来定义一个类中应该包含哪些属性和方法
        // 同时接口也可以当成类型声明去使用
        interface myInterface {
            name:string,
            age:number
        }
        interface myInterface {
            gender:string
        }

        const obj: myInterface = {
            name:'ssss',
            age:11,
            gender:'女'
        }






        
        // 接口可以在定义类的时候去限制类的结构
        // 接口中的所有属性都不能有实际的值
        // 接口只定义对象的结构  而不考虑实际值
        // 在接口中所有的方法都是抽象方法
        interface myInter{
            name:string;
            sayHello():void;
        }

        // 定义类时 可以使类去实现一个接口
        // 实现接口就是使类满足接口的要求
        class MyClass implements myInter{
            name:string;
            constructor(name:string){
                this.name = name
            }
            sayHello(){
                console.log('hello');  
            }
        }
        const name  = new MyClass("wa")

属性的封装

        //定义一个表示人的类
        class Person{
            //TS可以在属性前添加属性的修饰符
            // public修饰的属性可以在任何位置访问（修改）默认值
            // private私有属性   私有属性只能在类内部进行访问（修改）
            // 通过在类中添加方法使得私有属性可以被外部访问
            // protected 受包含的属性，只能在当前类和当前类的子类中访问  修改
            private _name:string;
            private _age:number;
            constructor(name:string,age:number){
                this._age = age
                this._name = name
            }

            // getter方法用来读取属性
            // setter方法用来设置属性
            // 它们被称为属性的存取器


            // 定义方法  用来获取name属性
            // getName(){
            //     return this._name
            // }

            // // 定义方法  用来设置name属性
            // setName(value:string){
            //     this._name = value
            // }
            // getAge(){
            //     return this._age
            // }
            // setAge(value:number){
            //     // 判断年龄是否合法
            //     if(value>0){
            //         this._age = value
            //     }
            // }
            // TS中设置getter方法的方式
            get name(){
                return this._name
            }
            set name(value){
                this._name = value
            }
            get age(){
                return this._age
            }
            set age(value){
                if(value>=0){
                    this._age = value
                }
            }
        }
        const per = new Person('小明',21)
        // 现在属性是在对象中设置的  属性可以任意的被修改
        // 属性可以任意的被修改将会导致对象中的数据变得非常不安全
        // per.setName('小红')
        // per.setAge(11)

        per.name = '小刚'
        per.age = 123





        class A{
            protected num:number;
            constructor(num:number){
                this.num = num
            }
        }

        class B extends A{
            test(){
                console.log(this.num);
            }
        }
        const b = new B(123)
        // b.num = 33




        class C{
            //可以直接将属性定义在构造函数中
            constructor(public name:string,public age:number){
            }
        }
        const c = new C('小小', 111)

泛型

// function fn(a:any):any{
//     return a
// }


// 在定义函数或是类时  如果遇到类型不明确就可以使用泛型
function fn<T>(a:T):T{
    return a
}

// 可以直接调用具有泛型的函数
let result = fn(10) //不指定类型，TS可以自动对类型进行推断

let result2 = fn<string>('hello')  //指定泛型



// 泛型可以同时指定多个
function fn2<T,K>(a:T,b:K):T{
    console.log(b);
    return a
}

fn2<number,string>(123,'hello')


interface Inter{
    length:number
}

//T extends Inter  表示泛型T必须是Inter实现类（子类）
function fn3<T extends Inter>(a:T):number{
    return a.length
}

class MyClass<T>{
    name:T;
    constructor(name:T){
        this.name = name
    }
}
const mc = new MyClass<string>('小智')

https://www.kancloud.cn/wangjiachong/vue_notes/2165553