在这个章节,我们将会直接使用 TypeScript 编程语言来创建出猜数字程序的项目,并逐步将它完成!并在撰写程序的过程中,来练习 TypeScript 编程语言基础的程序语法,以及针对 Node.js 和网页浏览器这两个不一样的运行环境来撰写程序。这支小程序在运行之后,将会先从 1 到 100 的整数中,随机抽取一个数字作为答案,并且允许用户输入要猜的数字,如果答错了,程序会回答用户输入的数字究竟是大于答案,还是小于答案,并持续让用户继续猜下去;如果答对了,程序会出现用户赢了的消息,并且结束程序。
创建新的 TypeScript 项目
我们依然先不要使用 npm,用最单纯的方式完成这个项目。首先,创建一个用来存放 TypeScript 项目的目录 guessing-game。
开始撰写代码
接着在项目目录中创建一个纯文字文件,文件名取为 index.ts。
然后用文字编辑器打开 index.ts,加入以下程序,目的是要让程序在屏幕上秀出 Guess the number! 这几个字。
function showMessage(text: string): void {
if (typeof window === "object") {
alert(text);
} else {
console.log(text);
}
}
showMessage("Guess the number!");
以上的 showMessage 函数主体中,我们利用由 if 和 else 关键字组成的条件判断语法。if 关键字后必须要接上一对小括号 (),括号中间必须要放入一个表达式。当这个表达式的值并非 undefined、null、false(类型名称为 boolean)、0(类型名称为 number)、NaN(类型名称为 number)或 ""(类型名称为 string)时,这个小括号 () 后由大括号 {} 组成的程序区块(block)就会被运行,而不会去运行 else 关键字后的程序区块。反之,当 if 关键字后的小括号 () 中的表达式若为上述的值,就会去运行 else 关键字后的程序区块。
在这边,我们利用 typeof 关键字来取得 window 这个变量的类型。typeof 关键字后可以接上一个表达式,它会判断这个表达式的回传值,并且会传回一个字符串,其可能的值如下:
undefined:表示表达式回传值为undefined,或表达式为一个未声明的变量。object:表示表达式回传值的类型为object,或表达式回传值为null。boolean:表示表达式回传值的类型为boolean。number:表示表达式回传值的类型为number。bigint:表示表达式回传值的类型为bigint。string:表示表达式回传值的类型为string。symbol:表示表达式回传值的类型为symbol。function:表示表达式回传值的类型为Function。
这边还有一个观念要先提及,那就是 JavaScript 中没有被声明的变量,在非使用 typeof 关键字的情况下是无法直接被使用的,运行时会有错误发生。而若在 TypeScript 中使用未声明的变量,更是无论有没有用 typeof 关键字都会在编译阶段时就被检查出来。但是在以上程序中,我们并没有去声明 window 变量就直接用了,这是因为 window 以及其下预设的属性,和 JavaScript 内置的对象(如 Math、Date、RegExp 等)与函数(如 parseInt、isNaN 等)属于例外的状况,可以直接被用在 TypeScript 代码中并成功通过编译。
网页浏览器都会有 window 这个对象,所以我们可以借由判断 window 变量的值的类型是否是 object(利用 === 操作符来判断),来侦测运行这个 JavaScript 程序的环境是否为网页浏览器。若是,就直接使用 window 对象的 alert 方法来让网页浏览器跳出文字消息方块;若否,我们就假设环境是 Node.js,并用 window 对象下的 console 对象提供的 log 方法来在终端机画面上印出文字消息。
等等!为什么我们可以假设明明没有定义 window 对象的 Node.js 也去用 window 对象下的属性?虽然我们可以在网页浏览器和 Node.js 下直接使用 console 对象,但前者的 console 对象在 window 这个对象下,而后者的 console 对象在 global 这个对象下。在使用 window 和 global 这两个对象下的属性时,window 和 global 这两个对象名称都可以省略不写,因为网页浏览器预设就会把没有声明出来的名称当作是 window 这个对象下的属性,而 Node.js 则会当作是 global 这个对象下的属性。
所以,以下这行 TypeScript/JavaScript 程序,在 Node.js 中可以运行:
global.console.log("Hello world!");
但是若将以上这进程式码交给 tsc 来编译的话,就会编译失败,因为 global 在 TypeScript 程序中并没有被声明!
所以我们将以上这进程式写成:
console.log("Hello world!");
如此一来,尽管 tsc 以为这个 console 是在 window 之下的属性,而不会去要求 console 要声明才能编译,但是当把这进程式码交给 Node.js 来运行时,在 Node.js 实际看来,它就是 global 这对象下的 console 属性。所以这样的写法除了可以通过 tsc 的编译之外,还能够正常地在网页浏览器和 Node.js 的环境中使用。当然,TypeScript 也不是不能支持 Node.js 环境内置的对象,这部份会在之后的章节做介绍。
接下来介绍产生一个 1 到 100 随机整数的方式。
function showMessage(text: string): void {
if (typeof window === "object") {
alert(text);
} else {
console.log(text);
}
}
showMessage("Guess the number!");
let secretNumber: number = Math.floor((Math.random() * 100) + 1);
来看一下我们添加的第 11 行叙述。let 这个关键字可以声明(创建)变量,例如:
let foo = bar;
这进程式可以声明出一个变量 foo,并且让它存放 bar 这个值(value)。在变量名称的后面,可以再使用一个冒号 : 来连接一个类型名称,以限制这个变量所能保存的值的类型。如果不使用冒号,则会使用在声明时设置的初始值的类型作为这个变量的类型。
例如:
let n: number = 1;
let s: string = "Hi";
let a = 123;
一个 let 关键字可以声明多个变量,用逗号 , 隔开即可。例如:
let n: number = 1, s: string = "Hi", a = 123;
接下来我们来看一下 Math.floor((Math.random() * 100) + 1) 到底是什么意思吧!JavaScript 内置了 Math 对象,这个对象提供了许多与数学计算有关的方法。其中,floor 可以用来将传入的数值舍弃掉小数点后的位数后再回传出来。random 则是可以随机回传大于等于 0 且小于 1 的数值。
为了要取得一个 1 到 100 随机整数,我们要先把 Math.random() 的回传值再乘上 100,使其范围扩充为大于等于 0 且小于 100 的数值。接着再将这个数值加一,使其范围变成大于等于 1 且小于 101 的数值。最后再取这个数值的整数部份,也就会得到大于等于 1,且小于等于 100 的数值啦!
我们可以将这个随机产生出来的数值再利用前面介绍过的「模板定数」语法和 showMessage 这个函数,输出到屏幕上。程序如下:
function showMessage(text: string): void {
if (typeof window === "object") {
alert(text);
} else {
console.log(text);
}
}
showMessage("Guess the number!");
let secretNumber: number = Math.floor((Math.random() * 100) + 1);
showMessage(`The secret number is: ${secretNumber}`);
再来要稍微修正一下我们目前程序有的问题。由于这个程序会调用两次以上的 showMessage 函数,所以 showMessage 函数主体内的 typeof window === 'object' 表达式也会被计算很多次,这个是很没有意义的。利用刚才学到的 let 关键字,我们可以再声明一个变量来保存 typeof window === 'object' 表达式的计算结果。程序可以修改如下:
let isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
showMessage("Guess the number!");
let secretNumber: number = Math.floor((Math.random() * 100) + 1);
showMessage(`The secret number is: ${secretNumber}`);
由于 isBrowser 和 secretNumber 变量在被赋值之后就不会被改变,因此我们也可以将 let 关键字改为 const 关键字,使它们变成常数。程序再修改如下:
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
showMessage("Guess the number!");
const secretNumber: number = Math.floor((Math.random() * 100) + 1);
showMessage(`The secret number is: ${secretNumber}`);
接下来要来撰写让用户输入他们要猜的数字的程序,由于这部份网页浏览器和 Node.js 的作法不一样,因此我们在 showMessage 函数下方再加上一个函数,如下:
const isBrowser: boolean = typeof window === 'object';
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
function showMessageAndInputText(text: string): string {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
showMessage('Guess the number!');
const secretNumber: number = Math.floor(Math.random() * 100 + 1);
showMessage(`The secret number is: ${secretNumber}`);
这个新加入的 showMessageAndInputText 函数有点复杂,它可以传入一个字符串来提示用户要输入什么样的数据,然后回传用户输入的字符串。如果 JavaScript 的运行环境是网页浏览器,那么只要使用 window 对象提供的 prompt 方法来让网页浏览器跳出文字输入方块就好了。但如果 JavaScript 的运行环境是 Node.js,我们就需要从标准输入(stdin)中读取用户输入的数据。
Node.js 内置 readline 这个模块,可以用来读取 Readable 串流中的数据,此处就是用它来读取标准输入串流的数据。我们可以利用 Node.js 内置的 require 函数来加载指定的模块,要加载 Node.js 内置的模块,最好在模块名称再加上 node: 前缀,才不会和外面的模块混淆。
程序第 19 行,利用 readline 的 createInterface 方法来创建 readline 模块底下的 Interface 这个对象的实体。并且用大括号 {} 语法直接创建一个对象,作为参数传给 createInterface 方法。这个用大括号 {} 创建出来的对象,有一个 input 字段,它可以用来设置 Interface 这个对象要读取的 Readable 串流对象,而 Node.js 内置的 process.stdin 就是标准输入的串流对象。
程序第 21 到第 23 行,利用了 new 关键字来创建 Promise<string> 这个对象的实体(由小于 < 和大于 > 符号括起来的部份称为「泛型」,之后的章节会再介绍)。在构造器参数的部份需要传入一个函数,此处使用 ES6 加入的 Lambda 语法来定义匿名函数,可以省下撰写 function 关键字的麻烦。有关匿名函数和 Lambda 语法会在之后的章节做比较详细的介绍。总之在此处,创建了一个参数为 resolve 的函数,在这个函数的主体中,调用了 Interface 对象的 on 方法,用来异步地监听 line 这个事件。当 Interface 对象从输入串流读取到一行数据时,就会随时触发 on 方法第二个参数传入的函数,这个函数的第一个参数,就保存着该行 Interface 对象读取到的数据。
传入 Promise 构造器的函数所用的 resolve 参数,它其实是一个函数,可以用来包裹某个值,作为回传的「正确值」。所以在程序第 22 行,我们用了 resolve 函数来包裹 line 参数的值,作为这个 Promise 对象所回传的「正确值」。
之所以把程序写得那么复杂,是因为 readline 模块只有提供异步的 API 来读取 Readable 串流中的数据,我们需要依靠 ES6 提供的 Promise 对象将异步的 API 包裹起来,再利用 ES2017 之后才有的「async/await」语法达成同步。有关于 Promise 和「async/await」语法,之后的章节会再详细介绍。
程序第 25 行,利用 await 关键字来等候传入 Promise 对象构造器的函数的 resolve 函数被调用,并取得被 resolve 函数包裹的值。
程序第 27 行,调用 Interface 对象的 close 方法来关闭它,如果此处没有关闭的话会造成一些不正常的状态。
此时若使用 tsc index.ts 指令来编译程序,会遇到几个大问题。
首先就是 TypeScript 并不认识 Node.js 内置的 require 函数和 process 对象,也不认识 ES6 后才被内置在 JavaScript 中的 Promise 对象(因为 TypeScript 的预设编译目标为 ES3)。
若要解决 require 函数和 process 对象的问题,可以利用 declare 关键字和 const,在 TypeScript 程序的最外层声明 require 和 process 这两个常数。如下:
declare const require;
declare const process;
...
TypeScript 提供的 declare 关键字可以使编译器知道某个不存在 TypeScript 代码中的名称是怎么样被声明的,让这些名称就算没有被真正声明出来也可以通过编译。
至于 Promise 对象的问题,现阶段我们可以替 tsc 指令加上 -t ES6 参数来解决。不过,此时使用 tsc index.ts -t ES6 指令来编译程序,也还是会编译失败。
这是因为 await 关键字必须要用在有用 async 关键字的函数中,于是我们要将程序修改如下:
declare const require;
declare const process;
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
async function showMessageAndInputText(text: string): string {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
showMessage("Guess the number!");
const secretNumber: number = Math.floor((Math.random() * 100) + 1);
showMessage(`The secret number is: ${secretNumber}`);
再次使用 tsc index.ts -t ES6 指令来编译程序,还是会编译失败。这是因为有用 async 关键字的函数,其回传值类型必须要是 Promise<T>,这边的 T 可以换成任意类型名称。根据程序逻辑,我们的 showMessageAndInputText 函数的回传值类型应为 Promise<string>。
declare const require;
declare const process;
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
async function showMessageAndInputText(text: string): Promise<string> {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
showMessage("Guess the number!");
const secretNumber: number = Math.floor((Math.random() * 100) + 1);
showMessage(`The secret number is: ${secretNumber}`);
再次使用 tsc index.ts -t ES6 指令来编译程序,就可以编译成功了!
既然 showMessageAndInputText 函数已经实作完成了,那就开始用它吧!由于 showMessageAndInputText 函数是回传 Promise<string> 对象,因此我们就如同程序第 28 行那样,用 await 关键字来取得 Promise 对象所回传的「正确值」。
程序撰写如下:
declare const require;
declare const process;
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
async function showMessageAndInputText(text: string): Promise<string> {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
showMessage("Guess the number!");
const secretNumber: number = Math.floor((Math.random() * 100) + 1);
showMessage(`The secret number is: ${secretNumber}`);
const line: string = await showMessageAndInputText("Please input your guess.");
再次使用 tsc index.ts -t ES6 指令来编译程序,程序又编译失败了。这依然是因为 await 关键字必须要用在有用 async 关键字的函数中,于是我们要将程序修改如下:
declare const require;
declare const process;
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
async function showMessageAndInputText(text: string): Promise<string> {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
async function main(): Promise<void> {
showMessage("Guess the number!");
const secretNumber: number = Math.floor(Math.random() * 100 + 1);
showMessage(`The secret number is: ${secretNumber}`);
const line: string = await showMessageAndInputText("Please input your guess.");
}
main();
我们实作了一个使用了 async 关键字的 main 函数来作为程序进入点,如此一来就可以在其中随意地使用 await 关键字。
能够正常读取用户输入的数据后,就可以继续实作接下来的程序了!
首先要把 showMessageAndInputText 函数回传的字符串尝试转成整数数值,如果不能转换的话,就出现提示;如果可以转换的话,就输出用户输入的数值,并判断用户输入的数值比答案大还是小,或者是一模一样,来输出不同的消息。
declare const require;
declare const process;
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
async function showMessageAndInputText(text: string): Promise<string> {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
async function main(): Promise<void> {
showMessage("Guess the number!");
const secretNumber: number = Math.floor(Math.random() * 100 + 1);
showMessage(`The secret number is: ${secretNumber}`);
const line: string = await showMessageAndInputText("Please input your guess.");
const guess: number = parseInt(line);
if (isNaN(guess)) {
showMessage("Please type a number!");
} else {
showMessage(`You guessed: ${guess}`);
if (guess < secretNumber) {
showMessage("Too small!");
} else if (guess > secretNumber) {
showMessage("Too big!");
} else {
showMessage("You win!");
}
}
}
main();
JavaScript 内置的 parseInt 函数可以用来将传入参数的字符串转成整数数值,如果转换失败的话,它会回传 NaN (not a number),这个值也是属于 number 类型。而 JavaScript 内置的 isNaN 函数,可以用来判断传入参数的数值是否为 NaN。
再来,我们要想办法让用户在猜错或是输入错误之后,还能够依照提示继续猜下去,而不是直接结束程序,因此我们会需要用到 while 关键字来创建程序循环。将程序改写如下:
declare const require;
declare const process;
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
async function showMessageAndInputText(text: string): Promise<string> {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
async function main(): Promise<void> {
showMessage("Guess the number!");
const secretNumber: number = Math.floor(Math.random() * 100 + 1);
showMessage(`The secret number is: ${secretNumber}`);
while (true) {
const line: string = await showMessageAndInputText("Please input your guess.");
const guess: number = parseInt(line);
if (isNaN(guess)) {
showMessage("Please type a number!");
} else {
showMessage(`You guessed: ${guess}`);
if (guess < secretNumber) {
showMessage("Too small!");
} else if (guess > secretNumber) {
showMessage("Too big!");
} else {
showMessage("You win!");
}
}
}
}
main();
程序第 43 行和第 61 行,我们利用 while 关键字将让用户输入文字并显示猜测结果的程序包成了一个区块,while 关键字所形成的循环会根据 while 关键字后面小括号 () 内的表达式来决定要不要继续运行,条件判断规则和 if 关键字是一样的。因为此处提供给 while 关键字的表达式为 true,所以程序如果未在这个区块运行到 break 或是 return 叙述,就会不断地重复运行这个区块内的叙述。为了能够让用户在猜对数字之后结束程序,我们需要再将程序进行改写,如下:
declare const require;
declare const process;
const isBrowser: boolean = typeof window === "object";
function showMessage(text: string): void {
if (isBrowser) {
alert(text);
} else {
console.log(text);
}
}
async function showMessageAndInputText(text: string): Promise<string> {
if (isBrowser) {
return prompt(text);
} else {
console.log(text);
const readline = require("node:readline");
const rl = readline.createInterface({ input: process.stdin });
const lineResolver: Promise<string> = new Promise<string>(resolve => {
rl.on("line", line => resolve(line));
});
const line: string = await lineResolver;
rl.close();
return line;
}
}
async function main(): Promise<void> {
showMessage("Guess the number!");
const secretNumber: number = Math.floor(Math.random() * 100 + 1);
showMessage(`The secret number is: ${secretNumber}`);
while (true) {
const line: string = await showMessageAndInputText("Please input your guess.");
const guess: number = parseInt(line);
if (isNaN(guess)) {
showMessage("Please type a number!");
} else {
showMessage(`You guessed: ${guess}`);
if (guess < secretNumber) {
showMessage("Too small!");
} else if (guess > secretNumber) {
showMessage("Too big!");
} else {
showMessage("You win!");
break;
}
}
}
}
main();
和其他大多数的编程语言一样,TypeScript 编程语言循环中的 break 叙述是用来跳出循环;continue 叙述是用来跳过这次循环的运行,直接进入下一次。若此处将程序第 59 进程式改为 return 叙述也是可以的。
至此,我们已经差不多完成了这个猜数字程序了。可以用 tsc index.ts -t ES6 指令编译程序后,再用 node index.js 指令玩个几次试试。
tsc 编译时引用的函数库(Library)
即便 2016 年后的主流网页浏览器都有支持 ES6,但如果想要降版本到 ES5 并且还能够使用 Promise 对象也是可行的,毕竟 Promise 在早期(2014 年)就已被各大主流网页浏览器支持了(但 Promise 在 Internet Explorer 没办法直接用,不过现在也没有什么人在用 IE 了,无所谓)。
所以虽然 tsc 预设的编译目标是 ES3,我们还是可以还算安全地将其提升到 ES5,并且加上一些 ES6 才有添加,但是在早期就有被支持的功能。
替 tsc 指令加上 --lib 参数,可以设置 tsc 编译时要引用的函数库。当编译目标设为 ES5 时,预设会激活的函数库为 dom,es5,scripthost。若要再加上 Promise 对象的支持,可以再加上 es2015.promise 和 es2015.iterable 这两个函数库。
例如要编译 index.ts 文件并将其输出成 ES5 且支持 Promise 的版本,指令如下:
实务上,若我们的 TypeScript 程序只会运行在 Node.js 环境时,编译目标可以设置为 ES2018,现行的 LTS 版本的 Node.js 都能支持。而如果要让它运行在网页浏览器上,我们通常还是会透过 Webpack+Babel 等集成转译的 JS 工具来输出 JS 文件,在这个情况下将 TypeScript 的编译目标设置为 ESNEXT(最新版本的 JavaScript/ECMAScript),再用集成工具去进行降版转译会是比较好的作法。
在网页浏览器上运行猜数字程序
在我们的猜数字程序的项目根目录下添加 index.html 文件,加上以下内容:
<html>
<head>
<meta charset="utf-8"/>
</head>
<body>
<script src="./index.js"></script>
</body>
</html>
接着再用网页浏览器打开这个 index.html 文件即可。
总结
在这一章中,我们成功地完成了猜数字程序,已经用过了 let、const、declare、if、while、typeof、new、async、await 等基本的关键字,稍微接触了 JavaScript 内置的对象和函数,以及网页浏览器和 Node.js 环境特有的对象与函数。
此外,由于多次的编译失败,使我们对于 JavaScript 的版本和环境差异也有更深入的了解。在下一章节中,我们还是要继续开发这个猜数字程序,不过这回我们会用 npm 创建 Node.js 项目来完成。



