fix some typesetting (#45)

* fix some typesetting

* fix

docs/documentation/zh/handbook-v2/Basics.md

@@ -2,7 +2,7 @@
 title: 基础
 layout: docs
 permalink: /zh/docs/handbook/2/basic-types.html
-oneline: "学习 TypeScript 的第一步：基本类型。"
+oneline: "学习 TypeScript 的第一步：基本类型"
 preamble: >
   <p>欢迎来到手册的第一页。如果这是你第一次接触到 TypeScript，你可能需要先阅读一下'<a href='/zh/docs/handbook/intro.html#get-started'>入门</a>'指南</p>
 ---

docs/documentation/zh/handbook-v2/Modules.md

@@ -2,14 +2,14 @@
 title: 模块
 layout: docs
 permalink: /zh/docs/handbook/2/modules.html
-oneline: "JavaScript 处理跨文件通信的方式。"
+oneline: "JavaScript 处理跨文件通信的方式"
 ---
 
 JavaScript 历来具有多种处理代码模块化的方式。TypeScript 自 2012 年问世以来，已经实现了对这其中很多格式的支持。但随着时间的推移，社区和 JavaScript 规范已经趋于使用一种称为 ES 模块（或 ES6 模块）的格式。它使用的是 `import`/`export` 语法。
 
 ES 模块在 2015 年被添加到 JavaScript 规范中，并且截至 2020 年已经在大多数 Web 浏览器和 JavaScript 运行时中得到广泛支持。
 
-本手册将重点介绍 ES 模块及其流行的前身 CommonJS `module.exports =` 语法，你可以在参考部分的 [模块](/docs/handbook/modules.html) 下找到其他模块模式的信息。
+本手册将重点介绍 ES 模块及其流行的前身 CommonJS `module.exports =` 语法，你可以在参考部分的[模块](/docs/handbook/modules.html)下找到其他模块模式的信息。
 
 ## JavaScript 模块的定义方式
 
@@ -198,7 +198,7 @@ TypeScript 通过两个用来声明类型导入的概念，扩展了 `import` 
 
 ###### `import type`
 
-这是一个_仅_能导入类型的导入语句：
+这是一个*仅*能导入类型的导入语句：
 
 ```ts twoslash
 // @filename: animal.ts
@@ -237,7 +237,7 @@ const name = createCatName();
 
 #### 具有 CommonJS 行为的 ES 模块语法
 
-TypeScript 具有 ES 模块语法，它与 CommonJS 和 AMD 的 `require` _直接_对应。使用 ES 模块进行导入在大多数情况下与这些环境中的 `require` 相同，但是此语法确保你的 TypeScript 文件与 CommonJS 输出保持一对一的匹配：
+TypeScript 具有 ES 模块语法，它与 CommonJS 和 AMD 的 `require` *直接*对应。使用 ES 模块进行导入在大多数情况下与这些环境中的 `require` 相同，但是此语法确保你的 TypeScript 文件与 CommonJS 输出保持一对一的匹配：
 
 ```ts twoslash
 /// <reference types="node" />
@@ -247,7 +247,7 @@ import fs = require("fs");
 const code = fs.readFileSync("hello.ts", "utf8");
 ```
 
-你可以在 [模块参考页面](/docs/handbook/modules.html#export--and-import--require) 了解更多关于此语法的信息。
+你可以在[模块参考页面](/docs/handbook/modules.html#export--and-import--require)了解更多关于此语法的信息。
 
 ## CommonJS 语法
 
@@ -333,7 +333,7 @@ TypeScript 包括两种解析策略：经典解析和 Node 解析。经典解析
 
 有许多 TSConfig 标志会影响 TypeScript 内部的模块策略，包括 [`moduleResolution`](/tsconfig#moduleResolution)、[`baseUrl`](/tsconfig#baseUrl)、[`paths`](/tsconfig#paths) 和 [`rootDirs`](/tsconfig#rootDirs)。
 
-要了解这些策略的详细信息，可以参考 [模块解析](/docs/handbook/module-resolution.html)。
+要了解这些策略的详细信息，可以参考[模块解析](/docs/handbook/module-resolution.html)。
 
 ## TypeScript 的模块输出选项
 
@@ -393,7 +393,7 @@ export const twoPi = valueOfPi * 2;
 
 > 请注意，ES2020 在功能上与原始的 `index.ts` 相同。
 
-你可以在 [TSConfig 的 `module` 配置参考页面](/tsconfig#module) 中查看所有可用选项及其生成的 JavaScript 代码。
+你可以在 [TSConfig 的 `module` 配置参考页面](/tsconfig#module)中查看所有可用选项及其生成的 JavaScript 代码。
 
 ## TypeScript 命名空间
 

docs/documentation/zh/handbook-v2/More on Functions.md

@@ -2,14 +2,14 @@
 title: 函数进阶
 layout: docs
 permalink: /zh/docs/handbook/2/functions.html
-oneline: "学习 TypeScript 中函数的工作原理。"
+oneline: "学习 TypeScript 中函数的工作原理"
 ---
 
 函数是任何应用程序的基本构建块，它们可以是本地函数、从另一个模块导入的函数或者类的方法。它们也是值，并且与其他值一样，TypeScript 有很多方法来描述函数的调用方式。让我们来学习如何编写用于描述函数的类型。
 
 ## 函数类型表达式
 
-描述函数的最简单方式是使用_函数类型表达式_。这些类型在语法上类似于箭头函数：
+描述函数的最简单方式是使用*函数类型表达式*。这些类型在语法上类似于箭头函数：
 
 ```ts twoslash
 function greeter(fn: (a: string) => void) {
@@ -38,7 +38,7 @@ function greeter(fn: GreetFunction) {
 
 ## 调用签名
 
-在 JavaScript 中，函数除了可以被调用之外，还可以有其他属性。然而，函数类型表达式语法不允许声明属性。如果我们想描述带有属性的可调用对象，可以在其对象类型中编写一个_调用签名（call signature）_：
+在 JavaScript 中，函数除了可以被调用之外，还可以有其他属性。然而，函数类型表达式语法不允许声明属性。如果我们想描述带有属性的可调用对象，可以在其对象类型中编写一个*调用签名（call signature）*：
 
 ```ts twoslash
 type DescribableFunction = {
@@ -95,7 +95,7 @@ function firstElement(arr: any[]) {
 
 这个函数完成了它的工作，但不太好的是它的返回类型是 `any`。如果函数返回数组元素的类型会更好。
 
-在 TypeScript 中，当我们想要描述两个值之间的对应关系时，我们使用_泛型_。我们可以在函数签名中声明_类型参数_：
+在 TypeScript 中，当我们想要描述两个值之间的对应关系时，我们使用*泛型*。我们可以在函数签名中声明*类型参数*：
 
 ```ts twoslash
 function firstElement<Type>(arr: Type[]): Type | undefined {
@@ -118,7 +118,7 @@ const u = firstElement([]);
 
 ### 类型推断
 
-请注意，在这个示例中我们不必指定 `Type`。TypeScript 会自动_推断_类型。
+请注意，在这个示例中我们不必指定 `Type`。TypeScript 会自动*推断*类型。
 
 我们也可以使用多个类型参数。例如，`map` 函数的独立版本如下：
 
@@ -137,9 +137,9 @@ const parsed = map(["1", "2", "3"], (n) => parseInt(n));
 
 ### 约束
 
-我们编写了一些泛型函数，可以适用于_任何_类型的值。有时候我们想要关联两个值，但只能对某个子集的类型的值进行操作。在这种情况下，我们可以使用_约束_来限制类型参数可以接受的类型的子集。
+我们编写了一些泛型函数，可以适用于*任何*类型的值。有时候我们想要关联两个值，但只能对某个子集的类型的值进行操作。在这种情况下，我们可以使用*约束*来限制类型参数可以接受的类型的子集。
 
-让我们编写一个返回两个值中较长的值的函数。为了做到这一点，我们需要值属于具有 `length` 属性的类型。我们通过编写 `extends` 子句将类型参数_约束_为该类型：
+让我们编写一个返回两个值中较长的值的函数。为了做到这一点，我们需要值属于具有 `length` 属性的类型。我们通过编写 `extends` 子句将类型参数*约束*为该类型：
 
 ```ts twoslash
 // @errors: 2345 2322
@@ -159,7 +159,7 @@ const longerString = longest("alice", "bob");
 const notOK = longest(10, 100);
 ```
 
-这个例子中有几个有趣的地方。我们允许 TypeScript _推断_ `longest` 的返回类型。返回类型推断也适用于泛型函数。
+这个例子中有几个有趣的地方。我们允许 TypeScript *推断* `longest` 的返回类型。返回类型推断也适用于泛型函数。
 
 由于我们将 `Type` 约束为 `{ length: number }`，我们可以访问 `a` 和 `b` 参数的 `.length` 属性。如果没有类型约束，我们将无法访问这些属性，因为这些值可能是没有 length 属性的其他类型。
 
@@ -185,7 +185,7 @@ function minimumLength<Type extends { length: number }>(
 }
 ```
 
-这个函数看起来可能没问题——`Type` 被约束为 `{ length: number }`，而函数要么返回 `Type` 类型的值，要么返回与该约束相匹配的值。问题在于该函数承诺返回与传入的对象_相同_类型的对象，而不仅仅是与约束匹配的_任意_对象。如果这段代码可以通过检查，那么你可以编写肯定不起作用的代码：
+这个函数看起来可能没问题——`Type` 被约束为 `{ length: number }`，而函数要么返回 `Type` 类型的值，要么返回与该约束相匹配的值。问题在于该函数承诺返回与传入的对象*相同*类型的对象，而不仅仅是与约束匹配的*任意*对象。如果这段代码可以通过检查，那么你可以编写肯定不起作用的代码：
 
 ```ts twoslash
 declare function minimumLength<Type extends { length: number }>(
@@ -270,7 +270,7 @@ function filter2<Type, Func extends (arg: Type) => boolean>(
 }
 ```
 
-我们创建了一个类型参数 `Func`，它_没有将任何两个值进行关联_。这总是一个警告信号，因为这意味着调用者想要指定类型参数时，必须手动为无关的类型参数指定额外的类型参数。`Func` 没有任何用处，只是让函数变得更难阅读和理解！
+我们创建了一个类型参数 `Func`，它*没有将任何两个值进行关联*。这总是一个警告信号，因为这意味着调用者想要指定类型参数时，必须手动为无关的类型参数指定额外的类型参数。`Func` 没有任何用处，只是让函数变得更难阅读和理解！
 
 > **规则**：使用尽可能少的类型参数。
 
@@ -294,7 +294,7 @@ function greet(s: string) {
 }
 ```
 
-记住，类型参数是用于_关联多个值的类型_。如果类型参数在函数签名中只被使用一次，它就没有在关联任何内容。这包括推断的返回类型；例如，如果 `Str` 是 `greet` 的推断返回类型的一部分，它将关联参数和返回类型，因此在写入的代码中只出现一次，但实际上使用了两次。
+记住，类型参数是用于*关联多个值的类型*。如果类型参数在函数签名中只被使用一次，它就没有在关联任何内容。这包括推断的返回类型；例如，如果 `Str` 是 `greet` 的推断返回类型的一部分，它将关联参数和返回类型，因此在写入的代码中只出现一次，但实际上使用了两次。
 
 > **规则**：如果一个类型参数只出现在一个位置，请仔细考虑是否真的需要它。
 
@@ -309,7 +309,7 @@ function f(n: number) {
 }
 ```
 
-我们可以在 TypeScript 中使用 `?` 将参数标记为_可选_：
+我们可以在 TypeScript 中使用 `?` 将参数标记为*可选*：
 
 ```ts twoslash
 function f(x?: number) {
@@ -321,7 +321,7 @@ f(10); // 可以
 
 尽管参数的类型被指定为 `number`，但是因为 JavaScript 中未指定的参数其值被当作 `undefined`，所以 `x` 参数实际上具有类型 `number | undefined`。
 
-你还可以提供参数的_默认值_：
+你还可以提供参数的*默认值*：
 
 ```ts twoslash
 function f(x = 10) {
@@ -365,7 +365,7 @@ myForEach([1, 2, 3], (a) => console.log(a));
 myForEach([1, 2, 3], (a, i) => console.log(a, i));
 ```
 
-然而，_实际上_这样的话 _`callback` 只可能会被传递一个参数_。换句话说，函数定义表示其实现可能如下所示：
+然而，*实际上*这样的话 *`callback` 只可能会被传递一个参数*。换句话说，函数定义表示其实现可能如下所示：
 
 ```ts twoslash
 // @errors: 2532 18048
@@ -394,13 +394,13 @@ myForEach([1, 2, 3], (a, i) => {
 
 在 JavaScript 中，如果你用比参数多的实参调用一个函数，多余的实参会被忽略。TypeScript 的行为也是一样的。参数较少（类型相同）的函数总是可以替代参数较多的函数。
 
-> **规则**：在编写回调函数的函数类型时，除非你打算在_调用_函数时不传递该参数，否则_永远不要_编写可选参数。
+> **规则**：在编写回调函数的函数类型时，除非你打算在*调用*函数时不传递该参数，否则*永远不要*编写可选参数。
 
 ## 函数重载
 
 某些 JavaScript 函数可以以不同数量或类型的实参进行调用。例如，你可以编写函数来创建 `Date` 对象，它既可以接受时间戳作为参数（一个实参），也可以接受月份/日期/年份作为参数（三个实参）。
 
-在 TypeScript 中，我们可以通过编写_重载签名_来指定可以以不同方式调用的函数。为此，我们先编写一些函数签名（通常是两个或更多），然后再编写函数的具体实现：
+在 TypeScript 中，我们可以通过编写*重载签名*来指定可以以不同方式调用的函数。为此，我们先编写一些函数签名（通常是两个或更多），然后再编写函数的具体实现：
 
 ```ts twoslash
 // @errors: 2575
@@ -418,9 +418,9 @@ const d2 = makeDate(5, 5, 5);
 const d3 = makeDate(1, 3);
 ```
 
-在这个示例中，我们编写了两个重载：一个接受一个参数，另一个接受三个参数。这两个签名被称为_重载签名_。
+在这个示例中，我们编写了两个重载：一个接受一个参数，另一个接受三个参数。这两个签名被称为*重载签名*。
 
-然后，我们编写了一个具体的函数实现，其签名与重载签名是兼容的。函数有一个_具体实现_签名，但这个签名不能直接调用。尽管我们在函数必需的参数后面写了两个可选参数，但它不能用两个参数调用！
+然后，我们编写了一个具体的函数实现，其签名与重载签名是兼容的。函数有一个*具体实现*签名，但这个签名不能直接调用。尽管我们在函数必需的参数后面写了两个可选参数，但它不能用两个参数调用！
 
 ### 重载签名和具体实现签名
 
@@ -438,10 +438,10 @@ fn();
 
 同样，函数体的签名在外部是“看”不到的。
 
-> 外部无法看到_具体实现_的签名。
-> 当编写重载函数时，你应该始终在函数实现之前编写_两个_或更多的签名。
+> 外部无法看到*具体实现*的签名。
+> 当编写重载函数时，你应该始终在函数实现之前编写*两个*或更多的签名。
 
-具体实现的签名也必须与重载签名_兼容_。例如，下面的函数存在错误，因为具体实现的签名与重载签名不匹配：
+具体实现的签名也必须与重载签名*兼容*。例如，下面的函数存在错误，因为具体实现的签名与重载签名不匹配：
 
 ```ts twoslash
 // @errors: 2394
@@ -475,7 +475,7 @@ function len(x: any) {
 }
 ```
 
-这个函数是无错误的；我们可以用字符串或数组调用它。然而，我们不能用可能是字符串_或_数组的值调用它，因为 TypeScript 只能解析函数调用为单个重载：
+这个函数是无错误的；我们可以用字符串或数组调用它。然而，我们不能用可能是字符串*或*数组的值调用它，因为 TypeScript 只能解析函数调用为单个重载：
 
 ```ts twoslash
 // @errors: 2769
@@ -572,15 +572,15 @@ function noop() {
 
 ### `object`
 
-特殊类型 `object` 指代任何非原始类型（`string`、`number`、`bigint`、`boolean`、`symbol`、`null` 或 `undefined`）的值。这与 _空对象类型_ `{ }` 不同，也不同于全局类型 `Object`。你可能永远不会使用 `Object`。
+特殊类型 `object` 指代任何非原始类型（`string`、`number`、`bigint`、`boolean`、`symbol`、`null` 或 `undefined`）的值。这与 *空对象类型* `{ }` 不同，也不同于全局类型 `Object`。你可能永远不会使用 `Object`。
 
 > `object` 不是 `Object`。请**总是**使用 `object`！
 
 需要注意的是，在 JavaScript 中，函数值也是对象：它们具有属性，在原型链中包含 `Object.prototype`，是 `instanceof Object`，可以对它们调用 `Object.keys` 等等。因此，在 TypeScript 中，函数类型被认为是 `object` 类型。
 
 ### `unknown`
 
-`unknown` 类型表示_任意_值。这与 `any` 类型类似，但更安全，因为无法对 `unknown` 值进行任何操作：
+`unknown` 类型表示*任意*值。这与 `any` 类型类似，但更安全，因为无法对 `unknown` 值进行任何操作：
 
 ```ts twoslash
 // @errors: 2571 18046
@@ -643,7 +643,7 @@ function doSomething(f: Function) {
 }
 ```
 
-这是一个_无类型的函数调用_，一般最好避免使用，因为它具有不安全的 `any` 返回类型。
+这是一个*无类型的函数调用*，一般最好避免使用，因为它具有不安全的 `any` 返回类型。
 
 如果你需要接受任意函数但不打算调用它，类型 `() => void` 通常更安全。
 
@@ -658,7 +658,7 @@ function doSomething(f: Function) {
 
 ### 剩余参数
 
-除了使用可选参数或重载来创建可以接受各种固定参数数量的函数之外，我们还可以使用_剩余参数_定义可以接受**不确定数量**实参的函数。
+除了使用可选参数或重载来创建可以接受各种固定参数数量的函数之外，我们还可以使用*剩余参数*定义可以接受**不确定数量**实参的函数。
 
 剩余参数位于其他参数之后，使用 `...` 语法：
 
@@ -674,7 +674,7 @@ const a = multiply(10, 1, 2, 3, 4);
 
 ### 剩余实参
 
-相反地，我们可以使用扩展语法从可迭代对象（例如数组）中_提供_可变数量的实参。例如，数组的 `push` 方法接受任意数量的实参：
+相反地，我们可以使用扩展语法从可迭代对象（例如数组）中*提供*可变数量的实参。例如，数组的 `push` 方法接受任意数量的实参：
 
 ```ts twoslash
 const arr1 = [1, 2, 3];
@@ -745,7 +745,7 @@ function sum({ a, b, c }: ABC) {
 
 对于返回类型为 `void` 的函数，它们可能会产生一些不寻常但是符合预期的行为。
 
-使用返回类型为 `void` 的上下文类型并**不会**强制函数**不**返回任何值。换句话说，当实现一个带有 `void` 返回类型的上下文函数类型（`type voidFunc = () => void`）时，它可以返回_任何_其他值，但是该返回值会被忽略。
+使用返回类型为 `void` 的上下文类型并**不会**强制函数**不**返回任何值。换句话说，当实现一个带有 `void` 返回类型的上下文函数类型（`type voidFunc = () => void`）时，它可以返回*任何*其他值，但是该返回值会被忽略。
 
 因此，以下 `() => void` 类型的实现是有效的：