typescript 学习笔记

一、基础类型

1.1 布尔类型

let isTest: boolean = false;

1.2 string

let text: string = 'this is a text';
// 模板字符串 ``
let str = 'about template string!';
let templateText: string = `this is a text ${str}`;

1.3 number

与 js 一样，在 ts 中所有数值都是浮点型，而这些浮点型的类型都是 number。同时还支持二进制、八进制、十六进制。

let num: number = 100;

1.4 数组

// 使用确定类型的数组
let arr: number[] = [1,2,3,4];
// 使用泛型数组
let list: Array<number> = [];

1.5 元组（tuple）

元组类型允许构建一个已知元素数量和类型的数组，数组内元素类型不必相同。

let tupleArr: [string, number];
tupleArr = ["test", 100];
console.log(tupleArr[0]); // "test"
console.log(tupleArr[1]); // 100

1.6 枚举

enum 是对JavaScript标准数据类型的一个补充。像C#等其它语言一样，使用枚举类型可以为一组数值赋予友好的名字。

enum Color {Red = 1, Green, Blue}
let c: Color = Color.Green;

1.7 任意值（any）

有时我们在编程阶段还不清楚数据的具体类型，它可能是动态的内容，来自服务器、用户输入等。这时我们不希望类型检查器对这些数据进行检查，此时就可以使用 any 来标记。

1.8 空值（void）

void 表示没有返回值，没有任何类型

function warnUser(): void {
    alert("This is my warning message");
}

1.9 null 和 undefined

2.0 never

never 类型表示的是那些永不存在的值的类型

二、类型断言

有的时候我们比 ts 更了解某个值的详细信息，通常发生在清楚的知道一个值会有哪些具体的类型。可以通过类型断言来告诉编译器，“我知道自己在做什么”。类型断言好比其它语言里的类型转换，但是不进行特殊的数据检查和解构。它没有运行时的影响，只是在编译阶段起作用。 TypeScript会假设你，程序员，已经进行了必须的检查。

// 使用尖括号
let strLength: number = (<string>someValue).length;
// 使用 as
let strLength: number = (someValue as  string).length;

三、变量声明和解构

3.1 变量声明

var let const

3.2 数组解构和对象解构

解构可以将数组或对象中的值，用一句代码解析到多个变量中

/ 数组解构  /
// javascript:
let input = [1, 2, 3, 4];
let first = input[0];
let second = input[1];
let third = input[2];
let forth = input[3];
// typescript:
let input = [1, 2, 3, 4];
let [first, second, third, forth] = input;
console.log(first); // outputs 1
console.log(second); // outputs 2
console.log(third); // outputs 3
console.log(forth); // outputs 4
/ 对象解构  /
// javascript:
let o = {
    a: "foo",
    b: 12,
    c: "bar"
};
let a = o.a;
let b = o.b;
let c = o.c;
// typescript:
let o = {
    a: "foo",
    b: 12,
    c: "bar"
};
let { a, b, c } = o;

四、接口

#

五、类

5.1 类的实现和继承类

class Animal{
  name: string;
  age: number;
  constructor(name, age) {
    this.name = name;
    this.age = age;
  }
  Move(): void{
    ...
  }
}
class Dog extends Animal {
  name: string;
  age: number;
  constructor(name, age) {
    super(name, age);
    this.name = name;
    this.age = age;
  }
  Move(): void{
    ...
  }
}

5.2 权限修饰符： public、protected、private

5.2.1 private

当成员被标记为 private 属性时，这个成员不能在声明它的类的外部访问。

class Animal {
    private name: string;
    constructor(theName: string) { this.name = theName; }
}
new Animal("Cat").name; // 错误: 'name' 是私有的.

5.2.2 protected

被标记为 protected 的成员，可以在声明类的派生类中访问。

class Person {
    protected name: string;
    constructor(name: string) { this.name = name; }
}
class Employee extends Person {
    private department: string;
    constructor(name: string, department: string) {
        super(name)
        this.department = department;
    }
    public getElevatorPitch() {
        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
    }
}
let howard = new Employee("Howard", "Sales");
console.log(howard.getElevatorPitch());
console.log(howard.name); // 错误