函数的基本使用_(function) sa:any-CSDN博客

本文链接：https://blog.csdn.net/weixin_56393766/article/details/126769907

数据类型	关键字	描述
任意类型	any	声明为 any 的变量可以赋予任意类型的值。
数字类型	number	双精度 64 位浮点值。它可以用来表示整数和分数。 let binaryLiteral: number = 0b1010; // 二进制 let octalLiteral: number = 0o744; // 八进制 let decLiteral: number = 6; // 十进制 let hexLiteral: number = 0xf00d; // 十六进制
字符串类型	string	一个字符系列，使用单引号（'）或双引号（"）来表示字符串类型。反引号（`）来定义多行文本和内嵌表达式。 let name: string = "Runoob"; let years: number = 5; let words: string = `您好，今年是 ${ name } 发布 ${ years + 1} 周年`;
布尔类型	boolean	表示逻辑值：true 和 false。 let flag: boolean = true;
数组类型	无	声明变量为数组。 // 在元素类型后面加上[] let arr: number[] = [1, 2]; // 或者使用数组泛型 let arr: Array<number> = [1, 2];
元组	无	元组类型用来表示已知元素数量和类型的数组，各元素的类型不必相同，对应位置的类型需要相同。 let x: [string, number]; x = ['Runoob', 1]; // 运行正常 x = [1, 'Runoob']; // 报错 console.log(x[0]); // 输出 Runoob
枚举	enum	枚举类型用于定义数值集合。 enum Color {Red, Green, Blue}; let c: Color = Color.Blue; console.log(c); // 输出 2
void	void	用于标识方法返回值的类型，表示该方法没有返回值。 function hello(): void { alert("Hello Runoob"); }
null	null	表示对象值缺失。
undefined	undefined	用于初始化变量为一个未定义的值
never	never	never 是其它类型（包括 null 和 undefined）的子类型，代表从不会出现的值。

TypeScript	JavaScript
含有类型	无类型
箭头函数	箭头函数（ES2015）
函数类型	无函数类型
必填和可选参数	所有参数都是可选的
默认参数	默认参数
剩余参数	剩余参数
函数重载	无函数重载

匿名函数

匿名函数是一个没有函数名的函数。

匿名函数在程序运行时动态声明，除了没有函数名外，其他的与标准函数一样。

const mkst = function(a:number,b:number):number{
    return a+b
}
let app =  mkst(1,2)
console.log(app);

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

function app(a:number,b:number):number{
    return a
}
app(1,2)

箭头函数

 const app =(time:number):void=>console.log(`我每天看${time}个小时电脑`);
 app(8)

接口函数

type app=(a:number,b:number)=>number
const add:app=(c:number,d:number)=> c+d

console.log(add(1,2));

函数的参数的处理

可选参数

 const func1:(a:number,b?:number)=>number=function(x,y){
 return x;
}
 const func2 = function(a:number,b?:number):number{
     return a
 }
 func2(10)
 func2(10,20)

函数的默认值

 const func3 = function(a:number,b:number=2){
     return a+b
 }
 func3(10)
 func3(10,40)

函数的剩余参数

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,40,"刘","李")

构造函数

Function函数是包含在Function和End Function 语句之间的一组 VBScript 语句。 Function函数与 Sub过程类似。但 Function函数可以有返回值。可以使用参数。如果 Function函数没有任何参数，则 Function语句必须要包含空括号。

var myfe = new Function("a","b","return a*b")
console.log(myfe(10,20));

函数重载

不使用函数重载的问题

function add1(a: number, b: number) {
  return a + b
}
add1(10, 20)
function add2(a: string, b: string) {
  return a + b
}
add2('我的名字叫做：', '迪丽热巴')

function add3(a: string | number, b: string | number) {
  if (typeof a == 'number' && typeof b == 'number') {
    return a + b
  } else if (typeof a == 'string' && typeof b == 'string') {
    return a + b
  } else if (typeof a == 'number' && typeof b == 'string') {
    return a + b
  } else if (typeof a == 'string' && typeof b == 'number') {
    return a + b
  }
}
add3('我的名字叫做：', '迪丽热巴')
add3(10, 15)
add3(10, '杨幂')
add3('白鹿', 19)

