Let

doc/handbook/Basic Types.md

@@ -8,7 +8,7 @@ TypeScript支持与JavaScript几乎相同的数据类型，此外还提供了实
 最基本的数据类型就是简单的true/false值，在JavaScript和TypeScript里叫做`boolean`（其它语言中也一样）。
 
 ```ts
-var isDone: boolean = false;
+let isDone: boolean = false;
 ```
 
 # 数字
@@ -18,10 +18,10 @@ var isDone: boolean = false;
 除了支持十进制和十六进制字面量，Typescript还支持ECMAScript 2015中引入的二进制和八进制字面量。
 
 ```ts
-var decLiteral: number = 6;
-var hexLiteral: number = 0x9837abdef;
-var binaryLiteral: number = 0b0010;
-var octalLiteral: number = 0o74563;
+let decLiteral: number = 6;
+let hexLiteral: number = 0xf00d;
+let binaryLiteral: number = 0b1010;
+let octalLiteral: number = 0o744;
 ```
 
 # 字符串
@@ -31,7 +31,7 @@ JavaScript程序的另一项基本操作是处理网页或服务器端的文本
 和JavaScript一样，可以使用双引号（`"`）或单引号（`'`）表示字符串。
 
 ```ts
-var name: string = "bob";
+let name: string = "bob";
 name = "smith";
 ```
 
@@ -39,9 +39,9 @@ name = "smith";
 这种字符串是被反引号包围（`` ` ``），并且以`${ expr }`这种形式嵌入表达式
 
 ```ts
-var name: string = `Gene`;
-var age: number = 37;
-var sentence: string = `Hello, my name is ${ name }.
+let name: string = `Gene`;
+let age: number = 37;
+let sentence: string = `Hello, my name is ${ name }.
 
 I'll be ${ age + 1 } years old next month.`;
 ```
@@ -49,7 +49,7 @@ I'll be ${ age + 1 } years old next month.`;
 这与下面定义`sentence`的方式效果相同：
 
 ```ts
-var sentence: string = "Hello, my name is " + name + ".\n\n" +
+let sentence: string = "Hello, my name is " + name + ".\n\n" +
     "I'll be " + (age + 1) + " years old next month.";
 ```
 
@@ -60,13 +60,13 @@ TypeScript像JavaScript一样可以操作数组元素。
 第一种，可以在元素类型后面接上`[]`，表示由此类型元素组成的一个数组：
 
 ```ts
-var list: number[] = [1, 2, 3];
+let list: number[] = [1, 2, 3];
 ```
 
 第二种方式是使用数组泛型，`Array<元素类型>`：
 
 ```ts
-var list: Array<number> = [1, 2, 3];
+let list: Array<number> = [1, 2, 3];
 ```
 
 # 元组 Tuple
@@ -76,7 +76,7 @@ var list: Array<number> = [1, 2, 3];
 
 ```ts
 // Declare a tuple type
-var x: [string, number];
+let x: [string, number];
 // Initialize it
 x = ['hello', 10]; // OK
 // Initialize it incorrectly
@@ -94,7 +94,9 @@ console.log(x[1].substr(1)); // Error, 'number' does not have 'substr'
 
 ```ts
 x[3] = 'world'; // OK, 字符串可以赋值给(string | number)类型
+
 console.log(x[5].toString()); // OK, 'string' 和 'number' 都有 toString
+
 x[6] = true; // Error, 布尔不是(string | number)类型
 ```
 
@@ -107,7 +109,7 @@ x[6] = true; // Error, 布尔不是(string | number)类型
 
 ```ts
 enum Color {Red, Green, Blue};
-var c: Color = Color.Green;
+let c: Color = Color.Green;
 ```
 
 默认情况下，从`0`开始为元素编号。
@@ -116,14 +118,14 @@ var c: Color = Color.Green;
 
 ```ts
 enum Color {Red = 1, Green, Blue};
-var c: Color = Color.Green;
+let c: Color = Color.Green;
 ```
 
 或者，全部都采用手动赋值：
 
 ```ts
 enum Color {Red = 1, Green = 2, Blue = 4};
-var c: Color = Color.Green;
+let c: Color = Color.Green;
 ```
 
 枚举类型提供的一个便利是你可以由枚举的值得到它的名字。
@@ -131,7 +133,7 @@ var c: Color = Color.Green;
 
 ```ts
 enum Color {Red = 1, Green, Blue};
-var colorName: string = Color[2];
+let colorName: string = Color[2];
 
 alert(colorName);
 ```
@@ -144,7 +146,7 @@ alert(colorName);
 那么我们可以使用`any`类型来标记这些变量：
 
 ```ts
-var notSure: any = 4;
+let notSure: any = 4;
 notSure = "maybe a string instead";
 notSure = false; // okay, definitely a boolean
 ```
@@ -154,18 +156,19 @@ notSure = false; // okay, definitely a boolean
 但是`Object`类型的变量只是允许你给它赋任意值 -- 但是你不像在它上面调用任意方法，就算它真的包含了这些方法：
 
 ```ts
-var notSure: any = 4;
+let notSure: any = 4;
 notSure.ifItExists(); // okay, ifItExists might exist at runtime
 notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)
-var prettySure: Object = 4;
-prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'. 
+
+let prettySure: Object = 4;
+prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'.
 ```
 
 当你只知道数据的类型的一部分时，`any`类型也是有用的。
 比如，你有一个数组，它包含了不同的数据类型：
 
 ```ts
-var list: any[] = [1, true, "free"];
+let list: any[] = [1, true, "free"];
 
 list[1] = 100;
 ```
@@ -184,6 +187,11 @@ function warnUser(): void {
 声明一个`void`类型的变量没有什么大用，因为你只能为它赋予`undefined`和`null`：
 
 ```ts
-var unusable: void = undefined;
+let unusable: void = undefined;
 ```
 
+# 关于`let`
+
+你可能已经注意到了，我们使用`let`关键字来代替大家所熟悉的JavaScript关键字`var`。
+`let`关键字是JavaScript的一个新概念，TypeScript实现了它。
+我们会在以后详细介绍它，很多常见的问题都可以通过使用`let`来解决，所以尽可能地使用`let`来代替`var`吧。

doc/handbook/Classes.md

@@ -19,7 +19,7 @@ class Greeter {
     }
 }
 
-var greeter = new Greeter("world");
+let greeter = new Greeter("world");
 ```
 
 如果你使用过C#或Java，你会对这种语法非常熟悉。
