let arr1: number[] = [1,2,3]
// 下面就是使用 TS 内置的 Array 泛型接口来实现的
let arr2: Array<number | string> = [1,2,3,"abc"]

let tuple: [number, string] = [0, "1"];

tuple.push(2)  // 不报错
console.log(tuple) // [0, "1", 2] 也能都打印出来
console.log(tuple[2]) // 但是想取出元组中的越界元素，就会报错元组长度是2，在index为2时没有元素

let compute: (x: number, y: number) => number;
compute = (a, b) => a + b;

let obj: object = { x: 1, y: 2 };
obj.x = 3; // 会报错，只是简单的定义了是object类型，但是里面到底有什么属性没有标明
​
// 需要改成如下的对象类型定义
let obj: { x: number; y: number } = { x: 1, y: 2 };
obj.x = 3;

let s1: symbol = Symbol();
let s2 = Symbol();
console.log(s1 === s2)  // false

let un: undefined = undefined;
let nu: null = null;
un = 1 // 会报错
nu = 1 // 会报错

// 设置 "strictNullChecks": false
let num: number = 123;
num = undefined;
num = null;
​
// 但是更建议将 num 设置为联合类型
let num: number | undefined | null = 123;
num = undefined;
num = null;

enum Role {
  Reporter = 1,
  Developer,
  Maintainer,
  Owner,
  Guest
}
Role.Reporter = 2 // 枚举成员是只读的，不能修改重新赋值
​
console.log(Role)
//打印出来：{1: "Reporter", 2: "Developer", 3: "Maintainer", 4: "Owner", 5: "Guest", Reporter: 1, Developer: 2, Maintainer: 3, Owner: 4, Guest: 5}
//我们看到打印出来是一个对象，对象中有索引值作为 key 的，有名字作为 key 的，所以枚举既能通过名字取值，又能通过索引取值
​
// 看一下 TS 编译器是怎么用反向映射实现枚举的。
"use strict";
var Role;
(function (Role) {
    Role[Role["Reporter"] = 1] = "Reporter";
    Role[Role["Developer"] = 2] = "Developer";
    Role[Role["Maintainer"] = 3] = "Maintainer";
    Role[Role["Owner"] = 4] = "Owner";
    Role[Role["Guest"] = 5] = "Guest";
})(Role || (Role = {}));

enum Message {
  Success = '成功',
  Fail = '失败'
}
console.log(Message)
// 打印出来：{Success: "成功", Fail: "失败"}
// 我们看到只有名字作为 key ，说明字符串枚举不能反向映射

const enum Month {
  Jan,
  Feb,
  Mar
}
let month = [Month.Jan, Month.Feb, Month.Mar];

enum Answer {
  N,
  Y = 'Yes',
  // C, // 在字符串枚举成员后面的枚举成员必须赋一个初始值
  //  X = Math.random() // 含字符串成员的枚举中不允许使用计算值
}

  interface List {
    id: number;
    name: string;
  }
  interface Result {
    data: List[];
  }
​
  function render(result: Result) {
    result.data.forEach((value) => {
      console.log(value.id,value.name)
    })
  }
​
  render({
    data: [
      {id: 1, name: 'A',sex: 'male'},
      {id: 2,name: 'B'}
    ]
  });
  // 这就是对象类型接口直接验证有冗余字段的“对象字面量”，上面render中会有报错，说对象只能指定已知属性，并且"sex"不在类型"List"中

 // 把字面量先赋值给一个变量这样就能绕过检测
  let result = {
    data: [
      {id: 1, name: 'A',sex: 'male'},
      {id: 2,name: 'B'}
    ]
  }
  render(result);

  render({
    data: [{ id: 1, name: "A", sex: "male" }, { id: 2, name: "B" }]
  } as Result);
​
  // 但是如果传入的对象字面量中没有一项是符合的，那用类型断言还是会报错
  render({
    data: [{ id: 1, name: "A", sex: "male" }]
  } as Result); // 还是会报错属性"data"的类型不兼容