函数重载

function add(a: number, b: number): number
function add(a: string, b: number): string
function add(a: number, b: string): string
function add(a: string, b: string): string

function add(a: any, b: any): any {
  return a + b
}

console.log(add(10, 20))

参数数量不同

function str(s: string): string
function str(s: number, n: number): void
function str(s: any, n?: any): any {
  console.log(s)
  console.log(n)
  console.log(s + n)
}
str(10, 20)

类的基本使用

lass Person {
  //字段（属性）
  name: string
  age: number
  //构造函数
  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
  //函数（方法）
  sayHellow(): void {
    console.log(`你是谁${this.name}，你多少${this.age}岁了`)
  }
}
//实例化类
let p=new Person("铭",30)
p.sayHellow()

类的继承

class Person {
  //字段（属性）
  name: string
  age: number
  //构造函数
  constructor(name: string, age: number) {
    this.name = name
    this.age = age
  }
  //函数（方法）
  sayHellow(): void {
    console.log(`你是谁${this.name}，你多少${this.age}岁了`)
  }
}
// extends 继承 super 调用所继承对象的属性
class Stu extends Person{
    score:string
    constructor(name:string,age:number,score:string) {
        super(name,age)
        this.score=score
    }
    sayHellow(): void {
        //调用父类中的方法
        // super.sayHellow()
        //重写父类中的方法
        console.log(`我是重写的方法，我叫${this.name}，今年${this.age}岁，我的成绩是${this.score}`);
    }
}
let s=new Stu("赵李",18,"A")
s.sayHellow()

static和instanceof

//static 关键字用于定义类的数据成员（属性和方法）为镜头的 静态成员可以直接通过类名调用
class Sta{
    static salary:number
    static say():void{
        console.log(`我们想要的工资是${Sta.salary}k`);
    }
}
Sta.salary=18
Sta.say()
// instanceof运算符
//instanceof运算符用于判断对象书否是指定类型 如果是返回true 否则返回false

class Pes{}
let p = new Pes()
let isPerson = p instanceof Pes
console.log("p是Pes实例话出来的吗",isPerson);
class Stu extends Pes{}
let s= new Stu
let isSt = s instanceof Pes
console.log("s是person实例化出来的吗？",isSt);

类的修饰符

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 {
  scored: string
  constructor(name: string, age: number, sex: string, scored: string) {
    super(name, age, sex)
    this.scored = scored
  }
  say(): void {
    console.log(this.name)
    console.log(this.age)
    console.log(this.scored)
  }
}
let s = new Student('张三', 18, '女', 'A')

//readonly 可以使用 `readonly`关键字将属性设置为只读 只读属性必须在生命时或者构造函数里被初始化
// 只读 readonly
class Print {
  readonly str1: string = 'HTML'
  readonly str2: string
  readonly str3: string
  readonly str4: string
  constructor(str1: string, str2: string, str3: string, str4: string) {
    this.str2 = str2
    this.str3 = str3
    this.str4 = str4
  } // show():void{ //     this.str2='js' // }
}
let p = new Print('JavaScript', 'jQuery', 'Bootstrap', 'TypeScript')
console.log(p)

getter与setter

class MyName{
    private _fullName:string="杨幂"
    //读取字段的值
    get fullName(){
        console.log("get被调用了");
        return this._fullName
    }
    //为字段赋值
    set fullName(newName:string){
        console.log("set被调用了");
        this._fullName=newName
    }
}
let n = new MyName();
n.fullName="刘亦非"
console.log(n);
console.log(n.fullName);

抽象类

abstract class Person {
  abstract name: string
  abstract age: number
  abstract show(): string
  showName(): void {
    console.log('Hello Wored')
  }
}
class Student extends Person {
  name: string = '赵四'
  age: number = 18
  show() {
    return '熊出没'
  }
}
let s = new Student()
let res = s.show()
console.log(res)