• TS函数与类

    TS函数

    1.1函数的基本使用

    函数分为匿名函数，命名函数(有名函数、普通函数)，箭头函数，接口函数（函数起别名）

    1.1.1 匿名函数

    简单来说就是没有定义名字的，可以节省内存中变量定义空间

    1. const myFun=function(a:string,b:string):string{
    2.     return b
    3. }
    4. let result=myFun("张三","李四")
    5. console.log(result)
    6. ​

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

    顾名思义就是有名字的函数，可以通过函数名调用

    1. function myFun_1(hour:number,sell:number):void{
    2.     console.log(`我一天学习${hour}小时`)
    3. }
    4. myFun_1(8,1)

    1.1.3 箭头函数

    1. const myFun_2=(set:string):void=>{
    2. console.log(set)
    3. }

    函数体就一行可以简写

    1. const myFun_2=(set:string):void=>console.log(set)
    2. ​
    3.     myFun_2("今天又是美好的一天")
    4. ​

    1.1.4 接口函数 (给函数起别名)

       
    1.  type Mfun=(x:number,y:number)=>number
    2.     let myFun_3:Mfun=(c:number,d:number)=>c+d+200
    3.     const re=myFun_3(1,9)
    4.     console.log(re)

    1.2 函数参数的处理

    分为：可选参数、参数的默认值、 函数的剩余参数

    1.2.1 可选参数

    与可选属性一样加上一个(?)问号

    1. const fun:(x:number,y?:number)=>number=(a:number,b?:number)=>{
    2.     return a
    3. }
    4. console.log(fun(200))
    5. const fun_2=function(x:number,y?:number):number{
    6.     return x
    7. }

    1.2.2 参数的默认值

    参数的默认值就是如果不给它传递参数就会按照默认值来，如果传递了就按照传递的进行

    1. const fun_3=function(x:number=100,y:number=500,z:number=400){
    2.     console.log(x+y+z)
    3. }
    4. fun_3(100,200,300)
    5. fun_3(100,200)
    6. fun_3()

    1.2.3 函数的剩余参数

    剩余参数使用扩展运算符三个点(...)

    1. const fun_4=function(...args:any[]){
    2.     console.log(args)
    3. }
    4. fun_4(4,5,3,4,"zahns","李四")
    5. ​
    6. const fun_5=function(a:number,b:string,...args:any[]){
    7.     console.log(a)
    8.     console.log(b)
    9.     console.log(args)
    10. }
    11. fun_5(200,"展示",12,20,45,5,"李四")

    1.3 构造函数

    如果是普通的就要调用之后在赋值而构造函数在调用的时候已经把参数传过去了

    1. export default{}
    2. // 实例化
    3. const myfunc=new Function("a","b","return a+b")
    4. // 给了具体的值 调用
    5. let result=myfunc(10,20)
    6. console.log(result)

    1.4 函数的重载

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

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

    3.如果参数类型不同，则参数类型应设为any

    1.4.1 普通

    1. function myfunc(x:number,y:number):number
    2. function myfunc(x:string,y:string):string
    3. function myfunc(x:number,y:string):string
    4. function myfunc(x:string,y:number):number
    5.  
    6. function myfunc(a:any,b:any):any{
    7.     return a+b
    8. }
    9. let a=myfunc(1,2)
    10. myfunc("张三","李四")
    11. myfunc(10,"展示")
    12. // console.log(a)
    13.  
    14. console.log(myfunc("李四",20))

    1.4.2 参数的数量不同

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

    1. function myFun(x:number):number
    2. function myFun(x:string,y:number):string
    3.  
    4. function myFun(a:any,b?:any):any{
    5.     return a+b
    6. }
    7. myFun(1)
    8. myFun("展示",2)

    TS 类

    2.1 类的基本使用

    定义：

    1.TS是面向对象的JS

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

    3.TS支持面向对象的所以特性 ， 如：类、接口等

    1. export default {}
    2.  
    3.  
    4. // 类的基本使用
    5. class Person{
    6.     // 字段（属性）
    7.     name:string
    8.     age:number
    9.  
    10.     // 构造函数
    11.     constructor(name:string,age:number){
    12.         this.name=name
    13.         this.age=age
    14.     }
    15.     // 函数（方法）
    16.     sayHello():void{
    17.         console.log(`我是一名学生我就${this.name},我今年${this.age}岁了`)
    18.     }
    19. }
    20. // 实例化类
    21. let p=new Person("张三",20)
    22. p.sayHello()

    注：constructor里面的this指的是Person这个类，前面的this.name表示的是Person类里面的属性,后面的name是构造函数传递的形参，名字随便可以是a、x等，但是为了名字有意义尽量一样

    2.2 类的继承

    1.类的继承和接口的继承的继承很相似，都是使用关键字extends， 2.Typescript支持继承类，即我们可以在创建类的时候继承一个已存在的类，这个已存在的类称为父类，继承它的类称为子类，子类除了不能继承父类的私有成员(方法和属性)和构造函数，其他的都可以继承。 3.TypeScript一次只能继承一个类，不支持继承多个类，但TypeScript支持多重继承（A继承B，B继承C)。语法格式

    1. export default {}
    2.  
    3.  
    4. // 父
    5. class Person{
    6.     // 字段（属性）
    7.     name:string
    8.     age:number
    9.     // 构造函数
    10.     constructor(name:string,age:number){
    11.         this.name=name
    12.         this.age=age
    13.     }
    14.     // 函数（方法）
    15.     sayHello():void{
    16.         console.log(`我是一名学生我就${this.name},我今年${this.age}岁了`)
    17.     }
    18. }
    19. // 子
    20. class Student extends Person{
    21.     scor:string
    22.     constructor(name:string,age:number,scor:string){
    23.         // super调用父类里面一些东西
    24.         super(name,age)
    25.         this.scor=scor
    26.     }
    27.     sayHello(): void {
    28.         // 调用父类里面的方法
    29.         super.sayHello()
    30.         // 重写父类的方法
    31.         console.log(`我叫${this.name},今年${this.age}岁了，成绩为${this.scor}`)
    32.     }
    33. }
    34. // 实例化
    35. let s=new Student("张三",20,"100")
    36. s.sayHello()

    2.3 static和instanceof

    2.3.1 static

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

    1. export default{}
    2.  
    3.  
    4. class Person{
    5.     // static关键字用于定义类的数据成员（属性和方法）为静态的，静态成员可以直接通过类名调用
    6.     static scor:string
    7.     static say():void{
    8.         console.log(`我是静态方法${this.scor}`)
    9.     }
    10. }
    11. Person.scor="静态的"
    12. Person.say()

    2.3.2 instanceof

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

    1. class Stude{}
    2. // p就是对象   Stude()就是类型
    3. let p=new Stude()
    4. let isStude=p instanceof Stude
    5. console.log(`p是Stude实例来的吗？`,isStude)
    6.  
    7. class a extends Stude{}
    8. let a1=new a()
    9. let isStude_1=a1 instanceof Stude
    10. console.log(isStude_1)
    11. // console.log(Person instanceof Number);

    2.4 类中的修饰符

    2.4.1 public、protected、private

    public 默认：公有的，可以在任何地方访问

    protected 受保护的：可以被其自身以及子类访问

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

    1. export default{}
    2.  
    3.  
    4. class Person{
    5.     // 默认：公有的，可以在任何地方访问
    6.     public name:string
    7.     // 受保护的：可以被其自身以及子类访问
    8.     protected age:number
    9.     // 私有：只能被其定义所在的类访问
    10.     private sex:string
    11.     constructor(name:string,age:number,sex:string){
    12.         this.name=name
    13.         this.age=age
    14.         this.sex=sex
    15.     }
    16.     sey():void{
    17.         console.log(`我的名字${this.name},我的年龄${this.age}，我的性别${this.sex}`)
    18.     }
    19. }
    20.  
    21. class Studen extends Person{
    22.     scor:string
    23.     constructor(name:string,age:number,sex:string,scor:string){
    24.         super(name,age,sex)
    25.         this.scor=scor
    26.     }
    27.     sey(): void {
    28.         console.log(this.name)
    29.         console.log(this.age)
    30.         // console.log(this.sex)报错因为是私有的
    31.         console.log(this.scor)
    32.     }
    33. }
    34. let p=new Studen("张三",20,"男" ,"A")
    35. p.sey()

    2.4.2 readonly

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

    1. class Print{
    2.     readonly str1:string="我是声明时赋值"
    3.     readonly str2:string
    4.     readonly str3:string
    5.     readonly str4:string
    6.     readonly str5:string
    7.     constructor(str2:string,str3:string,str4:string,str5:string){
    8.         this.str2=str2
    9.         this.str3=str3
    10.         this.str4=str4
    11.         this.str5=str5
    12.     }
    13. }
    14. let s=new Print("我是构造函数赋值的2","我是构造函数赋值的3","我是构造函数赋值的4","我是构造函数赋值的5")
    15. console.log(s.str1)
    16. console.log(s.str2)
    17. console.log(s.str3)
    18. console.log(s.str4)
    19. console.log(s.str5)

    2.5 getter和setter

    通过getter/setter来截取对对象成员的访问

    1. export default{}
    2.  
    3. class Person{
    4.     private _fullName:string="扎实"
    5.     // get 读取字段的值
    6.     get fullName(){
    7.     console.log("get")
    8.         return this._fullName
    9.     }
    10.     // set 为字段赋值
    11.     set fullName(newName:string){
    12.     console.log("set")
    13.      this._fullName=newName
    14.     }
    15. }
    16. let p=new Person()
    17. p.fullName="李四"
    18. console.log(p)
    19.  
    20. console.log(p.fullName)

    注意点：

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

    2.如果没有只读setter参数的类型，他将从getter的返回类型中推断出了

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

    2.6抽象类

    定义：

    1.抽象类作为其他派生类的基类使用。他们一般不会被直接实例化

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

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

    抽象类和接口的区别

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

    2.接口中只能定义约束，不能定义具体实现，而抽象类中

    1. abstract class Person{
    2.     abstract name:string
    3.     abstract age:number
    4.     abstract show():string
    5.     showName(){
    6.         console.log("hello word")
    7.     }
    8. }
    9. class Stude extends Person{
    10.     name: string="张三"
    11.     age: number=60
    12.     show(): string {
    13.         return "他的学习很好"
    14.     }
    15. }
    16. let s=new Stude()
    17. console.log(s.age)
    18. console.log(s.show())
    19. s.showName()

    2.7

    2.8 类的初始化顺序

    1.父类的字段初始化

    2.父类的构造函数

    3.子类的字段初始化

    4.子类的构造函数

    1. class Old{
    2.     name:string="张三"
    3.     constructor(){
    4.         console.log(`我的名字叫${this.name}`)
    5.     }
    6. }
    7. class Yong extends Old{
    8.     name: string="李四"
    9.     constructor(){
    10.         super()
    11.         console.log(`我的名字叫${this.name}`)
    12.     }
    13. }
    14. let y=new Yong()

  • 相关阅读:
    Burp+Xray的联动使用
    混淆技术研究笔记（八）扩展yGuard实现签名
    图像滤波算法
    硬盘io性能分析
    HDU1228 A + B
    开发者职场“生存状态”大调研报告分析 - 第一版
    spline本地运行的方法
    互联网摸鱼日报（2022-11-07）
    openssh快速安装
    个性化推送通知的3种方法，提升60% ROI
  • 原文地址：https://blog.csdn.net/sh2001824/article/details/126775534