Typescript 学习 —— 数据类型，交叉类型，联合类型

// 字符串类型声明，单引号/双引号不影响类型推断
let str: string = 'Hello World';

// 数字类型声明
let num: number = 120;
// 这些值也是合法的数字类型
let nan: number = NaN;
let max: number = Infinity;
let min: number = -Infinity;

// 布尔类型声明
let not: boolean = false;
// Typescript 只对结果进行检查，!0 最后得到 true，因此不会报错
let yep: boolean = !0;

// symbol 类型声明
let key: symbol = Symbol('key');

// never 类型不能进行赋值
// 执行console.log(never === undefined)，执行结果为true
let never: never;
// 但即使 never === undefined ，赋值逻辑仍然会报错
never = undefined;

// 除了never，未开启 strictNullChecks 时，其他类型变量赋值为 null / undefined /void 0 不报错
let always: boolean = true;
let isNull: null = null;
// 不会报错
always = null;
isNull = undefined;

// 数组类型有 Array<T> 和 T[] 两种写法
let arr1: Array<number> = [1];
let arr2: number[] = [2];

// 未开启 strictNullChecks 时，赋值为 null / undefined / void 0 不报错
let arr3: number[] = null;
// 编译时不会报错，运行时报错
arr3.push(1);

// 元组类型
// 坐标表示
let coordinate: [number, number] = [114.256429, 22.724147];

// 赋值给数字不会报错
let one: Object = 1;
// 也赋值给数组,但无法使用数组的 push 方法
let arr: Object = [];
// 会报错
arr.push(1);

// 赋值会报错
let two: object = 2;

// object 作为类型声明时，赋值给对象时不会报错
let obj1: object = {};
let obj2: object = { name: '王五' };
let Obj3: Object = {};

// 会报错
obj1.name = '张三';
obj1.toString();
obj2.name;

// 不会报错
Obj3.name = '李四';
Obj3.toString();

// {} 等同于匿名形式的 type
type UserType = { name: string };

let user: UserType = { name: '李四' };
let data: { name: string } = { name: '张三' };

type Form1Type = { name: string } & { gender: number };
// 等于 type Form1Type = { name: string; gender: number; }
type Form2Type = { name: string } | { gender: number };
// 等于 type Form2Type = { name?: string; gender?: number; }

let form1: Form1Type = { name: '王五' }; // 提示缺少gender参数
let form2: Form2Type = { name: '刘六' }; // 验证通过

type Form3Type = { name: string } & { name?: string; gender: number };
// 等于 type Form3Type = { name: string; gender: number; }
type Form4Type = { name: string } | { name?: string; gender: number };
// 等于 type Form4Type = { name?: string; gender: number; }

let form3: Form3Type = { gender: 1 }; // 提示缺少name参数
let form4: Form4Type = { gender: 1 }; // 验证通过

type Form5Type = { name: string } & { name?: number; gender: number };
// 等于 type Form5Type = { name: never; gender: number; }
type Form6Type = { name: string } | { name?: number; gender: number };
// 等于 type Form6Type = { name?: string | number; gender: number; }

let form5: Form5Type = { name: '张三', gender: 1 }; // 提示name的类型为never，不能进行赋值
let form6: Form6Type = { name: '张三', gender: 1 }; // 验证通过

// 原价购买
type StandardPricing = {
  mode: 'standard';
};
// 教育优惠购买需要提供购买人姓名和相关证件
type EducationPricing = {
  mode: 'education';
  buyer_name: string;
  sic_or_tic: string;
};
// 通过 & 和 | 合并类型
type BuyiPhone12 = { price: number } & (StandardPricing | EducationPricing);

let standard: BuyiPhone12 = { mode: 'standard', price: 5000 };
let education: BuyiPhone12 = {
  mode: 'education',
  price: 4000,
  buyer_name: '张三',
  sic_or_tic: '证件',
};

// 用 interface 定义一个学生的基础属性为姓名、性别、学校、年级、班级
interface Student {
  name: string;
  gender: '男' | '女';
  school: string;
  grade: string | number;
  class: number;
}

// 用 interface 继承学生的基础属性
// 并追加定义三好学生的标准为遵守校规、乐于助人，班级前三
interface MeritStudent extends Student {
  toeTheLine: boolean;
  helpingOther: boolean;
  topThreeInClass: boolean;
}

// 可以通过 type 将 interface 声明的类型声明到新声明上
type StudentType = Student;

// interface 虽然不能直接使用 type 声明的类型，但是可以通过继承间接使用
interface CollageStudent extends StudentType {}

// 然后声明相对应的逻辑去实现
let xiaoming: Student = {
  name: '小明',
  gender: '男',
  school: '清华幼儿园',
  grade: '大大班',
  class: 1,
};

let xiaowang: MeritStudent = {
  name: '小王',
  gender: '男',
  school: '清华幼儿园',
  grade: '大大班',
  class: 1,
  toeTheLine: true,
  helpingOther: true,
  topThreeInClass: true,
};

let xiaohong: StudentType = {
  name: '小红',
  gender: '女',
  school: '朝阳小学',
  grade: 1,
  class: 1,
};

// type 可以给类型定义别名
type StudentName = string;

// interface 可以像 Java 定义一个学生的抽象类
interface StudentInterface {
  addRecord: (subject: string, score: number, term: string) => void;
}

// 等同于 let name: string = '张三'
let name: StudentName = '张三';

// 构造函数 CollageStudent 获得抽象类 StudentInterface 的声明
class CollageStudent implements StudentInterface {
  public record = [];

  addRecord(subject, score, term) {
    this.record.push({ subject, score, term });
  }
}

// type 其实也定义类似的类型声明结构，但是从语义上来说并不是抽象类
type TeacherType = {
  subject: Array<string>;
};
// 构造函数也可以获得 type 声明的类型，语法上是可以实现的
// 但是从语义和规范的层面上来说不推荐这么写
class CollageTeacher implements TeacherType {
  subject: ['数学', '体育'];
}