深入浅出 TypeScript

  // 抛出异常的函数永远不会有返回值
  function error(message: string): never {
      throw new Error(message);
  }

  // 空数组，而且永远是空的
  const empty: never[] = []

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

  const x: [string, number] = ['hello', 0]

  // 上述元组可以看做为：
  interface Tuple extends Array<string | number> {
    0: string;
    1: number;
    length: 2;
  }

enum Direction {
    Up,
    Down,
    Left,
    Right
}
console.log(Direction.Up === 0) // true

const enum Direction {
    Up = 'Up',
    Down = 'Down',
    Left = 'Left',
    Right = 'Right'
}

const a = Direction.Up;

enum Direction {
    Up,
    Down,
    Left,
    Right
}

declare let a: Direction

interface User {
    name: string
    age?: number // 可选属性
    readonly isMale: boolean // 只读属性
}

interface Say {
    (words: string) : string
}

interface User {
    name: string
    age?: number
    readonly isMale: boolean
    say: (words: string) => string
    say: Say // 或者使用接口描述函数类型
}

interface Height {
  [name: string]: string // 属性值可以是任意字符串
}

interface Config {
   width?: number;
   height: Height,
   [propName: string]: any;
}

interface VIPUser extends User, SupperUser { // 可以继承多个接口
    broadcast: () => void
}

abstract class Animal {
    abstract makeSound(): void;
    move(): void {
        console.log('move');
    }
}

// 加粗部分就是函数类型的定义
const add: **(a: number, b: number) => number** = (a: number, b: number) => a + b;

const add = (a: number, b?: number) => a + (b ? b : 0) // 可选参数，类型为**联合类型number | undefined**
const add = (a: number, b = 1) => a + b // 默认参数
const add = (a: number, ...rest: number[]) => rest.reduce((a, b) => a + b, a) // 剩余参数rest

function any (info: any): any {
  return info;
}

function error(message: string): never {
  throw new Error(message);
}

function void(): void {
  console.log('void');
}

function getItem<T>(params: T): T {
  return params; // 传入参数类型和返回参数类型一致
}

function getArrayLength<T>(arg: Array<T>) {
  console.log((arg as Array<any>).length)
  return arg;
}

interface returnItemFn<T> {
  (params: T): T
}

const returnItem: returnItemFn<number> = params => params // 使用泛型接口声明函数

class Stack<T> {
  private arr: T[] = []

  public push(item: T) {
    this.arr.push(item)
  }

  public pop() {
    this.arr.pop()
  }
}

type Params = number | string;

class Stack<T extends Params> {
  private arr: T[] = []

  public push(item: T) {
    this.arr.push(item)
  }

  public pop() {
    this.arr.pop()
  }
}

function getValue<T extends object, U extends keyof T>(obj: T, key: U) {
  return obj[key];
}

interface FirstInterface {
  one(): number
}

interface SecondInterface {
  two(): string
}

class Union<T extends FirstInterface & SecondInterface> {
  private genericProperty: T

  use() {
    this.genericProperty.one();
    this.genericProperty.two();
  }
}

function factory<T>(type: { new(): T }): T {
  return new type();
}

interface Person {
  name: string;
  age: number;
}

const person = {} as Person; // 类型断言为Person接口

person.name = 'xx';
person.age = 18;

interface Person {
  name: string;
  age: number;
}

const person = 'xx' as any as Person; // 双重断言为Person接口

if (arg instanceof Person) {}
if ('name' in Person) {}
if (arg.name === 'chuck') {}
if (typeof name === 'string') {}

let x = (a: number) => 0;
let y = (b: number, s: string) => 0;

y = x; // OK
x = y; // Error 不能将类型“(b: number, s: string) => number”分配给类型“(a: number) => number”。

enum Status {
  Ready,
  Waiting
}

let status = Status.Ready;
let num = 0;

status = num;
num = status;

class Animal {
  feet: number;
  constructor(name: string, numFeet: number) {}
}

class Size {
  feet: number;
  constructor(meters: number) {}
}

let a: Animal;
let s: Size;

a = s; // OK
s = a; // OK

interface Person<T> { // 没有被成员使用，ok

}

let x : Person<string>
let y : Person<number>

x = y // ok
y = x // ok

interface Person<T> { // 被成员name使用，不ok
    name: T
}

let x : Person<string>
let y : Person<number>

