开通极客学院VIP会员，免费观看全部会员课程
最低 21.6 元 / 月
VIP会员尊享特权
观看全部会员课程
720P高清视频下载
已有会员账号，请
视频太卡？试试切换线路
本课时介绍 TypeScript 函数的函数类型，掌握在声明一个函数的同时添加函数的类型以及函数参数的类型。
本课时讲解 TypeScript 函数的可选和默认参数，根据可选参数和默认参数可以满足参数上不同的要求。
本课时讲解 TypeScript 函数的可变参数，通过可变参数来满足项目中对参数不同的需求。
本课时主要讲解TypeScript函数的Lambads和this关键字的应用，通过Lambads来修改this关键字的指向问题。
本课时主要讲解 TypeScript 函数的重载，通过使用从在可以自己添加代码提示，提高开发速度。
只有成为VIP会员才能提问&回复，快吧！如果你还没有账号你可以一个账号。
添加新技术问题
课程 [TypeScript 函数-可选和默认参数]
中已存在问题
添加新技术问题
问题描述越详细，被解答的速度越快
有新回答时请邮件提醒我
着急，拜托快点
不急，慢慢解决
关联课程 [TypeScript 函数-可选和默认参数]使用Typescript来写javascript
时间： 16:26:06
&&&& 阅读：525
&&&& 评论：
&&&& 收藏：0
标签：使用Typescript来写javascript&
昨天偶然发现idea居然支持typescript了，于是打算尝试一下typescript，目前的感觉还不错，相比haxejs，它与angularjs之间的配合要流畅得多。
与coffeescript的比较
Typescript与Coffeescript都是对javascript的改进，但两者走的是不同路线。Coffeescript是从语法的角度，通过提供类似于python/ruby的语法，让代码写起来更加简洁，可读性更好。并且它提供的一些控制结构，可以避开Javascript中的问题，比如for&...&in&...，使用coffeescript可以让多层嵌套看起来不那么痛苦：
self.validate json, (err, json) -&
if err then cb(err)
else self.mapFiles json, (err, json) -&
if err then cb(err)
else self.addFields json, (err, json) -&
if err then cb(err)
else self.store.create json, cb
回调的参数放在右边，看起来就像是把前面函数的返回值放在了右边供调用，读起来比较轻松。习惯于python/ruby的开发者可能会比较喜欢coffeescript，我也觉得它在这方面很好。
而Typescript走的是另一条路，通过增加静态类型，提高程序的可靠性，并没有从语法层面进行大的改进。
我觉得它们两者是互补的，如果能把两者结合起来，既提供静态类型，又增强语法就太好了，不过这可能在很久以后才有可能出现。
编辑器支持
Idea并没有声明已经支持typescript，没有看到相关插件，在建项目时也没有任何提示，只有在创建一个以.ts结尾的文件时，它可以识别出来，说明这还是一个实验性的功能，没有完全完成。不过经过我的试用，基本功能都有了：
代码高亮、格式化
其中编译为js文件的功能似乎有点问题，另外module()函数的检验有时候也不太对，不过这并不影响我们的使用。尽管还是一个开发中的功能，但已经跟idea对haxe的支持不相上下了。
另外，你还可以使用VS2012+typescript插件，这是官方推荐的。另外喜欢用sublime text2的同学，可到这里下载：。另外vim/emacs也有相关的插件也有，eclipse这里似乎还没有动静。
据说typescript提供了一些服务性质的api，可以让IDE实现功能（如代码提示等）更加容易。
官方地址：
先到nodejs网站下载并安装nodejs，然后运行以下命令：
npm install -g typescript
其中npm是由nodejs提供的包管理工具，安装nodejs后就直接可用了。
Typescript相关的资料不多，目前官网上仅有一些示例和简单的文档，我收集的有以下这些链接
语言规范：，可用来参考，很难看懂
Typescript官方的文档很简单，只给出了一个简单的例子，没有详细的文档来讲解各功能，所以对于初学者入门还是稍有难度，我花了不少时间才基本会用，比我预想的时间多了很多。
难度不是在语言特性上，而是在代码的组织和示例上，实在太少。比如如何调用声明文件，如何按module来组织代码等，对于初次接触typescript的人还需要一些时间理解。
我对Typescript的印象，可总结为以下几点：
Typescript的思路还是Javascript，只是对它进行了增强
Typescript可以看作是Javascript的超集，所有javascript代码可以直接写在typescript中，这一点对于Javascript程序员来说很方便
Typescript中增加了静态系统，提供了class/interface/method的支持。类型系统可以让我们在编译期验证代码是否有笔误，也可以获得编辑器的提示
Typescript以module方式来组织代码，既支持commonjs的方式，又支持amd的方式
Typescript中的文件可分为实现文件和声明文件，有点像c++中的.cpp和.h的关系。
Typescript即可用来写后台代码，也可以用来写前台代码，初步感觉似乎更偏后台一些
Class/Interface/Method
Typescript中提供了class、interface关键字，可将代码以类的方式组织在一起。构造函数为constructor，静态方法前要加static。在实例方法中调用静态方法时，必须在前面加上类名。这块看起来比较普通，很好理解。
class User {
constructor(name:string, age:number) {
alert("hell, " + name);
User.test(age);
static test(n:number) {
console.log("this is a static method, argument: " + n);
这块对于非Javascript程序员来说，有点不太好理解。我之前虽然学习了一段时间的nodejs，但现在已经快忘光了，这几天拾起来的时候，还是很痛苦的，资料很少。现在只能算是有所了解，讲的可能不全对。
Javascript在语言层面没有提供模块机制，当代码多了以后，很难组织起来。比如在服务器端，将不同的功能分在不同的文件中以复用，或者在浏览器端，想把一个大文件分成多个，按需下载。但文件之间依赖关系、如何向外暴露对象供使用等，都没有规定。所以人们做了很多尝试，制定了一些规范来解决这个问题，其中比较有名的有两个名词，一个commonjs，一个是amd。
关于它们的介绍和相互关系，可以看这篇文章，说得很好：
简单地说，commonjs是一套规范，它定义了如何将代码组织为模块，如何向外暴露对象，如果依赖。在导入模块时，又可以分为同步和异步，一般可认为commonjs代表同步，AMD代表异步。服务器端代码更需要同步，浏览器那边更需要异步，在typescript的编译器中同时支持这两种方式。但commonjs是默认的，所以我前面说感觉它更偏向后端。
当我们在代码中使用了module()函数时，Typescript可以把它们编译为commonjs或amd方式的调用。比如：
/// &reference path="./libs/underscore.d.ts"/&
import _ = module("underscore");
当我们这样编译时：
tsc test.ts
它会生成这样的js代码：
var _ = require("underscore");
当我们指定为amd时：
tsc --module amd test.ts
它会生成这样的代码：
define(["require", "exports", "underscore"], function(require, exports, _____) {
var _ = _____;
在服务器端我们一般用前者，在浏览器端一般使用后者（或者完全不用module）。
不使用Module
如果我们在typescript使用了module函数，则生成的代码在浏览器端执行时，需要有一些script loader的支持。对于浏览器端代码，我们一般生成amd风格的代码，所以需要找一个支持amd的库放在前端。这样的库有很多，比如：
JSLocalnet
可根据自己的需要使用。我尝试了，不喜欢它的网站风格，写了那么多，但总是没说重点。比如关于它的配置，我们需要面对的第一个问题，可是它就是没给一个示例出来，让我在网上到处找别人写的例子。要想用好它，可能得先好好读它的文档，再到网上找别人的代码看。
所以最后我还是按照传统的方式来组织代码，在typescript中完全不使用module函数，而用了全局声明的方式：
/// &reference path="../../libs/underscore.browser.d.ts"/&
declare var _:UnderscoreStatic;
/// &reference path="../../libs/underscore.browser.d.ts"/&
import _ = module("underscore")
当使用declare&var来声明某变量时，即假设它已经在全局中可用，后面的UnderscoreStatic则是在underscore.browser.d.ts这个文件中定义的，关于underscore提供的所有方法的接口描述。
使用这种方式时，我们保证这段js在浏览器端运行时，已经导入了underscore.js。我们可以按照传统的方式来引用js文件：
如果你既不想用requirejs等库，又想异步下载js文件，可以考虑这个库：
headjs不支持commonjs/amd，它有自己的异步下载的api，十分简洁好用。配合我上面的declare var方式，很好用。
这里给出一个简单的例子（headjs+jquery+underscore+angularjs+本站js）：
在head.js()方法中，可传入多个js路径，它们并行下载，但按照声明顺序依次执行。可以把一个head.js()分开写成多个。head.ready()方法将会在所有js下载完成后执行里面的回调函数。
headjs有一个非常好用的特性，即可以把head.js()放在head.ready()的后面：
head.js(".../a.js");
head.ready(function() { console.log(‘I‘m ready‘)});
head.js(".../b.js");
其中的head.ready()函数，虽然写在"b.js"前面，但还是会等到b.js下载并执行完后，才会执行。
如果我们的模板引擎使用了继承关系，则该特性很有用。比如在play中有一个layout.html文件和内页main.html，我们可以这样组织代码。
layout.html
#{extends "layout.html" /}
head.js(".../main.js",
// 仅在本页中使用的js文件)
head.ready(function() {
// 可以在这里为layout.html最后的函数调用准备数据
在这里要补充一句，如果你使用angularjs+headjs的话，不能在&html&上声明ng-app="xxx"，而应该在layout.html中最后的函数中调用：
注意一定要把&html&上的ng-app去掉。我之前尝试把它们两个结合使用总是失败，这次终于找到原因。
如果你仔细看了前面的例子，会发现有一些以三个斜杠开头的代码，如：
/// &reference path="../../libs/underscore.browser.d.ts"/&
它是一种注释，告诉typescript编译器，当前文件使用了哪些声明文件，以帮助编辑器提示信息，及编译器检查类型。这种注释很重要，如果后面的路径不对，则编译会失败。
引用的文件以.d.ts结尾，它们是一种声明文件，就像是c语言中的header文件，只包含了类或函数的签名，而没有实际内容，用于编辑器提示和编译器验证。它们的内容形如：
declare interface UnderscoreVoidListIterator {
(element : any, index : number, list : any[]) : void;
declare interface UnderscoreMemoListIterator {
(memo : any, element : any, index : number, list : any[]) : any;
declare interface UnderscoreListIterator {
(element : any, index : number, list : any[]) : any;
这种文件很重要，因为我们要想使用第三方的js库，一般都需要手动做出这样的声明文件，才能在typesafe的环境中使用它们。只需要以注释的方式写上即可，不需要在实际代码中声明或引用什么。
现在在idea中，这些引用还得手动去写，不太方便，我想tsc或者编辑器应该会对它进行增强。
下载第三方js库的声明文件
现在有很多优秀的第三方js库，我们要在typescript中使用它们，难道要一一手动创建这些文件吗？这个工作量可不小。
好在已经有人这么做并把成果开源出来了，我们可以直接下载它们，放在自己的项目中，再加上引用注释即可。
包含几乎全部的：，你应该把它clone到本地。
使用方法：把它们clone到本地，放在某个地方（比如工具目录中），然后在我们自己的typescript中添加以一个引用即可：
/// &reference path="../../libs/AngularTS.module.d.ts"/&
/// &reference path="../../libs/underscore.browser.d.ts"/&
创建自己的声明文件
如果我们用typescript写了一些模块，想让别人调用，除了把整个代码复制给他以外，还可以生成一个声明文件(.d.ts)，让他使用该声明文件即可。tsc提供了选项让我们生成.d.ts:
tsc --declaration my.ts
如果一切正常，将会在当前目录下产生一个my.d.ts文件，里面包含了my.ts中定义的代码的接口声明。
Typescript在javascript的基础上提供了类型系统，但它同时也支持动态类型。如果我们把一个变量或者返回值声明为any，则它表示&动态类型&，编译器不会检查它的类型信息，但我们也得不到编辑器的提示信息。
function(obj: any) {
obj.non_exist_method();
如代码中所示，obj被声明为any，虽然内部调用了一个不存在的方法，编译器也不会提示有误，只有在运行期才知道。
虽然typescript支持静态类型，但我们并不需要像java那样，在每个地方都要声明类型，因为typescript可以推断：
var name = "Freewind";
则name会被认为是string类型.
function myname(name:string) {
return name;
则myname函数的返回值被认为是string类型。
但我们在声明的地方，最好还是加上类型，以后看起来会比较清楚。
可表示动态类型
true或false
字符串数组
等于{a: b:}
{ a:string, b: }
{ a:string, ()=& }
后面那个是函数
() =& void
表示形如 function() {} 这样的函数
(string) =& number
表示形如 function(name:string) { return 10; } 这样的函数
{ [string]: }
表示一个object，它的key为string，值为数学，形如：{ "aaa": 111, "bbb": 222}
this.filter((todo: Todo) =& todo.get(‘done‘));
使用grunt自动编译typescript
如果你使用的编辑器还不支持自动编译typescript，可以使用grunt来编译，还可以进行更多的任务，如对产生的js进和合并、压缩等工作，十分方便。
具体可参看这篇文章：
Typescript待实现的特性
仅以目前的typescript来说，虽然在类型方面做的不错，但是语言本身还有很多可以改进的地方。比如简化语法，提供更好用的控制结构，对异步进行更好的支持等。如果可以在语言层面改进javascript那些容易出错、不方便的地方，我想会有更多人采用typescript。
，可以看到呼声较高的特性有：
实现await关键字：可以让异步调用变得简单
for & of：js内置的for(x in y)对于数组来说，容易产生问题，但我们又需要经常遍历数组，所以提供for of代替
内置压缩js的功能
protected关键字
生成xml格式的文档
extension methods：可以让我们的函数调用更加流畅，比如underscore的那些方法 ，就可以写成 array.filter(function(item) {return ..})
allow module.exports
string interpolatio and block strings
support for abstract classes
macros：利用macro，可以扩展语言本身
其中我对2,3,6,10,11这几项很感兴趣，如果它们实现了，则typescript的吸引力会大大增强。
TypeScript展望
对于Typescript的未来，我还是比较看好的，因为对于服务器端的编程，类型系统是很重要的，可以让我们的代码质量变得更高，让不同版本之间的库的兼容性也更好。
我之前使用nodejs感觉很郁闷的一点是，某一个库升级了（如改变了api接口），则相关的库都出错了，而想要找出问题很难，只能通过单元测试找到问题，再查看文档解决。而这样的问题在java中出现的就比较少，因为有类型系统的保证，如果接口改变了，直接编译都会出错。
使用typescript后，让nodejs代码也具有的这样的能力，对于社区的前进是很有帮助的。而且对于java/c#程序员来说，这是很有吸引力的。
随着以后typescript相关编辑器、工具的成熟，可以预见它将和coffeescript一样，成为javascript开发人员的标准备选，也许会有一些库和工具直接支持typescript，那样的话就会有更多人来使用typescript了。
如果你对typescript也感兴趣，欢迎加入QQ群：Typescript热情交流群（）
相关工具还不够成熟
经过几天的试用，发现现在使用它也还是不够方便。主要有几下几点：
Idea的编辑器支持typescript的高亮、格式化及代码提示，但还不能像java那样，实时显示错误，所以只能借助第三方工具（比如gruntjs）来编译并显示错误。这种方式对于一个静态类型的语言来说，不是很方便，因为类型方面的错误很容易犯，如果分成两步走，来回切换工具会让定位很麻烦。
我使用的是gruntjs，它基于nodejs，有typescript插件可以编译typescript文件。但是由于nodejs在windows平台上的有一个bug导致无法全面取得错误信息，当ts文件有错误时，只能取到第一行（错误行号），而拿不到具体信息。有时候怎么看那一行都不知道错在哪儿，只好又另开一个cmd，调用tsc命令去编译，很麻烦。
更麻烦的事情来了。在gruntjs中编译提示有误，但我手动调用tsc编译又没错，调试很久都不找不到原因。gruntjs就没法用了。
Typescript不支持将多个ts文件合并生成一个js并压缩，所以我只能借助gruntjs工具实现，但gruntjs又有点问题。
Typescript语言本身还存在一些问题。比如array明明有length属性，但不能被识别，导致明明与它匹配的接口会编译出错。另外，一个any[]类型的数组，应该可以包含各种对象，但放入一个string和一个函数后，提示有误，必须在string前加一个&any&（可能是因为Typescript目前还不支持泛型，导致推断有误）
综上所述，目前使用typescript进行前端开发，问题还比较多，各种小问题都会影响开发效率。所以看样子，只能老老实实地使用javascript（或者coffeescript?），等到typescript成熟一些后再用它。标签：
&&国之画&&&& &&&&chrome插件&&
版权所有 京ICP备号-2
迷上了代码！1，TypeScript是由谷歌开发的，并且新出的Angular2框架就是谷歌公司由TypeScript语言编写的，所以现在TypeScript是有微软和谷歌一起支持的；
2，TypeScript在javascript基础上扩充，任何javascript程序都可以不加修改的拿到typescript环境下运行；
3，ES是客户端脚本语言的规范，ES5和 ES6是这个规范的不同版本，javascript和typescript是客户端脚本语言，javascript实现了ES5规范，typescript实现了ES6规范；ES5的语法即代表javascript的语法，ES6即代表typescript的语法；
3，TypeScript的优势：
1）支持ES6的规范（指出了未来客户端脚本语言的发展方向）；
2）强大的IDE支持（体现在三个特性上）：
　　1）类型检查；
　　2）语法提示；
　　3）重构；体现在修改一个变量，其他引用此变量的代码会自动修改；
3）是Angular2的开发语言，可以更好的理解Angular2;
4，搭建TypeScript环境：
就是搭建compiler(编译器): 作用是将TypeScript编译成javascript语言；
为什么用compiler？ 因为ES6规范是2015年发布的的，到2016年，一些主流浏览器还未完全支持ES6，所以需要转换成javascript才能在浏览器中跑；
1）使用在线compiler：
百度搜索Typescript，到官网上找到学习乐园，点进去即看到在线compiler界面；
或者是 &http://www.typescriptlang.org/play/index.html &
2）本地compiler：（需要先下载node.js）
实际开放中，多数利用本地compiler，使用npm（node package manager &包管理器）下载compiler到本地；所以要想使用本地compiler就先下载nodejs到本地，自然就有npm了，可以使用npm -version 检测npm的版本；
在命令行里使用npm install -g typescript &下载typescript，得到tsc 即compiler；
5，TypeScript字符串新特性：
1）多行字符串：
传统的javascript中，若是将字符串换行表示，需要在中间利用加号来衔接，可读性不好；所以typescript引入了多行字符串的概念；
利用双撇号来声明字符串就不会出现换行的问题了，双撇号就是数字键盘1做左边的符号；被翻译成javascript的时候，就会自动加上换行符 \；
2）字符串模板：在多行字符串里通过表达式来声明变量或插入方法；表达式的格式就是 ${ 表达式名称 }&
在编译器中编译后得到的javascript代码会很清晰明了；
例：在compiler中写入如下代码，注意双撇号的使用：
&注意 ${} 这种写法必须用在撇号的内部才会被解析，若是在双引号内部，只会被原样显示为字符串的形式；
例：使用；撇号来声明常用的标签：
3)第三个特性就是自动拆分字符串：
使用字符串模板去调用一个方法的时候，字符串模板里的表达式的值会自动赋给被调用方法中的参数。
整个模板会被切成一个数组放到被调用的方法的第一个参数里，使用的两个表达式的最终评估处理的值放到被调用方法的后两个参数中；
注意：调用方法的时候，传统的是 ''方法名()'' &,但此处不用小括号，直接写 &方法名`hello ${myname}, i'm${getAge}`
5，参数新特性：
1）第一个参数新特性：在参数名称后面使用冒号来指定参数类型；
5种基本类型：string，any，number，boolean，自定义类型（class和接口声明），方法的返回值类型：void，此时的方法不需要返回值，
方法的参数类型的声明也是如此，调用方法时注意参数类型是否匹配；
变量类型的声明：
var myname : string = "LEE";
这样如果在后面给myname赋值时，如果类型不匹配，就会报错，这就是传说中的TypeScript的类型检查；
但是这种报错只会在typescript的编辑器里出现，javascript不会报错；
typescript还有一个机制---类型推断机制（当第一次为变量声明值后（即使未声明类型），会自动推断该变量的类型，以后如果再给该变量赋值，不是同种类型的话会报错）
var ali="hhhhh";
ali=13; &//此时会报错
如果想让一个变量既可以声明为字符串，又可以声明为数字甚至其他类型，则可以将其声明为any类型；
var &ali： any ="hhhhh"; //声明为any后，就可以再将其声明为其他类型的如数字了；
除了以上的5类型之外，typescript还有通过class和接口自定义的类型；
class Person{
　　name :
var zhangsan：Person =new Person(); //此时 可以 声明一个Person类型的变量zhangsan
再输入zhangsan 时 ，就会有语法提示，zhangsan.name , zhangsan.age 有助于提高效率；
接口定义的类型，见TypeScript 学习之面向对象新特性 文章；
2）第二个参数新特性：
在参数声明后面用等号来指定参数的默认值；这个就是普通的var a : string = "hhhh"; //此处的等号用来指定默认值，后面的即为默认值；
另一个就是给方法的变量指定默认值；注意，指定默认值的参数要声明在最后面；
正常的声明一个带参数的方法后，调用该方法时传入参数的个数必须和方法声明时的参数个数相同，否则会报错，此时如果将其中某个参数指定默认值，则调用时参数的个数和原方法参数个数不同，也不会报错；
将第三个参数 指定了默认值18，在调用方法时，不传第三个参数，也不会报错了：
但是要注意：指定默认值的参数一定要声明在最后面；
&否则，如果第一个参数指定了默认值，但是调用方法传参的时候，只传了两个参数，那是传了前两个参数，最后的参数没穿，会报错的；
6，函数新特性：
为函数定义类型时，先给参数加类型，然后再给函数本身加类型；typescript能根据返回语句自动推断返回值类型，因此通常忽略它；
匿名函数类型：使用箭头，在函数和返回值类型之前使用=&，
完整的函数类型包括参数类型和函数类型：只要参数类型匹配，就是有效的函数，不用在乎参数名是否正确；
function add( num1:number , num2:number ) :number{
　　return num1+num2;
1）第一个新特性是Rest and Spread 操作符：用来声明任意数量的方法参数：通过使用三个点 ( . . . );
Rest and Spread 还可以反过来用；如下
&如上所见，在typescript（有些版本暂不支持），但是javascript中仍然能运行，运行后的结果就是：
方法一中没有传第三个参数，所以是未定义，方法二中将前三个参数传递了，因为方法定义中只有三个形参；
2）函数的第二个新特性：generator函数，控制函数的执行过程，手工暂停和恢复代码执行；
generator函数就是在function的后面加上星号，function* &, 并且与yield关键字，next（）方法结合使用；并且在调用该方法时，需要将该方法声明为一个变量再调用；
执行过程：每调用一次next（）方法，就执行到yield关键字处停止，再次调用next（）方法时，再从yield关键字处开始继续执行，直到下一个yield关键字为止；yield关键字相当于打断点
这个特性有的版本的typescript不支持，所以去搜索babel这是个编辑器(也是两侧显示代码的)，使用它来写下:
&3）函数的第三个新特性：destructuring析构表达式：通过表达式 将对象或数组拆分成任意数量的变量；
一：使用表达式将对象进行拆分：使用大括号声明析构表达式
正常的ES5规范也就是javascript语法中，声明变量需要如下图中7，8,9行声明，但是ES6规范也就是typescript中使用析构表达式则只需要第11行一行代码即可表示；对应右边的第10行，分别将各变量解析出来了；
&注意1）如果想要在打印时，将变量以别名的形式打出来：在使用表达式的时候使用冒号即可添加本地变量的别名：如下图中第11行代码所示；
&注意2）：如何取一个嵌套的属性；就是在析构表达式里再嵌套析构表达式；
例：如果price对象下有两个嵌套的属性price1和price2 ，注意逗号分隔，则可以使用冒号和嵌套析构表达式 来获得 嵌套属性中的某个单独的属性；
意思就是通过price2变量获得千套属性中price2属性；
&注意3）：假如还存在一些其他没有使用析构表达式的属性，但并不影响析构表达式的使用；
&二：使用表达式将数组进行拆分：使用方括号对析构表达式声明；只想输出部分值的时候使用
上图中打印出来的num1和num2分别是1和3；
var [ &, &,num1,nm2 ] = &//这样打印出来的是3和4；&
var [num1,num2, & , & ] = //这样打印出来的是1和2；
var [num1 , & , & , & ] = //这样打印出来的是1 ；
2）数组中的析构表达式和Rest and Spread 操作符（用来声明任意数量的方法参数）结合使用；
运行结果为：
说明Rest and Spread 操作符此处将剩余的两个元素放到了others数组里面了，
&3）将析构表达式作为方法的参数使用：
执行结果是和上例中相同的，也是将后两个参数放到了others数组里面；
7，变量声明时，使用let 和 var 的区别：
let：使用let 声明一个变量时，使用的是词法作用域或块作用域；不同于使用var声明的变量那样可以在包含它们的函数外访问；块作用域变量在包含它们的块或for循环之外是不能访问的；并且不能在声明之前被读写（typescript会提示）；
8，屏蔽：在一个嵌套的作用域里引入一个新名字的行为称为屏蔽；
function sumMatrix(matrix: number[][]) {
let sum = 0;
for (let i = 0; i & matrix. i++) {
var currentRow = matrix[i];
//如果没有这句屏蔽，则会报错，因为两个嵌套的for循环里的i重复了
for (let i = 0; i & currentRow. i++) {
sum += currentRow[i];
&9，基本类型：布尔类型，数字类型，字符串类型，枚举类型，自定义类型，any类型，空值（undefined ，null）；
布尔类型：就是true或false；
数字类型：typescript里的所有数字都是浮点数，就是number类型，除了支持十进制和十六进制（0x开头），还支持二进制和八进制（0o或者是0）；
字符串类型：以双引号或单引号括起；
枚举类型enum：枚举类型的便利就是可以通过枚举值找到名字；
enum Color{Green , Yellow ,Black};
let c：Color = Color.G
默认情况从0开始赋值，但也可以手动给某个元素或全部元素的编号赋值；
enum Color {Red=1 , Yellow, Black}; &//手动给某个元素编号，现在就从编号1开始赋值了
let c: Color = Color.G
enum Color {Red = 1, Yellow = 2, Black = 3}
let c: Color = Color.G & //手动给全部元素编号；
例：通过枚举值找到名字：
enum Color {Red = 1, Yellow ,Black};
let colorName:string =Color[2];
alert(colorName);
10，数组：定义有两种方式：
let list :number[] = [1,2,3,4];
let list : Array&number& = [1,2,3,4];
11，元组Tuple：
元组允许表示一个已知元素数量和类型的数组，各元素的类型不必相同。
let x : [ string , number];
x = ['hello' ,100 ] ; &//而不能是x = [100,'hello']&
&console.log( x[0].substr（1）); &//是正确的；
console.log( x[1].substr（1）); & & //是错误的，number类型没有子串
12，类型断言：好比其他语言里的类型转换，但不进行特殊的数据检查可解构；
类型断言有两种方式：其一是尖括号语法；
let someValue : any = "this is a string";
let strLength : number = (&string&someValue).
其二是as语法：
let someValue : any = "this is a string";
let strLength :number = (someValue as string).
13，当在类里使用this的时候，说明使用this引用的就是类成员；
阅读(...) 评论()