TypeScript函数和类

函数介绍

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

1.函数的基本类型

//匿名函数
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(21,1);
console.log(`我今天写代码${res1}小时`);

//箭头函数
// const styMeimei=(time:number):void=>{
//     console.log(`郭旭家里有${time}元票票`);
// }

 const styMeimei=(time:number):void=> console.log(`郭旭家里有${time}元票票`);
 styMeimei(3000);

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

 const myFunc:myFunc =(a:number,b:number)=> a+b

2.函数参数的处理

可选参数:

在TypeScript函数里，如果我们定义了参数，则我们必须传入这些参数，除非将这些参数设置为可选，可选参数使用问号标识

默认参数

我们也可以设置参数的默认值，这样在调用函数的时候，如果不传入该参数的值，则使用默认参数

剩余参数:

有一种情况，我们不知道要向函数传入多少个参数，这时候我们就可以使用剩余参数来定义。剩余参数语法允许我们将一个不确定数量的参数作为一个数组传入。...args:any[]

//可选参数
// const func1:(a:number,b:number)=>number=(x:number,y:number)=>{
//     return x;
// }
// const func2=function(a:number,b?:number):number{
//     return a;
// }
// func2(10);
// func2(10,20);
// func2(10,undefined);

//参数的默认值
// const fun3=function(x:number,y:number,z:number=300){
//     return x+z+y;
// }
// let res = fun3(100,200);
// console.log(res);

// let res = fun3(100,200,400);
// console.log(res);

const  fun3=function(x:number=100,y:number=200,z:number=300){
    return x+y+z;
}
let res = fun3(100,200,400);
fun3();
fun3(1,2)
console.log(res);

//函数的剩余参数
const func4 = function(...args:any[]){
    console.log(args);
    
}
func4(21,25,30,"库里");

const func5 =function(a:number,b:number, ...args:any[]){
    console.log(a);
    console.log(b);
    console.log(args);
}

func5(44,77,36,69,"拉文");

3.构造函数

Typescript 也支持使用JavaScript内置的构造函数Function()来定义函数

参数说明:

 arg1, arg2, ... argN:参数列表

functionBody:一个含有包括函数定义的JavaScript语句的字符串。

export default{}

//构造函数

var myfunc=new Function("a","b","return a*b");
var res =myfunc(21,79);
console.log(res);

4.重载函数

重载是方法名字相同，而参数不同，返回类型可以相同也可以不同。

每个重载的方法（或者构造函数)都必须有一个独一无二的参数类型列表。

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

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

export default {}
//函数重载
// 重载是方法名字相同，而参数不同r返回类型可以相同也可以不同。
// 每个重载的方法（或者构造函数)都必须有一个独一无二的参数类型列表。
 
function addFunc(a: number, b: number): number
function addFunc(a: string, b: string): string
function addFunc(a: number, b: string): number
function addFunc(a: string, b: number): number
function addFunc(a: any, b: any): any {
    return a + b;
}
addFunc(10, 20);
addFunc("刘亦菲", "鞠婧祎");
addFunc("杨幂", 18);
addFunc(18, "迪丽热巴");
 
 
//参数数量不同
function star(s1: string): string
function star(s1: number, n1: number): void
function star(s1: any, n1?: any): any {
    let res = s1 + n1;
    console.log(s1);
    console.log(n1);
}
star("11");
star(10, 10);
 
 

类

1.类的基本使用

export default{}

//类的基本使用
class person{
    //字段
    name:string
    age:number

    //构造函数
    constructor(name:string,age:number){
        this.name=name;
        this.age=age;
    }
    //函数(方式)
    sayHello():void{
        console.log(`我的女神是${this.name}0她今年${this.age}.在我心里他永远是3岁`);
    }
}
//实例化类
let p=new person("郭旭",11);
p.sayHello();

2.类的继承

export default{}
//类的基本使用
class person{
    //字段
    name:string
    age:number

