typescript函数和类的基础

目录

函数

函数的基本使用

函数参数的使用

构造函数

函数重载

类的基本使用

类的继承

static与instanceof

修饰符

getter与setter

抽象类

初始化


函数

函数的基本使用

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

匿名函数

const aa = function(a:number,b:number):number{
    return a
}
let a1 = aa(8,9)
console.log(a1);

有名函数

function bb(a:number,b:number){
    return b
}
let b1 = bb(7,6)
console.log(b1);

箭头函数

const cc = (a:number,b:number):void=>{
    console.log(`我都两年就爱上的巴士的v阿三不擦时间${a}`);
}
cc(10,11)

接口函数

type dd = (a:number,b:number)=>number
const d1:dd = (x:number,y:number)=>x+y
let d2 = d1(56,87)
console.log(d2);

函数参数的使用

可选参数

const aa:(a:number,b:number)=>number=(x:number,y:number)=>{
    return y
}
const bb = function(a:number,b?:number):number{
    return a
}
let b1 = bb(10,undefined)
console.log(b1);

默认值

let cc = function(a:number,b:number,c:number=20){
    return a+b+c
}
let c1 = cc(20,50)
console.log(c1);

剩余参数

const dd = function(...a:any[]){
    console.log(a);
}
dd(10,50,60,90,'dasd')
const d1 = function(a:number,b:number,...c:any[]){
    console.log(a);
    console.log(b);
    console.log(c);
}
d1(20,50,'dasd','wwww',10)

构造函数

var aa = new Function("a","b","return a*b")
var bb =  aa(10,50)
console.log(bb);

函数重载

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

function aa(a:number,b:number):number
function aa(a:string,b:string):string
function aa(a:string,b:number):string
function aa(a:number,b:string):string
function aa(a:any,b:any):any{
    return a+b
}
let a1 = aa(50,'dsd')
console.log(a1);

参数数量不同的时候

如果参数类型不同,则参数类型应设置为any。参数数量不同你可以将不同的参数设置为可选。

function bb(a:string):number
function bb(a:number,b:string):void
function bb(a:any,b?:any):any{
    console.log(a);
    console.log(b);
}
// bb(85)
bb(85,'dasdasdasdasdasdasdasdasd')

定义
TypeScript是面向对像的JavaScript。类描述了所创建的对象共同的属性和方法。
TypeScript支持面向对象的所有特性,比如类、接口等。

类的基本使用

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

class Person{
    // 字段
    name:string
    age:number
    // 构造函数
    constructor(a:string,b:number){
        this.name = a
        this.age = b
    }
    // 方法
    sey():void{
        console.log(`我叫${this.name}我今年${this.age}岁了`);
    }
}
// 实例化
let aa = new Person('wd',20)
aa.sey()

类的继承

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

class Person{
    name:string
    age:number
    constructor(a:string,b:number){
        this.name = a
        this.age = b
    }
    sey():void{
        console.log(`我叫${this.name}我今年${this.age}岁了`);
    }
}
// let aa = new Person('搜索',20)
// aa.sey()

// 继承
class Student extends Person{
    sex:string
    constructor(name:string,age:number,sex:string){
        super(name,age)
        this.sex = sex
    }
    sey():void{
        super.sey()
        console.log(`我叫${this.name}我今年${this.age}岁了我的性别是${this.sex}`);
    }
}
let bb = new Student('订单',20,'女')
bb.sey()

static与instanceof

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

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

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

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

修饰符

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

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

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

class Person{
    // 字段
    // public:默认,公有的,可以在任何地方被访问
    // protected:受保护,可以被自身及其子类访问
    // private:私有,只能被其定义所在的类访问
   public name:string
   protected age:number
   private sex:string
    // 构造函数
    constructor(a:string,b:number,c:string){
        this.name = a
        this.age = b
        this.sex = c
    }
    // 方法
    sey():void{
        console.log(`我叫${this.name}我今年${this.age}岁了`);
    }
}
class Student extends Person{
    shengao:number
    constructor(a:string,b:number,c:string,d:number){
        super(a,b,c)
        
        this.shengao = d
    }
    sey(): void {
        console.log('aa');
        this.name='我当时'
        this.age= 85
        // this.sex = '男'
        this.shengao = 185
    }
}

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

class Plll{
    // readonly:只读
    readonly str: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
    }
    sey(){
        console.log(this.str2,this.str3,this.str4,this.str5);
        // this.str2 = 'dasdasd'
    }
}
let b = new Plll('dasdasdasd','dasdasdasdasd','dasdasdas','dwwwasd')
b.sey()

getter与setter

官方的另外一个名字:存取器
通过getters/setters来截取对对象成员的访问
如果存在get,但没有set,则该属性自动是只读的
如果没有指定setter 参数的类型,它将从getter的返回类型中推断出来访问器和设置器必须有相同的成员可见性
 

class Pll{
    private _name:string = '球球'
    get name():string{
        console.log('get被调用了');        
        return this._name  //取
    }
    set name(newName){
        console.log('set被调用了');
        this._name = newName  //存
    }
}
let a = new Pll()
a.name = '王五'
console.log(a);
console.log(a.name);

抽象类

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

export default {}
abstract class Person{
    abstract name:string
    abstract age:number
    abstract show():string
    sey(){
        console.log('嗡嗡嗡');
        
    }
}
class Student extends Person{
    name:string = '周慧敏'
    age:number = 20
    show(){
        return '我啊倒萨打算'
    }
}
let a = new Student()

console.log(a.show());

初始化

初始化顺序:

  • 基类的字段被初始化
  • 基类构造函数运行
  • 子类的字段被初始化
  • 子类构造函数运行
export default {}
class fu{
    name:string = '请求'
    constructor(){
        console.log(`大苏打${this.name}`);
        
    }
}
class zi extends fu{
    name:string = '王五'
    constructor(){
        super()
        console.log(`大苏打${this.name}`);
        
    }
}
let p = new zi
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值