从 JavaScript 到 TypeScript-低调大师

从 JavaScript 到 TypeScript

2018-02-13 607

文中的案例代码已经上传到 TypeScript

TypeScript 并不是一个完全新的语言, 它是 JavaScript 的超集，为 JavaScript 的生态增加了类型机制，并最终将代码编译为纯粹的 JavaScript 代码。

TypeScript 简介

TypeScript 由 Microsoft(算上 Angular 2 的话加上 Google)开发和维护的一种开源编程语言。它支持 JavaScript 的所有语法和语义，同时通过作为 ECMAScript 的超集来提供一些额外的功能，如类型检测和更丰富的语法。下图显示了 TypeScript 与 ES5，ES2015，ES2016 之间的关系。

image

使用 TypeScript 的原因

JavaScript 是一门弱类型语言，变量的数据类型具有动态性，只有执行时才能确定变量的类型，这种后知后觉的认错方法会让开发者成为调试大师，但无益于编程能力的提升，还会降低开发效率。TypeScript 的类型机制可以有效杜绝由变量类型引起的误用问题，而且开发者可以控制对类型的监控程度，是严格限制变量类型还是宽松限制变量类型，都取决于开发者的开发需求。添加类型机制之后，副作用主要有两个：增大了开发人员的学习曲线，增加了设定类型的开发时间。总体而言，这些付出相对于代码的健壮性和可维护性，都是值得的。

此外，类型注释是 TypeScript 的内置功能之一，允许文本编辑器和 IDE 可以对我们的代码执行更好的静态分析。这意味着我们可以通过自动编译工具的帮助，在编写代码时减少错误，从而提高我们的生产力。

对 TypeScript 的简介到此，接下来对其特有的知识点进行简单概括总结，(网上很多教程实际上把 ES6， ES7 的知识点也算进 ts 的知识点了，当然这没错~)

数据类型

String 类型

一个保存字符串的文本，类型声明为 string。可以发现类型声明可大写也可小写，后文同理。

|

1

2

</pre>

|

let name: string = 'muyy'

let name2: String = 'muyy'

</pre>

|

</figure>

Boolen 类型

boolean是 true 或 false 的值，所以 let isBool3: boolean = new Boolean(1) 就会编译报错，因为 new Boolean(1) 生成的是一个 Bool 对象。

|

1

</pre>

|

let isBool1: boolean = false

</pre>

|

</figure>

Number 类型

|

1

</pre>

|

let number: number = 10;

</pre>

|

</figure>

Array 类型

数组是 Array 类型。然而，因为数组是一个集合，我们还需要指定在数组中的元素的类型。我们通过 Array<type> or type[] 语法为数组内的元素指定类型

|

1

2

3

4

5

</pre>

|

let arr:number[] = [1, 2, 3, 4, 5];

let arr2:Array<number> = [1, 2, 3, 4, 5];

let arr3:string[] = ["1","2"];

let arr4:Array<string> = ["1","2"];

</pre>

|

</figure>

Enums 类型

列出所有可用值，一个枚举的默认初始值是0。你可以调整一开始的范围：

|

1

2

3

</pre>

|

enum Role {Employee = 3, Manager, Admin}

let role: Role = Role.Employee

console.log(role) // 3

</pre>

|

</figure>

Any 类型

any 是默认的类型，其类型的变量允许任何类型的值：

|

1

2

</pre>

|

let notSure:any = 10;

let notSure2:any[] = [1,"2",false];

</pre>

|

</figure>

Void 类型

JavaScript 没有空值 Void 的概念，在 TypeScirpt 中，可以用 void 表示没有任何返回值的函数：

|

1

2

3

</pre>

|

function alertName(): void {

console.log('My name is muyy')

}

</pre>

|

</figure>

函数

为函数定义类型

我们可以给每个参数添加类型之后再为函数本身添加返回值类型。 TypeScript能够根据返回语句自动推断出返回值类型，因此我们通常省略它。下面函数 add, add2, add3 的效果是一样的，其中是 add3 函数是函数完整类型。

|

1

2

3

4

5

6

7

8

9

10

11

</pre>

|

function add(x: string, y: string): string{

return "Hello TypeScript";

}

let add2 = function(x: string, y: string): string{

return "Hello TypeScript";

}

