TypeScript 从入门到放弃(一)：基础类型、接口、函数和类

let isDone: boolean = false
// 构造函数 Boolean 创建的对象不是布尔值。
// 错误：“boolean”是基元，但“Boolean”是包装器对象
// let booleanObj: boolean = new Boolean(1) // Error

let isError: boolean = Boolean(0)
// 直接使用 Boolean 返回 `boolean` 类型。

function foo (): void {
    //...
}

let num: number = undefined
let str: string = undefined
//...

let anyVar: any = 1
anyVar = '1'
anyVar = true

// 对于为指定类型的变量，默认是任意值类型。
let something
something = 1
something = true
something = 'aaa'

let str = 'aaa' // 推断为 string 类型
// str = 1 // error，已经被推断为 string 类型，不可以在赋值 number 类型。

let strOrNumber: string | number
strOrNumber = 1 
// 此时，只能访问 number 类型的方法。访问 length 会报错。

strOrNumber = 'aaa'
// 访问 string 类型方法

// strOrNumber = true // error

type StrOrNumber = string | number 
let strOrNum : StrOrNumber

let list: number[] = [1, 2, 3]
let list1: Array<number> = [1, 2, 3]

// 联合类型数组
let list2: Array<number|string> = [1, 2, '3']

let ta: [string, number]
ta = ['hello', 10]
// ta = [10, 'hello'] // error

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

let someValue: any = 'aaaa'
let strLength: number = (someValue as string).length // 使用断言，告诉编译器 someValue 此时是字符串类型。

interface Person {
  name: string;
  age: number
}
let tom: Person = {
  name: 'Tom',
  age: 24,
  // score: 100 // error score 并没有定义在 Person 接口中
}
// 接口中的 name 和 age 都必须实现。
// tom 不可以增加和减少属性个数。

// 含有一个可选类型的接口。
interface Person {
  name: string;
  age: number;
  score?: number; // 可选属性
}
let per: Person = {
  name: 'owenlee',
  age: 27,
  // score: 99, // 可有可无
}

interface Point {
  readonly x: number;
  readonly y: number;
}
let p1: Point = { x: 10, y: 20 }
// p1.x = 5 // error, x 是只读的。

interface Person {
  name: string;
  age: number;
  score?: number;
  [propName: string]: any;
}
let pTom: Person = {
  name: 'tom',
  age: 10,
  gender: 'm'
}
// [propName: string] 定义了任意属性取 string 类型的值。

interface numOrStr {
    [str: string]: string;
    [num: number]: string;
}

// 函数声明
function sum (x, y) {
  return x + y
}
// 函数表达式
let summ = function (x, y) {
  return x + y
}

function sum (x: number, y: number): number {
  return x + y
}
// 类型推断，summ 是 (x:number,y:number) => number类型的。
let summ = function (x: number, y: number): number {
  return x + y
}
// 完整写法
let summm: (x: number, y: number) => number = function (x: number, y: number): number {
  return x + y
}

// 定义一个函数类型的接口
// interface Sum {
//   (x: number, y: number): number
// }
// 或者使用 type 声明一个类型别名。
type Sum = (x: number, y: number) => number
// 编写一个函数
let add: Sum = (x, y) => x + y

class TPerson {
  name: string
  constructor(name: string) {
    this.name = name
  }
  say (): void {
    console.log(this.name)
  }
}
let per1 = new TPerson('owenlee')

// 继承
class TStudent extends TPerson {
  score: number
  constructor(name: string, score: number) {
    super(name)
    this.score = score
  }
  say (): void {
    console.log(this.name, this.score)
  }
}
let stu = new TStudent('owenlee', 100)

class TAnimal {
  public name: string // 公开属性，默认为 public
  private phone: string // 私有属性，只能自己访问，不可被子类访问。
  protected age: string // 保护属性，只允许被继承
  public constructor(name: string) {
    this.name = name
  }
}
// 继承
class Cat extends TAnimal {
  readonly color: string // 只读属性
  constructor(name: string) {
    super(name)
    console.log(this.name)
  }
}

// 抽象类定义方式
abstract class ABAnimal {
  name: string;
  constructor(name: string) {
    this.name = name
  }
  abstract sayHi (): void; // 抽象方法
}
// 继承自抽象类
class ADog extends ABAnimal {
  constructor(name: string) {
    super(name)
  }
  eat () {
    console.log(`${this.name} is eating`)
  }
  // 必须实现抽象类的抽象方法
  sayHi () {
    console.log('汪汪')
  }
}
// 继承抽象方法
class ACat extends ABAnimal {
  constructor(name: string) {
    super(name)
  }
  sayHi () {
    console.log('喵喵')
  }
}
// 两个子类都实现了抽象方法 sayHi
let adog = new ADog('pipi')
let acat = new ACat('fwfw')
let animals: ABAnimal[] = [adog, acat]
// 动态调用子类中的方法的实现，这就是多态。
animals.forEach(item => {
  item.sayHi()
})
// 输出：汪汪 喵喵

interface Human {
  name: string;
  eat (): void;
}
// 用接口约束类的成员属性和方法。
class Asian implements Human {
  constructor(name: string) {
    this.name = name
  }
  name: string
  eat () { }
}
// 注意：类实现接口是必须实现接口所有的属性和方法。
// 只能约束共有成员或者方法
// 不可以约束构造函数

interface Human {
  name: string;
  eat (): void;
}
// 接口的继承
interface Man extends Human {
  run (): void
}
interface Child {
  cry (): void
}
// 继承多个接口
interface Boy extends Man, Child { }
// 实现 Boy 接口
let boy: Boy = {
  name: '',
  eat () { },
  run () { },
  cry () { }
}

class Auto {
  state = 1
  action () { }
}
// 接口继承自类
interface AutoInterface extends Auto {
    // 抽离出类的成员和方法，包括私有和公有和保护的成员。
}

// 实现接口
class CAuto implements AutoInterface {
  state: number = 2
  action (): void {
    console.log('CAuto action methods')
  }
}
// 接口继承类的好处呢？
class Bus extends Auto implements AutoInterface {
  // 此时不需要实现 state, action 方法，因为在父类已经实现的。
}