在这个章节将会介绍许多其它编程语言也都有的基础概念,包含变量、数据类型、函数、注解以及条件和循环的流程控制。
变量和常数
let 变量
在前几个章节中,我们已经会用 let 关键字来声明变量了,这边再加强一下观念。
首先要提到的是 let 变量的使用范围(scope)。let 变量的 scope 是在其被声明出来的同一个程序区块之后。例如:
{
let a = 5;
console.log(a);
}
console.log(a);
以上的第六进程式会编译失败,因为 a 变量是用 let 关键字来声明的,它的 scope 并无法到达其被声明的程序区块外。
学过编程语言的人大多会觉得这个很正常,没有什么好提的。等等介绍 var 关键字的时候您就会知道为什么要特别提到 let 变量的 scope 了。
再来要提的是,let 变量的屏蔽(shadowing),只能发生在子区块中,不能在同一个区块。例如:
let a = 1;
{
let a = 5;
console.log(a);
}
console.log(a);
程序第四行,数值为 1 的 a 变量被新声明且数值为 5 的 a 变量给屏蔽掉了。然后前面有提到过,let 关键字声明出来的变量的 scope 只在同一个程序区块之后,因此会输出:
1
而不是:
5
再举一个例子:
let a = 1;
let a = 5;
console.log(a);
以上程序,第一行和第三行都会编译失败,因为 a 变量在同一个程序区块中被声明过了。
let 变量的屏蔽可以使用不同类型,例如以下程序是合法的:
let a = 1;
{
let a = '5';
console.log(a);
}
console.log(a);
最后要提到的是,被声明出来的 let 变量,其默认值为 undefined。例如:
let a;
console.log(a);
a = 5;
console.log(a);
以上程序会输出:
5
注意哦!以上程序,因为我们在 a 变量被指派值之前就先去读取它,因此变量 a 的类型会变成 number | undefined。还记得我们在上一章节提到的严格模式吗?在严格模式下,以下程序是会编译失败的:
let a: number;
console.log(a);
a = 5;
console.log(a);
必须要改成以下这样才能成功编译:
let a: number | undefined;
console.log(a);
a = 5;
console.log(a);
const 常数
在前几个章节中,我们也已经会用 const 关键字来声明常数了,const 常数的用法、scope 和屏蔽特性都和 let 变量完全一样。差别只在 const 常数在被声明出来之后就必须要被指派值,而且一旦被赋值之后就无法再被更改。
例如:
const a;
console.log(a);
以上程序会编译失败。因为常数 a 在声明时并没有被指派值。
再例如:
const a = 1;
a = 2;
console.log(a);
以上程序会编译失败,因为第 3 行我们去修改常数 a 所保存的值。
虽然 const 关键字是用来定义常数,但不可变的部份只限于常数所保存的值,而非值的本身。什么意思呢?好比下面这个例子,const 常数保存一个对象,但这个对象的字段依然是可变的。有关于 JavaScript 的对象,在之后的章节会详细介绍。
const a = {
f: 1
};
a.f = 2;
console.log(a.f);
以上程序会输出:
var 变量
事实上,刚才介绍的 let 和 const 关键字,虽然我们用得很理所当然,但它们都是 ES6 之后才有的语法,在 ES5 和 ES5 之前只能够使用 var 关键字来声明变量。
TypeScript 中,用 var 关键字来声明变量的语法和用 let 关键字是一样的。最大的差别在于 var 变量的 scope 是在其被声明出来的同一个函数主体之后。例如:
{
var a = 5;
console.log(a);
}
console.log(a);
以上程序会编译成功,并且输出:
5
再例如:
function f() {
var a = 5;
console.log(a);
}
console.log(a);
以上的第六进程式会编译失败,因为 a 变量是用 var 关键字来声明的,它的 scope 并无法到达其被声明的函数主体外。
这下知道为什么刚才在介绍 let 关键字时还要特地提及它的 scope 了吧!
事实上,在非严格模式下,以下这样的程序也是可以通过编译并被正常运行的:
{
console.log(a);
var a = 5;
}
console.log(a);
以上程序会输出:
5
虽然变量 a 是在运行完 console.log(a) 叙述后才被声明,但变量 a 还是可以被提前使用,因为 var 关键字声明出来的变量,它的 scope 其实是在其被声明出来的同一个函数主体中,无分程序叙述的顺序,声明时设置的初始值则必须要等到程序运行到该叙述才会被真正指派。不过一般不会将程序写成这样,因为太不直觉了。
还没完呢!var 变量的屏蔽会比 let 变量还来得稍微复杂一点。在同一个函数主体下,我们可以用 var 关键字来声明名称相同的变量,例如:
var a = 1;
var a = 2;
console.log(a);
以上程序会输出:
再例如:
var a = 1;
{
var a = 5;
console.log(a);
}
console.log(a);
以上程序会输出:
5
其实在同一个函数主体下,var 变量并不会发生屏蔽,它其实比较像重新指派新的值给原本的变量。像是上面的两个例子,其实可以等同于:
var a = 1;
a = 2;
console.log(a);
var a = 1;
{
a = 5;
console.log(a);
}
console.log(a);
也就是说,以下程序是会编译失败的:
var a = 1;
{
var a = "5";
console.log(a);
}
console.log(a);
因为很显然地,第四行的字符串 5 不能交给类型为 number 的 a 变量保存。
不过,虽然在同一个函数主体下,我们不能用 var 变量来屏蔽 var 变量,但是可以用 let 变量或是 const 常数来屏蔽 var 变量。例如:
var a = 1;
{
let a = "5";
console.log(a);
}
console.log(a);
以上程序会输出:
1
以下才是 var 变量发生屏蔽的例子:
var a = 1;
function f() {
var a = "5";
console.log(a);
}
f();
console.log(a);
以上程序会输出:
1
被声明出来的 var 变量,其默认值为 undefined,这点和 let 变量是一样的。例如:
var a: number | undefined;
console.log(a);
a = 5;
console.log(a);
以上程序会输出:
5
在声明时未定义初始值的变量类型
之前的章节有提到过,在声明变量或是常数时,若不使用冒号 : 来定义类型的话,则会使用声明时设置的初始值的类型作为这个变量的类型。例如:
let a = 1;
a = "5";
以上程序会编译失败,因为第一行被声明出来的 a 变量类型为 number,所以第二行的字符串 5 不能交给 a 变量来保存。
那如果将程序改成以下这样呢?
let a;
a = 1;
a = "5";
以上程序可以通过编译,但是变量 a 的类型是什么?
没有定义类型也没有初始值的变量,其类型其实是任意类型 any,之后要指派什么类型的值给它都可以。在严格模式下,编译器还会依照最近一次指派的值来推论变量在程序各处的类型,例如以上程序第三行之后的 a 会被当作 number,第四行之后则会被当作 string。
如果要限制 a 变量只能保存数值或字符串,可以写成以下这样:
let a: number | string;
a = 1;
a = "5";
这个 a 变量的类型就是 number | string。依此类推,可以写出以下能够通过编译的程序:
let a: number | string | boolean | object;
a = 1;
a = "5";
a = true;
a = {};
再把我们刚才学到的变量默认值为 undefined 的观念融合进去,以下程序可以通过严格模式的编译:
let a: number | string | boolean | object | undefined;
let b = a;
a = 1;
a = "5";
a = true;
a = {};
数据类型
TypeScript 是「静态类型」(Static Typing)的编程语言,在编译阶段就要完全决定好变量的类型。在许多情况下,tsc 会替我们推论出变量的类型,使我们不需要明确定义出来。例如:
let a;
a = 1;
a = "5";
let b = false;
以上程序,变量 a 的类型在严格模式下会被编译器依照指派的值推论为 number(第三行之后)和 string(第四行之后),变量 b 的类型会被编译器推论为 boolean。
而函数的参数类型,若不明确定义的话,预设会被编译器推论为任意类型 any。例如:
function f(x) {
}
以上程序等同于:
function f(x: any) {
}
不过,在严格模式下,函数的参数并不会被自动推论为 any,这点在前面的章节已有提到。
至于函数的回传值类型,若没有定义的话,编译器就会根据这个函数内所有回传的值的类型,组合成回传值类型。例如:
function f(x: any) {
if (typeof x === "number") {
return 1;
} else {
return "something";
}
}
以上程序等同于:
function f(x: any): number | string {
if (typeof x === "number") {
return 1;
} else {
return "something";
}
}
如果函数不回传任何值,则编译器会推论这个函数的回传值类型为 void。例如:
function f(x: any) {
}
以上程序等同于:
function f(x: any): void {
}
基本数据类型(Primitive Data Types)
JavaScript 编程语言中一共有七种基本数据类型,分别是数值(number)、布尔(boolean)、字符串(string)、符号(symbol)、任意精度整数(bigint)、Null (null)和 Undefined (undefined),底下将分别介绍这七种类型。
数值(number)
number 类型采用 64 比特的 IEEE 754 标准来表示整数和浮点数数值。其中整数的安全范围在 -(253 - 1) ~ 253 - 1 之间。我们可以透过 Number.MIN_SAFE_INTEGER 和 Number.MAX_SAFE_INTEGER 来得到其所能表示的整数最小值与最大值。
console.log(Number.MAX_SAFE_INTEGER);
console.log(Number.MIN_SAFE_INTEGER);
透过 Number.MIN_VALUE 和 Number.MAX_VALUE 可以得到其所能表示的浮点数最小正数与最大值。
console.log(Number.MAX_VALUE);
console.log(Number.MIN_VALUE);
JavaScript 允许加上底线 _ 来分割太多位数的数值。例如:
let x = 12_345;
如同其它大部份编程语言,JavaScript 的整数也支持 16 进制、8 进制、2 进制的表示方式。如下:
let h = 0xff;
let o = 0o377;
let b = 0b11111111;
除了一般的数值之外,number 类型的数据还有两种特别的值。第一种为 NaN,表示这个 number 类型的数据并不是一个数值;第二种为 Infinity,表示这个 number 类型的数据为正无限大,若加上负号则表示为负无限大。
由于任何值包括 NaN 本身都无法与 NaN 相等,因此如果要判断 number 类型的值是否为 NaN 的话,只能够使用 JavaScript 内置的 isNaN 函数。例如:
let a = NaN;
if (isNaN(a)) {
console.log("Equal!");
}
至于两个 Infinity 值,不论怎么与一般数值做加减法,都是永远相等的。例如:
let a = Infinity - 99999;
if (a === Infinity + 99999) {
console.log("Equal!");
}
布尔(boolean)
和其它大多数的编程语言一样,JavaScript 的布尔类型也只有 true 和 false 两种值。布尔的类型名称为 boolean。这个类型我们在之前就有用到了,也没什么好多提的。
字符串(string)
JavaScript 的字符串在内部是用 UTF-16 的编码格式来保存的,所以 Unicode 能支持的字符,都可以被用在 JavaScript 的字符串当中。字符串的类型名称为 string。这个类型我们在之前就有用到了,在此只再补充两点。
首先,字符串和字符串或是其它类型的值可以直接用 + 操作符来串接起来。例如:
let major = 1;
let minor = 0;
let patch = 0;
let version = major + "." + minor + "." + patch;
console.log(version);
以上程序会输出:
不过现在既然有「模板定数」语法能用,就多加利用吧!以上程序可以改写如下:
let major = 1;
let minor = 0;
let patch = 0;
let version = `${major}.${minor}.${patch}`;
console.log(version);
有没有觉得更容易阅读了呢?
再来,我们在先前的章节用到的 parseInt 函数可以将字符串转成整数数值,而如果要转成浮点数数值的话,就要用 parseFloat 函数,如下:
let s = "2.75";
let i = parseInt(s);
let f = parseFloat(s);
console.log(i);
console.log(f);
以上程序的运行结果如下:
2.75
符号(symbol)
symbol 是 ES6 后才被加进 JavaScript 中的新类型。它的样子如下:
let a: symbol = Symbol(undefined);
let b: symbol = Symbol("description");
let c: symbol = Symbol(1);
Symbol 是一个 JavaScript 内置,用来产生并回传 symbol 类型的值的函数。它有一个参数,这个参数的类型为 number | string | undefined,为了让开发者能方便区分不同的 symbol 类型的值。不管这个参数被代进什么值,创建出来的两个 symbol 类型的值都是不相等的。例如:
let a: symbol = Symbol(undefined);
let b: symbol = Symbol(undefined);
let c: symbol = Symbol(1);
let d: symbol = Symbol(1);
if (a === b) {
console.log("a, b are equal!");
}
if (c === d) {
console.log("c, d are equal!");
}
以上程序不会输出任何数据。
所以 symbol 类型可以用来干嘛?利用它的不可被重制性,我们可以用它来实作私有的属性(property)。这个部份会于之后的章节在介绍对象时实际应用。
任意精度整数(bigint)
bigint 是未来才会被正式加进 JavaScript 中的新类型,它可以解决 JavaScript 的 number 类型只能表示 54 比特整数的问题,因为 bigint 能够表示的整数范围完全没有限制!想要在 TypeScript 使用 bigint,编译目标必须要改成 ES2020 之后的版本。
我们可以在一般的整数定数后面直接加上一个 n,来将其转成 bigint 的定数。例如:
let i: bigint = 633825300114114700748351602688n;
number 类型能用的操作符,除了 >>>(无号向右位移)和一元的 + 操作符外,bigint 也都可以用。
Null (null)
null 值的类型即为 null。在预设的情况下,null 是任意类型的子类型,所以任意类型都可以使用 null 值。例如:
function f1(): number {
return null;
}
function f2(): boolean {
return null;
}
function f3(): string {
return null;
}
以上程序是可以通过编译的。
但是在严格模式下,null 值的类型就只能是 null 或是 any。所以以上程序要改写成下面这样才能通过编译:
function f1(): number | null {
return null;
}
function f2(): boolean | null {
return null;
}
function f3(): string | null {
return null;
}
Undefined (undefined)
undefined 值的类型即为 undefined。在预设的情况下,undefined 是任意类型的子类型,所以任意类型都可以使用 undefined 值。例如:
function f1(): number {
return undefined;
}
function f2(): boolean {
return undefined;
}
function f3(): string {
return undefined;
}
以上程序是可以通过编译的。
但是在严格模式下,undefined 类型只为 any 或是 void 的子类型,所以以上程序可以借由改写成下面这样来通过编译:
function f1(): number | undefined {
return undefined;
}
function f2(): boolean | undefined {
return undefined;
}
function f3(): string | void {
return undefined;
}
若是一个表达式回传的类型可能有 null、undefined 或是 void,可以在其尾端加上惊叹号 !,来消除 null、undefined 以及 void。例如:
function f1(): number | undefined | null | void {
return 1;
}
const r1: number = f1()!;
这里要注意的是,就算上面的 f1 函数是直接回传 undefined,还是能通过编译,且 r1 的变量值也会是 undefined。惊叹号 ! 是在当你完全确定这个表达式是绝对会回传有意义的东西的时候才用的。
数组
数组是 JavaScript 对象的一种,可以用来保存多个不同型态的值,这些值在数组中被称为元素值(element)。JavaScript 的数组为可变长度,可以在运行阶段自由增减。利用逗号 , 在中括号 [] 内分隔元素值,就能将它们组合成「数组」。例如:
let a = [2, 4, 6, 8, 10];
以上程序,a 变量的类型可以表示为 number[],如下:
let a: number[] = [2, 4, 6, 8, 10];
访问数组的方式很简单,例如:
let a: number[] = [2, 4, 6, 8, 10];
a[2] = a[1] + a[0];
在数组后面加上一对中括号 [],在中括号的里面放入要访问的数组索引值(键值)即可。
如果查找的索引值并不是该数组所拥有的话,就会回传 undefined。不过这个部份由于是在 JavaScript 的运行阶段才能检查得出来,TypeScript 根本就管不着,因此以下程序虽然 b 变量被指定为 number 类型,却可以在严格模式下被成功编译,在运行之后输出 undefined,由此可见 TypeScript 也不是多么安全的编程语言。
let a: number[] = [2, 4, 6, 8, 10];
let b: number = a[6];
console.log(b);
以下再介绍几个其它数组的常见用法。
要取得数组的长度的话,可以去读取数组的 length 属性。例如:
let a: number[] = [2, 4, 6, 8, 10];
console.log(a.length);
要增加元素的话,可以使用其提供的 push 方法。例如:
let a: number[] = [2, 4, 6, 8, 10];
a.push(12);
若使用 typeof 关键字来侦测数组的话,会与侦测对象一样只会回传 object 字符串,并没有办法区分出这个对象到底是不是数组,因此最好用 JavaScript 内置的 Array.isArray 函数来判断传入参数的值是否为数组。例如:
let a: number[] = [2, 4, 6, 8, 10];
if (Array.isArray(a)) {
console.log(a[0]);
}
对象
由于 JavaScript 的对象比较复杂一些,所以留到之后的章节再做介绍。
== 和 ===
JavaScript 的「相等」操作符有 == 和 === 两种,前者(两个等于)会自动将两个操作数的值转成相同类型,然后去判断值是否相同,而后者(三个等于)则会判断类型和值是否都相同,所以后者也会算得比前者还要来得快。
例如:
let a: number | string = 5;
let b: number | string = 0;
if (1) {
b = "5";
}
console.log(a == b);
console.log(a === b);
以上程序会输出:
false
因为 TypeScript 会检查关系操作符两边的操作数类型的一致性,所以以上程序无法直接写成:
console.log(5 == "5");
console.log(5 === "5");
如果要判断两个值是否「不相等」的话,操作符则是使用 != 或 !==。
函数
编程语言最重要的观念就是函数啦!我们先前已经有使用过 function 关键字,甚至是 Lambda 语法来设计函数,这边要再介绍更多相关的用法。
先来看看下面这个函数:
function save(path: string, data: string, force: boolean): boolean {
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
以上这个 save 函数,可以透过参数传入一个文件路径和字符串,将字符串存进指定的文件中,并且可以设置当文件存在时,是否要强制覆盖(先删除已存在的文件)。所以,当我们在调用 save 函数时,就必须要传入三个参数才行。
有没有什么办法能让 save 函数传入前两个参数就好,剩下来的 force 参数就预设为 false 呢?
当然可以!只要在 force 参数的类型后面,用 = 语法指派一个默认值给它就好了。如下:
function save(path: string, data: string, force: boolean = false): boolean {
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
像这样直接在函数的参数定义中指定参数的默认值的用法,是从 ES6 之后才有的语法。
如果不想要替 force 参数指定默认值,我们也可以直接在其名称后加上问号 ?,来表示这个参数是可选填的。如下:
function save(path: string, data: string, force?: boolean): boolean {
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
此时的 force 参数的类型虽然是被明确定义为 boolean,但它实际上是 boolean | undefined。
那如果连 data 参数都想能够省略不填,并预设为 Hello, world! 呢?
若将 save 函数改写成以下这样:
function save(path: string, data: string = "Hello, world!", force: boolean = false): boolean {
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
我们希望可以运行以下叙述,将 Hello, world! 文字存到 123 文件中,并且覆盖掉原先的文件。
save("123", true);
然而,我们会发现不管怎么样,我们都无法跳过第二个参数,直接发送参数到第三个参数。最少都还是得把 undefined 传进第二个参数中,来当作没有传入第二个参数。
save("123", undefined, true);
如果您有学过 Java 编程语言,可能会想尝试以下这样的写法:
function save(path: string, data: string, force: boolean = false): boolean {
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
function save(path: string, force: boolean = false): boolean {
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, "Hello, world!");
return true;
}
虽然以上的写法是错的,且 JavaScript 确实没有支持函数多载(overloading),但 TypeScript 是有支持函数多载的哦!这部份稍候会再提到,在此先用 typeof 关键字来解决这个问题,如下:
function save(path: string, data_force?: string | boolean, force?: boolean): boolean {
let data;
const t_data_force = typeof data_force;
if (t_data_force === "undefined") {
data = "Hello, world!";
force = false;
} else if (t_data_force === "boolean") {
data = "Hello, world!";
force = data_force;
} else { // string
data = data_force;
}
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
然而,以上程序第 11 行会编译失败,因为 force 参数允许的类型中没有 string 类型,所以无法保存 data_force 参数的值。还记得在前面的章节中我们有学到可以利用流程控制来限缩变量的类型范围吗?您可能会问,这边的 else if (t_data_force === "boolean") 不是应该就有限缩 data_force 的类型范围只能是 boolean 了吗?这个就是 TypeScript 编译器的限制了,它无法知道此处 t_data_force 变量存的值其实就是 typeof data_force。
如果我们将 else if (t_data_force === "boolean") 改为 else if (typeof data_force === "boolean") 的话,就可以通过编译了。但是这样做的话,显然性能会差一点。
为了解决这个问题,我们需要使用 TypeScript 的「显式转型」(explicit casting)。在要转型的表达式后加上 as 关键字,再加上要转型的类型名称,即可进行显式转型。这种转型方式可以向上或是向下转型,不可以转成完全无关的类型。如下:
function save(path: string, data_force?: string | boolean, force?: boolean): boolean {
let data;
const t_data_force = typeof data_force;
if (t_data_force === "undefined") {
data = "Hello, world!";
force = false;
} else if (t_data_force === "boolean") {
data = "Hello, world!";
force = data_force as boolean;
} else { // string
data = data_force;
}
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
接着来谈谈 TypeScript 要怎么做到多载吧!简单来说,就是替函数撰写多个签名,使用分号 ; 隔开,共用一个函数主体。例如以上程序,可以改写成以下这样:
function save(path: string): boolean;
function save(path: string, data: string): boolean;
function save(path: string, data: string, force: boolean): boolean;
function save(path: string, force: boolean): boolean;
function save(path: string, data_force?: string | boolean, force?: boolean): boolean {
let data;
const t_data_force = typeof data_force;
if (t_data_force === "undefined") {
data = "Hello, world!";
force = false;
} else if (t_data_force === "boolean") {
data = "Hello, world!";
force = data_force as boolean;
} else { // string
data = data_force;
}
const fs = require("node:fs");
if (fs.existsSync(path)) {
if (force) {
fs.unlinkSync(path);
} else {
return false;
}
}
fs.writeFileSync(path, data);
return true;
}
save("/path/to/file", true, false); // compilation error
注意以上第 35 进程式叙述会编译失败,因为程序第 5 行的函数签名是给主体内看的,函数外只会看第 1 行到第 4 行的签名。另外,多载的函数签名中,必须要明确地写出函数的回传值类型。
函数也可以像数值或字符串一样,直接用变量、常数或是参数来保存,这个在前面的章节撰写猜数字程序的时候有碰到过(即 Promise 构造器的函数所用的 resolve 参数)。而函数的类型可以用 (参数) => 回传值类型 这样的语法来表示,也可以直接用它们的父类型──Function。
这边再举一个例子:
function add(a: number, b: number): number {
return a + b;
}
const subtract = function (a: number, b: number): number {
return a - b;
};
function math(a: number, b: number, f: Function): number {
return f(a, b);
}
let answer = math(2, 1, add);
console.log(answer);
answer = math(2, 1, subtract);
console.log(answer);
以上程序会输出:
1
注意这边程序第五行到第七行的函数写法。我们直接使用 subtract 常数来定义并保存一个函数,此时的 function 关键字后就不用撰写函数名称了,这样的函数就称为「匿名函数」(Anonymous Function)。
先前稍微用过的 Lambda 语法,就是匿名函数的简化写法。它是在 ES6 之后才被加入的语法。省略了 function 关键字和函数名称,直接从函数的参数开始定义,并用等于大于 => 符号来连接函数的主体。
例如以上程序,可以用 Lambda 语法改写为:
function math(a: number, b: number, f: Function): number {
return f(a, b);
}
let answer = math(2, 1, (a: number, b: number) => {
return a + b;
});
console.log(answer);
answer = math(2, 1, (a: number, b: number) => {
return a - b;
});
console.log(answer);
事实上,=> 符号能连接的不只有函数的主体,它还可以直接连接一个表达式,作为函数要回传的值。例如:
function math(a: number, b: number, f: Function): number {
return f(a, b);
}
let answer = math(2, 1, (a: number, b: number) => a + b);
console.log(answer);
answer = math(2, 1, (a: number, b: number) => a - b);
console.log(answer);
如何?有没有觉得改用 Lambda 语法后,代码精简了很多?
若将 f 参数的函数类型用 (参数) => 回传值类型 这样的语法来表示,作为参数的匿名函数的参数就不需要明确地写出类型了!例如:
function math(a: number, b: number, f: (a: number, b: number) => number): number {
return f(a, b);
}
let answer = math(2, 1, (a, b) => a + b);
console.log(answer);
answer = math(2, 1, (a, b) => a - b);
console.log(answer);
如果您有学过 Java 编程语言的话,一定会知道 Java 编程语言有「varargs」语法,它可以使函数的最后一个参数变成一个数组,接收所有剩下来的参数。JavaScript 在 ES6 之后也有这样的语法,称为「其余参数」(Rest Parameters)。只要在参数名称前加上三个点 ...,就是其余参数了。函数只有最后一个参数可以是其余参数,用来接收所有剩下来的参数。
于是我们再将 math 函数升级成可以接受任意数量的数值作为操作数的版本,如下:
function math(f: (...numbers: number[]) => number, ...numbers: number[]): number {
return f(...numbers); // logically equals to `return f(numbers[0], numbers[1], numbers[2], ..., numbers[numbers.length - 1]);`
}
let answer = math((...numbers) => numbers.reduce((a, b) => a + b), 100, 50, 10, 2);
console.log(answer);
answer = math((...numbers) => numbers.reduce((a, b) => a - b), 100, 50, 10, 2);
console.log(answer);
以上程序会输出:
38
数组的 reduce 方法,可以传入一个函数,用来走访所有元素做累进计算。这个函数的第一个参数为累进值(初始值为第一个元素),第二个参数为目前走访到的元素值(从第二个元素开始),函数回传值则会被当成下一次迭代的第一个参数的值,直到走访完最后一个元素,reduce 方法就会把累进值回传出来。
这边比较需要注意到的地方是程序第二行,我们在传递 numbers 参数的值给函数 f 的时候,不是直接传入 numbers,而是使用「蔓延语法」(Spread Syntax),在 numbers 前加上三个点 ...。这是因为如果我们将一个数组作为参数直接传给其余参数时,这个数组并不会被自动展开成多个参数,必须要在数组参数上使用蔓延语法,将其展开成多个参数。
错误示范如下:
function math(f: (...numbers: number[]) => number, ...numbers: number[]): number {
return f(numbers);
}
let answer = math((...numbers) => numbers.reduce((a, b) => a + b), 100, 50, 10, 2);
console.log(answer);
answer = math((...numbers) => numbers.reduce((a, b) => a - b), 100, 50, 10, 2);
console.log(answer);
以上程序会编译错误,因为传进 f 函数的参数并不是 number,而是 number[]。
注解
TypeScript 编程语言的单行注解都是由 // 开头,直到该行结束。例如:
// So we're doing something complicated here, long enough that we need
// multiple lines of comments to do it! Whew! Hopefully, this comment will
// explain what's going on.
多行注解则是由 /* 开头,直到 */ 结束。例如:
/*
So we're doing something complicated here, long enough that we need
multiple lines of comments to do it! Whew! Hopefully, this comment will
explain what's going on.
*/
在代码中加入适当的注解可以让程序变得更容易理解。
在预设的情况下,TypeScript 的注解在被编译之后,也会保留在 JavaScript 代码中。如果想要移除注解,就要在 tsconfig.json 设置档中的 compilerOptions 字段,加上 removeComments 字段,并将其值设为 true。如下:
{
"compilerOptions": {
...
"removeComments": true
...
}
...
}
不过如果是位于源代码文件最上面,以 /*! 为开头的注解,TypeScript 就会保留它,这种通常是用来标示源代码授权消息的注解。
流程控制
大部分的编程语言可以借由判断条件来决定要运行哪些程序,以及重复运行哪些程序。
if 条件判断语法
if 和 else 关键字组成的条件判断语法我们已经会用了,这边要再多提一个三元条件运算的语法,可以用来精简程序。
如果我们说 if-else 的语法结构是以下这样:
if (条件表达式) {
条件表达式的值不为undefined、null、false、0、NaN或空字符串时运行的程序叙述区块
} else {
条件表达式的值为undefined、null、false、0、NaN或空字符串时运行的程序叙述区块
}
那么这个三元条件操作符的语法的结构就是以下这样:
条件表达式 ? 条件表达式的值不为undefined、null、false、0、NaN或空字符串时运行的表达式 : 条件表达式的值为undefined、null、false、0、NaN或空字符串时运行的表达式
举例来说:
let y: number;
...
let x;
if (y >= 0) {
x = y;
} else {
x = -y;
}
以上程序可以用三元条件操作符的语法改写为:
let y = 0;
...
let x = y >= 0 ? y : -y;
switch 判断语法
有时候我们会需要撰写如下的程序逻辑:
let mode: number;
if (mode === 0) {
// do something
} else if (mode === 1) {
// do something
} else if (mode === 2) {
// do something
} else if (mode === 3 || mode === 4) {
if (mode === 3) {
// do something
}
// do something
} else {
// do something
}
这时候可以改用 switch、case 和 default 关键字组成来实作这样的程序逻辑,如下:
switch (mode) {
case 0:
// do something
break;
case 1:
// do something
break;
case 2:
// do something
break;
case 3:
// do something
case 4:
// do something
break;
default:
// do something
}
switch 关键字后必须要接上一对小括号 (),括号中间必须要放入一个表达式。在这对 小括号 的后面,要再接上一对大括号 {} 作为 switch 判断语法的程序叙述区块。在这个程序叙述区块中,可以使用 case 关键字来设置当表达式为哪些值的时候,要直接跳到程序区块的哪个位置运行程序叙述。为避免运行到不该运行的程序叙述,可以使用 break 叙述来直接跳出 switch 判断语法的程序叙述区块。default 关键字则可以用来设置当表达式的值都不符合 case 关键字指定的值的话,要直接跳到程序区块的哪个位置运行程序叙述,这通常会写在 case 关键字之后。
在 switch 判断语法的程序叙述区块中,case 关键字或是 default 关键字都是选用的。
循环
循环可以让相同的程序自动运行一次以上,JavaScript 提供了 while、do、for 关键字来创建用途不同的循环。
while 循环
while 关键字所创建的循环可以借由判断表达式的值来决定要不要脱离循环。用法如下:
while (条件表达式) {
条件表达式的值不为undefined、null、false、0、NaN或空字符串时运行的程序叙述区块
}
举例来说:
let number = 3;
while (number !== 0) {
console.log(number);
number = number - 1;
}
console.log("LIFTOFF!!!");
以上程序,当 number 变量的值不等于 0 的时候就会一直运行 while 循环内的程序叙述。运行结果如下:
2
1
LIFTOFF!!!
while 循环内的程序叙述区块可以使用 break 和 continue 叙述。前者可以立即跳出循环,后者可以立即进入下一次迭代。
do-while 循环
do 和 while 关键字所创建的循环可以借由判断表达式的值来决定要不要脱离循环。用法如下:
do {
可重复运行的程序叙述区块
} while (条件表达式)
do-while 循环和 while 循环的不同点在于,do-while 循环是先运行一次循环内的程序叙述之后,再去用条件表达式判断要不要再次重复运行。所以不管条件表达式是什么,循环内的程序叙述都会至少被运行一次。
do-while 循环内的程序叙述区块也可以使用 break 和 continue 叙述。
for 循环
for 关键字可以用来创建计次循环或是走访一个结构。用法如下:
for ([let 变量名称1[, 变量名称2[, 变量名称n]]]; [条件表达式]; [步进表达式]) {
条件表达式的值不为undefined、null、false、0、NaN或空字符串时运行的程序叙述区块
}
在 for 循环的小括号 () 中用 let 关键字声明的变量,可以被用在 for 循环的小括号和循环的程序叙述区块中。除了 let 变量之外,也可以用 var 变量或是 const 常数,不过通常不会这样用。
例如要走访一个数组,我们可以先利用 while 循环来实作看看。如下:
let a = [10, 20, 30, 40, 50];
let index = 0;
while (index < a.length) {
console.log(`the value is: ${a[index]}`);
index = index + 1;
}
程序运行结果:
the value is: 20
the value is: 30
the value is: 40
the value is: 50
改成 for 循环的话则为:
let a = [10, 20, 30, 40, 50];
for (let index = 0; index < a.length; index++) {
console.log(`the value is: ${a[index]}`);
}
以上程序中,index++ 也可以写成 ++index、index += 1 或 index = index + 1,都是让 index 变量本身加一的意思。但事实上,index++ 与其它三种表达式有微小的差异。演示如下:
let a = 1;
console.log(a);
console.log(a = a + 1);
console.log(a);
console.log(a += 1);
console.log(a);
console.log(++a);
console.log(a);
console.log(a++);
console.log(a);
以上程序的输出结果如下:
2
2
3
3
4
4
4
5
我们可以发现,只有 a++ 是回传原先的 a 值,而不是 a 加 1 过后的值。依此类推,减法 --a、a-- 也是有这样的差异。
for 循环内的程序叙述区块也可以使用 break 和 continue 叙述。
for-in 循环
我们可以在 for 循环的小括号中,使用 in 关键字来直接取得数组或是对象结构的所有键值(key),包含其继承(Inheritance)的键值。此时的 for 循环小括号内的语法会和刚才介绍的有些不一样,如下:
for (const 常数名称 in 数组或对象) {
可重复运行的程序叙述区块
}
for-in 循环的小括号中可以使用变量或是常数,建议使用常数。
例如:
let a = [10, 20, 30, 40, 50];
for (const index in a) {
console.log(`the value is: ${a[index]}`);
}
有个很重要的地方要注意的是,for-in 循环所取得的数组键值,会是一个字符串,而不是数值。且用来保存键值的变量或是常数,不能明确定义出类型,只能由编译器来推论。
for-of 循环
在 ES6 之后,如果想要直接取得数组的所有值(value),可以在 for 循环的小括号中,使用 of 关键字。用法如下:
for (const 常数名称 of 数组或对象) {
可重复运行的程序叙述区块
}
for-of 循环的小括号中可以使用变量或是常数,建议使用常数。
例如:
let a = [10, 20, 30, 40, 50];
for (const element of a) {
console.log(`the value is: ${element}`);
}
除了数组之外,for-of 循环还可以用来走访一个字符串。
例如:
let s = "Hello";
for (const element of s) {
console.log(element);
}
以上程序会输出:
e
l
l
o
除了数组和字符串外,for-of 循环其实也可以用于特定的对象,这个会在之后的章节介绍。
嵌套循环
在循环的程序叙述区块中也可以再使用其它的循环,形成「嵌套循环」(Nested Loop)。在这样的程序结构下,我们可以替比较外层的循环前加上 标签名称:,形成「标签」,这样内层的循环就可以用 break 标签名称 或是 continue 标签名称 这样的叙述来控制外层的循环了。
例如:
let a = [10, 20, 30, 40, 50];
let b = [1, 3, 5, 7, 9];
outer: for (const index1 in a) {
for (const index2 in b) {
if (index2 === "2") {
continue outer;
}
console.log(`the value is: ${a[index1] + b[index2]}`);
}
}
以上程序会输出:
the value is: 13
the value is: 21
the value is: 23
the value is: 31
the value is: 33
the value is: 41
the value is: 43
the value is: 51
the value is: 53
总结
在这个章节中,我们学会了 TypeScript 编程语言的变量、数据类型、函数、注解以及条件和循环的流程控制。在下一章节中,要来介绍在本章跳过的对象。
下一章:TypeScript 编程语言的对象。
