TypeScript

class Sub extends Base {
  a = 1 // 2
  constructor() {
    super() // 1
    foo() // 4
  }
  b = 2 // 3 (写在构造函数上面和下面没有区别, 执行顺序仍是晚于父类的构造函数, 早于当前类的构造函数)
}

type Colors = 'red' | 'green' | 'blue'
type RGB = [red: number, green: number, blue: number]
// 变量类型为
// {
//   red: number[]
//   green: string
//   blue: number[]
// }
const palette = {
  red: [255, 0, 0]
, green: '#00ff00'
, blue: [0, 0, 255]
}
// 不符合 Record<Colors, string | RGB>
// 变量类型为
// {
//   readonly red: readonly [255, 0, 0]
//   readonly green: '#00ff00'
//   readonly blue: readonly [0, 0, 255]
// }
const palette = {
  red: [255, 0, 0]
, green: '#00ff00'
, blue: [0, 0, 255]
} as const
// 不符合 Record<Colors, string | RGB>, 但由于结果包含readonly修饰符, 不能再修改了
// 变量类型为
// Record<Colors, string | RGB> 
const paletteA: Record<Colors, string | RGB> = {
  red: [255, 0, 0]
, green: '#00ff00'
, blue: [0, 0, 255]
}
// 符合 Record<Colors, string | RGB>, 但red, green, blue的具体类型丢失
// 变量类型为
// Record<Colors, string | RGB> 
const palette = {
  red: [255, 0, 0]
, green: '#00ff00'
, blue: [0, 0, 255]
} as Record<Colors, string | RGB>
// 符合 Record<Colors, string | RGB>, 但red, green, blue的具体类型丢失
// 变量类型为
// {
//   red: [number, number, number]
//   green: string
//   blue: [number, number, number]
// }
const palette = {
  red: [255, 0, 0]
, green: '#00ff00'
, blue: [0, 0, 255]
} satisfies Record<Colors, string | RGB>
// 符合 Record<Colors, string | RGB>, 且red, green, blue的具体类型得到保留

• ts-toolbelt: https://github.com/millsp/ts-toolbelt
• purify: https://github.com/gigobyte/purify
• <<typetype>>: https://github.com/mistlog/typetype
• type-challenges: https://github.com/type-challenges/type-challenges
• fp-ts: https://github.com/gcanti/fp-ts

type Getters<Type> = {
  [Property in keyof Type as `get${Capitalize<string & Property>}`]: () => Type[Property]
}
type RemoveKindField<Type> = {
  [Property in keyof Type as Exclude<Property, 'kind'>]: Type[Property]
}

type A = () => void
type B = () => undefined
const a: A = () => true // ok
const b: B = () => true // oops!

// 类型形式
type DescribableFunction = {
  (someArg: number): boolean
  description: string
}
// 接口形式
interface DescribableFunction {
  (someArg: number): boolean
  description: string
}

interface Base {
  prop: string | number
}
// OK
interface Sub1 extends Base {
  prop: string
}
// Type 'boolean' is not assignable to type 'string | number'
interface Sub2 extends Base {
  prop: boolean
}
// Type 'boolean' is not assignable to type 'string | number'
interface Sub3 extends Base {
  prop: string | boolean
}
// Type 'boolean' is not assignable to type 'string | number'
interface Sub4 extends Base {
  prop: string | number | boolean
}

interface Base {
  prop: string | number
}
// 找到并返回共有部分, 返回{ prop: string }
type Result1 = Base & { prop: string }
// 没有共有部分, 返回never
type Result2 = Base & { prop: boolean }
// 找到并返回共有部分, 返回{ prop: string }
type Result3 = Base & { prop: string | boolean }
// 找到并返回共有部分, 返回{ prop: string | number }
type Result4 = Base & { prop: string | number | boolean }

// 不同的类型
type Foo = string
type Bar = number
type Result = Foo & Bar // never
// 有重叠的union类型
type Foo = string | boolean
type Bar = number | boolean
type Result = Foo & Bar // boolean
// 有重叠的接口
interface Foo {
  prop: string
  a: string
}
interface Bar {
  prop: number
  b: string
}
type Result = Foo & Bar // { a: string; b: string; prop: never }
// 当接口里存在值类型为never的必要字段时, 该接口无法使用, 因此不应该在有重叠的接口上使用&.
// 可选与必需成员重叠的接口
interface Foo {
  prop?: string
}
interface Bar {
  prop: string
}
type Result = Foo & Bar // { prop: string }
type Result = Bar & Foo // 该运算符合交换律, 即使调换顺序也会得到 { prop: string }
// 不重叠的接口
interface Foo {
  a: string
}
interface Bar {
  b: number
}
type Result = Foo & Bar // { a: string; b: number }

// 不同的类型
type Foo = string
type Bar = number
type Result = Foo | Bar // string | number
// 有重叠的union类型
type Foo = string | boolean
type Bar = number | boolean
type Result = Foo | Bar // string | number | boolean
// 有重叠的接口
interface Foo {
  prop: string
  a: string
}
interface Bar {
  prop: number
  b: number
}
type Result = Foo | Bar
// | { prop: string; a: string }
// | { prop: number; b: number }
// | { prop: string | number; a: string; b: number }
// 可选与必需成员重叠的接口
interface Foo {
  prop?: string
}
interface Bar {
  prop: string
}
type Result = Foo | Bar // { prop?: string | undefined }
type Result = Bar | Foo // 该运算符合交换律, 即使调换顺序也会得到 { prop?: string | undefined }
// 不重叠的接口
interface Foo {
  a: string
}
interface Bar {
  b: number
}
type Result = Foo | Bar
// | { a: string }
// | { b: number }
// | { a: string; b: number }

type Record<K extends keyof any, T> = {
  [P in K]: T
}

export type Equals<X, Y> =
  (<T>() => T extends X ? 1 : 2) extends (<T>() => T extends Y ? 1 : 2)
  ? true
  : false

type Tuple = [string, number]
type FirstOfTuple = Tuple[0] // string
type Length = Tuple['length'] // 2

type Head<T extends unknown[]> =
  T extends [infer U, ...unknown[]]
  ? U
  : never
type Tail<T extends unknown[]> =
  T extends [unknown, ...infer U]
  ? U
  : []
type HasTail<T extends unknown[]> =
  T extends [] | [unknown]
  ? false
  : true
// 递归类型
type Last<T extends unknown[]> = {
  0: Head<T>
  1: Last<Tail<T>>
}[HasTail<T> extends true ? 1 : 0]