​
  // 现在就需要这么写，用 as unknown as xxx
  render({
    data: [{ id: 1, name: "A", sex: "male" }]
  } as unknown as Result);

  interface List {
    id: number;
    name: string;
    [x:string]: any;
  }
  // 这样对象字面量就可以包含任意多个字符串属性了。

  interface List {
    readonly id: number; // 只读属性
    name: string;
    age?: number; // 可选属性
  }

  interface Names {
    [x: string]: number | string;
    // y: boolean; // 会报错 boolean 不会赋值给字符串索引类型，因为字符串索引签名的类型是 number | string，所以之后再定义的属性必须是签名值类型的子类型
    [z: number]: number; // 字符串索引签名后也能定义数字索引签名，数字索引的返回值必须是字符串索引返回值类型的子类型
  }

interface Add {
  (x: number, y: number): number;
}
// 跟变量声明是等价的：let Add: (a: number, b: number) => number
let add4: Add = (a,b) => a + b

interface Lib {
  version: string;
  ():void;
  doSomething():void;
}
// 需要用到类型断言
let lib: Lib = (() => {}) as Lib;
lib.version = '1.0'
lib.doSomething = () => {}

// 以下是接口继承的例子
interface Human {
  name: string;
  eat(): void;
}
interface Man extends Human {
  run(): void
}
interface Child {
  cry():void
}
​
interface Boy extends Man, Child {}
let boy: Boy = {
  name: '',
  run(){},
  eat(){},
  cry(){}
}

// 第一种，直接声明
function add1 (x:number, y:number):number {
  return x + y
}
// 应用时形参和实参一一对应
add1(1, 2)
​
// 第二种 变量声明
let add2: (x:number, y:number) => number
// 应用如下
add2  = (a, b) => a + b
add2(2, 2)
​
// 第三种 类型别名
type Add3 = (x: number, y: number) => number
// 应用如下
let add3: Add3 = (a, b) => a + b
add3(3, 2)
​
​
// 第四种 接口实现
interface Add4 {
  (x: number, y: number): number;
}
// 跟变量声明是等价的：let Add4: (a: number, b: number) => number
let add4: Add4 = (a,b) => a + b
add4(4, 2)

// y后面不能再有必选参数，所以d会报错
// function add5(x:number, y?:number, d:number) {
​
// 正确如下
function add5(x:number, y?:number) {
  return y? y + x: x
}
add5(1)

function add6 (x: number, y = 0, z:number,q = 1) {
  return x +y + z +q
}
// 第二个参数必须传入undefined占位
add6(1,undefined,2)

function add8(...rest: number[]):number
function add8(...rest: string[]):string
function add8(...rest: any[]):any {
  let first = rest[0]
  if(typeof first === 'string') {
    return rest.join('')
  }
  if(typeof first === 'number') {
    return rest.reduce((pre,cur) => pre + cur)
  }
}
add8(1,2,3) // 6
add8('1','2','3') // '123'

class Dog {
  constructor(name: string) {
    this.name = name
    this.legs = 4 // 已经有默认值的只读属性是可以被重新初始化的
  }
  public name: string
  run() { }
  private pri() { }
  protected pro() { }
  readonly legs: number = 3
  static food: string = 'bones'
}
let dog = new Dog('jinmao')
// dog.pri() // 私有属性不能在实例中调用
// dog.pro() // 受保护的属性，不能在实例中调用
console.log(Dog.food) // 'bones'
​
​
class Husky extends Dog {
  constructor(name: string, public color: string) {
    super(name)
    this.color = color
    // this.legs = 5 // 子类的构造函数中是不能对父类的只读属性重新初始化的
    // this.pri() // 子类不能调用父类的私有属性
    this.pro() // 子类可以调用父类的受保护属性
  }
  protected age: number = 3
  private nickname: string = '二哈'
  info(): string {
    return this.age + this.nickname
  }
  // color: string // 参数用了修饰符，可以直接定义为属性，这里就不需要了
}
​
let husky = new Husky('husky', 'black')
husky.info() // 如果调用的类的方法中有对类的私有属性和受保护属性的访问，这是不报错的。
console.log(Husky.food) // 'bones' 子类可以调用父类的静态属性

