同名.ts             //是 TypeScript 文件的后缀  
同名.d.ts           //DefinitelyTyped 用于给非ts的库添加语法提示,骗编译器 , 仅仅会用于编译时的检查 

//ts3.7中可以利用 JSDoc 语法从 js 生成 .d.ts 文件
import type { SomeThing } from "./some-module.js";//TypeScript 3.8 为仅类型导入和导出添加了新语法

tsconfig.json//告诉ts它应该ts文件们在哪
    路径包含 //编译器将尝试使用适当的路径查找a.ts, a.tsx然后是a.d.ts如果找不到特定文件，则编译器将查找环境模块声明
        //假如仍然无法解析，那么可以检查下 tsconfig.json 中的 files、include 和 exclude 配置
         方式1: "files": ["./some/file.ts"  ]
         方式2: "include": ["./folder"],   "exclude": ["./folder/**/*.spec.ts","./folder/someSubFolder"]
    //单纯执行tsc命令,编译器会逐级向上搜索父目录查找tsconfig.json文件
    "include": ["src/**/*"], //默认值为["**/*"]
    "exclude": ["node_modules", "**/*.spec.ts"]  //默认值["node_modules", "bower_components", "jspm_packages", "dist"]
    "compilerOptions": {
        strictNullChecks:true; //这样let y: number | null;  y = undefined;报错;
        noImplicitAny:true; //declare function testImplicitAny();报错;declare function testImplicitAny() : void;不报错;
        allowJs: true///扩展名可以是 .js/.jsx
        具体看: https://jkchao.github.io/typescript-book-chinese/project/compilationContext.html#%E7%BC%96%E8%AF%91%E9%80%89%E9%A1%B9
        "baseUrl": ".",//baseUrl: 用来设置下面 path 路径的根路径。
        "paths": {//path: 用来设置相对应的路径映射，数组中的路径相对应 baseUrl 的路径。
               "@/*": ["./src/*"],
              "@srcTypes/*": ["src/types/*"],/别名/
              "@utils/*": ["src/utils/*"]
        } 
     }

declare ,TypeScript 将不会把它编译成任何代码, 只是用来表述一个其他地方已经存在的代码, 可以放在 .ts 或者 .d.ts 里
    三斜线指令: 早期版本现在不推荐了<reference path="node.d.ts"/> 仅在其包含文件的顶部有效,声明文件的模块的声明在哪里
    /在全局变量的声明文件d.ts中，是不允许出现 import, export 关键字的。一旦出现了，那么他就会被视为一个 npm 包或 UMD 库，就不再是全局变量的声明文件了/
   所以, d.ts中，出现在顶层的import, export,就必须用三斜线指令了
        
    declare global 扩展全局变量
    declare module 扩展模块,/是可以被import等导入的/
    declare var/function/class/enum
    declare namespace 声明（含有子属性的）全局对象//随着 ES6 的广泛应用，现已经不建议使用 ts 中的 namespace，而推荐使用 ES6 模块化方案，但在声明文件中，declare namespace 还是比较常用的
    interface 和 type 声明全局类型
    /declare interface和interface之间没有区别/,因为:接口没有代码生成，它们只存在于Typescript中的接口本质上是声明
    偷懒用速记模块 declare module "hot-new-module"; 仅解决报错,没有代码提示作用, 来自速记模块的所有导入都将具有该any类型  
  
 export , 使用 declare 先声明多个变量，最后再用 export 一次性导出   
        export namespace 导出（含有子属性的）对象
        export default ES6 默认导出
        export = commonjs 导出模块
        export as namespace 既可以通过<script>标签引入，又可以通过import导入的库，称为UMD库, 需要局部变量声明为全局变量 

