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() // 含字符串成员的枚举中不允许使用计算值
}

// 枚举成员
enum Char {
  // const member 常量枚举，会在编译阶段计算结果，以常量的形式出现在运行时环境
  a,
  b = Char.a,
  c = 1 + 3,
​
  // computed member 需要被计算的枚举成员，不会在编译阶段进行计算，会被保留到执行阶段
  d = Math.random(),
  e = "123".length,
  // 在 computed member 后面的枚举成员，一定要赋一个初始值，否则报错
  f = 1,
}
console.log(Char);
​
// 枚举 number
enum number {
  a = 1,
  b = 5,
  c = 4,
  d,
}
console.log(number); //打印出{1: "a", 4: "c", 5: "d", a: 1, b: 5, c: 4, d: 5}
// b赋初始值为5，c赋初始值为4，按照索引递增，d的索引就是5，索引相同时，后面的值覆盖前面的，所以5对应的 value 就是d

enum E {
  a,
  b,
} // 枚举成员都没有初始值
enum F {
  a = 1,
  b = 5,
  c = 4,
  d,
} // 枚举成员都是数字枚举
enum G {
  a = "apple",
  b = "banana",
} // 枚举成员都是字符串枚举
​
// 变量定义为数字枚举类型，赋值任意number类型的值都是可以的，对枚举没有影响，但是不能赋值字符串等。
let e: E = 3;
let f: F = 3;
// e === f // 不同的枚举类型是不能比较的，会报错
console.log(E, F, e, f); // 打印：{0: "a", 1: "b", a: 0, b: 1}， {1: "a", 4: "c", 5: "d", a: 1, b: 5, c: 4, d: 5}， 3， 3
// 可见变量定义为E，F赋值，对E,F枚举本身没有影响
​
let e1: E = 3;
let e2: E = 3;
console.log(e1 === e2); // 同一个枚举类型是可以比较的，结果为true
​
let e3: E.a = 3;
let e4: E.b = 3;
// e3 === e4 // 同一个枚举类型的不同枚举成员是不能比较的,会报错
console.log(E, E.a, E.b, e3, e4); // 打印：{0: "a", 1: "b", a: 0, b: 1} 0 1 3 3 ，可见变量定义为E.a，E.b赋值，对E以及E.a,E.b枚举本身没有影响
​
//字符串枚举类型的赋值，只能用枚举成员，不能随意赋值。
let g1: G = "abc"; // 会报错
let g2: G = G.a; // g2能赋值G.a或者G.b
let g3: G.a = G.a; // g2 只能赋值G.a

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;
}
// 这样对象字面量就可以包含任意多个字符串属性了。

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是字符的子类型）