1 基础数据类型

let isDone: boolean = false;
let createdByBoolean: boolean = Boolean(1);
let createdByNewBoolean: Boolean = new Boolean(1);
let decLiteral: number = 6;
let myName: string = 'Tom';
function alertName(): void {
    alert('My name is Tom');
}
let unusable: void = undefined;
let u: undefined = undefined;
let n: null = null;

2 任意值

在任意值上访问任何属性都是允许的，也允许调用任何方法

let anyThing: any = 'seven';
console.log(anyThing.myName);
anyThing.setName('Jerry');
// 在声明的时候，未指定其类型，那么它会被识别为任意值类型
let something;
something = 'seven';
something = 7;

3 联合类型

let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
myFavoriteNumber = 7;
// 只能访问此联合类型的所有类型里共有的属性或方法。
myFavoriteNumber.toString()

// 联合类型的变量在被赋值的时候，会根据类型推论的规则推断出一个类型
let myFavoriteNumber: string | number;
myFavoriteNumber = 'seven';
console.log(myFavoriteNumber.length); // 5，推断为字符串
myFavoriteNumber = 7;
console.log(myFavoriteNumber.length); // 编译时报错，推断为数字，所以报错了

4 对象

interface Person {
    readonly id: number; // 只读属性
    name: string;
    age?: number; // 可选属性
    [propName: string]: any; // 任意属性
}
let hh: Person = {
    id: 100,
    name: 'life',
    // age: 300,
    // sex: 'male',
}
hh.id = 101; // 报错，只读属性，不能赋值

5 数组

// 使用「类型 + 方括号」来表示数组
let fibonacci: number[] = [1, 1, 2, 3, 5];
// 使用数组泛型 Array<elemType> 来表示数组
let fibonacci: Array<number> = [1, 1, 2, 3, 5];
// 使用接口表示数组
interface NumberArray {
    [index: number]: number;
}
let fibonacci: NumberArray = [1, 1, 2, 3, 5];
// 类数组（Array-like Object）不是数组类型，比如 arguments
function sum() {
    let args1: {
        [index: number]: number;
        length: number;
        callee: Function;
    } = arguments;
    let args2: IArguments = arguments;
}
// 用 any 表示数组中允许出现任意类型
let list: any[] = ['xcatliu', 25, { website: 'http://xcatliu.com' }];

6 函数

6.1 基础使用

function sum(x: number, y: number): number {
    return x + y;
}
// 等号左边的 mySum，是通过赋值操作进行类型推论而推断出来的
let mySum = function (x: number, y: number): number {
    return x + y;
};
// 手动给 mySum 添加类型
let mySum: (x: number, y: number) => number
    = function (x: number, y: number): number {
        return x + y;
    };
// 用接口定义函数的形状
interface ISearchFunc {
    (source: string, subString: string): boolean;
    cllTimes: number;
}
function SearchFunc(source: string, subString: string): boolean {
    SearchFunc.cllTimes++;
    return source.search(subString) !== -1;
}
SearchFunc.cllTimes = 0
let mySearch: ISearchFunc = SearchFunc;

6.2 可选参数、默认值、剩余参数

// 可选参数
function sum(x: number, y?: number): number {
  if(y) { return x + y; } 
  else { return x; }
}
// 默认值
function sum(x: number, y: number=10): number {}
// 剩余参数
function push(array: any[], ...items: any[]) {}

6.3 重载

重载允许一个函数接受不同数量或类型的参数时，作出不同的处理。

function reverse(x: number): number;
function reverse(x: string): string;
function reverse(x: number | string): number | string {
    if (typeof x === 'number') {
        return Number(x.toString().split('').reverse().join(''));
    } else if (typeof x === 'string') {
        return x.split('').reverse().join('');
    }
}

7 类型断言

类型断言（Type Assertion）可以用来手动指定一个值的类型。

// 方式1  <类型>值
let a = (<any>window).a
// 方式2  值 as 类型
// 在 tsx 语法（React 的 jsx 语法的 ts 版）中必须用方式2。
let b = (window as any).a

function getLength(something: string | number): number {
    if ((<string>something).length) {
        return (<string>something).length;
    } else {
        return something.toString().length;
    }
}

8 声明文件

当使用第三方库时，我们需要引用它的声明文件，才能获得对应的代码补全、接口提示等功能。
https://ts.xcatliu.com/basics/declaration-files

// jQuery.d.ts
declare function jQuery(selector: string): any;
declare function jQuery(domReadyCallback: () => any): any;
declare namespace jQuery {
    function ajax(url: string, settings?: any): void;
    const version: number;
    class Event {
        blur(eventType: EventType): void
    }
    enum EventType {
        CustomClick
    }
}
// index.ts
jQuery('#foo');
jQuery(function () {
    alert('Dom Ready!');
});
jQuery.ajax('/api/get_something');

9 内置对象

JavaScript 中有很多内置对象，它们可以直接在 TypeScript 中当做定义好了的类型。
内置对象是指根据标准在全局作用域（Global）上存在的对象。这里的标准是指 ECMAScript 和其他环境（比如 DOM）的标准。

9.1 ECMAScript的内置对象

更多的内置对象，可以查看 MDN 的文档。
他们的定义文件，则在 TypeScript 核心库的定义文件中。

let b: Boolean = new Boolean(1);
let e: Error = new Error('Error occurred');
let d: Date = new Date();
let r: RegExp = /[a-z]/;

9.2 DOM、BOM的内置对象

它们的定义文件同样在 TypeScript 核心库的定义文件中。

let body: HTMLElement = document.body;
let allDiv: NodeList = document.querySelectorAll('div');
document.addEventListener('click', function(e: MouseEvent) {
  // Do something
});

9.3 TypeScript 核心库的定义文件

TypeScript 核心库的定义文件中定义了所有浏览器环境需要用到的类型，并且是预置在 TypeScript 中的。
当你在使用一些常用的方法的时候，TypeScript 实际上已经帮你做了很多类型判断的工作了。

9.4 如何用来写Node.js

TypeScript 核心库的定义中不包含 Node.js 部分。
Node.js 不是内置对象的一部分，如果想用 TypeScript 写 Node.js，则需要引入第三方声明文件：

$ npm install @types/node --save-dev