Typescript--4节

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

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

编译后

var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
//创建一个Person类    
var Person = /** @class */ (function () {
    function Person() {
    }
    Person.prototype.say = function () {
        console.log("我的名字是" + this.name + ",我的年龄为：" + this.age);
    };
    return Person;
}());
//创建Person的实例 
// var p=new Person();
// p.say();
// private属性只能在类的内部进行访问!!!
// console.log(p.name);//当一个类成员变量没有修饰的时候，外界是可以进行访问的，默认就是public进行修饰
//创建一个Child子类  
//一旦父类将属性定义成私有的之后，子类就不可以进行访问了
//父类的属性定义成受保护的之后，可以在子类里面进行访问!
var Child = /** @class */ (function (_super) {
    __extends(Child, _super);
    function Child() {
        return _super !== null && _super.apply(this, arguments) || this;
    }
    Child.prototype.callParent = function () {
        // console.log(super.age);
        _super.prototype.say.call(this);
    };
    Child.test = function () {
        console.log("test");
    };
    return Child;
}(Person));
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);