Typescript--4节

你的名字 2021-07-24 18:51 372阅读 0赞

# Typescript–4节 #

## Typescript枚举 ##

*  枚举（Enum）类型用于取值被限定在一定范围内的场景
 *  采用关键字enum定义，例如:enum、Days
 *  枚举成员会被赋值为从0开始递增的数字，同时也会被枚举值到枚举名进行反向映射

代码实例  
编译前

//使用枚举可以定义一些有名字的数字常量  
    enum Days{
        Sun=0,
        Mon,
        Tue,
        Wed,
        Thu,
        Fri,
        Sat
    }
    
    console.log(Days.Sun);//0
    console.log(Days.Sat);//6
    console.log(Days);//枚举类型会被编译成一个双向映射的对象
    console.log(Days[0]==='Sun');//true

编译后

//使用枚举可以定义一些有名字的数字常量  
    var Days;
    (function (Days) {
        Days[Days["Sun"] = 0] = "Sun";
        Days[Days["Mon"] = 1] = "Mon";
        Days[Days["Tue"] = 2] = "Tue";
        Days[Days["Wed"] = 3] = "Wed";
        Days[Days["Thu"] = 4] = "Thu";
        Days[Days["Fri"] = 5] = "Fri";
        Days[Days["Sat"] = 6] = "Sat";
    })(Days || (Days = {}));
    console.log(Days.Sun); //0
    console.log(Days.Sat); //6
    console.log(Days); //枚举类型会被编译成一个双向映射的对象
    console.log(Days[0] === 'Sun'); //true

![运行结果][20200221144717577.png]

## Typescript类的修饰符 ##

*  public private和protected
 *  public修饰的属性或者方法是共有的，可以在任何地方被访问到，默认所有的属性或者方法都是public的
 *  private修饰的属性或者方法是私有的，不能在声明它的类外面访问
 *  protected修饰的属性或者方法是受保护的，它和private类似

代码实例：  
编译前

//创建一个Person类    
    class Person{
        private name:"张三疯"
        protected age:19
        say(){
            console.log("我的名字是"+this.name+",我的年龄为："+this.age);
        }
    }
    
    //创建Person的实例 
    // var p=new Person();
    // p.say();
    // private属性只能在类的内部进行访问!!!
    // console.log(p.name);//当一个类成员变量没有修饰的时候，外界是可以进行访问的，默认就是public进行修饰
    
    //创建一个Child子类  
    //一旦父类将属性定义成私有的之后，子类就不可以进行访问了
    //父类的属性定义成受保护的之后，可以在子类里面进行访问!
    class Child extends Person{
        callParent(){
            // console.log(super.age);
            super.say();
        }
        static test(){
            console.log("test");
        }
    }
    
    var c=new Child();
    c.callParent();
    // console.log(c.age);//子类继承了父类，但是没有办法直接获取到私有的属性或者受保护的属性
    console.log(c.say());//子类继承了父类，子类就可以访问到父类公开的属性或者方法了
    console.log(Child.test());//类的静态方法里面，是不允许this

编译后

## Typeascript泛型 ##

**泛型是指在定义函数、接口或者类的时候，不预先指定具体类型，而在使用的时候再指定类型的一种特性**  
代码实例:  
编译前

//没有确切的定义返回值类型，运行的数组每一项都可以是任意类型
    // function createArray(length:number,value:any):Array<any>{
    //     let arr=[];
    //     for(var i=0;i<length;i++){
    //         arr[i]=value;
    //     }
    //     console.log(arr);
    //     return arr;
    // }
    // createArray(3,1);
    
    
    //使用泛型将其进行改造  
    //不传的时侯根据类型进行倒推
    //泛型可以帮助我们限定约束规范
    function createArray<T>(length:number,value:T):Array<T>{
        let arr=[];
        for(var i=0;i<length;i++){
            arr[i]=value;
        }
        console.log(arr);
        return arr;
    }
    
    var strArr:string[]=createArray<string>(3,'1');
    var numArr:number[]=createArray(3,1);  
    
    
    //接口当中采用泛型
    interface ICreate{
        <T>(name:string,value:T):Array<T>
    }
    let func:ICreate;
    func=function<T>(name:string,value:T):Array<T>{
        return [];
    }
    var strArr2:string[]=func("张三疯",'str');
    console.log(strArr2);

编译后

//没有确切的定义返回值类型，运行的数组每一项都可以是任意类型
    // function createArray(length:number,value:any):Array<any>{
    //     let arr=[];
    //     for(var i=0;i<length;i++){
    //         arr[i]=value;
    //     }
    //     console.log(arr);
    //     return arr;
    // }
    // createArray(3,1);
    //使用泛型将其进行改造  
    //不传的时侯根据类型进行倒推
    //泛型可以帮助我们限定约束规范
    function createArray(length, value) {
        var arr = [];
        for (var i = 0; i < length; i++) {
            arr[i] = value;
        }
        console.log(arr);
        return arr;
    }
    var strArr = createArray(3, '1');
    var numArr = createArray(3, 1);
    var func;
    func = function (name, value) {
        return [];
    };
    var strArr2 = func("张三疯", 'str');
    console.log(strArr2);

[20200221144717577.png]: /images/20210724/7531006fe6f346388812d89f9ac83336.png