// 没有设置类型时，TS会根据赋值的类型推断类型
let a1; 　　　　// 等价于 let a1: any
let a = 1; 　　// 等价于 let a: number
let b = [1];　 // 等价于 let b: number[]
let c = [1, null]; 　　　　 // 等价于 let c: number[]
let c1 = (x = 1) => {} 　　// 等价于 let c1: (x?: number) => void
let d = (x = 1) => x + 1; // 等价于 let d: (x?: number) => number

// 断言好处：改造旧代码会很有效，但避免滥用，需对上下文环境有充足的预判，否则会带来安全隐患
interface Foo {
    bar: number
}
// let foo = {}; // 报错
// let foo = {} as Foo; // 注意：不可滥用断言，若去掉bar属性,foo对象就没有按照接口的严格约定返回，就会遗漏
// foo.bar = 1; 
let foo: Foo = { // 最佳通用类型推断
    bar: 1
};

// x 兼容 y : x (目标类型) =  y(源类型)
let s: string = ‘a‘
s = null; // 报错

interface XX {
    a: any;
    b: any;
}
interface YY {
    a: any;
    b: any;
    c: any;
}
let xx: XX = {a:1, b:2}
let yy: YY = {a:1, b:2, c:3}

xx = yy;
// yy = xx; // 报错。注意：源类型必须要具备目标类型的必要属性。xx可以兼容yy类型，反之不行

type Handler = (a: number, b: number) => void; // Handler 为目标类型，传入的参数为源类型
function hocf(handler: Handler){
    return handler
}
// 目标函数要兼容源函数需要同时满足以下三点：
// 1) 参数个数要求: 目标函数的个数要多于源函数参数的个数
    // 固定参数个数
    let handler1 = (a: number) => {};
    hocf(handler1);
    // let handler2 = (a: number, b: number, c: number) => {};
    // hocf(handler2); // 报错。目标函数的个数要多于源函数参数的个数
    
    // 不固定参数：可选参数和剩余参数: 需坚持三原则
    let l = (p1: number, p2: number) => {}
    let m = (p1?: number, p2?: number) => {}
    let n = (...args: number[]) => {}
    // - 1.固定参数可以兼容可选参数和剩余参数
    l = m;
    l = n;
    // - 2.可选参数不兼容固定参数和剩余参数，但设置 tsconfig strictFunctionTypes：false 属性，可预防报错
    m = n // 报错
    m = n // 报错
    // - 3.剩余参数可以兼容固定参数和可选参数
    n = l
    n = m
    
// 2) 参数类型要求
    // 基础类型接口
    let handler3 = (a: string) => {};
    // hocf(handler3); // 报错。类型不兼容

    // 对象类型接口：成员多的兼容成员少的，与接口成员兼容相反，可以看成参数，参数多的兼容参数少的
    interface Point3D {
        x: number;
        y: number;
        z: number;
    }
    interface Point2D {
        x: number;
        y: number;
    }
    // 参数个数相同，参数类型相同Object
    let p3d = (point: Point3D) => {}
    let p2d = (point: Point2D) => {}
    p3d = p2d
    p2d = p3d // 报错。设置 tsconfig strictFunctionTypes：false 属性，可预防报错
    // 函数参数之间可以相互赋值的情况被称为 参数双向协变。作用：可以把精确类型 赋值给 不精确类型，这样就不需要把不精确的类型断言成精确类型

// 3)  返回值类型。ts要求我们目标函数的返回值类型必须要和源函数返回值类型一致或者是其子类型
    // 成员少的兼容成员多的 
    let o = () => ({name: "Alice"});
    let p = () => ({name: "Alice", location: ‘Beijing‘});
    o = p;
    // p = o; // 报错

// 在重载中，目标函数的参数要多于源函数的参数
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, b: any, c: any): any {} // 报错。在重载中，目标函数的参数要多于源函数的参数
// function overload(a: any, b: any) {} // 报错。返回值参数类型不兼容

enum Fruit { Apple, Banana }
enum Color { Red, Yellow }
// 枚举类型和数字类型是完全可以互相兼容和赋值的
let fruit: Fruit.Apple = 3; 
let no: number = Fruit.Apple;
// 枚举类型之间是不兼容的
// let color: Color.Red = Fruit.Apple; // 报错

// - 不会报错
interface Empty<T>{  }
let obj1: Empty<number> = {  }
let obj2: Empty<number> = {  }
obj1 = obj2;
// - 会报错 只有接口参数T被接口使用的时候，才会影响泛型的兼容性
// interface Empty<T>{
//     value: T
// }
// let obj1: Empty<number> = {}
// let obj2: Empty<number> = {}
// obj1 = obj2;

// 2. 泛型函数
let loog1 = <T>(x: T): T => {
    console.log(‘x‘)
    return x
}
let loog2 = <U>(y: U): U => {
    console.log(‘y‘)
    return y
}
loog1 = loog2; // 两个泛型函数的定义相同，并没有指定类型参数，泛型函数也是兼容的

enum Type { Strong, Week }
class Java {
    helloJava(){
        console.log(‘Hello Java‘)
    }
    java: any
}
class JavaScript {
    helloJavaScript(){
        console.log(‘Hello JavaScript‘)
    }
    javascript: any
}
function getLanguage(type: Type, x: string|number){
    let lang = type === Type.Strong ? new Java() : new JavaScript();
    // 用类型断言解决返回值不确定的情况，可读性差
    if((lang as Java).helloJava){
        (lang as Java).helloJava()
    } else {
        (lang as JavaScript).helloJavaScript()
    }
    // console.log(lang, ‘lang‘)
    return lang;
}

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

function getLanguage(type: Type, x: string|number){
    let lang = type === Type.Strong ? new Java() : new JavaScript();
  if(‘java‘ in lang){
        lang.helloJava()
    } else {
        lang.helloJavaScript()
    }
    // console.log(lang, ‘lang‘)
    return lang;
}

function getLanguage(type: Type, x: string|number){
    let lang = type === Type.Strong ? new Java() : new JavaScript();
　　// x也是联合类型，typeof类型保护，可以判断出基本类型。
    if(typeof x === ‘string‘){
        x.length
    } else {
        x.toFixed
    }
    // console.log(lang, ‘lang‘)
    return lang;
}

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

    // console.log(lang, ‘lang‘)
    return lang;
}

// 类型保护函数，可以传递任何值给 isJava 函数，用来判断它是不是 Java。isJava 函数与普通函数的最大区别是，该函数的返回类型是 lang is Java，这就是 "类型谓词"。
function isJava(lang: Java | JavaScript): lang is Java{
// 类型谓词可参考：https://segmentfault.com/a/1190000022883470
return (lang as Java).helloJava !== undefined // 返回结果是 true，那么当前判断的 lang 变量值的类型是 Java 类型。
}