x = y // 不能将类型“Person<number>”分配给类型“Person<string>”。
y = x // 不能将类型“Person<string>”分配给类型“Person<number>”。

interface IAnyObject {
    [prop: string]: any
}

function mixin<T extends IAnyObject, U extends IAnyObject>(first: T, second: U): T & U {
    const result = <T & U>{};
    for (let id in first) {
      (<T>result)[id] = first[id];
    }
    for (let id in second) {
      if (!result.hasOwnProperty(id)) {
        (<U>result)[id] = second[id];
      }
    }

    return result;
  }

  const x = mixin({ a: 'hello' }, { b: 42 });

  // 现在 x 拥有了 a 属性与 b 属性
  const a = x.a;
  const b = x.b;

const wrapRaf = ref<HTMLDivElement | null>(null); // vue3中声明一个dom元素的引用

const fn = (a?: number) => {} // 可选参数a的类型就是联合类型 number | undefined

type some = boolean | number;
type Container<T> = { value: T };
type Tree<T> = { // 属性中引用自己
    value: T;
    left: Tree<T>;
    right: Tree<T>;
}

const a: 886 = 886; // ok
const site: 'chuck' = 'chuck'; // ok

type Direction = 'North' | 'East' | 'South' | 'West'; // 该类型别名只有指定的四个方向值

type Foo = {
  baz: [
    number,
    'chuck'
  ];
  toString(): string;
  readonly [Symbol.iterator]: 'github';
  0x1: 'foo';
  "bar": 12n;
};

type UserAction = | {
    id: number
    action: 'delete'
    info: Info
} |
{
    action: 'create'
    info: Info
}

const UserReducer = (userAction: UserAction) => {
    switch (userAction.action) { // 可辨识的标签
        case 'delete':
            console.log(userAction.id);
            break;
        default:
            break;
    }
}

class Images {
    public src: string = 'https://www.google.com.hk/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png'
    public alt: string = '谷歌'
    public width: number = 500
}

type propsNames = keyof Images // type propsNames = 'src' | 'alt' | 'width'

function pick<T, K extends keyof T>(o: T, names: K[]): T[K][] {
 return names.map(n => o[n]);
}

type partial<T> = { [K in keyof T]?: T[K] }

T extends U ? X : Y

// 裸类型参数,没有被任何其他类型包裹即T
type NakedUsage<T> = T extends boolean ? "YES" : "NO"
type Distributed = NakedUsage<number | boolean> //  等价于NakedUsage<number> | NakedUsage<boolean> =  "NO" | "YES"

type Diff<T, U> = T extends U ? never : T; // 找出T类型中U不包含的部分

type R = Diff<"a" | "b" | "c" | "d", "a" | "c" | "f">; // "b" | "d"

type Filter<T, U> = T extends U ? T : never; // filter方法

type NonNullable<T> = Diff<T, null | undefined>; // 剔除null和undefined

interface Part {
    id: number;
    name: string;
    subparts: Part[];
    updatePart(newName: string): void;
}

type R = FunctionPropertyNames<Part>;

type FunctionPropertyNames<T> = { [K in keyof T]: T[K] extends Function ? K : never }[keyof T]

type R = {
 id: never;
  name: never;
  subparts: never;
  updatePart: "updatePart"; // 该类型是Function，所以接口的值是泛型的key
}

type ParamType<T> = T extends (param: infer P) => any ? P : T;

type ReturnType<T> = T extends (...args: any[]) => infer P ? P : any;

type ConstuctorParameters<T extends new (...args: any[]) => any> = T extends new (...args: infer P) => any ? P : never;

type ELementOf<T> = T extends Array<infer E> ? E : never;

type TTuple = [string, number];

type ToUnion = ElementOf<TTuple>; // string | number;

type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;

type Result = UnionToIntersection<string | number>;

type Partial<T> = { [K in keyof T]?: T[K] };

type DeepPartial<T> = {
 [U in keyof T]?: T[U] extends Object ? DeepPartial<T[U]> : T[U];
}
// 当value为对象类型，则递归调用

type Required<T> = { [P in keyof T]-?: T[P] };

type Exclude<T, U> = T extends U ? never : T;

type TT = Exclude<1 | 2, 1 | 3>; // 2

type Omit<T, K> = Pick<T, Exclude<keyof T, K>>;

