TypeScript 基础

---

类型

---

# typescript 可以认为是添加了类型限定的 javascript

---

基础类型

// 基础静态类型
let a: boolean = true;
let b: number = 1;
let c: string = "hello";

// any 为任意类型
let d: any = "world";
// object 类型
let date: object = new Date();

// 定义数据类型为 number /string
let e: (number | string) = 1;

---

数组类型

---

// 定义数组类型
let arr: string[] = ["web", "html", "css"];
let numArr: number[] = [1, 2, 3, 4, 5];

// 定义数组中的数据类型可以为 number/string
let allArr: (number | string)[] = [1, "2", 3, "hello"];

// 对应位置元素的类型限定
let strArr: [string, number, string] = ["", 2, ""];

---

对象类型

---

class Person {
    // 声明属性的数据类型
    name: string;
    age: number;

    constructor(name, age) {
        this.name = name;
        this.age = age;
    }

}

// 定义对象类型
const person: Person = new Person("vivi", 19);

---

类型别名

---

// 类型别名
type User = {name: string, password: string};
let users: User[] = [
		{name: "vivi", password: "123"}, 
		{name: "雯雯", password: "456"}
];

---

函数类型（lambda）

---

// 定义函数类型、返回值为 number
const sum: () => number = () => (1 + 2);

// 定义函数类型、返回值为 void
const hello: () => void = () => console.log("hello ts");

---

函数类型

---

// 定义函数参数的类型
function getSum(a: number, b: number) {
    return a + b;
}

// 限定函数的返回值类型
function getSub(a: number, b: number): string {
    return a - b + "";
}

// 函数返回值类型为 void
function sayHello(): void {
    console.log("hello world");
}

// 限定入参对象中参数的类型
function obj({name, age}: {name: string, age: number}): string {
    return name + " ==> " + age;
}
obj({name: "vivi", age: 19});

---

接口和类

---

# 在面向对象的世界中、接口中只应该定义方法、而不应该定义数据
# 也就是说、接口只是对对象的**行为**做限定、而不应该对对象的**属性**做限定
# 接口约定对象可以**做什么事！！**而不应该是对象**有什么！！**
# 也就是说接口的名字是动词或形容词、而不应该是名词！！

# 类的三种访问权限修饰符：public protected private
# 因为接口中方法的访问权限是 public 所以类中不加访问权限修饰符的方法、访问权限默认为 public

# 类中 set get 为关键字 在 typescript 中称为：访问器

// 接口
interface say {
    // 定义说话的方法、返回值为 string
    say(): string;
}

interface sleep {
    // 定义睡觉的方法、返回值 void
    sleep(): void;
}

// 定义 user 类 实现 接口
export default class User implements say, sleep {

    private username: string;
    private age: number;

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

    public sleep(): void {
        console.log(this.username + " ==> " + this.age + " ==> " + "在睡觉");
    }

    public say(): string {
        return this.username + "在说话";
    }

	get Username(): string {
        return this.username;
    }

    get Age(): number {
        return this.age;
    }

    set Username(username: string) {
        this.username = username;
    }

    set Age(age: number) {
        this.age = age;
    }
    
}

let user: User = new User("vivi", 19);
// 调用 set 访问器
user.Age = 20;
user.Username = "雯雯";
// 调用 get 访问器
console.log(user.Username);
console.log(user.Age);

console.log(user);

---

类的继承

---

// 类的继承是单继承、不支持多继承
class A {
    sayHello() : void {
        console.log("A");
    }
}

class B extends A {
    sayHello(): void {
        console.log("B");
    }
}

class C extends B {
    sayHello(): void {
        console.log("C");
    }
}
// 类支持多态
let aa: A = new B();
aa.sayHello(); // B

let cc: A = new C();
cc.sayHello(); // C

---

抽象类

---

abstract class D {

    // readonly 关键字 定义只读属性
    public readonly name: string = "vivi";

    // 抽象方法
    abstract sayHello(): void;

}

---

枚举

---

// 枚举
enum Season {
    SPRING, 
    SUMMER, 
    AUTUMN,
    WINTER
}

---

泛型

---

function getMul<T>(a: T, b: T): void {
    console.log(a, b);
}

getMul<number>(1, 4);

---

未完待续…