    //构造函数
    constructor(name:string,age:number){
        this.name=name;
        this.age=age;
    }
    //函数(方式)
    sayHello():void{
        console.log(`我的女神是${this.name}0她今年${this.age}.在我心里他永远是3岁`);
    }
}
//实例化类
let p=new person("郭旭",11);
p.sayHello();
class Student 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}.今年${this.age}岁.我的成绩是${this.score}`);
    }
}
let s =new Student("虢胥",10,"A");
s.sayHello();

3.static与instanceof

static关键字用于定义类的数据成员(属性和方法)为静态的，静态成员可以直接通过类名调用。.instanceof运算符用于判断对象是否是指定的类型,如果是返回true，否则返回false,

export default{}

//static 关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用。
class StaticTest{
    static salary:number
    static say():void{
        console.log(`我们想要的工资是${StaticTest.salary}k`)
    }
}
StaticTest.salary=15;
StaticTest.say();
//instanceof运算符
//instanceof运算符用于判断对象是否是指定的类型，如果是返回 true，否则返回 false.
class Person{}
let p=new Person();
let isPerson= p instanceof Person;
console.log("p是实例化出来吗？",isPerson);

class Student extends Person{}

let s =new Student();
let isStudent=s instanceof Person;
console.log("s是 Person实例化出来吗",isStudent);

4.类的修饰符

export default {}
// public(默认): 公有，可以在任何地方被访问
// protected: 受保护，可以被其自身以及其子类访问
// private: 私有，只能被其定义所在的类访问。
 
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 Student 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);
    }
}
let s = new Student("王心凌", 18, "女", "A");
s.say();
 
//readonly: 可以使用readonly关键字将属性设置为只读的。只读属性必须在声明时或构造函数里被初始化。
class Print {
    readonly str1: string = "我是声明时赋值的"
    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;
    }
    hx() {
        console.log(this.str1, this.str2, this.str3, this.str4, this.str5);
 
    }
}
let ss = new Print("库里1", "库里2", "库里3", "库里4");
ss.hx();

5.getter与setter

官万的另外一个名字:存取器

通过getters/setters来截取对对象成员的访问

注意点:

如果存在get，但没有set，则该属性自动是只读的

如果没有指定setter参数的类型，它将从getter的返回类型中推断出来访问器和设置器必须有相同的成员可见性

export default {}
// 如果存在get，但没有set，则该属性自动是只读的
// 如果没有指定setter参数的类型，它将从getter的返回类型中推断出来访问器和设置器必须有相同的成员可见性
 
class MyName {
    private _fullName: string = "杨幂";
    //读取字段的值
    get fullName() {
        console.log("获取到get属性");
        return this._fullName;
    }
    //添加字段值 
    set fu11Name(newName: string) {
        console.log("获取到set属性");
        this._fullName = newName;
    }
}
let n = new MyName();
n.fu11Name = "刘亦菲";//赋值
 
console.log(n);
console.log(n.fullName);//取值

6.抽象类

定义

抽象类做为其它派生类的基类使用。它们一般不会直接被实例化抽象类是专门用于定义哪些不希望被外界直接创建的类的

抽象类和接口一样用于约束子类

抽象类和接口区别

抽象方法必须包含abstract关键字并且可以包含访问修饰符

接口中只能定义约束,不能定义具体实现。而抽象类中既可以定义约束,又可以定义具体实现

export default {}
// 定义
// 抽象类做为其它派生类的基类使用。它们一般不会直接被实例化抽象类是专门用于定义哪些不希望被外界直接创建的类的
// 抽象类和接口一样用于约束子类
 
// 抽象类和接口区别
// 抽象方法必须包含abstract关键字并且可以包含访问修饰符
// 接口中只能定义约束, 不能定义具体实现。而抽象类中既可以定义约束, 又可以定义具体实现
abstract class Person {
    abstract name: string
    abstract age: number
    abstract show(): string
 
    showName(): void {
        console.log("hello world");
 
    }
}
 
class Studemt extends Person {
    name: string = "张三"
    age: number = 18
    show() {
        return "仙剑奇侠传"
    }
}
 
let s = new Studemt()
let res = s.show()
console.log(res);

7.类的初始化顺序

基类的字段被初始化
基类构造函数运行子类的字段被初始化·子类构造函数运行

基类构造函数运行子类的字段被初始化·子类构造函数运行

export default {}
class Old {
    name: string = "李易峰";
    constructor() {
        console.log(`我是${this.name}，我主演了古剑奇谭`);
    }
}
class Young extends Old {
    name: string = "刘亦菲";
    constructor() {
        super();
        console.log(`我是${this.name},我主演了天龙八部`)
    }
};
let y = new Young();