type Foo = Omit<{ name: string, age: number }, 'name'> // { age: number }

type Compute<A extends any> = A extends Function ? A : { [K in keyof A]: A[K] };

type R1 = Compute<{ x: 'x' } & { y: 'y' }> // {x: "x", y: "y"}

type R2 = Compute<{ x: 'x'; y: 'y1' } & { y: 'y' }> // {x: "x", y: never}

type Merge<O1 extends object, O2 extends object> = Compute<O1 & Omit<O2, keyof O1>>;

type O1 = {
  name: string;
  id: string;
};

type O2 = {
  id: number;
  from: string;
};

type R2 = Merge<O1, O2>; // {name: string, id: string, from: string}

type Extract<T, U> = T extends U ? T : never;

type Intersection<T extends object, U extends object> = Pick<
  T,
  Extract<keyof T, keyof U> & Extract<keyof U, keyof T>
>;

type Props = { name: string; age: number; visible: boolean };
type DefaultProps = { age: number };

type DuplicatedProps = Intersection<Props, DefaultProps>; // { age: number; }

type Overwrite<
  T extends object,
  U extends object,
  I = Diff<T, U> & Intersection<U, T>
> = Pick<I, keyof I>;

// From T, pick a set of properties whose keys are in the union K
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};

type Mutable<T> = { -readonly [P in keyof T]: T[P] }

// Make all properties in T readonly
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

// Construct a type with a set of properties K of type T
type Record<K extends keyof any, T> = {
    [P in K]: T;
};

type K = 'A' | 'B' | 'C';

// {A: {id: number}, B: {id: number}, C: {id: number}}
type result = Record<K, { id: number }>

SourceCode（源码）+ 扫描器 --> Token 流

Token 流 + 解析器 --> AST（抽象语法树）

AST + 绑定器 --> Symbols（符号）

AST + 符号 + 检查器 --> 类型验证

AST + 检查器 + 发射器 --> JavaScript 代码

npm install --save-dev @types/node

declare const jQuery: (selector: string) => any;

declare function jQuery(selector: string): any;

declare class Person {
  name: string;
  constructor(name: string);
  say(): string;
}

declare enum Directions {
  Up,
  Down,
  Left,
  Right
}

interface AjaxSettings {
    method?: 'GET' | 'POST'
    data?: any;
}
declare namespace jQuery {
    function ajax(url: string, settings?: AjaxSettings): void;
}

declare function jQuery(selector: string): any;
declare namespace jQuery {
    function ajax(url: string, settings?: any): void;
}

// tsconfig.json
{
    "compilerOptions": {
        "module": "commonjs",
        "outDir": "lib", // 输出目录
        "declaration": true, // 生成声明文件
    }
}

// index.d.ts
export type Listener = (...args: any[]) => void;
export type Type = string | symbol

export class EventEmitter {
  static listenerCount(emitter: EventEmitter, type: Type): number;
  static defaultMaxListeners: number;

  eventNames(): Array<Type>;
  setMaxListeners(n: number): this;
  getMaxListeners(): number;
  emit(type: Type, ...args: any[]): boolean;
  addListener(type: Type, listener: Listener): this;
  on(type: Type, listener: Listener): this;
  once(type: Type, listener: Listener): this;
  prependOnceListener(type: Type, listener: Listener): this;
  removeListener(type: Type, listener: Listener): this;
  off(type: Type, listener: Listener): this;
  removeAllListeners(type?: Type): this;
  listeners(type: Type): Listener[];
  listenerCount(type: Type): number;
  prependListener(type: Type, listener: Listener): this;
  rawListeners(type: Type): Listener[];
}

