更新到内置对象，去掉个人化的例子，规范代码风格

Author: xcatliu

basics/type-assertion.md

@@ -1,46 +1,48 @@
 # 类型断言
 
-类型断言（Type Assertion）可以用来绕过编译器的类型推断，手动指定一个值的类型（即程序员对编译器**断言**）。
+类型断言（Type Assertion）可以用来手动指定一个值的类型。
 
 ## 语法
 
 ```ts
 <类型>值
+```
 
-// 或
+或
 
+```ts
 值 as 类型
-
-// 在TSX语法 (React的JSX语法的TS版）中必须用后一种
 ```
 
+在 tsx 语法（React 的 jsx 语法的 ts 版）中必须用后一种。
+
 ## 例子：将一个联合类型的变量指定为一个更加具体的类型
 
 [之前提到过](union-types.md#访问联合类型的属性或方法)，当 TypeScript 不确定一个联合类型的变量到底是哪个类型的时候，我们**只能访问此联合类型的所有类型里共有的属性或方法**：
 
 ```ts
 function getLength(something: string | number): number {
-  return something.length;
+    return something.length;
 }
 
-// index.ts(2,20): error TS2339: Property 'length' does not exist on type 'string | number'.
+// index.ts(2,22): error TS2339: Property 'length' does not exist on type 'string | number'.
 //   Property 'length' does not exist on type 'number'.
 ```
 
 而有时候，我们确实需要在还不确定类型的时候就访问其中一个类型的属性或方法，比如：
 
 ```ts
 function getLength(something: string | number): number {
-  if (something.length) {
-    return something.length;
-  } else {
-    return something.toString().length;
-  }
+    if (something.length) {
+        return something.length;
+    } else {
+        return something.toString().length;
+    }
 }
 
-// index.ts(2,17): error TS2339: Property 'length' does not exist on type 'string | number'.
+// index.ts(2,19): error TS2339: Property 'length' does not exist on type 'string | number'.
 //   Property 'length' does not exist on type 'number'.
-// index.ts(3,22): error TS2339: Property 'length' does not exist on type 'string | number'.
+// index.ts(3,26): error TS2339: Property 'length' does not exist on type 'string | number'.
 //   Property 'length' does not exist on type 'number'.
 ```
 
@@ -50,11 +52,11 @@ function getLength(something: string | number): number {
 
 ```ts
 function getLength(something: string | number): number {
-  if ((<string>something).length) {
-    return (<string>something).length;
-  } else {
-    return something.toString().length;
-  }
+    if ((<string>something).length) {
+        return (<string>something).length;
+    } else {
+        return something.toString().length;
+    }
 }
 ```
 
@@ -64,7 +66,7 @@ function getLength(something: string | number): number {
 
 ```ts
 function toBoolean(something: string | number): boolean {
-  return <boolean>something;
+    return <boolean>something;
 }
 
 // index.ts(2,10): error TS2352: Type 'string | number' cannot be converted to type 'boolean'.

basics/type-of-array.md

@@ -20,7 +20,9 @@ let fibonacci: number[] = [1, '1', 2, 3, 5];
 //     Type 'string' is not assignable to type 'number'.
 ```
 
-此时 `[1, '1', 2, 3, 5]` 的类型被推断为 `(number | string)[]`，这是联合类型和数组的结合。
+上例中，`[1, '1', 2, 3, 5]` 的类型被推断为 `(number | string)[]`，这是联合类型和数组的结合。
+
+数组的一些方法的参数也会根据数组在定义时约定的类型进行限制：
 
 ```ts
 let fibonacci: number[] = [1, 1, 2, 3, 5];
@@ -29,9 +31,11 @@ fibonacci.push('8');
 // index.ts(2,16): error TS2345: Argument of type 'string' is not assignable to parameter of type 'number'.
 ```
 
+上例中，`push` 方法只允许传入 `number` 类型的参数，但是却传了一个 `string` 类型的参数，所以报错了。
+
 ## 数组泛型
 
-也可以使用数组泛型（Generic） `Array<elemType>` 来表示数组：
+也可以使用数组泛型（Array Generic） `Array<elemType>` 来表示数组：
 
 ```ts
 let fibonacci: Array<number> = [1, 1, 2, 3, 5];
@@ -45,7 +49,7 @@ let fibonacci: Array<number> = [1, 1, 2, 3, 5];
 
 ```ts
 interface NumberArray {
-  [index: number]: number;
+    [index: number]: number;
 }
 let fibonacci: NumberArray = [1, 1, 2, 3, 5];
 ```
@@ -66,7 +70,7 @@ let list: any[] = ['Xcat Liu', 25, { website: 'http://xcatliu.com' }];
 
 ```ts
 function sum() {
-  let args: number[] = arguments;
+    let args: number[] = arguments;
 }
 
 // index.ts(2,7): error TS2322: Type 'IArguments' is not assignable to type 'number[]'.
@@ -77,7 +81,7 @@ function sum() {
 
 ```ts
 function sum() {
-  let args: IArguments = arguments;
+    let args: IArguments = arguments;
 }
 ```
 

basics/type-of-function.md

@@ -9,28 +9,28 @@
 ```js
 // 函数声明（Function Declaration）
 function sum(x, y) {
-  return x + y;
+    return x + y;
 }
 
 // 函数表达式（Function Expression）
 let mySum = function (x, y) {
-  return x + y;
+    return x + y;
 };
 ```
 
 一个函数有输入和输出，要在 TypeScript 中对其进行约束，需要把输入和输出都考虑到，其中函数声明的类型定义较简单：
 
 ```ts
 function sum(x: number, y: number): number {
-  return x + y;
+    return x + y;
 }
 ```
 
 注意，**输入多余的（或者少于要求的）参数，是不被允许的**：
 
 ```ts
 function sum(x: number, y: number): number {
-  return x + y;
+    return x + y;
 }
 sum(1, 2, 3);
 
@@ -39,7 +39,7 @@ sum(1, 2, 3);
 
 ```ts
 function sum(x: number, y: number): number {
-  return x + y;
+    return x + y;
 }
 sum(1);
 
@@ -52,34 +52,36 @@ sum(1);
 
 ```ts
 let mySum = function (x: number, y: number): number {
-  return x + y;
+    return x + y;
 };
 ```
 
 这是可以通过编译的，不过事实上，上面的代码只对等号右侧的匿名函数进行了类型定义，而等号左边的 `mySum`，是通过赋值操作进行类型推论而推断出来的。如果需要我们手动给 `mySum` 添加类型，则应该是这样：
 
 ```ts
 let mySum: (x: number, y: number) => number = function (x: number, y: number): number {
-  return x + y;
+    return x + y;
 };
 ```
 
+注意不要混淆了 TypeScript 中的 `=>` 和 ES6 中的 `=>`。
+
 在 TypeScript 的类型定义中，`=>` 用来表示函数的定义，左边是输入类型，需要用括号括起来，右边是输出类型。
 
-其中，`=>` 在 ES6 中叫箭头函数，应用十分广泛，可以参考 [ES6 中的箭头函数][]。
+在 ES6 中，`=>` 叫做箭头函数，应用十分广泛，可以参考 [ES6 中的箭头函数][]。
 
-## 接口中函数的定义
+## 用接口定义函数的形状
 
 我们也可以使用接口的方式来定义一个函数需要符合的形状：
 
 ```ts
 interface SearchFunc {
-  (source: string, subString: string): boolean;
+    (source: string, subString: string): boolean;
 }
 
 let mySearch: SearchFunc;
 mySearch = function(source: string, subString: string) {
-  return source.search(subString) !== -1;
+    return source.search(subString) !== -1;
 }
 ```
 
@@ -91,52 +93,52 @@ mySearch = function(source: string, subString: string) {
 
 ```ts
 function buildName(firstName: string, lastName?: string) {
-  if (lastName) {
-    return firstName + ' ' + lastName;
-  } else {
-    return firstName;
-  }
+    if (lastName) {
+        return firstName + ' ' + lastName;
+    } else {
+        return firstName;
+    }
 }
-let xcatliu = buildName('Xcat', 'Liu');
-let xcat = buildName('Xcat');
+let tomcat = buildName('Tom', 'Cat');
+let tom = buildName('Tom');
 ```
 
 需要注意的是，可选参数必须接在必需参数后面。换句话说，**可选参数后面不允许再出现必须参数了**：
 
 ```ts
 function buildName(firstName?: string, lastName: string) {
-  if (firstName) {
-    return firstName + ' ' + lastName;
-  } else {
-    return lastName;
-  }
+    if (firstName) {
+        return firstName + ' ' + lastName;
+    } else {
+        return lastName;
+    }
 }
-let xcatliu = buildName('Xcat', 'Liu');
-let xcat = buildName(undefined, 'Xcat');
+let tomcat = buildName('Tom', 'Cat');
+let tom = buildName(undefined, 'Tom');
 
 // index.ts(1,40): error TS1016: A required parameter cannot follow an optional parameter.
 ```
 
 ## 参数默认值
 
-在 ES6 中，我们允许给函数的参数添加默认值，TypeScript 会将**添加了默认值的参数识别为可选参数**：
+在 ES6 中，我们允许给函数的参数添加默认值，**TypeScript 会将添加了默认值的参数识别为可选参数**：
 
 ```ts
-function buildName(firstName: string, lastName: string = 'Liu') {
-  return firstName + ' ' + lastName;
+function buildName(firstName: string, lastName: string = 'Cat') {
+    return firstName + ' ' + lastName;
 }
-let xcatliu = buildName('Xcat', 'Liu');
-let xcat = buildName('Xcat');
+let tomcat = buildName('Tom', 'Cat');
+let tom = buildName('Tom');
 ```
 
 此时就不受「可选参数必须接在必需参数后面」的限制了：
 
 ```ts
-function buildName(firstName: string = 'Xcat', lastName: string) {
-  return firstName + ' ' + lastName;
+function buildName(firstName: string = 'Tom', lastName: string) {
+    return firstName + ' ' + lastName;
 }
-let xcatliu = buildName('Xcat', 'Liu');
-let xcat = buildName(undefined, 'Xcat');
+let tomcat = buildName('Tom', 'Cat');
+let cat = buildName(undefined, 'Cat');
 ```
 
 > 关于默认参数，可以参考 [ES6 中函数参数的默认值][]。
@@ -147,9 +149,9 @@ ES6 中，可以使用 `...rest` 的方式获取函数中的剩余参数（rest
 
 ```js
 function push(array, ...items) {
-  items.forEach(function(item) {
-    array.push(item);
-  });
+    items.forEach(function(item) {
+        array.push(item);
+    });
 }
 
 let a = [];
@@ -160,9 +162,9 @@ push(a, 1, 2, 3);
 
 ```ts
 function push(array: any[], ...items: any[]) {
-  items.forEach(function(item) {
-    array.push(item);
-  });
+    items.forEach(function(item) {
+        array.push(item);
+    });
 }
 
 let a = [];
@@ -181,11 +183,11 @@ push(a, 1, 2, 3);
 
 ```ts
 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('');
-  }
+    if (typeof x === 'number') {
+        return Number(x.toString().split('').reverse().join(''));
+    } else if (typeof x === 'string') {
+        return x.split('').reverse().join('');
+    }
 }
 ```
 
@@ -197,11 +199,11 @@ function reverse(x: number | string): number | string {
 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('');
-  }
+    if (typeof x === 'number') {
+        return Number(x.toString().split('').reverse().join(''));
+    } else if (typeof x === 'string') {
+        return x.split('').reverse().join('');
+    }
 }
 ```