// 函数兼容性
type Handler = (a: number, b: number) => void
function hof(handler: Handler) {
  return handler
}

// 1)参数个数
let handler1 = (a: number) => { }
hof(handler1)
let handler2 = (a: number, b: number, c: number) => { }
// 类型“(a: number, b: number, c: number) => void”的参数不能赋给类型“Handler”的参数。
// hof(handler2)

// 可选参数和剩余参数
let a = (p1: number, p2: number) => { }
let b = (p1?: number, p2?: number) => { }
let c = (...args: number[]) => { }
a = b
a = c
// 可选参数不兼容固定参数 ，剩余参数
// b = a
// b = c
c = a
c = b

// 2)参数类型
let handler3 = (a: string) => { }
// hof(handler3)

interface Point3D {
  x: number;
  y: number;
  z: number;
}
interface Point2D {
  x: number;
  y: number;
}
let p3d = (point: Point3D) => { }
let p2d = (point: Point2D) => { }
p3d = p2d
// 成员少的可以兼容多的
// p2d = p3d

// 3) 返回值类型
let f = () => ({ name: 'Alice' })
let g = () => ({ name: 'Alice', location: 'Beijing' })
f = g
// 不能将类型“() => { name: string; }”分配给类型“() => { name: string; location: string; }”。Property 'location' is missing in type '{ name: string; }' but required in type '{ name: string; location: string; }'.
// g = f

// 函数重载 
// 重载列表
function overload(a: number, b: number): number
function overload(a: string, b: string): string
// 具体实现
function overload(a: any, b: any): any { }
// function overload(a: any): any {}
// This overload signature is not compatible with its implementation signature.
// function overload(a: any, b: any, c: any): any {}
// This overload signature is not compatible with its implementation signature.
// function overload(a: any, b: any) {}

// 枚举兼容性
enum Fruit { Apple, Banana }
enum Color { Red, Yellow }
let fruit: Fruit.Apple = 1
let no: number = Fruit.Apple
// 不能将类型“Fruit.Apple”分配给类型“Color.Red”。
let color: Color.Red = Fruit.Apple

// 类兼容性
class A {
  constructor(p: number, q: number) { }
  id: number = 1
  private name: string = ''
}
class B {
  static s = 1
  constructor(p: number) { }
  id: number = 2
  private name: string = ''
}
class C extends A { }
let aa = new A(1, 2)
let bb = new B(1)
// 不能将类型“B”分配给类型“A”。类型具有私有属性“name”的单独声明。
aa = bb
// 不能将类型“A”分配给类型“B”。类型具有私有属性“name”的单独声明。
bb = aa
let cc = new C(1, 2)
aa = cc
cc = aa

// 泛型接口
interface Empty<T> {
  value: T
}
let obj1: Empty<number> = {};
let obj2: Empty<string> = {};
// 不能将类型“Empty<string>”分配给类型“Empty<number>”。不能将类型“string”分配给类型“number”。
obj1 = obj2

// 泛型接口
interface Empty<T> {
  // value: T //没有使用泛型变量 T
}
let obj1: Empty<number> = {};
let obj2: Empty<string> = {};
obj1 = obj2

let log1 = <T>(x: T): T => {
  console.log('x')
  return x
}
let log2 = <U>(y: U): U => {
  console.log('y')
  return y
}
log1 = log2

enum Type { Strong, Week }

class JavaScript {
  helloJavaScript() {
    console.log('Hello JavaScript')
  }
  js: any
}

function getLanguage(type: Type) {
  let lang = type === Type.Strong ? new Java() : new JavaScript();

  // 类型“Java | JavaScript”上不存在属性“helloJava”。类型“JavaScript”上不存在属性“helloJava”。
  // if (lang.helloJava) {
  //   lang.helloJava();
  // } else {
  //   // 类型“Java | JavaScript”上不存在属性“helloJavaScript”。类型“Java”上不存在属性“helloJavaScript”。
  //   lang.helloJavaScript();
  // }
  // 类型断言
  if ((lang as Java).helloJava){
    (lang as Java).helloJava();
  }else{
    (lang as JavaScript).helloJavaScript();
  }
}

getLanguage(Type.Week)

enum Type { Strong, Week }

class Java {
    helloJava() {
        console.log('Hello Java')
    }
    java: any
}

class JavaScript {
    helloJavaScript() {
        console.log('Hello JavaScript')
    }
    js: any
}

// 类型保护函数
// lang is Java：类型谓词
function isJava(lang: Java | JavaScript): lang is Java {
    return (lang as Java).helloJava !== undefined
}

function getLanguage(type: Type, x: string | number) {
    let lang = type === Type.Strong ? new Java() : new JavaScript();
    
    if (isJava(lang)) {
        lang.helloJava();
    } else {
        lang.helloJavaScript();
    }

    // if ((lang as Java).helloJava) {
    //     (lang as Java).helloJava();
    // } else {
    //     (lang as JavaScript).helloJavaScript();
    // }

    // instanceof
    // if (lang instanceof Java) {
    //     lang.helloJava()
    //     // lang.helloJavaScript()
    // } else {
    //     lang.helloJavaScript()
    // }

    // in
    // if ('java' in lang) {
    //     lang.helloJava()
    // } else {
    //     lang.helloJavaScript()
    // }

    // typeof
    // if (typeof x === 'string') {
    //     console.log(x.length)
    // } else {
    //     console.log(x.toFixed(2))
    // }

    return lang;
}

getLanguage(Type.Week, 1)