let add3: (x: string, y: string) => string = function(x: string, y: string): string{

return "Hello TypeScript";

}

</pre>

|

</figure>

可选参数和默认参数

JavaScript 里，每个参数都是可选的，可传可不传。没传参的时候，它的值就是 undefined 。在 TypeScript 里我们可以在参数名旁使用?实现可选参数的功能。比如，我们想让 lastname 是可选的：

|

1

2

3

4

5

6

7

</pre>

|

function buildName(firstName: string, lastname?: string){

console.log(lastname ? firstName + "" + lastname : firstName)

}

let res1 = buildName("鸣","人"); // 鸣人

let res2 = buildName("鸣"); // 鸣

let res3 = buildName("鸣", "人", "君"); // Supplied parameters do not match any signature of call target.

</pre>

|

</figure>

如果带默认值的参数出现在必须参数前面，用户必须明确的传入 undefined 值来获得默认值。例如，我们重写上例子，让 firstName 是带默认值的参数：

|

1

2

3

4

5

6

</pre>

|

function buildName2(firstName = "鸣", lastName?: string){

console.log(firstName + "" + lastName)

}

let res4 = buildName2("人"); // undefined人

let res5 = buildName2(undefined, "人"); // 鸣人

</pre>

|

</figure>

类

传统的JavaScript程序使用函数和基于原型的继承来创建可重用的组件，但对于熟悉使用面向对象方式的程序员来讲就有些棘手，因为他们用的是基于类的继承并且对象是由类构建出来的。从ECMAScript 2015，也就是ECMAScript 6开始，JavaScript程序员将能够使用基于类的面向对象的方式。使用TypeScript，我们允许开发者现在就使用这些特性，并且编译后的JavaScript可以在所有主流浏览器和平台上运行，而不需要等到下个JavaScript版本。

类

|

1

2

3

4

5

6

7

8

9

10

11

12

13

14

</pre>

|

class Person{

name:string; // 这个是对后文this.name类型的定义

age:number;

constructor(name:string,age:number){

    this.name = name;

    this.age = age;

}

print(){

    return this.name + this.age;

}

}

let person:Person = new Person('muyy',23)

console.log(person.print()) // muyy23

</pre>

|

</figure>

我们在引用任何一个类成员的时候都用了 this。它表示我们访问的是类的成员。其实这本质上还是 ES6 的知识，只是在 ES6 的基础上多上了对 this 字段和引用参数的类型声明。

继承

|

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

</pre>

|

class Person{

public name:string;  // public、private、static 是 typescript 中的类访问修饰符

age:number;

constructor(name:string,age:number){

    this.name = name;

    this.age = age;

}

tell(){

    console.log(this.name + this.age);

}

}

class Student extends Person{

gender:string;

constructor(gender:string){

    super("muyy",23);

    this.gender = gender;

}

tell(){

    console.log(this.name + this.age + this.gender);

}

}

var student = new Student("male");

student.tell(); // muyy23male

</pre>

|

</figure>

这个例子展示了 TypeScript 中继承的一些特征，可以看到其实也是 ES6 的知识上加上类型声明。不过这里多了一个知识点 —— 公共，私有，以及受保护的修饰符。TypeScript 里，成员默认为 public ；当成员被标记成 private 时，它就不能在声明它的类的外部访问；protected 修饰符与private 修饰符的行为很相似，但有一点不同，protected 成员在派生类中仍然可以访问。

存储器

TypeScript 支持通过 getters/setters 来截取对对象成员的访问。它能帮助你有效的控制对对象成员的访问。

对于存取器有下面几点需要注意的：
首先，存取器要求你将编译器设置为输出 ECMAScript 5 或更高。不支持降级到 ECMAScript 3。其次，只带有 get 不带有 set 的存取器自动被推断为 readonly。这在从代码生成 .d.ts 文件时是有帮助的，因为利用这个属性的用户会看到不允许够改变它的值。

|

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

</pre>

|

class Hello{

private _name: string;

private _age: number;

get name(): string {

    return this._name;

}

set name(value: string) {

    this._name = value;

}

get age(): number{

    return this._age;

}

set age(age: number) {

    if(age>0 && age<100){

        console.log("年龄在0-100之间"); // 年龄在0-100之间

        return;

    }

    this._age = age;

}

}

