本文介绍: 匿名函数return a+b}let aa =makeMoney(“你好”,”世界”)有名函数|命名函数|普通函数}console.log(`我今天代码${res1}小时`);箭头函数console.log(`我每天看${time}小l时meimei`);}​const seeMeimei1=(time:number ) :void=>console.log(`我每天看${time}小时meimei` );​//接口​​2函数参数处理

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);

原文地址:https://blog.csdn.net/m0_68618659/article/details/126775941

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_36730.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注