函数和类

函数

定义函数

有两种定义函数的方式：声明式定义和字面量定义

声明式定义

TypeScript 可以为参数与返回值设置类型，代码示例如下

function add(x: number, y: number): number {
  return x + y
}

let sub = function(x: number, y: number): number { 
  return x + y
}

let times = (a: number, b: number): number => {
    return a * b;
}

✨ TypeScript 能够根据返回语句自动推断出返回值类型，因此我们通常省略返回值的类型。

字面量定义

字面量的完整写法

const f1:(a:number, b:number)=>number = function (a:number,b:number):number{
    return a + b;
}

字面量的简写：利用类型推断

const f2 = function (a:number, b:number):number{
    return a + b;
}

undefined null

在非严格模式下，undefined null 是任何类型的子类型，可以给任何类型赋值

// 编辑 tsconfig.json 文件
"strict": true, => "strict": false,
    
let a:number = undefined;
let obj:object = null;
obj = {username:'atguigu'}

参数

可选参数

TypeScript 默认要求函数实参数量要与形参的数量保持一致，不过可以使用 ?: 设置参数为可选参数

function f3(a:number, b?:number):number{
    return a + b ? b : 1;
}

⚠️ 在非严格模式下，undefined null 是任何类型的子类型，可以给任何类型赋值

在 tsconfig.json中可以设置严格模式

默认参数

TypeScript 与 JavaScript 一样，允许为参数设置默认值

function f4(a:number, b:number = 4):number{
    return a + b;
}

剩余参数

针对不定个数参数的函数时，我们可以使用 ES6 提供的 rest 参数来处理。不过在 TypeScript 中需要设置类型

//剩余参数
function add(a: number, b: number, ...args: number[]):number{
  //求和
  args = [a, b, ...args];
  return args.reduce((prev: number, current: number) => {
    return prev + current;
  })
}

返回值

能够根据返回语句自动推断出返回值类型，因此我们通常省略返回值的类型
void 没有return的函数 函数类型是void，有return的函数根据返回值的类型写return函数

Class类

TS 中的类与 JS 的类使用方式类似, 不过增加了对属性与方法的类型限制

成员类型限制

这里的类型限制跟变量和函数的类型限制是非常相似的

class Person{
    //声明属性
    name: string;
    age: number;
    //声明并赋值
    alias: string = '张三';

    //构造方法
    constructor(name: string, age: number){
        this.name = name;
        this.age = age;
    }

    //声明方法
    intro():void{
        console.log(`我叫 ${this.name}, 今年 ${this.age} 岁`)
    }
}

//实例化对象
let me: Person = new Person('xiaohigh', 35);

//调用实例方法
me.intro();

继承

TypeScript 继承语法与 JavaScript 完全相同

class Programmer extends Person{
    skill:string;
    constructor(name: string, age: number, skill:string){
       super(name, age);
       this.skill = skill
    }

  //编程的功能
  info():void{
    console.log(this.name, this.age, this.skill);
  }
}

let pro1 = new Programmer('aqua', 5, 'javascript')
console.log(pro1)
pro1.info()

成员修饰符

一些面向对象编程语言（Java, C++）中都有成员修饰符特性，TypeScript 也引入成员修饰符

成员修饰符有三个：

• public (默认) 公开的
• protected 受保护的
• private 私有的

这些修饰符实现了对类中的成员(属性和方法)的访问控制

	自身类	子类	类外部
public	√	√	√
protected	√	√	X
private	√	X	X

class Father{
    public name:string;	// 所有人都可以访问
    protected money:number; // 子类中可以使用
    private secret:string;	// 仅自己可以访问

    constructor(name:string, money:number, secret:string){
        this.name = name;
        this.money = money;
        this.secret = secret;
    }

    say():void{
        console.log('public: ', this.name);
        console.log('protected: ', this.money);
        console.log('private: ', this.secret);
    }
}

class Son extends Father{
    constructor(name:string, money:number, secret:string){
        super(name, money, secret);
    }

    hello():void{
        console.log('public name: ', this.name);	// 可以访问
        console.log('protected money: ', this.money); // 可以访问
        // console.log('private secret: ', this.secret); // 报错，私有属性子类无法访问
    }
}

let s1 = new Son('aqua',5, 'Akua graduated on August 28, 2024 ')
console.log(s1.name); // 外部可以访问
console.log(s1.money); // 报错，外部无法访问
console.log(s1.secret); // 报错，外部无法访问