let hello = new Hello();

hello.name = "muyy";

hello.age = 23

console.log(hello.name); // muyy

</pre>

|

</figure>

接口

TypeScript的核心原则之一是对值所具有的结构进行类型检查。在TypeScript里，接口的作用就是为这些类型命名和为你的代码或第三方代码定义契约。

|

1

2

3

4

5

6

7

8

9

10

11

12

</pre>

|

interface LabelValue{

label: string;

}

function printLabel(labelObj: LabelValue){

console.log(labelObj.label);

}

let myObj = {

"label":"hello Interface"

};

printLabel(myObj);

</pre>

|

</figure>

LabelledValue 接口就好比一个名字，它代表了有一个 label 属性且类型为 string 的对象。只要传入的对象满足上述必要条件，那么它就是被允许的。

另外，类型检查器不会去检查属性的顺序，只要相应的属性存在并且类型也是对的就可以。

可选属性

带有可选属性的接口与普通的接口定义差不多，只是在可选属性名字定义的后面加一个 ? 符号。可选属性的好处之一是可以对可能存在的属性进行预定义，好处之二是可以捕获引用了不存在的属性时的错误。

|

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

</pre>

|

interface Person{

name?:string;

age?:number;

}

function printInfo(info:Person){

console.log(info);

}

let info = {

"name":"muyy",

"age":23

};

printInfo(info); // {"name": "muyy", "age": 23}

let info2 = {

"name":"muyy"

};

printInfo(info2); // {"name": "muyy"}

</pre>

|

</figure>

函数类型

接口能够描述 JavaScript 中对象拥有的各种各样的外形。除了描述带有属性的普通对象外，接口也可以描述函数类型。定义的函数类型接口就像是一个只有参数列表和返回值类型的函数定义。参数列表里的每个参数都需要名字和类型。定义后完成后，我们可以像使用其它接口一样使用这个函数类型的接口。

|

1

2

3

4

5

6

7

8

9

10

11

</pre>

|

interface SearchFunc{

(source: string, subString: string): boolean;

}

let mySearch: SearchFunc;

mySearch = function(source: string,subString: string){

return source.search(subString) !== -1;

};

console.log(mySearch("鸣人","鸣")); // true

console.log(mySearch("鸣人","缨")); // false

</pre>

|

</figure>

可索引类型

与使用接口描述函数类型差不多，我们也可以描述那些能够“通过索引得到”的类型，比如 a[10] 或 ageMap["daniel"]。可索引类型具有一个索引签名，它描述了对象索引的类型，还有相应的索引返回值类型。让我们看如下例子：

|

1

2

3

4

5

6

7

</pre>

|

interface StringArray{

[index: number]: string;

}

let MyArray: StringArray;

MyArray = ["是","云","随","风"];

console.log(MyArray[2]); // 随

</pre>

|

</figure>

类类型

与 C# 或 Java 里接口的基本作用一样，TypeScript 也能够用它来明确的强制一个类去符合某种契约。

我们可以在接口中描述一个方法，在类里实现它，如同下面的 setTime 方法一样：

|

1

2

3

4

5

6

7

8

9

10

11

12

</pre>

|

interface ClockInterface{

currentTime: Date;

setTime(d: Date);

}

class Clock implements ClockInterface{

currentTime: Date;

setTime(d: Date){

    this.currentTime = d;

}

constructor(h: number, m: number) {}

}

</pre>

|

</figure>

继承接口

和类一样，接口也可以相互继承。这让我们能够从一个接口里复制成员到另一个接口里，可以更灵活地将接口分割到可重用的模块里。

|

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

</pre>

|

interface Shape{

color: string;

}

interface PenStroke{

penWidth: number;

}

interface Square extends Shape,PenStroke{

sideLength: number;

}

let s = <Square>{};

s.color = "blue";

s.penWidth = 100;

s.sideLength = 10;

</pre>

|

</figure>

模块

TypeScript 与 ECMAScript 2015 一样，任何包含顶级 import 或者 export 的文件都被当成一个模块。

|

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

</pre>

|

export interface StringValidator{

isAcceptable(s:string): boolean;

}

