TypeScript编写

通常，我们写js的时候有两种引入js的方式：

1. 在html文件中通过<script>标签全局引入全局变量。
2. 通过require模块加载器引入其它js文件。

全局类型

全局变量的声明：

declare var aaa: number; //一般变量使用var
declare var bbb: number|string;
declare const ccc:200 //常量使用const

全局函数的声明：

/** id是用户的id，可以是number或者string */
declare function getName(id: number|string): string; //有返回值
/** id是用户的id，可以是number或者string */
declare function setName(id: number|string): void; //无返回值，void

在js文件中会出现代码提示(&注释)：

全局函数

函数的多种写法表示：

declare function get(id: number): string;
declare function get(name: string, age: number): string;

? 表示参数可有可无：

declare function render(callback?:()=>void): string;

类(class)的声明：

declare class Person {
     static maxAge: number; //静态变量
     static getMaxAge(): number; //静态方法
     constructor(name: string, age: number); //构造函数
     getName(id: number): string; //实例方法
}

构造函数 实例方法 静态变量&静态方法
对象的声明：

declare namespace 000{

}

在对象中添加变量的声明、函数的声明、类的声明：

declare namespace 000 {
     var aaa: number; //变量声明
     function getName(id: number): string; // 函数声明
     //类的声明
     class Person {                        
          static maxAge: number; //静态变量
          static getMaxAge(): number; //静态方法
          constructor(name: string, age: number); //构造函数
          getName(id: number): string; //实例方法
     }
}

注意：declare 只需要在最外面声明一次
效果：

对象里面嵌套对象：

declare namespace 000 {
      //....
      namespace 02 {
            let b: number 
      }
}

效果：

混合类型：
当一个值既是函数又是class又是对象，我们常用的jquery有各种写法：

new $()
$.ajax()
$()

既是函数又是对象：

declare  function $2(s: string): void;
declare namespace $2 {
      let aaa: number;
}

效果：
作为函数用：

作为对象用：

既是函数又是类：

//实例方法
interface People {
      name: string
      age:  number
      getName(): string
      getAge(): number
}

interface People_Static {
      new (name: string, age: number): People
      /** 静态方法 */
      staticA(): number 
      (w: number): number
}
declare var People:People_Static

效果：
作为函数使用：

类的静态方法：

类的构造函数：

类的实例方法：

---

模块化

除了上面的全局的方式，我们有时候还是通过require的方式引入模块化的代码。

比如这样的效果： 模块化引入

对应的写法是这样的：

  declare module "abcde" {
      export let a: number
      export function b(): number
      export namespace c {
             let cd: string 
      }
  } 

有时候我们导出去的是一个函数本身，比如这样的：

对应的写法如下：

declare module "app" {
    function aaa(some: number): number
    export=aaa
}

导出一个变量或常量如下写法：

declare module "ccc" {
   const c: 400
   export=c
}

---

UMD

有一种代码，既可以通过全局变量访问到，也可以通过require的方式访问到。
比如 jquery：

全局变量方式访问
模块化加载方式访问
其实就是按照全局的方式写，写完后加上declare module "xxx"的描述：

declare namespace UUU {
    let a: number
}
declare module "UUU" {
      export=UUU
}

效果如下：

全局变量
模块加载使用

---

其它

如果扩展了内置对象，比如给Date增加了一个format的实例方法：

对应的写法如下：

interface Date {
    format(f: string): string
}