@@ -63,8 +63,8 @@ class Horse extends Animal {
     }
 }
 
-var sam = new Snake("Sammy the Python");
-var tom: Animal = new Horse("Tommy the Palomino");
+let sam = new Snake("Sammy the Python");
+let tom: Animal = new Horse("Tommy the Palomino");
 
 sam.move();
 tom.move(34);
@@ -144,9 +144,9 @@ class Employee {
     constructor(theName: string) { this.name = theName; } 
 }
 
-var animal = new Animal("Goat");
-var rhino = new Rhino();
-var employee = new Employee("Bob");
+let animal = new Animal("Goat");
+let rhino = new Rhino();
+let employee = new Employee("Bob");
 
 animal = rhino;
 animal = employee; // Error: Animal and Employee are not compatible
@@ -182,7 +182,7 @@ class Employee extends Person {
     }
 }
 
-var howard = new Employee("Howard", "Sales");
+let howard = new Employee("Howard", "Sales");
 console.log(howard.getElevatorPitch());
 console.log(howard.name); // error
 ```
@@ -223,7 +223,7 @@ class Employee {
     fullName: string;
 }
 
-var employee = new Employee();
+let employee = new Employee();
 employee.fullName = "Bob Smith";
 if (employee.fullName) {
     console.log(employee.fullName);
@@ -237,7 +237,7 @@ if (employee.fullName) {
 我们也加了一个`get`方法，让上面的例子仍然可以工作。
 
 ```ts
-var passcode = "secret passcode";
+let passcode = "secret passcode";
 
 class Employee {
     private _fullName: string;
@@ -256,7 +256,7 @@ class Employee {
     }
 }
 