var strReg = /^[A-Za-z]+$/;

var numReg = /^[0-9]+$/;

export class letterValidator implements StringValidator{

isAcceptable(s:string): boolean{

    return strReg.test(s);

}

}

export class zipCode implements StringValidator{

isAcceptable(s: string): boolean{

    return s.length == 5 && numReg.test(s);

}

}

</pre>

|

</figure>

泛型

软件工程中，我们不仅要创建一致的定义良好的 API ，同时也要考虑可重用性。组件不仅能够支持当前的数据类型，同时也能支持未来的数据类型，这在创建大型系统时为你提供了十分灵活的功能。
在像 C# 和 Java 这样的语言中，可以使用泛型来创建可重用的组件，一个组件可以支持多种类型的数据。这样用户就可以以自己的数据类型来使用组件。

初探泛型

如下代码，我们给 Hello 函数添加了类型变量 T ，T 帮助我们捕获用户传入的类型（比如：string）。我们把这个版本的 Hello 函数叫做泛型，因为它可以适用于多个类型。代码中 output 和 output2 是效果是相同的，第二种方法更加普遍，利用了类型推论 —— 即编译器会根据传入的参数自动地帮助我们确定T的类型：

|

1

2

3

4

5

6

7

8

9

</pre>

|

function Hello<T>(arg:T):T{

return arg;

}

let outPut = Hello<string>('Hello Generic');

let output2 = Hello('Hello Generic')

console.log(outPut);

console.log(outPut2);

</pre>

|

</figure>

参考资料

本文标题:从 JavaScript 到 TypeScript

文章作者:牧云云

发布时间:2017年07月02日 - 13:07

最后更新:2018年01月06日 - 23:01

原始链接:http://muyunyun.cn/posts/66a54fc2/

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际转载请保留原文链接及作者。

微信关注我们

原文链接：https://yq.aliyun.com/articles/626981

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

2018 最值得关注的前端技术

1.前言 2017悄然过去，2018已经来到。人在进步，技术在发展。2018年前端有哪些领域，技术值得关注，哪些技术会兴起，哪些技术会没落。下面就我个人的判断进行一个预测判断，希望能对大家起到一个参考作用！下面提及的技术，只是建议大家关注，也不是建议大家全部的都要学，而是建议大家按需学，自己觉得哪些需要学，对哪些有兴趣就学哪些！如果大家有什么工具，框架，库觉得可以推荐的，欢迎在评论区提点，让大家相互进步，学习！ 2.PWA PWA(Progressive Web Apps)由谷歌提出，用前沿的技术开发，让网页使用如同App般的体验的一系列方案。明确的一点就是：PWA就是一个网页, 可以通过前沿的技术开发出一个网页应用。自从谷歌提出PWA后，就持续的获得了业界的关注，热度可见一斑。就在今年，谷歌也宣布： PWA将获得与安卓原生应用同等的待遇与权限。这就意味着以后的网页基本和APP将越发将近，那么关注度将会进一步的上升。资料参考： PWA 入门: 写个非常简单的 PWA 页面【转载】你的首个 Progressive Web App 【转载】下一代Web应用模型：Progressiv...

2018-02-14

621

给出一个简单的POJO 使用databind，我们需要一个最基础的对象com.fasterxml.jackson.databind.ObjectMapper这里我们构造一个: 注意:这个objectMapper是可以复用的 ObjectMapper 该映射器（或数据绑定器或编解码器）为Java对象之间和匹配的JSON结构的转换提供功能属性(为序列化过程定义基本的全局设置的配置对象) _serializationConfig _deserializationConfig image.png Inclusion 需要的传参用于定义Java Bean的哪些属性将被包含在序列化中的枚举 ALWAYS 指示属性始终被包含独立于值 NON_NULL 该值指示仅包含具有非空值的属性 NON_DEFAULT 只包含没有默认值的属性（意味着当它使用无参数构造函数构造Bean时的值） Map通常无用，因为它们没有默认值，如果使用，则与ALWAYS NON_EMPTY 属性值为null或被认为是空的属性不包括在内 Feature 定义了可引导序列化功能的可触发功能的枚举 WRITE_DATES_AS_...

2018-02-14

868

资源下载

更多资源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。