typeScript存取器

函数

//匿名函数

const fn = function(x:number,y:number):number(返回值的类型){return x+y}；

//箭头函数

const fn = (x:number):void=>console.log(x);

//接口函数

type my = (x:number,y:number)=>number;

const myHour:my=(a:number,b:number)=>a+b;

函数参数处理

可选参数：在形参后面加上?.

默认值：在形参后面加等号和值，然后不传值就用默认值，如果传值就是传入的值。

剩余参数：...然后就可以传入任意数量的值。

export default{}

// 可选参数
// 可以单独输出但是不能运算
const fn_1=(x:number,y?:number)=>{
    return y
}
console.log(fn_1(100,200));

// 默认值
const fn_2 =(x:number,y:number=200)=>{
    return x+y
}
console.log(fn_2(100));

// 剩余参数
const fn_3 = (x:number,...arrs:any[])=>{
    console.log(x);
    console.log(arrs);
}
fn_3(100,"王瑞利","田利业","杨杜坤")

构造函数

// 关键字 Function
const fn = new Function("a","b","if(a*b<100){return a}else{return b}");
console.log(fn(100,200));

​

函数重载

重载是方法名字相同，而参数不同，返回类型可以相同也可以不同。 每个重载的方法(或者构造函数〉都必须有一个独一无二的参数类型列表。

export default{}

// 设置函数重载

// 重载是方法名字相同，而参数不同，返回类型可以相同也可以不同。
// 每个重载的方法(或者构造函数〉都必须有一个独一无二的参数类型列表。
function fn(x:number,y:number):number
function fn(x:number,y:string):string
function fn(x:string,y:string):string
function fn(x:string,y:number):string

function fn(x:any,y:any){
    return x+y
}
console.log(fn(1,2));
console.log(fn(1,"田利业"));
console.log(fn("田利业","田利业"));
console.log(fn("田利业",2));

// 参数不同的情况

function fn_1(x:number):number
function fn_1(x:number,y:string):string
function fn_1(x:any,y?:any){
    // return x;
    return y;
    
}

console.log(fn_1(10));
console.log(fn_1(10,"哈哈哈"));

类

定义类的关键字为class，后面紧跟类名，类可以包含以下几个模块（类的数据成员):·字段-字段是类里面声明的变量。字段表示对象的有关数据。 构造函数-类实例化时调用,可以为类的对象分配内存。·方法-方法为对象要执行的操作。

// 创建一个类
class Person{
    name:string;
    age:number;
    // 创建一个构造函数  里面参数可以随便命名但是最好要有意义
    constructor(name:string,age:number){
        // this指向Person这个类
        this.name=name;
        this.age=age
    }
    // 创建一个方法
    sayHello():void{
        console.log(`我叫${this.name},今年${this.age}`);
        
    }
}
// 实例化一个类
let p = new Person("杨杜坤",21);
// 使用方法
p.sayHello()

类的继承

export default {}
​
// 创建一个类
class Person{
    name:string;
    age:number;
    // 创建一个构造函数  里面参数可以随便命名但是最好要有意义
    constructor(name:string,age:number){
        // this指向Person这个类
        this.name=name;
        this.age=age
    }
    // 创建一个方法
    sayHello():void{
        console.log(`我是父类,今年${this.age}`);
        
    }
}
// 实例化一个类
// let p = new Person("杨杜坤",21);
// // 使用方法
// p.sayHello()
​
// 类的继承
class Person_1 extends Person{
    score:string;
    constructor(name:string,age:number,score:string){
        // 继承父类中的属性
        super(name,age);
        this.score=score;
    }
    sayHello(): void {
        // 调用父类的方法
        super.sayHello();
        console.log(`我是${this.name},`);
        
    }
}
// 实例化类
let p = new Person_1("子类",19,"A");
p.sayHello()

static与instanceof

static关键字用于定义类的数据成员(属性和方法)为静态的,静态成员可以直接通过类名调用。

instanceof运算符用于判断对象是否是指定的类型，如果是返回true,否则返回false.

export default{}

// static
class Person{
    static sex:string;
    static say():void{
        console.log(`我叫${this.sex}`);
        
    }
}
Person.sex = "杨杜坤";
Person.say()

// instanceof
// 判断是否是指定类型返回true false
class Person_1{}
let p = new Person_1();
let isPerson_1 = p instanceof Person_1;
console.log("返回"+isPerson_1);

类中的修饰符

public(默认):公有,可以在任何地方被访问

protected:受保护，可以被其自身以及其子类访问。

private:私有,只能被其定义所在的类访问。

readonly: 可以使用readon1y关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。

getter与setter

官方的另外一个名字:存取器 通过getters/setters来截取对对象成员的访问

注意点: 如果存在get，但没有setI则该属性白动是只读的 如果没有指定setter 参数的类型，它将从getter的返回类型中推断 出来访问器和设置器必须有相同的成员可见性

export default {}
// 创建类
class fn{
    private _name : string ="赋值";
    // 取值
    get name_1():string{
        console.log("get被调用了");
        return this._name
    }
    // 赋值 
    set name_1(name:string){
        console.log("set被调用了");
        this._name = name;
    }
}
let p = new fn();
// 因为这是赋值的过程所以会先输出set
p.name_1 = "田利业";
console.log(p);
console.log(p.name_1);

抽象类

定义 抽象类做为其它派生类的基类使用。它们一般不会直接被实例化 抽象类是专门用于定义哪些不希望被外界直接创建的类的 抽象类和接口一样用于约束子类 抽象类和接口区别 抽象方法必须包含abstract关键字并且可以包含访问修饰符 接口中只能定义约束,不能定义具体实现。而抽象类中既可以定义约束,又可以定义具体实现

export default {}

// 创建一个抽象类
abstract class  fn {
    abstract name:string;
    abstract age:number;
    abstract show():string;
}

// 继承抽象类
class name extends fn{
    name="杨杜坤";
    age=21;
    show():string {
        return this.name        
    }
}
// 实例化
let p = new name();
console.log(p.show());