{
  "compilerOptions": {
    /* Basic Options */
    "target": "es5" /* target用于指定编译之后的版本目标: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017', 'ES2018', 'ES2019' or 'ESNEXT'. */,
    "module": "commonjs" /* 用来指定要使用的模块标准: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
    "lib": ["es6", "dom"] /* lib用于指定要包含在编译中的库文件 */,
    "allowJs": true,                       /* allowJs设置的值为true或false，用来指定是否允许编译js文件，默认是false，即不编译js文件 */
    "checkJs": true,                       /* checkJs的值为true或false，用来指定是否检查和报告js文件中的错误，默认是false */
    "jsx": "preserve",                     /* 指定jsx代码用于的开发环境: 'preserve', 'react-native', or 'react'. */
    "declaration": true,                   /* declaration的值为true或false，用来指定是否在编译的时候生成相应的".d.ts"声明文件。如果设为true，编译每个ts文件之后会生成一个js文件和一个声明文件。但是declaration和allowJs不能同时设为true */
    "declarationMap": true,                /* 值为true或false，指定是否为声明文件.d.ts生成map文件 */
    "sourceMap": true,                     /* sourceMap的值为true或false，用来指定编译时是否生成.map文件 */
    "outFile": "./dist/main.js",           /* outFile用于指定将输出文件合并为一个文件，它的值为一个文件路径名。比如设置为"./dist/main.js"，则输出的文件为一个main.js文件。但是要注意，只有设置module的值为amd和system模块时才支持这个配置 */
    "outDir": "./dist",                    /* outDir用来指定输出文件夹，值为一个文件夹路径字符串，输出的文件都将放置在这个文件夹 */
    "rootDir": "./",                       /* 用来指定编译文件的根目录，编译器会在根目录查找入口文件，如果编译器发现以rootDir的值作为根目录查找入口文件并不会把所有文件加载进去的话会报错，但是不会停止编译 */
    "composite": true,                     /* 是否编译构建引用项目  */
    "removeComments": true,                /* removeComments的值为true或false，用于指定是否将编译后的文件中的注释删掉，设为true的话即删掉注释，默认为false */
    "noEmit": true,                        /* 不生成编译文件，这个一般比较少用 */
    "importHelpers": true,                 /* importHelpers的值为true或false，指定是否引入tslib里的辅助工具函数，默认为false */
    "downlevelIteration": true,            /* 当target为'ES5' or 'ES3'时，为'for-of', spread, and destructuring'中的迭代器提供完全支持 */
    "isolatedModules": true,               /* isolatedModules的值为true或false，指定是否将每个文件作为单独的模块，默认为true，它不可以和declaration同时设定 */

    /* Strict Type-Checking Options */
    "strict": true /* strict的值为true或false，用于指定是否启动所有类型检查，如果设为true则会同时开启下面这几个严格类型检查，默认为false */,
    "noImplicitAny": true,                 /* noImplicitAny的值为true或false，如果我们没有为一些值设置明确的类型，编译器会默认认为这个值为any，如果noImplicitAny的值为true的话。则没有明确的类型会报错。默认值为false */
    "strictNullChecks": true,              /* strictNullChecks为true时，null和undefined值不能赋给非这两种类型的值，别的类型也不能赋给他们，除了any类型。还有个例外就是undefined可以赋值给void类型 */
    "strictFunctionTypes": true,           /* strictFunctionTypes的值为true或false，用于指定是否使用函数参数双向协变检查 */
    "strictBindCallApply": true,           /* 设为true后会对bind、call和apply绑定的方法的参数的检测是严格检测的 */
    "strictPropertyInitialization": true,  /* 设为true后会检查类的非undefined属性是否已经在构造函数里初始化，如果要开启这项，需要同时开启strictNullChecks，默认为false */
    "noImplicitThis": true,                 /* 当this表达式的值为any类型的时候，生成一个错误 */
    "alwaysStrict": true,                  /* alwaysStrict的值为true或false，指定始终以严格模式检查每个模块，并且在编译之后的js文件中加入"use strict"字符串，用来告诉浏览器该js为严格模式 */

    /* Additional Checks */
    "noUnusedLocals": true,                /* 用于检查是否有定义了但是没有使用的变量，对于这一点的检测，使用eslint可以在你书写代码的时候做提示，你可以配合使用。它的默认值为false */
    "noUnusedParameters": true,            /* 用于检查是否有在函数体中没有使用的参数，这个也可以配合eslint来做检查，默认为false */
    "noImplicitReturns": true,             /* 用于检查函数是否有返回值，设为true后，如果函数没有返回值则会提示，默认为false */
    "noFallthroughCasesInSwitch": true,    /* 用于检查switch中是否有case没有使用break跳出switch，默认为false */

    /* Module Resolution Options */
    "moduleResolution": "node",            /* 用于选择模块解析策略，有'node'和'classic'两种类型' */
    "baseUrl": "./",                       /* baseUrl用于设置解析非相对模块名称的基本目录，相对模块不会受baseUrl的影响 */
    "paths": {},                           /* 用于设置模块名称到基于baseUrl的路径映射 */
    "rootDirs": [],                        /* rootDirs可以指定一个路径列表，在构建时编译器会将这个路径列表中的路径的内容都放到一个文件夹中 */
    "typeRoots": [],                       /* typeRoots用来指定声明文件或文件夹的路径列表，如果指定了此项，则只有在这里列出的声明文件才会被加载 */
    "types": [],                           /* types用来指定需要包含的模块，只有在这里列出的模块的声明文件才会被加载进来 */
    "allowSyntheticDefaultImports": true,  /* 用来指定允许从没有默认导出的模块中默认导入 */
    "esModuleInterop": true /* 通过为导入内容创建命名空间，实现CommonJS和ES模块之间的互操作性 */,
    "preserveSymlinks": true,              /* 不把符号链接解析为其真实路径，具体可以了解下webpack和nodejs的symlink相关知识 */

    /* Source Map Options */
    "sourceRoot": "",                      /* sourceRoot用于指定调试器应该找到TypeScript文件而不是源文件位置，这个值会被写进.map文件里 */
    "mapRoot": "",                         /* mapRoot用于指定调试器找到映射文件而非生成文件的位置，指定map文件的根路径，该选项会影响.map文件中的sources属性 */
    "inlineSourceMap": true,               /* 指定是否将map文件的内容和js文件编译在同一个js文件中，如果设为true，则map的内容会以//# sourceMappingURL=然后拼接base64字符串的形式插入在js文件底部 */
    "inlineSources": true,                 /* 用于指定是否进一步将.ts文件的内容也包含到输入文件中 */

    /* Experimental Options */
    "experimentalDecorators": true         /* 用于指定是否启用实验性的装饰器特性 */
    "emitDecoratorMetadata": true,         /* 用于指定是否为装饰器提供元数据支持，关于元数据，也是ES6的新标准，可以通过Reflect提供的静态方法获取元数据，如果需要使用Reflect的一些方法，需要引入ES2015.Reflect这个库 */
  }
  "files": [], // files可以配置一个数组列表，里面包含指定文件的相对或绝对路径，编译器在编译的时候只会编译包含在files中列出的文件，如果不指定，则取决于有没有设置include选项，如果没有include选项，则默认会编译根目录以及所有子目录中的文件。这里列出的路径必须是指定文件，而不是某个文件夹，而且不能使用* ? **/ 等通配符
  "include": [],  // include也可以指定要编译的路径列表，但是和files的区别在于，这里的路径可以是文件夹，也可以是文件，可以使用相对和绝对路径，而且可以使用通配符，比如"./src"即表示要编译src文件夹下的所有文件以及子文件夹的文件
  "exclude": [],  // exclude表示要排除的、不编译的文件，它也可以指定一个列表，规则和include一样，可以是文件或文件夹，可以是相对路径或绝对路径，可以使用通配符
  "extends": "",   // extends可以通过指定一个其他的tsconfig.json文件路径，来继承这个配置文件里的配置，继承来的文件的配置会覆盖当前文件定义的配置。TS在3.2版本开始，支持继承一个来自Node.js包的tsconfig.json配置文件
  "compileOnSave": true,  // compileOnSave的值是true或false，如果设为true，在我们编辑了项目中的文件保存的时候，编辑器会根据tsconfig.json中的配置重新生成文件，不过这个要编辑器支持
  "references": [],  // 一个对象数组，指定要引用的项目
}

npm install -g eslint

eslint --init

module.exports = {
  env: { // 用于指定环境
    browser: true,
    es6: true,
    node: true,
  },
  extends: [ // 字符串或字符串数组，数组中每个配置项继承它前面的配置。
    'airbnb-base',
  ],
  globals: { // 脚本在执行期间访问的额外的全局变量
    Atomics: 'readonly',
    SharedArrayBuffer: 'readonly',
  },
  parser: '@typescript-eslint/parser', // 解析器
  parserOptions: { // parser 解析代码时的配置参数
    ecmaVersion: 2020, // 指定es版本
    sourceType: 'module', // 指定资源类型为ECMAScript 模块
  },
  plugins: [ // 第三方插件，插件名称可以省略 eslint-plugin- 前缀
    '@typescript-eslint',
  ],
  rules: { // 具体规则的配置，可以用来进行覆盖或者修改指定规则
  },
};