声明合并/扩展
    TypeScript 有两种模块类型声明：
        本地（普通模块）
        环境（全局）///允许编写与现有模块 声明合并 的全局模块声明。        
            d.ts仅当文件没有任何导入时，文件才被视为环境模块声明,/如果您提供一个import行，它现在被视为一个普通的模块文件，而不是全局的 ,所以增加模块定义不起作用。/
                Q:那全局模块声明要怎么导入才不会被视为普通模块?  
                A:从 TS 2.9 开始，我们可以使用import()语法将类型导入    
    
    src/shims-vue.d.ts ,/被@vue_cli-plugin-typescript使用/
        declare module '*.vue' {} //这样import *.vue的时候获得的是这里导出的Vue
        declare module 'vue/types/vue' {//'vue/types/vue'是路径, 会声明合并
          interface Vue {$myProperty: string //让ts知道我再vue的属性上有定义vue.$myProperty这个,会顺利编译通过      }
          interface VueConstructor {$myGlobal: string  }//Vue.$myGlobal
        }    
    
        
/type适合业务代码,interface适合类库, 差不多/
    //规定对象的数据结构
    interface Model {  name: string;  [key: string]: any;} //通用匹配
                   {name: 'hello', length: 100, casdf:1}//这样也是通过的
       
    type Name = string;//使用 type 创建string的别名
    type EventNames = 'click' | 'scroll' | 'mousemove';//联合类型(Union Types) ,能取三种字符串中的一种


泛型 //泛型方法,泛型常用 T、U、V 表示。泛型还可以自己起名称,通常以 T 作为泛型名称的前缀
    function GenericsFunc<T>(a: number): Array<T> {//调用: GenericsFunc<string>(3, 'x');
        let result: T[] = []; //<string> 表示用string替换所有的T,变成:  let result: string[] = []; //这样result肯定是字符串数组了
        return result;
    }

extends 
    type numberOrString<T> = T extends number ? number : string; //传入<number>的话,它就是number,否则它就是string  //T extends number表示它T是否有一个number属性
        let pickAbObject: numberOrString<number> = '1'; //错误, 因为 numberOrString<number>等同于 number
    
infer X 某某变量 // 提取某某变量里的所有值作为类型, 赋值给X            
    type InferredAb<T> = T extends { a: infer U, b: infer U } ? U : T; //U的值是传入的a，U的值是传入的b
        let asdf: InferredAb<{ a:123, b:234 }> = 12;//报错Type '12' is not assignable to type '123 | 234'
        等同于 123|234
        let asdf:            123|234           = 12;
        
    type extractArrayType<T> = T extends (infer U)[] ? U : never; //T是个数组, 推断出数组的类型们赋值给U
        let stringType : extractArrayType< ["test1",1]> = "test3";//报错Type '"test3"' is not assignable to type '"test1" | 1'.   
        它等同:
        let stringType :            "test1" | 1         = "test3";// U是 "test1" | 1
    
    
keyof 频率16
    type PartialProps<T> = {[K in keyof T]?: T[K];}//T传入的是键值对象
        let a:PartialProps<{a: number;b: string;c: boolean;}> = { a: 1, b: "test", c: undefined ,d:1};//d:1会造成错误
        
    let key: keyof IPerson='123'//keyof 顾名思义
    
实用程序类型//vite项目中的使用频率如下
    //定义位于D:/Users/86159/AppData/Local/Programs/Microsoft VS Code/resources/app/extensions/node_modules/typescript/lib/lib.es5.d.ts
    104  Record<Keys, Type> //概括对象键值对
            Record<string, string> 表示{a:'1',b:'2'}  
            let recordAcNumbers : Record< "a" | "c", string> = { a: 1, c: "test"}; //表示a和c都要用到,且都得是string   //a:1会报错
    9    Omit<Type, Keys> 
    5    NonNullable<Type> 
    4    Partial<Type> //用来创建类型的所有属性 T 都是可选的
    2    ReturnType<Type> 
    2    Parameters<Type> 
    2    Exclude<UnionType, ExcludedMembers> 
    1    ThisType<Type> 
    1    Required<Type> 
    1    Readonly<Type> //创建类型的所有属性 T 都是只读的
    0    ThisParameterType<Type> 
    0    Pick<Type, Keys> 
            Pick <{a: number;b: string;c: boolean;},  "a" | "b">; //表示a和b都要用到，但不能用c
            let pickAbObject : Pick<{ a: number;b: string;c: boolean;},  "a" | "b"> = { a: 1, b: "test",c:true}; //c:true会造成错误
    0    OmitThisParameter<Type> 
    0    InstanceType<Type> 
    0    Extract<Type, Union> 
    0    ConstructorParameters<Type> 


b?: number;//等同于 b: number|undefined;
&的作用: function func<T, U>(first: T, second: U): T & U //assdf同时拥有类型T和类型U的成员
 
as//是ts的关键字,用来限制类型
     
0x00_FF_00===65280//true

never/unknown
    never //关键字来指示该函数将永远不会返回值, 更实际的用法是捕获bug:
        //在switch 语句之后，我们定义一个名为 returnValue ，类型 为的值 never ，并将传入的 value参数分配给它:
            let returnValue: never = value;//这样传入switch的case如果不存在的话就会在这里报错'*** is not assignable to type 'never''
                
    unknown //等同 any , 更安全 let unknownType: unknown = 1;
        let numberType: number;
        numberType = unknownType;//会报错,需要<number>unknownType把unknown转成number才行,这是与any的区别, 如果unknownType是any而不是unknown,这句就不会报错
    

元组:
    let tupleType: [string, boolean];//元组,赋值时都要赋到,否则会报错
        tupleType = ["test", false];//通过
        tupleType = ["test"];//报错
    let optionalTuple: [string, boolean?];//第二个参数可选的元组
    type RestTupleType = [number, ...string[]];//...string[] 表示很多个string
        let restTuple: RestTupleType = [1, "string1", "string2", "string3"];
        let [arg1, ...arg2] = restTuple;//arg1是1,arg2是数组["string1", "string2", "string3"]
        
overrides函数:
    function add(a: string, b: string): string;
    function add(a: number, b: number): number;
    function add(a: any, b: any): any {
        return a + b;
    }

类:
    class classWithAutomaticProperties {
        protected id: number | undefined;//不会被子类继承的
        constructor(public id: number, private name: string) {//自动属性:自动转为this.id=id; this.name=name;
            super(_id);//super是父类的constructor
        }
    }//let myAutoClass = new classWithAutomaticProperties(1, "className"); myAutoClass.id就可以访问到1了
    
    constructor(public firstName)//等同于 this.firstName = firstName;的简写

抽象类:
    //必须让子类各自去实现
    abstract class AbstractEmployee {
        public id: number | undefined;
        public name: string | undefined;
        abstract getDetails(): string;//抽象类中的抽象方法
        public printDetails() {
            console.log(this.getDetails());
        }
    }

Promise写法:
    function delayedPromise(): Promise<void|string> {
        return new Promise<void>(
            (resolve: () => void, reject: () => void )              => {resolve();} 
        ); 
        //或者带参数:
        return new Promise<string>(
            (resolve: (str: string) => void,reject: (str: string) => void) => {resolve("resolved_within_promise");}
        );
    }1038
  

//我们将基础类型叫做T，复合类型叫做Comp<T>
协变 (Covariant)：协变表示Comp<T>类型兼容和T的一致。是类型兼容性
逆变 (Contravariant)：逆变表示Comp<T>类型兼容和T相反。只会在一个函数赋值给另一个函数时, 在函数类型中的函数参数上出现
    例如:
        type NoOrStr = number | string
        type No = number
        let noOrStr = (a: NoOrStr) => {}
        let no = (a: No) => {}
        noOrStr = no //会报错! Type '(a: No) => void' is not assignable to type '(a: NoOrStr) => void'.
//双向协变 (Bivariant)：双向协变表示Comp<T>类型与T类型双向兼容。
//不变 (Invariant)：不变表示Comp<T>类型与T类型双向都不兼容。