-var employee = new Employee();
+let employee = new Employee();
 employee.fullName = "Bob Smith";
 if (employee.fullName) {
     alert(employee.fullName);
@@ -279,15 +279,15 @@ if (employee.fullName) {
 class Grid {
     static origin = {x: 0, y: 0};
     calculateDistanceFromOrigin(point: {x: number; y: number;}) {
-        var xDist = (point.x - Grid.origin.x);
-        var yDist = (point.y - Grid.origin.y);
+        let xDist = (point.x - Grid.origin.x);
+        let yDist = (point.y - Grid.origin.y);
         return Math.sqrt(xDist * xDist + yDist * yDist) / this.scale;
     }
     constructor (public scale: number) { }
 }
 
-var grid1 = new Grid(1.0);  // 1x scale
-var grid2 = new Grid(5.0);  // 5x scale
+let grid1 = new Grid(1.0);  // 1x scale
+let grid2 = new Grid(5.0);  // 5x scale
 
 console.log(grid1.calculateDistanceFromOrigin({x: 10, y: 10}));
 console.log(grid2.calculateDistanceFromOrigin({x: 10, y: 10}));
@@ -368,12 +368,12 @@ class Greeter {
     }
 }
 
-var greeter: Greeter;
+let greeter: Greeter;
 greeter = new Greeter("world");
 console.log(greeter.greet());
 ```
 
-在这里，我们写了`var greeter: Greeter`，意思是`Greeter`类实例的类型是`Greeter`。
+在这里，我们写了`let greeter: Greeter`，意思是`Greeter`类实例的类型是`Greeter`。
 这对于用过其它面向对象语言的程序员来讲已经是老习惯了。
 
 我们也创建了一个叫做*构造函数*的值。
@@ -381,7 +381,7 @@ console.log(greeter.greet());
 下面我们来看看，上面的代码被编译成JavaScript后是什么样子的：
 
 ```ts
-var Greeter = (function () {
+let Greeter = (function () {
     function Greeter(message) {
         this.greeting = message;
     }
@@ -391,12 +391,12 @@ var Greeter = (function () {
     return Greeter;
 })();
 
-var greeter;
+let greeter;
 greeter = new Greeter("world");
 console.log(greeter.greet());
 ```
 
-上面的代码里，`var Greeter`将被赋值为构造函数。
+上面的代码里，`let Greeter`将被赋值为构造函数。
 当我们使用`new`并执行这个函数后，便会得到一个类的实例。
 这个构造函数也包含了类的所有静态属性。
 换个角度说，我们可以认为类具有实例部分与静态部分这两个部分。
@@ -417,13 +417,13 @@ class Greeter {
     }
 }
 
-var greeter1: Greeter;
+let greeter1: Greeter;
 greeter1 = new Greeter();
 console.log(greeter1.greet());
 
-var greeterMaker: typeof Greeter = Greeter;
+let greeterMaker: typeof Greeter = Greeter;
 greeterMaker.standardGreeting = "Hey there!";
-var greeter2:Greeter = new greeterMaker();
+let greeter2:Greeter = new greeterMaker();
 console.log(greeter2.greet());
 ```
 
@@ -454,5 +454,5 @@ interface Point3d extends Point {
     z: number;
 }
 
-var point3d: Point3d = {x: 1, y: 2, z: 3};
+let point3d: Point3d = {x: 1, y: 2, z: 3};
 ```

doc/handbook/Declaration Merging.md

@@ -45,7 +45,7 @@ interface Box {
     scale: number;
 }
 
-var box: Box = {height: 5, width: 6, scale: 10};
+let box: Box = {height: 5, width: 6, scale: 10};
 ```
 
 接口中非函数的成员必须是唯一的。如果多个接口中具有相同名字的非函数成员就会报错。
@@ -124,7 +124,7 @@ namespace Animals {
 
 ```ts
 namespace Animal {
-    var haveMuscles = true;
+    let haveMuscles = true;
 
     export function animalsHaveMuscles() {
         return haveMuscles;
@@ -172,8 +172,8 @@ function buildLabel(name: string): string {
 }
 
 namespace buildLabel {
-    export var suffix = "";
-    export var prefix = "Hello, ";
+    export let suffix = "";
+    export let prefix = "Hello, ";
 }
 
 alert(buildLabel("Sam Smith"));

doc/handbook/Functions.md

@@ -19,7 +19,7 @@ function add(x, y) {
 }
 
 // Anonymous function
-var myAdd = function(x, y) { return x + y; };
+let myAdd = function(x, y) { return x + y; };
 ```
 
 在JavaScript里，函数可以可以使用函数体外部的变量。
@@ -27,7 +27,7 @@ var myAdd = function(x, y) { return x + y; };
 至于为什么可以这样做以及其中的利弊超出了本文的范围，但是深刻理解这个机制对学习JavaScript和TypeScript会很有帮助。
 
 ```ts
-var z = 100;
+let z = 100;
 
 function addToZ(x, y) {
     return x + y + z;
@@ -45,7 +45,7 @@ function add(x: number, y: number): number {
     return x + y;
 }
 
-var myAdd = function(x: number, y: number): number { return x+y; };
+let myAdd = function(x: number, y: number): number { return x+y; };
 ```
 
 我们可以给每个参数添加类型之后再为函数本身添加返回值类型。
@@ -56,7 +56,7 @@ TypeScript能够根据返回语句自动推断出返回值类型，因此我们
 现在我们已经为函数指定了类型，下面让我们写出函数的完整类型。
 
 ```ts
-var myAdd: (x:number, y:number)=>number =
+let myAdd: (x:number, y:number)=>number =
     function(x: number, y: number): number { return x+y; };
 ```
 
@@ -67,7 +67,7 @@ var myAdd: (x:number, y:number)=>number =
 我们也可以这么写：
 
 ```ts
-var myAdd: (baseValue:number, increment:number) => number =
+let myAdd: (baseValue:number, increment:number) => number =
     function(x: number, y: number): number { return x + y; };
 ```
 
@@ -87,10 +87,10 @@ var myAdd: (baseValue:number, increment:number) => number =
 
 ```ts
 // myAdd has the full function type
-var myAdd = function(x: number, y: number): number { return x + y; };
+let myAdd = function(x: number, y: number): number { return x + y; };
 
 // The parameters `x` and `y` have the type number
-var myAdd: (baseValue:number, increment:number) => number =
+let myAdd: (baseValue:number, increment:number) => number =
     function(x, y) { return x + y; };
 ```
 
@@ -109,9 +109,9 @@ function buildName(firstName: string, lastName: string) {
     return firstName + " " + lastName;
 }
 
-var result1 = buildName("Bob");                  // error, too few parameters
-var result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
-var result3 = buildName("Bob", "Adams");         // ah, just right
+let result1 = buildName("Bob");                  // error, too few parameters
+let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result3 = buildName("Bob", "Adams");         // ah, just right
 ```
 
 JavaScript里，每个参数都是可选的，可传可不传。
@@ -127,9 +127,9 @@ function buildName(firstName: string, lastName?: string) {
         return firstName;
 }
 
-var result1 = buildName("Bob");  // works correctly now
-var result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
-var result3 = buildName("Bob", "Adams");  // ah, just right
+let result1 = buildName("Bob");  // works correctly now
+let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result3 = buildName("Bob", "Adams");  // ah, just right
 ```
 
 可选参数必须在必须跟在必须参数后面。
@@ -144,10 +144,10 @@ function buildName(firstName: string, lastName = "Smith") {
     return firstName + " " + lastName;
 }
 
-var result1 = buildName("Bob");                  // works correctly now, returns "Bob Smith"
-var result2 = buildName("Bob, undefined");       // still works, also returns "Bob Smith"
-var result3 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
-var result4 = buildName("Bob", "Adams");         // ah, just right
+let result1 = buildName("Bob");                  // works correctly now, returns "Bob Smith"
+let result2 = buildName("Bob, undefined");       // still works, also returns "Bob Smith"
+let result3 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result4 = buildName("Bob", "Adams");         // ah, just right
 ```
 
 在所有必须参数后面的带默认初始化的参数都是可选的，与可选参数一样，在调用函数的时候可以省略。
@@ -179,10 +179,10 @@ function buildName(firstName = "Will", lastName: string) {
     return firstName + " " + lastName;
 }
 
-var result1 = buildName("Bob");                  // error, too few parameters
-var result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
-var result3 = buildName("Bob", "Adams");         // okay and returns "Bob Adams"
-var result4 = buildName(undefined, "Adams");     // okay and returns "Will Adams"
+let result1 = buildName("Bob");                  // error, too few parameters
+let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result3 = buildName("Bob", "Adams");         // okay and returns "Bob Adams"
+let result4 = buildName(undefined, "Adams");     // okay and returns "Will Adams"
 ```
 
 # 剩余参数
@@ -198,7 +198,7 @@ function buildName(firstName: string, ...restOfName: string[]) {
   return firstName + " " + restOfName.join(" ");
 }
 
-var employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");
+let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");
 ```
 
 剩余参数会被当做个数不限的可选参数。
@@ -212,7 +212,7 @@ function buildName(firstName: string, ...restOfName: string[]) {
   return firstName + " " + restOfName.join(" ");
 }
 
-var buildNameFun: (fname: string, ...rest: string[]) => string = buildName;
+let buildNameFun: (fname: string, ...rest: string[]) => string = buildName;
 ```
 
 # Lambda表达式和使用`this`
@@ -229,21 +229,21 @@ JavaScript里，`this`的值在函数被调用的时候才会指定。
 下面看一个例子：
 
 ```ts
-var deck = {
+let deck = {
     suits: ["hearts", "spades", "clubs", "diamonds"],
     cards: Array(52),
     createCardPicker: function() {
         return function() {
-            var pickedCard = Math.floor(Math.random() * 52);
-            var pickedSuit = Math.floor(pickedCard / 13);
+            let pickedCard = Math.floor(Math.random() * 52);
+            let pickedSuit = Math.floor(pickedCard / 13);
       
             return {suit: this.suits[pickedSuit], card: pickedCard % 13};
         }
     }
 }
 
-var cardPicker = deck.createCardPicker();
-var pickedCard = cardPicker();
+let cardPicker = deck.createCardPicker();
+let pickedCard = cardPicker();
 
 alert("card: " + pickedCard.card + " of " + pickedCard.suit);
 ```
@@ -259,22 +259,22 @@ alert("card: " + pickedCard.card + " of " + pickedCard.suit);
 这样就会在函数创建的时候就指定了‘this’值，而不是在函数调用的时候。
 
 ```ts
-var deck = {
+let deck = {
     suits: ["hearts", "spades", "clubs", "diamonds"],
     cards: Array(52),
     createCardPicker: function() {
         // Notice: the line below is now a lambda, allowing us to capture `this` earlier
         return () => {
-            var pickedCard = Math.floor(Math.random() * 52);
-            var pickedSuit = Math.floor(pickedCard / 13);
+            let pickedCard = Math.floor(Math.random() * 52);
+            let pickedSuit = Math.floor(pickedCard / 13);
       
             return {suit: this.suits[pickedSuit], card: pickedCard % 13};
         }
     }
 }
 
-var cardPicker = deck.createCardPicker();
-var pickedCard = cardPicker();
+let cardPicker = deck.createCardPicker();
+let pickedCard = cardPicker();
 
 alert("card: " + pickedCard.card + " of " + pickedCard.suit);
 ```
@@ -287,27 +287,27 @@ JavaScript本身是个动态语言。
 JavaScript里函数根据传入不同的参数而返回不同类型的数据是很常见的。
 
 ```ts
-var suits = ["hearts", "spades", "clubs", "diamonds"];
+let suits = ["hearts", "spades", "clubs", "diamonds"];
 
 function pickCard(x): any {
     // Check to see if we're working with an object/array
     // if so, they gave us the deck and we'll pick the card
     if (typeof x == "object") {
-        var pickedCard = Math.floor(Math.random() * x.length);
+        let pickedCard = Math.floor(Math.random() * x.length);
         return pickedCard;
     }
     // Otherwise just let them pick the card
     else if (typeof x == "number") {
-        var pickedSuit = Math.floor(x / 13);
+        let pickedSuit = Math.floor(x / 13);
         return { suit: suits[pickedSuit], card: x % 13 };
     }
 }
 
-var myDeck = [{ suit: "diamonds", card: 2 }, { suit: "spades", card: 10 }, { suit: "hearts", card: 4 }];
-var pickedCard1 = myDeck[pickCard(myDeck)];
+let myDeck = [{ suit: "diamonds", card: 2 }, { suit: "spades", card: 10 }, { suit: "hearts", card: 4 }];
+let pickedCard1 = myDeck[pickCard(myDeck)];
 alert("card: " + pickedCard1.card + " of " + pickedCard1.suit);
 
-var pickedCard2 = pickCard(15);
+let pickedCard2 = pickCard(15);
 alert("card: " + pickedCard2.card + " of " + pickedCard2.suit);
 ```
 
@@ -321,7 +321,7 @@ alert("card: " + pickedCard2.card + " of " + pickedCard2.suit);
 下面我们来重载`pickCard`函数。
 
 ```ts
-var suits = ["hearts", "spades", "clubs", "diamonds"];
+let suits = ["hearts", "spades", "clubs", "diamonds"];
 
 function pickCard(x: {suit: string; card: number; }[]): number;
 function pickCard(x: number): {suit: string; card: number; };
@@ -329,21 +329,21 @@ function pickCard(x): any {
     // Check to see if we're working with an object/array
     // if so, they gave us the deck and we'll pick the card
     if (typeof x == "object") {
-        var pickedCard = Math.floor(Math.random() * x.length);
+        let pickedCard = Math.floor(Math.random() * x.length);
         return pickedCard;
     }
     // Otherwise just let them pick the card
     else if (typeof x == "number") {
-        var pickedSuit = Math.floor(x / 13);
+        let pickedSuit = Math.floor(x / 13);
         return { suit: suits[pickedSuit], card: x % 13 };
     }
 }
 
-var myDeck = [{ suit: "diamonds", card: 2 }, { suit: "spades", card: 10 }, { suit: "hearts", card: 4 }];
-var pickedCard1 = myDeck[pickCard(myDeck)];
+let myDeck = [{ suit: "diamonds", card: 2 }, { suit: "spades", card: 10 }, { suit: "hearts", card: 4 }];
+let pickedCard1 = myDeck[pickCard(myDeck)];
 alert("card: " + pickedCard1.card + " of " + pickedCard1.suit);
 
-var pickedCard2 = pickCard(15);
+let pickedCard2 = pickCard(15);
 alert("card: " + pickedCard2.card + " of " + pickedCard2.suit);
 ```
 

doc/handbook/Generics.md

@@ -52,7 +52,7 @@ function identity<T>(arg: T): T {
 第一种是，传入所有的参数，包含类型参数：
 
 ```ts
-var output = identity<string>("myString");  // type of output will be 'string'
+let output = identity<string>("myString");  // type of output will be 'string'
 ```
 
 这里我们明确的指定了`T`是字符串类型，并做为一个参数传给函数，使用了`<>`括起来而不是`()`。
@@ -60,7 +60,7 @@ var output = identity<string>("myString");  // type of output will be 'string'
 第二种方法更普遍。利用了*类型推论*，编译器会根据传入的参数自动地帮助我们确定T的类型：
 
 ```ts
-var output = identity("myString");  // type of output will be 'string'
+let output = identity("myString");  // type of output will be 'string'
 ```
 
 注意我们并没用`<>`明确的指定类型，编译器看到了`myString`，把`T`设置为此类型。
@@ -130,7 +130,7 @@ function identity<T>(arg: T): T {
     return arg;
 }
 
-var myIdentity: <T>(arg: T) => T = identity;
+let myIdentity: <T>(arg: T) => T = identity;
 ```
 
 我们也可以使用不同的泛型参数名，只要在数量上和使用方式上能对应上就可以。
@@ -140,7 +140,7 @@ function identity<T>(arg: T): T {
     return arg;
 }
 
-var myIdentity: <U>(arg: U) => U = identity;
+let myIdentity: <U>(arg: U) => U = identity;
 ```
 
 我们还可以使用带有调用签名的对象字面量来定义泛型函数：
@@ -150,7 +150,7 @@ function identity<T>(arg: T): T {
     return arg;
 }
 
-var myIdentity: {<T>(arg: T): T} = identity;
+let myIdentity: {<T>(arg: T): T} = identity;
 ```
 
 这引导我们去写第一个泛型接口了。
@@ -165,7 +165,7 @@ function identity<T>(arg: T): T {
     return arg;
 }
 
-var myIdentity: GenericIdentityFn = identity;
+let myIdentity: GenericIdentityFn = identity;
 ```
 
 一个相似的例子，我们可能想把泛型参数当作整个接口的一个参数。
@@ -181,7 +181,7 @@ function identity<T>(arg: T): T {
     return arg;
 }
 
-var myIdentity: GenericIdentityFn<number> = identity;
+let myIdentity: GenericIdentityFn<number> = identity;
 ```
 
 注意，我们的示例做了少许改动。
@@ -203,7 +203,7 @@ class GenericNumber<T> {
     add: (x: T, y: T) => T;
 }
 
-var myGenericNumber = new GenericNumber<number>();
+let myGenericNumber = new GenericNumber<number>();
 myGenericNumber.zeroValue = 0;
 myGenericNumber.add = function(x, y) { return x + y; };
 ```
@@ -212,7 +212,7 @@ myGenericNumber.add = function(x, y) { return x + y; };
 也可以使用字符串或其它更复杂的类型。
 
 ```ts
-var stringNumeric = new GenericNumber<string>();
+let stringNumeric = new GenericNumber<string>();
 stringNumeric.zeroValue = "";
 stringNumeric.add = function(x, y) { return x + y; };
 

doc/handbook/Interfaces.md

@@ -13,7 +13,7 @@ function printLabel(labelledObj: { label: string }) {
   console.log(labelledObj.label);
 }
 
-var myObj = { size: 10, label: "Size 10 Object" };
+let myObj = { size: 10, label: "Size 10 Object" };
 printLabel(myObj);
 ```
 
@@ -32,7 +32,7 @@ function printLabel(labelledObj: LabelledValue) {
   console.log(labelledObj.label);
 }
 
-var myObj = {size: 10, label: "Size 10 Object"};
+let myObj = {size: 10, label: "Size 10 Object"};
 printLabel(myObj);
 ```
 
@@ -57,7 +57,7 @@ interface SquareConfig {
 }
 
 function createSquare(config: SquareConfig): {color: string; area: number} {
-  var newSquare = {color: "white", area: 100};
+  let newSquare = {color: "white", area: 100};
   if (config.color) {
     newSquare.color = config.color;
   }
@@ -67,7 +67,7 @@ function createSquare(config: SquareConfig): {color: string; area: number} {
   return newSquare;
 }
 
-var mySquare = createSquare({color: "black"});
+let mySquare = createSquare({color: "black"});
 ```
 
 带有可选属性的接口与普通的接口定义差不多，只是在可选属性名字定义的后面加一个`?`符号。
@@ -82,7 +82,7 @@ interface SquareConfig {
 }
 
 function createSquare(config: SquareConfig): {color: string; area: number} {
-  var newSquare = {color: "white", area: 100};
+  let newSquare = {color: "white", area: 100};
   if (config.color) {
     // Error: Property 'collor' does not exist on type 'SquareConfig'
     newSquare.color = config.collor;  // Type-checker can catch the mistyped name here
@@ -93,7 +93,7 @@ function createSquare(config: SquareConfig): {color: string; area: number} {
   return newSquare;
 }
 
-var mySquare = createSquare({color: "black"});
+let mySquare = createSquare({color: "black"});
 ```
 
 # 函数类型
@@ -114,9 +114,9 @@ interface SearchFunc {
 下例展示了如何创建一个函数类型的变量，并将一个同类型的函数赋值给这个变量。
 
 ```ts
-var mySearch: SearchFunc;
+let mySearch: SearchFunc;
 mySearch = function(source: string, subString: string) {
-  var result = source.search(subString);
+  let result = source.search(subString);
   if (result == -1) {
     return false;
   }
@@ -130,9 +130,9 @@ mySearch = function(source: string, subString: string) {
 比如，我们使用下面的代码重写上面的例子：
 
 ```ts
-var mySearch: SearchFunc;
+let mySearch: SearchFunc;
 mySearch = function(src: string, sub: string): boolean {
-  var result = src.search(sub);
+  let result = src.search(sub);
   if (result == -1) {
     return false;
   }
@@ -148,9 +148,9 @@ mySearch = function(src: string, sub: string): boolean {
 如果让这个函数返回数字或字符串，类型检查器会警告我们函数的返回值类型与`SearchFunc`接口中的定义不匹配。
 
 ```ts
-var mySearch: SearchFunc;
+let mySearch: SearchFunc;
 mySearch = function(src, sub) {
-    var result = src.search(sub);
+    let result = src.search(sub);
     if (result == -1) {
         return false;
     }
@@ -170,7 +170,7 @@ interface StringArray {
   [index: number]: string;
 }
 
-var myArray: StringArray;
+let myArray: StringArray;
 myArray = ["Bob", "Fred"];
 ```
 
@@ -274,8 +274,8 @@ class AnalogClock implements ClockInterface {
     }
 }
 
-var digital = createClock(DigitalClock, 12, 17);
-var analog = createClock(AnalogClock, 7, 32);
+let digital = createClock(DigitalClock, 12, 17);
+let analog = createClock(AnalogClock, 7, 32);
 ```
 
 因为`createClock`的第一个参数是`ClockConstructor`类型，在`createClock(AnalogClock, 12, 17)`里，会检查`AnalogClock`是否符合构造函数签名。
@@ -294,7 +294,7 @@ interface Square extends Shape {
     sideLength: number;
 }
 
-var square = <Square>{};
+let square = <Square>{};
 square.color = "blue";
 square.sideLength = 10;
 ```
@@ -314,7 +314,7 @@ interface Square extends Shape, PenStroke {
     sideLength: number;
 }
 
-var square = <Square>{};
+let square = <Square>{};
 square.color = "blue";
 square.sideLength = 10;
 square.penWidth = 5.0;
@@ -335,13 +335,13 @@ interface Counter {
 }
 
 function getCounter(): Counter {
-    var counter = <Counter>function (start: number) { };
+    let counter = <Counter>function (start: number) { };
     counter.interval = 123;
     counter.reset = function () { };
     return counter;
 }
 
-var c = getCounter();
+let c = getCounter();
 c(10);
 c.reset();
 c.interval = 5.0;

doc/handbook/Mixins.md

@@ -48,7 +48,7 @@ class SmartObject implements Disposable, Activatable {
 }
 applyMixins(SmartObject, [Disposable, Activatable])
 
-var smartObj = new SmartObject();
+let smartObj = new SmartObject();
 setTimeout(() => smartObj.interact(), 1000);
 
 ////////////////////////////////////////

doc/handbook/Modules.md

@@ -96,21 +96,21 @@ export * from "./ZipCodeValidator";  // exports class ZipCodeValidator
 ```ts
 import { ZipCodeValidator } from "./ZipCodeValidator";
 
-var myValidator = new ZipCodeValidator();
+let myValidator = new ZipCodeValidator();
 ```
 
 可以对导入内容重命名
 
 ```ts
 import { ZipCodeValidator as ZCV } from "./ZipCodeValidator";
-var myValidator = new ZCV();
+let myValidator = new ZCV();
 ```
 
 ## 将整个模块导入到一个变量，并通过它来访问模块的导出部分
 
 ```ts
 import * as validator from "./ZipCodeValidator";
-var myValidator = new validator.ZipCodeValidator();
+let myValidator = new validator.ZipCodeValidator();
 ```
 
 ## 具有副作用的导入模块
@@ -135,7 +135,7 @@ import "./my-module.js";
 ##### JQuery.d.ts
 
 ```ts
-declare var $: JQuery;
+declare let $: JQuery;
 export default $;
 ```
 
@@ -166,7 +166,7 @@ export default class ZipCodeValidator {
 ```ts
 import validator from "./ZipCodeValidator";
 
-var validator = new validator();
+let validator = new validator();
 ```
 
 或者
@@ -186,7 +186,7 @@ export default function (s: string) {
 ```ts
 import validate from "./StaticZipCodeValidator";
 
-var strings = ["Hello", "98052", "101"];
+let strings = ["Hello", "98052", "101"];
 
 // Use function validate
 strings.forEach(s => {
@@ -221,12 +221,12 @@ TypeScript模块支持`export =`语法，以配合传统的CommonJS和AMD的工
 `export =`语法定义一个模块的导出对象。
 它可以是类，接口，命名空间，函数或枚举。
 
-若要导入一个使用了`export =`的模块时，必须使用TypeScript提供的特定语法`import var = require("module")`。
+若要导入一个使用了`export =`的模块时，必须使用TypeScript提供的特定语法`import let = require("module")`。
 
 ##### ZipCodeValidator.ts
 
 ```ts
-var numberRegexp = /^[0-9]+$/;
+let numberRegexp = /^[0-9]+$/;
 class ZipCodeValidator {
     isAcceptable(s: string) {
         return s.length === 5 && numberRegexp.test(s);
@@ -241,10 +241,10 @@ export = ZipCodeValidator;
 import zip = require("./ZipCodeValidator");
 
 // Some samples to try
-var strings = ["Hello", "98052", "101"];
+let strings = ["Hello", "98052", "101"];
 
 // Validators to use
-var validator = new zip.ZipCodeValidator();
+let validator = new zip.ZipCodeValidator();
 
 // Show whether each string passed each validator
 strings.forEach(s => {
@@ -264,7 +264,7 @@ strings.forEach(s => {
 
 ```ts
 import m = require("mod");
-export var t = m.something + 1;
+export let t = m.something + 1;
 ```
 
 ##### AMD / RequireJS SimpleModule.js
@@ -278,7 +278,7 @@ define(["require", "exports", "./mod"], function (require, exports, mod_1) {
 ##### CommonJS / Node SimpleModule.js
 
 ```js
-var mod_1 = require("./mod");
+let mod_1 = require("./mod");
 exports.t = mod_1.something + 1;
 ```
 
@@ -287,13 +287,13 @@ exports.t = mod_1.something + 1;
 ```js
 (function (factory) {
     if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports); if (v !== undefined) module.exports = v;
+        let v = factory(require, exports); if (v !== undefined) module.exports = v;
     }
     else if (typeof define === "function" && define.amd) {
         define(["require", "exports", "./mod"], factory);
     }
 })(function (require, exports) {
-    var mod_1 = require("./mod");
+    let mod_1 = require("./mod");
     exports.t = mod_1.something + 1;
 });
 ```
@@ -302,8 +302,8 @@ exports.t = mod_1.something + 1;
 
 ```js
 System.register(["./mod"], function(exports_1) {
-    var mod_1;
-    var t;
+    let mod_1;
+    let t;
     return {
         setters:[
             function (mod_1_1) {
@@ -320,7 +320,7 @@ System.register(["./mod"], function(exports_1) {
 
 ```js
 import { something } from "./mod";
-export var t = something + 1;
+export let t = something + 1;
 ```
 
 # 简单示例
@@ -391,7 +391,7 @@ validators["Letters only"] = new LettersOnlyValidator();
 
 // Show whether each string passed each validator
 strings.forEach(s => {
-    for (var name in validators) {
+    for (let name in validators) {
         console.log(`"${ s }" - ${ validators[name].isAcceptable(s) ? "matches" : "does not match" } ${ name }`);
     }
 });
@@ -423,8 +423,8 @@ declare function require(moduleName: string): any;
 import { ZipCodeValidator as Zip } from "./ZipCodeValidator";
 
 if (needZipValidation) {
-    var ZipCodeValidator: typeof Zip = require("./ZipCodeValidator");
-    var validator = new ZipCodeValidator();
+    let ZipCodeValidator: typeof Zip = require("./ZipCodeValidator");
+    let validator = new ZipCodeValidator();
     if (validator.isAcceptable("...")) { /* ... */ }
 }
 ```
@@ -438,7 +438,7 @@ import { ZipCodeValidator as Zip } from "./ZipCodeValidator";
 
 if (needZipValidation) {
     require(["./ZipCodeValidator"], (ZipCodeValidator: typeof Zip) => {
-        var validator = new ZipCodeValidator();
+        let validator = new ZipCodeValidator();
         if (validator.isAcceptable("...")) { /* ... */ }
     });
 }
@@ -447,13 +447,13 @@ if (needZipValidation) {
 ##### 示例：System.js里的动态模块加载
 
 ```ts
-declare var System: any;
+declare let System: any;
 
 import { ZipCodeValidator as Zip } from "./ZipCodeValidator";
 
 if (needZipValidation) {
     System.import("./ZipCodeValidator").then((ZipCodeValidator: typeof Zip) => {
-        var x = new ZipCodeValidator();
+        let x = new ZipCodeValidator();
         if (x.isAcceptable("...")) { /* ... */ }
     });
 }
@@ -492,7 +492,7 @@ declare module "url" {
 declare module "path" {
     export function normalize(p: string): string;
     export function join(...paths: any[]): string;
-    export var sep: string;
+    export let sep: string;
 }
 ```
 
@@ -501,7 +501,7 @@ declare module "path" {
 ```ts
 /// <reference path="node.d.ts"/>
 import * as URL from "url";
-var myUrl = URL.parse("http://www.typescriptlang.org");
+let myUrl = URL.parse("http://www.typescriptlang.org");
 ```
 
 # 创建模块结构指导
@@ -544,7 +544,7 @@ export default function getThing() { return 'thing'; }
 ```ts
 import t from "./MyClass";
 import f from "./MyFunc";
-var x = new t();
+let x = new t();
 console.log(f());
 ```
 
@@ -567,8 +567,8 @@ export function someFunc() { /* ... */ }
 
 ```ts
 import { SomeType, SomeFunc } from "./MyThings";
-var x = new SomeType();
-var y = someFunc();
+let x = new SomeType();
+let y = someFunc();
 ```
 
 ### 使用命名空间导入模式当你要导出大量内容的时候
@@ -586,7 +586,7 @@ export class Flower { ... }
 
 ```ts
 import * as myLargeModule from "./MyLargeModule.ts";
-var x = new myLargeModule.Dog();
+let x = new myLargeModule.Dog();
 ```
 
 ## 使用重新导出进行扩展
@@ -683,7 +683,7 @@ export function test(c: Calculator, input: string) {
 import { Calculator, test } from "./Calculator";
 
 
-var c = new Calculator();
+let c = new Calculator();
 test(c, "1+2*33/11="); // prints 9
 ```
 
@@ -726,7 +726,7 @@ export { test } from "./Calculator";
 ```ts
 import { Calculator, test } from "./ProgrammerCalculator";
 
-var c = new Calculator(2);
+let c = new Calculator(2);
 test(c, "001+010="); // prints 3
 ```
 

doc/handbook/Namespaces and Modules.md

@@ -87,7 +87,7 @@ export namespace Shapes {
 
 ```ts
 import * as shapes from "./shapes";
-var t = new shapes.Shapes.Triangle(); // shapes.Shapes?
+let t = new shapes.Shapes.Triangle(); // shapes.Shapes?
 ```
 
 TypeScript里模块的一个特点是不同的模块永远也不会在相同的作用域内使用相同的名字。
@@ -109,7 +109,7 @@ export class Square { /* ... */ }
 
 ```ts
 import * as shapes from "./shapes";
-var t = new shapes.Triangle();
+let t = new shapes.Triangle();
 ```
 
 ## 模块的取舍

doc/handbook/Namespaces.md

@@ -25,8 +25,8 @@ interface StringValidator {
     isAcceptable(s: string): boolean;
 }
 
-var lettersRegexp = /^[A-Za-z]+$/;
-var numberRegexp = /^[0-9]+$/;
+let lettersRegexp = /^[A-Za-z]+$/;
+let numberRegexp = /^[0-9]+$/;
 
 class LettersOnlyValidator implements StringValidator {
     isAcceptable(s: string) {
@@ -41,14 +41,14 @@ class ZipCodeValidator implements StringValidator {
 }
 
 // Some samples to try
-var strings = ["Hello", "98052", "101"];
+let strings = ["Hello", "98052", "101"];
 // Validators to use
-var validators: { [s: string]: StringValidator; } = {};
+let validators: { [s: string]: StringValidator; } = {};
 validators["ZIP code"] = new ZipCodeValidator();
 validators["Letters only"] = new LettersOnlyValidator();
 // Show whether each string passed each validator
 strings.forEach(s => {
-    for (var name in validators) {
+    for (let name in validators) {
         console.log(""" + s + "" " + (validators[name].isAcceptable(s) ? " matches " : " does not match ") + name);
     }
 });
@@ -89,14 +89,14 @@ namespace Validation {
 }
 
 // Some samples to try
-var strings = ["Hello", "98052", "101"];
+let strings = ["Hello", "98052", "101"];
 // Validators to use
-var validators: { [s: string]: Validation.StringValidator; } = {};
+let validators: { [s: string]: Validation.StringValidator; } = {};
 validators["ZIP code"] = new Validation.ZipCodeValidator();
 validators["Letters only"] = new Validation.LettersOnlyValidator();
 // Show whether each string passed each validator
 strings.forEach(s => {
-    for (var name in validators) {
+    for (let name in validators) {
         console.log(`"${ s }" - ${ validators[name].isAcceptable(s) ? "matches" : "does not match" } ${ name }`);
     }
 });
@@ -159,14 +159,14 @@ namespace Validation {
 /// <reference path="ZipCodeValidator.ts" />
 
 // Some samples to try
-var strings = ["Hello", "98052", "101"];
+let strings = ["Hello", "98052", "101"];
 // Validators to use
-var validators: { [s: string]: Validation.StringValidator; } = {};
+let validators: { [s: string]: Validation.StringValidator; } = {};
 validators["ZIP code"] = new Validation.ZipCodeValidator();
 validators["Letters only"] = new Validation.LettersOnlyValidator();
 // Show whether each string passed each validator
 strings.forEach(s => {
-    for (var name in validators) {
+    for (let name in validators) {
         console.log(""" + s + "" " + (validators[name].isAcceptable(s) ? " matches " : " does not match ") + name);
     }
 });
@@ -214,7 +214,7 @@ namespace Shapes {
 }
 
 import polygons = Shapes.Polygons;
-var sq = new polygons.Square(); // Same as "new Shapes.Polygons.Square()"
+let sq = new polygons.Square(); // Same as "new Shapes.Polygons.Square()"
 ```
 
 注意，我们并没有使用`require`关键字，而是直接使用导入符号的限定名赋值。
@@ -260,5 +260,5 @@ declare namespace D3 {
     }
 }
 
-declare var d3: D3.Base;
+declare let d3: D3.Base;
 ```

doc/handbook/Symbols.md

@@ -5,16 +5,16 @@
 `symbol`类型的值是通过`Symbol`构造函数创建的。
 
 ```ts
-var sym1 = Symbol();
+let sym1 = Symbol();
 
-var sym2 = Symbol("key"); // 可选的字符串key
+let sym2 = Symbol("key"); // 可选的字符串key
 ```
 
 Symbols是不可改变的且唯一。
 
 ```ts
-var sym2 = Symbol("key");
-var sym3 = Symbol("key");
+let sym2 = Symbol("key");
+let sym3 = Symbol("key");
 
 sym2 === sym3; // false, symbols是唯一的
 ```

doc/handbook/Type Compatibility.md

@@ -14,7 +14,7 @@ class Person {
     name: string;
 }
 
-var p: Named;
+let p: Named;
 // OK, because of structural typing
 p = new Person();
 ```
@@ -36,9 +36,9 @@ interface Named {
     name: string;
 }
 
-var x: Named;
+let x: Named;
 // y's inferred type is { name: string; location: string; }
-var y = { name: 'Alice', location: 'Seattle' };
+let y = { name: 'Alice', location: 'Seattle' };
 x = y;
 ```
 
@@ -65,8 +65,8 @@ greet(y); // OK
 让我们以两个函数开始，它们仅有参数列表不同：
 
 ```ts
-var x = (a: number) => 0;
-var y = (b: number, s: string) => 0;
+let x = (a: number) => 0;
+let y = (b: number, s: string) => 0;
 
 y = x; // OK
 x = y; // Error
@@ -85,7 +85,7 @@ x = y; // Error
 尽管如此，传入一个只使用第一个参数的回调函数也是很有用的：
 
 ```ts
-var items = [1, 2, 3];
+let items = [1, 2, 3];
 
 // Don't force these extra arguments
 items.forEach((item, index, array) => console.log(item));
@@ -97,8 +97,8 @@ items.forEach((item) => console.log(item));
 下面来看看如何处理返回值类型，创建两个仅是返回值类型不同的函数：
 
 ```ts
-var x = () => ({name: 'Alice'});
-var y = () => ({name: 'Alice', location: 'Seattle'});
+let x = () => ({name: 'Alice'});
+let y = () => ({name: 'Alice', location: 'Seattle'});
 
 x = y; // OK
 y = x; // Error because x() lacks a location property
@@ -169,7 +169,7 @@ invokeLater([1, 2], (x?, y?) => console.log(x + ', ' + y));
 enum Status { Ready, Waiting };
 enum Color { Red, Blue, Green };
 
-var status = Status.Ready;
+let status = Status.Ready;
 status = Color.Green;  //error
 ```
 
@@ -190,8 +190,8 @@ class Size {
     constructor(numFeet: number) { }
 }
 
-var a: Animal;
-var s: Size;
+let a: Animal;
+let s: Size;
 
 a = s;  //OK
 s = a;  //OK
@@ -210,8 +210,8 @@ s = a;  //OK
 ```ts
 interface Empty<T> {
 }
-var x: Empty<number>;
-var y: Empty<string>;
+let x: Empty<number>;
+let y: Empty<string>;
 
 x = y;  // okay, y matches structure of x
 ```
@@ -223,8 +223,8 @@ x = y;  // okay, y matches structure of x
 interface NotEmpty<T> {
     data: T;
 }
-var x: NotEmpty<number>;
-var y: NotEmpty<string>;
+let x: NotEmpty<number>;
+let y: NotEmpty<string>;
 
 x = y;  // error, x and y are not compatible
 ```
@@ -237,11 +237,11 @@ x = y;  // error, x and y are not compatible
 比如，
 
 ```ts
-var identity = function<T>(x: T): T {
+let identity = function<T>(x: T): T {
     // ...
 }
 
-var reverse = function<U>(y: U): U {
+let reverse = function<U>(y: U): U {
     // ...
 }
 

doc/handbook/Type Inference.md

@@ -7,7 +7,7 @@
 TypeScript里，在有些没有明确指出类型的地方，类型推论会帮助提供类型。如下面的例子
 
 ```ts
-var x = 3;
+let x = 3;
 ```
 
 变量`x`的类型被推断为数字。
@@ -21,7 +21,7 @@ var x = 3;
 当需要从几个表达式中推断类型时候，会使用这些表达式的类型来推断出一个最合适的通用类型。例如，
 
 ```ts
-var x = [0, 1, null];
+let x = [0, 1, null];
 ```
 
 为了推断`x`的类型，我们必须考虑所有元素的类型。
@@ -31,14 +31,14 @@ var x = [0, 1, null];
 由于最终的通用类型取自候选类型，有些时候候选类型共享相同的通用类型，但是却没有一个类型能做为所有候选类型的类型。例如：
 
 ```ts
-var zoo = [new Rhino(), new Elephant(), new Snake()];
+let zoo = [new Rhino(), new Elephant(), new Snake()];
 ```
 
 这里，我们想让zoo被推断为`Animal[]`类型，但是这个数组里没有对象是`Animal`类型的，因此不能推断出这个结果。
 为了更正，当候选类型不能使用的时候我们需要明确的指出类型：
 
 ```ts
-var zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()];
+let zoo: Animal[] = [new Rhino(), new Elephant(), new Snake()];
 ```
 
 如果没有找到最佳通用类型的话，类型推论的结果是空对象类型，`{}`。

doc/handbook/Writing Definition Files.md

@@ -31,14 +31,14 @@ TypeScript 0.9.7+不会强制这种可选参数的使用，参数可选的双向
 #### 匿名类型var
 
 ```ts
-declare var MyPoint: { x: number; y: number; };
+declare let MyPoint: { x: number; y: number; };
 ```
 
 #### 接口类型var
 
 ```ts
 interface SomePoint { x: number; y: number; }
-declare var MyPoint: SomePoint;
+declare let MyPoint: SomePoint;
 ```
 
 从使用者角度来讲，它们是相同的，但是SomePoint类型能够通过接口合并来扩展：
@@ -80,7 +80,7 @@ interface A_Static {
 interface A_Instance {
     inst: number;
 }
-declare var A: A_Static;
+declare let A: A_Static;
 ```
 
 这里的利弊如下：
@@ -139,7 +139,7 @@ zooKeeper(giraffeCage);
 // Note: Function must precede namespace
 function zooKeeper(cage: AnimalCage);
 namespace zooKeeper {
-    var workSchedule: string;
+    let workSchedule: string;
 }
 ```
 
@@ -148,8 +148,8 @@ namespace zooKeeper {
 #### 使用方法
 
 ```ts
-var w = widget(32, 16);
-var y = new widget("sprocket");
+let w = widget(32, 16);
+let y = new widget("sprocket");
 // w and y are both widgets
 w.sprock();
 y.sprock();
@@ -167,7 +167,7 @@ interface WidgetFactory {
     (width: number, height: number): Widget;
 }
 
-declare var widget: WidgetFactory;
+declare let widget: WidgetFactory;
 ```
 
 ## 全局的/不清楚的Libraries
@@ -204,7 +204,7 @@ import eagle = require('./eagle');
 // Call directly
 eagle('bald').fly();
 // Invoke with new
-var eddie = new eagle('Mille');
+let eddie = new eagle('Mille');
 // Set properties
 eddie.favorite = 'golden';
 ```
@@ -215,7 +215,7 @@ eddie.favorite = 'golden';
 // Note: can use any name here, but has to be the same throughout this file
 declare function eagle(name: string): eagle;
 declare namespace eagle {
-    var favorite: string;
+    let favorite: string;
     function fly(): void;
 }
 interface eagle {