typescript学习笔记

基本类型

boolean：true和false，表示是否正确

number：浮点数

string：文本

array：数组，let list : number[] = [] or let list:Array<number> = []

enum：枚举，enum Color {Red,Blue}; var c ： Color = Color.Red

any：任意JS值进行最小静态化检查，var list:any[] = [1,true,'']

void：没有返回值

注：undefined 和 null，不能作为变量类型赋值

联合类型：

　　声明可以存储多种类型值变量

　　let path : string|string[]

TypeScript 中类的用法    public private 和 protected

• public 修饰的属性或方法是公有的，可以在任何地方被访问到，默认所有的属性和方法都是 public 的
• private 修饰的属性或方法是私有的，不能在声明它的类的外部访问
• protected 修饰的属性或方法是受保护的，它和 private 类似，区别是它在子类中也是允许被访问的

• abstract 用于定义抽象类和其中的抽象方法。 

•  抽象类是不允许被实例化的，即不能通过new去实例化，只能被继承

• 抽象类中的抽象方法必须被子类实现，即使用abstract 定义为抽象方法，那么必须在子类实现

　　 常用

declare 定义只读的变量；

/*
* 可索引接口
*
* */
// 对数组的的约束
```
interface Lx {
    [idnex:number]:string
}
var arr:Array<string>=["1111111","2222222"]
console.log(arr[1])

//对对象的约束：index为string类型
interface Obj {
    [index:string]:string
}
var obj:Obj={"jing":"guorui"}
console.log(obj)
```
//---------------------------------------------------------------------
/*
* 类类型的接口，
*implements用来继承类类型接口
* */
interface Animal {
    name:string,
eat(str:string):void
}
class Dog implements Animal{
    name:string
    constructor(name:string){
        this.name=name
    }
    eat(){
        console.log(this.name+"吃粮食")
    }
}
var dog=new Dog("狗")
dog.eat()
//---------------------------------------------------------------
/*
* 接口扩展，接口可以继承
*接口通过extends来继承另一个接口
* 接口通过implements来规范接口
* 子类继承父类，然后继承接口的使用
* 子类通过class wen extends Person implements Ren来继承接口以及父类的方法，
* 子类拥有了父类的方法，以及接口的规范
* */
interface Animals {
    eat():void
}
interface Ren extends Animals{
    work():void
}
class Person{
    public name:string
    constructor(name:string){
        this.name=name
    }
    xie(code:string){
        console.log(this.name+code)
    }
}

class wen extends Person implements Ren{
    constructor(name:string){
        super(name)
    }
    eat() {
        console.log(this.name+"喜欢吃馒头")
    }
    work(){
        console.log(this.name+"喜欢工作")
    }
}

var w=new wen("我")
w.work()
w.eat()
w.xie("喜欢玩游戏")
//-------------------------------------------------------
/*
* typescript中的泛型<T>
* 定义：在软件工程中我们不仅要创建一致的良好的api，同时也要考虑可重用性，以及对未来位置类型的定义
*any放弃了类型检查，typescript要求类型检查，传入number类型，必须返回number类型；
*泛型可以不支持特定的数据类型
* */

//<T>表示泛型，具体什么类型，调用这个方法的时候决定
function getData<T>(val:T) :T{
    return val
}
var s1=getData<string>("经过瑞")
var s2=getData<number>(1111)
console.log(s1,s2)

//泛型类,add表示添加，min表示返回一个最小值
class MinClass<T> {
    public list:T[]=[]
    add(num:T):void{
        this.list.push(num)
    }
    min():T{
       var minnum=this.list[0]
        for(var i=0;i<this.list.length;i++){
            if(minnum>this.list[i]){
                minnum=this.list[i]
            }
        }
        return minnum
    }
}
var m=new MinClass<number>();
m.add(12)
m.add(41)
m.add(22)
console.log(m.min())

var m1=new MinClass<string>();
m1.add("a")
m1.add("s")
m1.add("c")
console.log(m1.min())

/*----------------------------------------------------------------------
* 命名空间的使用
* */
namespace Draw{
    export class Animal {
        constructor(){

        }
        public eat(){
            console.log("aaaa")
        }
    }
}

var aa = new Draw.Animal()
aa.eat()