TS2 9/8笔记

函数的基础使用

·介绍
函数是JavaScript应用程序的基础。它帮助你实现抽象层，模拟类，信息隐藏和模块。在TypeScript里，虽然已经支持类，命名空间和模块，但函数仍然是主要的定义行为的地方。TypeScript为JavaScript函数添加了额外的功能，让我们可以更容易地使用
·函数定义的方式
 

export default {}
//匿名函数
const makeMoney=function(salary:number,reward:number):number{
    return salary+reward
}
let res=makeMoney(1000,500);
console.log(res);

//有名函数 | 命名函数 | 普通函数
function writeCode(hour:number,sleep:number):number{
    return hour;
}
let res1=writeCode(0,1);
console.log(`我今天学习${res1}小时`);


//箭头函数
const seeMeimei=(time:number):void=>{
    console.log(`黄兵理每天奖励自己${time}小时`)
}
seeMeimei(24);

//接口函数
type myFunc = (x: number, y: number) => number
const myFunc: myFunc = (a: number, b: number) => a + b

let res2 = myFunc(3, 2)
console.log(res2);

函数参数的处理

export default{}

// 可选参数
const fun1:(a:number,b:number)=>number=(x:number,y:number)=>{
    return x
}

const fun2=function(a:number,b?:number):number{
    return a
}

fun2(10)
fun2(10,20)
fun2(10,undefined)


// 参数的默认值
const fun3=function(x:number=2,y:number=1,z:number=100){
    return x+y+z
}

let res=fun3(100,200,300)
fun3()
fun3(1,2)

console.log(res);


// 函数的剩余参数
const fun4=function(...args:any[]){
    console.log(args);
    
}
fun4(1,2,34,5,"哈哈")


const fun5=function(a:number,b:string,...args:any[]){
    console.log(a);
    console.log(b);
    console.log(args);
    
}
fun5(10,"heihei",43,"哈哈","嘿嘿")

构造函数

export default {}

//构造函数
var myfunc=new Function("a","b","return a*b");
var res = myfunc(10,20);
console.log(res);

函数重载

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

 

如果参数类型不同,则参数类型应设置为any。

参数数量不同你可以将不同的参数设置为可选。

export default{}

//函数重载
function fun1(a:number,b:number):number
function fun1(a:string,b:string):string
function fun1(a:number,b:string):number
function fun1(a:string,b:number):number

function fun1(a:any,b:any):any{
    return a+b
}
console.log(fun1(10,20));

//参数数量不同
function fun2(c:string):string
function fun2(c:number,d:number):number

function fun2(c:any,d?:any):any{
    console.log(c);
    console.log(d);
}

fun2("刘亦菲")
fun2(18,19)

类

·定义
TypeScript是面向对旅的JavaScript。

类描述了所创建的对象共同的属性和方法。

TypeScript支持面向对象的所有特性，比如类、接口等。

TypeScript类定义方式如下:

 定义类的关键字为class，后面紧跟类名，类可以包含以下几个模块(类的数据成员):

·字段-字段是类里面声明的变量。字段表示对象的有关数据。

·构造函数–类实例化时调用，可以为类的对象分配内存。

·方法-方法为对象要执行的操作。

export default{}
class hs{
    name:string
    age:number

    //构造函数
    constructor(name:string,age:number){
        this.name=name
        this.age=age
    }
    //函数方法
    sayHello():void{
        console.log(`我的女神叫${this.name},她今年${this.age}岁了`);   
    }
}
// 实例化类
let p =new hs("李沁",30)
p.sayHello()


class student extends hs{
    score:number
    constructor(name:string,age:number,score:number){
        super(name,age)
        this.score=score
    }
    sayHello(): void {
       super.sayHello()
       console.log(`我的男神叫${this.name},他今年${this.age}岁了,他的考试成绩是${this.score}`);
       
    }
}
let s=new student("陈赫",32,98)
s.sayHello()

类中的修饰符

public(默认):公有，可以在任何地方被访问
 protected:受保护，可以被其自身以及其子类访问

private:私有，只能被其定义所在的类访问。
·ireadonly:可以使用readon1y关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
 

export default{}

class Person{
    public name:string
    protected age:number
    private sex:string

    constructor(name:string,age:number,sex:string){
        this.name=name
        this.age=age
        this.sex=sex
    }
    say():void{
        console.log(`我的名字是${this.name}性别是${this.sex},年龄是${this.age}`);
    }
}

class Studemt extends Person{
    score:string
    constructor(name:string,age:number,sex:string,score:string){
        super(name,age,sex)
        this.score=score
    }
    say(): void {
        console.log(this.name);
        console.log(this.age);
        // console.log(this.sex);  //私有的
        console.log(this.score);
    }
}


//**readonly**:可以使用‘readonly`关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
class Print{
    readonly str4string="我是声明时赋值的"
    readonly str2 :string
    readonly str3:string
    readonly str4:string
    readonly str5:string
    constructor(str2:string,str3:string,str4:string,str5:string)
    {
    this.str2=str2;
    this.str3=str3;
    this.str4=str4;
    this.str5=str5
    }

    // say():void{
    //     this.str2="爱你"
    // }
    hs():void{
        console.log(this.str2,this.str3,this.str4,this.str5);
        
    }
}
let p=new Print("刘亦菲","刘亦菲2","刘亦菲3","刘亦菲4")
p.hs()

static与instanceof

export default {}

// class Person{
//     // 字段
//    static aa:string
//     // 方法
//    static sey():void{
//         console.log("我叫"+Person.aa);
//     }
// }
// Person.aa
// Person.sey()

class Person{}
let a = new Person
let a1 = a instanceof Person
console.log(a1);

class Student extends Person{}
let b = new Student
let b1 = b instanceof Person
console.log(b1);

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

*注意点:*
如果存在get，但没有set，则该属性自动是只读的
如果没有指定setter参数的类型，它将从getter的返回类型中推断出来

访问器和设置器必须有相同的成员可见性
 

export default {}

class MyName{
    private _fullName:string="杨幂";

    //读取字段的值
    get fullName(){
        console.log("get被调用了")
        return this._fullName;
    }

    //为字段赋值
    set fullName(newName:string){
        console.log("set被调用了")
        this._fullName=newName;
    }
}

let n=new MyName();
// n.fullName="刘亦菲"; //赋值

console.log(n);

 console.log(n.fullName);  //取值

2.6抽象类
定义
抽象类做为其它派生类的基类使用。它们一般不会直接被实例化

抽象类是专门用于定义哪些不希望被外界直接创建的类的
抽象类和接口一样用于约束子类

抽象类和接口区别
抽象方法必须包含abstract关键字并且可以包含访问修饰符
接口中只能定义约束,不能定义具体实现。而抽象类中既可以定义约束,又可以定义具体实现
 

export default {}

abstract class Person{
    abstract name:string
    abstract age:number
    abstract show():string

    showName():void{
        console.log("hello world");
    }
}

class Student extends Person{
    name: string="刘亦菲"
    age:number=18
    show(){
        return"仙剑奇侠传一";
    }
}

//let p =new Peraon()
let s = new Student();
let res = s.show();
console.log(res)
console.log()