Applying TypeScript Coding Standards

When writing or reviewing TypeScript code, check against these rules in order of priority: 强制 (mandatory) rules must never be violated; 推荐 (recommended) rules should be followed unless there's a documented reason not to.

TypeScript
// Mandatory checks
const foo = 'bar' as string;         // not <string>'bar'
const foo2 = { x: 1 } as MyType;     // object literals: use `as`, not <T>
class Foo {
  foo(s: string): void;              // overloads adjacent
  foo(n: number): void;
  foo(sn: string | number): void {}
}
type Foo = { name: string; greet(): void };  // `;` delimiter
let x: string = 'bar';                        // space after colon

// Recommended checks
interface Point { x: number; y: number }      // prefer interface over type for objects
const arr: string[] = ['a'];                  // simple type -> T[]
const arr2: Array<{ id: string }> = [];       // complex type -> Array<T>

Progress checklist when reviewing/writing TS code:

• Confirm underlying JS spec is followed first (this spec only covers TS-specific additions)
• Check type assertions use as Type, never <Type>, never on object literals (except any/unknown)
• Check array type style: T[] for primitives, Array<T> for complex/union/object/function types
• Check interface/type member delimiter is ;, spacing around : and => is correct
• Check member ordering: static > instance, field > constructor > method, public > protected > private
• Check overloaded function/method signatures are grouped together
• Check accessibility modifiers are explicit for non-public members (private/protected)
• Check no namespace/module used for runtime code (only allowed in declare contexts)
• Check no require(), prefer ES2015 import
• Check no redundant type annotations when inference already narrows the type
• Check // @ts-ignore / // @ts-expect-error always has explanatory comment
• Check no dangling this alias (const self = this), prefer arrow functions
• Check + operator operands are both numbers or both strings (no implicit coercion)
• Check string literals use single quotes
• Check no triple-slash /// references outside .d.ts files
• Check empty interfaces are removed/merged
• Check as const used when value equals a literal type declaration

Example 1 — Type assertion: Input:

TypeScript
const x = { name: 'a' } as T;
const y = <string>someValue;

Output:

TypeScript
const x: T = { name: 'a' };   // object literal: declare type directly
const y = someValue as string; // use `as`, not angle brackets

Example 2 — Array type: Input:

TypeScript
const list: Array<string> = ['a', 'b'];
const objs: { id: string }[] = [];

Output:

TypeScript
const list: string[] = ['a', 'b'];          // simple type -> T[]
const objs: Array<{ id: string }> = [];     // complex type -> Array<T>

Example 3 — Member ordering & accessibility: Input:

TypeScript
class Foo {
  bar = 'bar';
  constructor() {}
  static foo = 'foo';
  getBar() {}
}

Output:

TypeScript
class Foo {
  public static foo = 'foo';
  protected bar = 'bar';
  public constructor() {}
  public getBar() {}
}