15 类型兼容性，开放心态满足灵活的 JS

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

y = x // 没问题

x = y // error Type '(b: number, s: string) => number' is not assignable to type '(a: number) => number'

const arr = [1, 2, 3]
arr.forEach((item, index, array) => {
  console.log(item)
})
arr.forEach((item) => {
  console.log(item)
})

let x = (a: number) => 0
let y = (b: string) => 0
let z = (c: number) => false
x = y // error 不能将类型“(b: string) => number”分配给类型“(a: number) => number”。
x = z // error 不能将类型“(c: number) => boolean”分配给类型“(a: number) => number”。

const getNum = (
  // 这里定义一个getNum函数，他有两个参数
  arr: number[], // 第一个参数是一个数组
  callback: (...args: number[]) => number // 第二个参数是一个函数，这个函数的类型要求可以传入任意多个参数，但是类型必须是数值类型，返回值必须是数值类型
): number => {
  return callback(...arr) // 这个getNum函数直接返回调用传入的第二个参数这个函数，以第一个参数这个数组作为参数的函数返回值
}
getNum(
  [1, 2],
  (...args: number[]): number => args.length // 这里传入一个函数，逻辑是返回参数的个数
)

const getNum = (
  arr: number[],
  callback: (arg1: number, arg2?: number) => number // 这里指定第二个参数callback是一个函数，函数的第二个参数为可选参数
): number => {
  return callback(...arr) // error 应有 1-2 个参数，但获得的数量大于等于 0
}

let funcA = function (arg: number | string): void {}
let funcB = function (arg: number): void {}
// funcA = funcB 和 funcB = funcA都可以

let x = (a: number): string | number => 0
let y = (b: number) => 'a'
let z = (c: number) => false
x = y
x = z // 不能将类型“(c: number) => boolean”分配给类型“(a: number) => string | number”

function merge(arg1: number, arg2: number): number // 这是merge函数重载的一部分
function merge(arg1: string, arg2: string): string // 这也是merge函数重载的一部分
function merge(arg1: any, arg2: any) {
  // 这是merge函数实体
  return arg1 + arg2
}
function sum(arg1: number, arg2: number): number // 这是sum函数重载的一部分
function sum(arg1: any, arg2: any): any {
  // 这是sum函数实体
  return arg1 + arg2
}
let func = merge
func = sum // error 不能将类型“(arg1: number, arg2: number) => number”分配给类型“{ (arg1: number, arg2: number): number; (arg1: string, arg2: string): string; }”

enum Status {
  On,
  Off,
}
let s = Status.On
s = 1
s = 3

enum Status {
  On,
  Off,
}
enum Color {
  White,
  Black,
}
let s = Status.On
s = Color.White // error Type 'Color.White' is not assignable to type 'Status'

enum Status {
  On = 'on',
  Off = 'off',
}
let s = Status.On
s = 'Lison' // error 不能将类型“"Lison"”分配给类型“Status”

class Animal {
  static age: number
  constructor(public name: string) {}
}
class People {
  static age: string
  constructor(public name: string) {}
}
class Food {
  constructor(public name: number) {}
}
let a: Animal
let p: People
let f: Food
a = p // right
a = f // error Type 'Food' is not assignable to type 'Animal'

class Parent {
  private age: number
  constructor() {}
}
class Children extends Parent {
  constructor() {
    super()
  }
}
class Other {
  private age: number
  constructor() {}
}

const children: Parent = new Children()
const other: Parent = new Other() // 不能将类型“Other”分配给类型“Parent”。类型具有私有属性“age”的单独声明

class Parent {
  protected age: number
  constructor() {}
}
class Children extends Parent {
  constructor() {
    super()
  }
}
class Other {
  protected age: number
  constructor() {}
}
const children: Parent = new Children()
const other: Parent = new Other() // 不能将类型“Other”分配给类型“Parent”。属性“age”受保护，但类型“Other”并不是从“Parent”派生的类

interface Data<T> {}
let data1: Data<number>
let data2: Data<string>

data1 = data2

interface Data<T> {
  data: T
}
let data1: Data<number>
let data2: Data<string>

data1 = data2 // error 不能将类型“Data<string>”分配给类型“Data<number>”。不能将类型“string”分配给类型“number”