Ts函数的及方法和类的基本使用

1函数的基本使用

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

2.函数定义的方式

匿名函数

const makeMoney = function(a:string,b:string){
return a+b
}
let aa =makeMoney("你好","世界")

有名函数|命名函数|普通函数

function writeCode(hour : number,sleep:number) :number{
    return hour;
}
let res1= writeCode(8,1);
console.log(`我今天写代码${res1}小时`);

箭头函数

const seeMeimei=(time : number ) : void=>{
    console.log(`我每天看${time}小l时meimei`);}
​
const seeMeimei1=(time:number ) :void=>console.log(`我每天看${time}小时meimei` );
seeMeimei1(2);
seeMeimei(8)
​
//接口
type aaa = (nun:number,tew:number)=>number
const Myfun:aaa =(x:number,y:number)=>x+y+200+0.2
​
let my = Myfun(100,200)
​
console.log(my);

2函数参数的处理

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

//可选参数
const fun1:(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);
​
//let res= func3(100, 200);
const func3=function(a:number=1,b:number=2,C:number=3){
    return a+b+C
}
let res= func3(103,200,400);
​
func3(); //600
func3(2,3);
console.log(res);

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

​
//函数的剩余参数
const func4 = function (...args : any[]){
    console.log(args);
}
func4(10,20 , 30,"赵四");
​
const func5 = function(a: number,b:number, ...args :any[]) {
    console.log(a);
    console.log(b);
    console.log(args);
}
func5(10,20 , 30,"神髓","韩赵燕");

3.构造函数

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

语法

var res = new Function ([arg1[，arg2[，...argN]],] functionBody)

参数说明:

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

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

export default{}
var my =new Function("b","a","return a*b")
var ars =my(10,20)
console.log(ars);

4函数重载

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

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

参数类型不同:

function disp(string) : void;
function disp(number) : void;

参数数量不同:

function disp(n1: number) : void;
function disp(x : number , y : number) : void;

参数类型顺序不同:

function disp(n1: number ,s1:string) :void;
function disp(s :string,n : number) : void;

//定义函数重载
function my(a:number,b:number):number
function my(a:string,b:string):string
function my(a:number,b:string):string
function my(a:string,b:number):string
//使用函数重载
function my(a:any,b:any):any{
   console.log(a+b);
    
}
my(1,5)
my("张三",18)
my("张三","麻子")
my(2,"小李")

function myfun (a:any,b:number):any
function myfun (a:string,b:number):string
function myfun (a:any,b:any):any
function myfun (a:number):number

function myfun(a:any,b?:any):any{
    a+b
}
myfun("ggg","mmm")

2类的使用

1类的基本使用

·定义

TypeScript是面向对象的JavaScript。

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

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

Typescript类定义方式如下:

class class_name {//类作用域}

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

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

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

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

export default{}

class por{
    name:string
    age:number

    //构造函数
    constructor(name:string,age:number){
    this.name=name
    this.age=age
    }
//函数（ff）
    se():void{
console.log(`他是${this.name}他${this.age}`);

    }

}
// 实例化
let my =new por("招生",8)
my.se()

//继承extends
class stu extends por{
    sto:string
   //构造函数  constructor
    constructor(sto:string,name:string,age:number){
        super(name,age)
        this.sto=sto
    }

    sayHi():void{
        //调用父类中的方法
        //super.sayHello();
        //重写父类中的方法
        console.log(`他是${this.name},他今年${this.age},他的成绩${this.sto}`);
        
    }
}
let y =new stu("杀杀杀","沈",22)
y.sayHi()

2类的继承

TypeScript支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类。类继承使用关键字extends，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。

TypeScript一次只能继承一个类，不支持继承多个类，但TypeScript支持多重继承(A继承B，B继承C)。

语法：c1ass child_class_name extends parent_c1ass_name

export default{}

class por{
    name:string
    age:number

    //构造函数
    constructor(name:string,age:number){
    this.name=name
    this.age=age
    }
//函数（ff）
    se():void{
console.log(`他是${this.name}他${this.age}`);

    }
}
// 实例化
let my =new por("招生",8)
my.se()

//继承extends
class stu extends por{
    sto:string
   //构造函数  constructor
    constructor(sto:string,name:string,age:number){
        super(name,age)
        this.sto=sto
    }
    sayHi():void{
        //调用父类中的方法
        //super.sayHello();
        //重写父类中的方法
        console.log(`他是${this.name},他今年${this.age},他的成绩${this.sto}`);
        
    }
}
let y =new stu("杀杀杀","沈",22)
y.sayHi()

3 static与instanceof

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

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

class StaticTest{
    static salary : number
    static say (): void{
        console.log(`我们想要的工资是${StaticTest.salary}k`)
    }
}
StaticTest.salary=18;

StaticTest.say()

instanceof运算符

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

class Person{}
let p=new Person();
let isPerson=p instanceof Person;
console.log(`q是q`,isPerson)

class studeht extends Person{}

let s=new studeht()
let isStudent=s instanceof Person;
console.log(`s是Person实例化出来的呼?`,isStudent);

4类中的修饰符

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

protected:受保护，可以被其自身以及其子类访问. private:私有，只能被其定义所在的类访问。

.readonly:可以使用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 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;
    }
    say():void{
        console.log(this.str2)
    }
}

5 getter与setter

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

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

注意点:

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

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

export default{}

class getname{
    private _funnymen:string="你好世界！"
    get furnace():string{
        console.log("get");
        return this._funnymen
    }
    set  furnace(name1:string){
        console.log("set");
        this._funnymen=name1
    }
}
let stance =new getname()
stance.furnace=""
console.log(stance);

6抽象类

定义

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

抽象类是专门用于定义哪些不希望被外界直接创建的类的

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

抽象类和接口区别

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

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

export default {}

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

a():void{
    console.log("aa"); 
 }
}

class stuly extends fun{
    name: string="早六"
    age:number=18
    show(){
        return "你好你好"
    }
}
let myfun =new stuly()
console.log(myfun);