abstract class Animal {
  eat() {
    console.log('eat')
  }
  abstract sleep(): void // 抽象方法，在子类中实现
}
// let animal = new Animal() // 会报错，抽象类无法创建实例
​
​
class Cat extends Animal {
  constructor(public name: string) {
    super()
  }
  run() { }
  // 必须实现抽象方法
  sleep() {
    console.log('sleep')
  }
}
​
let cat = new Cat('jiafei')
cat.eat()

interface Human {
  // new (name:string):void // 接口不能约束类的构造函数
  name: string;
  eat(): void;
}
​
class Asian implements Human {
  constructor (name: string) {
    this.name = name
  }
  name: string
  // private name: string  // 实现接口时用了私有属性会报错
  eat() {}
  sleep(){}
}

class Auto {
  state = 1
  // protected state2 = 0 // 下面的C会报错，因为C并不是 Auto 的子类，C只是实现了 Auto 抽象出来的接口
}
interface AutoInterface extends Auto {
​
}
class C implements AutoInterface {
  state = 1
}
​
// 被抽象的类的子类，也可以实现类抽象出来的接口，而且不用实现父类的已有的属性
class Bus extends Auto implements AutoInterface {
  // 不用设置 state ，Bus 的父类已经有了。
​
}

function log<T>(value: T): T {
  console.log(value)
  return value
}
​
log<string[]>(['a', 'b'])
log([1, 2]) // 可以不用指定类型，TS会自动推断
​
// 还可以用类型别名定义泛型函数
//下面的定义不用指定参数类型
type Log = <T>(value:T) => T // 不用指定参数类型，会自己推断
let myLog: Log = log
//下面的定义必须指定参数类型
type Log<T> = (value:T) => T // 如果这样用泛型定义函数类型，必须指定一个参数类型
let myLog: Log<string> = log

function log<T>(value: T): T {
  console.log(value)
  return value
}
​
// 以下仅约束泛型接口中的一个泛型函数，实现不用指定泛型的参数类型
interface Log {
  <T>(value: T): T;
}
let myLog: Log = log
​
// 以下约束整个泛型接口，实现需要指定泛型的参数类型，或者用带默认类型的泛型
interface Log1<T> {
  (value: T): T;
}
let myLog1: Log1<string> = log
​
interface Log2<T = string> {
  (value: T): T
}
let myLog2: Log2 = log

class Log3<T> {
  // 静态成员不能引用类的泛型参数
  // static start(value: T) {
  //   console.log(value)
  // }
  run(value: T) {
    console.log(value)
    return value
  }
}
let log3 = new Log3<number>()
log3.run(1)
​
//不指定类型，就可以传入任何类型
let log4 = new Log3()
log4.run('abc')

interface Length {
  length: number
}
function log5<T extends Length>(value: T) {
  // 想要打印出定义为泛型T的value的length属性，则T必须要有length属性，所以需要泛型约束，T继承length接口后，就肯定具有了length属性
  console.log(value,value.length)
  return value
}
log5([1])
log5('abc')
log5({length: 1})

let a = 1 // 推断为 number
let b = [1] // 推断为 number[]
let c = (x = 1) => x + 1 // 推断为 (x?: number) => number

let d = [1, null]
// 推断为一个最兼容的类型，所以推断为(number | null)[]
// 当关闭"strictNullChecks"配置项时，null是number的子类型，所以推断为number[]

interface Bar {
  bar: number
}
let foo = {} as Bar
foo.bar = 1
​
// 但是推荐变量声明时就要指定类型
let foo1: Bar = {
  bar: 1
}

let s: string = 'a'
s = null // 把编译配置中的strictNullChecks设置成false，字符类型是兼容null类型的（因为null是字符的子类型）

interface X {
  a: any;
  b: any;
}
interface Y {
  a: any;
  b: any;
  c: any;
}
​
let x: X = { a: 1, b: 2 }
let y: Y = { a: 1, b: 2, c: 3 }
// 源类型只要具有目标类型的必要属性，就可以进行赋值。接口之间相互兼容，成员少的兼容成员多的。
x = y
// y = x // 不兼容

type Handler = (a: number, b: number) => void
function test(handler: Handler) {
  return handler
}