TypeScript基础用法

let 变量: 类型; // 变量类型声明
let 变量 = 值; // 根据值自动推断变量类型
let 变量: 类型 = 值; // 声明类型并赋值
let 变量 = [0, 1, null]; // 自动推断为number或null联合类型的数组

let color: 'red' | 'blue' | 'black'; // color仅能取指定的三种颜色
let num: 1 | 2 | 3 | 4 | 5; // num仅能取所列出的整数
let unionType: string | number; // unionType可取string或number类型

// 若未初始化，则从0开始初始化，即相应的枚举成员值对应数字
enum Direction {
  Up = 1, // Up被初始化为1,其余成员在其前方成员基础上+1
  Down,
  Left,
  Right
}
// 数字枚举有反向映射，字符串枚举没有
console.log(Direction[1]); // 输出: 'Up'

enum Direction { // 字符串枚举每个成员必须被初始化
  Up = "UP",
  Down = "DOWN",
  Left = "LEFT",
  Right = "RIGHT",
}

// 从旧的类型中创建新类型的一种方式：类型映射
type Readonly<T> = {
  readonly [P in keyof T]: T[P]; // 此类型遍历T的每个key赋值给P类型变量，并将对应属性设置为只读，下同
  // 'keyof T'也可以是一种单独的联合类型
}
type Partial<T> = {
  [P in keyof T]?: T[P];
}
type PersonPartial = Partial<Person>;
type ReadonlyPerson = Readonly<Person>;
// Readonly<T>、 Partial<T>、Pick<T>、 Record<T>等被包含在ts标准库中

class 类型名1 extends 基础类型 { // 从基础类型进行继承(可选)
  属性名: 类型;
  public 公共属性: 类型; // 默认值，可在类、子类、实例中修改(外部读写)
  protected 保留属性: 类型; // 仅可以在类、子类中修改
  private 私有属性: 类型; // 仅可以在类中修改
  constructor(参数:类型){
    super(参数); // 执行父类构造函数，可传入参数，构造器中的super代表父类构造函数，与方法中的super不同。继承时必须调用super()执行基类构造函数
    this.属性名 = 参数;
  }
  static 方法名() {}
  static 静态属性: 类型;
  get 私有属性(){return 私有属性;}
  set 私有属性(value: 类型){this.私有属性 = value;}
  sayHi(){ // 方法，可复写父类中的方法
    super.sayHi(); // 在方法中使用super代表父类
  }
}
abstract class 抽象类 { // 抽象类只能用于extends继承，不能用来实例化对象
  abstract 抽象方法():void; // 抽象类中定义的抽象方法，子类必须实现该方法
}
class a extends 抽象类 {
  抽象方法(){console.log('')}
}
// 抽象类中可以有实现细节
// 接口类似于抽象类，但所有属性和方法都没有实际值，主要用于定义类的结构
// 接口也与类型别名相似，在一定条件下可以相互替换
interface Person extends 接口1 { // 接口可继承其他接口或类
  name: string;
  readonly weight: number; // 只读属性, 当做属性使用时使用readonly, 当使用变量时使用const。只读属性必须在声明或构造函数中初始化
  sayHello():void;
  age?:number; // 使用?修饰，可选属性
  [propName: string]: any; // 允许增加任意属性，确定属性和可选属性的类型必须是任意属性类型的子集，接口中只能定义一个任意属性
  
  (source:string):boolean; // 接口的方式表示函数类型，参数名可以不同，但类型必须相同

  // ts支持两种索引签名：字符串和数字
  [index:number]:null; // 数字索引的返回值类型必须时字符串索引值返回类型的子类
  [index:string]:string // 此例中null是string的子类，同时这样定义后声明的其他字面量属性必须时string的子类，如：
  name:number // error 因为number不是string的子类
}
class guy extends 抽象类 implements Person, 接口2 { // 继承抽象类并实现多个接口
// 此处接口实现仅针对实例部分进行了类型检查
  constructor(public name: string){ // 属性声明也可放在构造函数参数上
  }
  sayHello(){console.log(this.name)}
}

// 接口也可以继承一个类类型，此时它仅继承类的成员，不包括其实现
interface BadGuy extends guy {}

function test<T, K>(arg1: T, arg2: K): T {
  return arg1; // 泛型类似于占位符，不一定使用T,K表示
}

test(10, 'a'); // 自动推断
test<number, string>(10, 'a'); // 手动指定

interface MyInter<T> {
  length : number;
  (arg: T):T; // 泛型方法
}

class MyClass<T extends MyInter>{ // 限制T的类型范围,必须为MyInter的子类,此例中T具有了length属性
  private key: T;
  constructor(prop: T){
    this.key = prop;
  }
  keyAdd:(x:T) => T;
}

// 使用？定义了可选参数去后不可出现确定参数，默认参数将被视为可选参数，但不受前一条件约束，rest参数为一数组类型
// 可选参数与默认参数共享参数类型
function fn(确定参数: 类型, 可选参数?: 类型, 默认参数: string = 'name', ...rest: any[]): 返回类型{
}
// 函数表达式, 其中=>符号表示函数定义与es6中的箭头函数不同
let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
    return x + y;
};
interface func {
  (arg1: string, arg2: number): boolean; // 接口的方式定义函数形状
}
function foo(this:void) {}; // 可以为this显式指定一个参数，此时this必须出现在参数列表的最前方
// 在回调函数中也可以指定其他类型便于ts进行类型检查

function pickCard(x:object):number; // 重载1
function pickCard(x:number):object; // 重载2
function pickCard(x):any { // 函数具体实现逻辑
  if(typeof x === 'object') console.log('handle object');
  if(typeof x === 'number') console.log('handle number');
}
// pickCard调用时，查找重载列表，从上到下匹配，所以最精确的定义放在前面