From ed8175f631b16891628aefe2f8a4ab89a16277d4 Mon Sep 17 00:00:00 2001
From: gaufung <gaufung@outlook.com>
Date: Fri, 18 Aug 2023 08:05:37 +0800
Subject: [PATCH 01/78] change .Net to .NET
---
docs/intro.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/intro.md b/docs/intro.md
index bb965c6..9771caf 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -175,7 +175,7 @@ TypeScript 依赖 JavaScript 生态，需要用到很多外部模块。但是，
当时，Windows 8 即将发布，它的应用程序开发除了使用 C# 和 Visual Basic，还可以使用 HTML + JavaScript。微软希望，TypeScript 既能让 JavaScript 程序员快速上手，也能让 .Net 程序员感到熟悉。
-这就是说，TypeScript 的最初动机是减少 .Net 程序员的转移和学习成本。所以，它的很多语法概念跟 .Net 很类似。
+这就是说，TypeScript 的最初动机是减少 .NET 程序员的转移和学习成本。所以，它的很多语法概念跟 .NET 很类似。
另外，TypeScript 是一个开源项目，接受社区的参与，核心的编译器采用 Apache 2.0 许可证。微软希望通过这种做法，迅速提高这门语言在社区的接受度。
From 04d1a723d161bf647eee41836d7d40d4d6f93ae7 Mon Sep 17 00:00:00 2001
From: gaufung <gaufung@outlook.com>
Date: Fri, 18 Aug 2023 08:07:05 +0800
Subject: [PATCH 02/78] fix more .Net
---
docs/intro.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/intro.md b/docs/intro.md
index 9771caf..75000e0 100644
--- a/docs/intro.md
+++ b/docs/intro.md
@@ -169,7 +169,7 @@ TypeScript 依赖 JavaScript 生态，需要用到很多外部模块。但是，
下面简要介绍 TypeScript 的发展历史。
-2012年，微软公司宣布推出 TypeScript 语言，设计者是著名的编程语言设计大师 Anders Hejlsberg，他也是 C# 和 .Net 的设计师。
+2012年，微软公司宣布推出 TypeScript 语言，设计者是著名的编程语言设计大师 Anders Hejlsberg，他也是 C# 和 .NET 的设计师。
微软推出这门语言的主要目的，是让 JavaScript 程序员可以参与 Windows 8 应用程序的开发。
From 20effd34b555876047d249a16ba0b5d4a8334d34 Mon Sep 17 00:00:00 2001
From: nocodeempire <tioy102@gmail.com>
Date: Fri, 18 Aug 2023 09:20:31 +0800
Subject: [PATCH 03/78] fix: typo
---
docs/generics.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/generics.md b/docs/generics.md
index 4c8ad87..06723a9 100644
--- a/docs/generics.md
+++ b/docs/generics.md
@@ -221,7 +221,7 @@ foo.add = function (x, y) {
};
```
-上面示例中，先新建类`C`的实例`foo`，然后再定义示例的`value`属性和`add()`方法。类的定义中，属性和方法后面的感叹号是非空断言，告诉 TypeScript 它们都是非空的，后面会赋值。
+上面示例中，先新建类`C`的实例`foo`，然后再定义实例的`value`属性和`add()`方法。类的定义中，属性和方法后面的感叹号是非空断言，告诉 TypeScript 它们都是非空的，后面会赋值。
JavaScript 的类本质上是一个构造函数，因此也可以把泛型类写成构造函数。
From e139724341ad8f5f3d02038b595bb724857fba85 Mon Sep 17 00:00:00 2001
From: nocodeempire <tioy102@gmail.com>
Date: Fri, 18 Aug 2023 10:05:30 +0800
Subject: [PATCH 04/78] fix: typo
---
docs/enum.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/enum.md b/docs/enum.md
index c1d471a..2c795de 100644
--- a/docs/enum.md
+++ b/docs/enum.md
@@ -32,7 +32,7 @@ enum Color {
}
```
-上面示例声明了一个 Enum 结构`Color`，里面包含三个成员`Red`、`Green`和`Blue`。第一个成员的值默认为整数`0`，第二个为`1`，第二个为`2`，以此类推。
+上面示例声明了一个 Enum 结构`Color`，里面包含三个成员`Red`、`Green`和`Blue`。第一个成员的值默认为整数`0`，第二个为`1`，第三个为`2`，以此类推。
使用时，调用 Enum 的某个成员，与调用对象属性的写法一样，可以使用点运算符，也可以使用方括号运算符。
From 8009d3b347e050ee0cc3950095f33e846fd0e8da Mon Sep 17 00:00:00 2001
From: chentong <chentong19950106@gmail.com>
Date: Fri, 18 Aug 2023 15:45:51 +0800
Subject: [PATCH 05/78] fix:typo
---
docs/enum.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/enum.md b/docs/enum.md
index c1d471a..a87414e 100644
--- a/docs/enum.md
+++ b/docs/enum.md
@@ -532,7 +532,7 @@ enum MyEnum {
B = 'b'
}
-// { a：any, b: any }
+// { a: any, b: any }
type Foo = { [key in MyEnum]: any };
```
From 2d904579e33b233f1371cd77d4382a7d49fe67db Mon Sep 17 00:00:00 2001
From: chentong <chentong19950106@gmail.com>
Date: Fri, 18 Aug 2023 15:47:53 +0800
Subject: [PATCH 06/78] fix:typo
---
docs/operator.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/operator.md b/docs/operator.md
index 2f35583..15e096a 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -312,7 +312,7 @@ type T = Obj[string];
这个语法对于数组也适用，可以使用`number`作为方括号的参数。
```typescript
-// MyArray 的类型是 { [key:number]：string }
+// MyArray 的类型是 { [key:number]: string }
const MyArray = ['a','b','c'];
// 等同于 (typeof MyArray)[number]
From 0f7f99d27e38a1b7f80fabce5d737a4079acc545 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 19 Aug 2023 00:46:07 +0800
Subject: [PATCH 07/78] docs(types): fix Symbol/BigInt #56
---
docs/types.md | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/docs/types.md b/docs/types.md
index dab6564..e8d63b7 100644
--- a/docs/types.md
+++ b/docs/types.md
@@ -238,12 +238,14 @@ Math.abs(n2) // 报错
上一小节说过，`Symbol()`和`BigInt()`这两个函数不能当作构造函数使用，所以没有办法直接获得 symbol 类型和 bigint 类型的包装对象，除非使用下面的写法。但是，它们没有使用场景，因此`Symbol`和`BigInt`这两个类型虽然存在，但是完全没有使用的理由。
```typescript
-let a:Symbol = Object(Symbol());
-let b:BigInt = Object(BigInt());
+let a = Object(Symbol());
+let b = Object(BigInt());
```
上面示例中，得到的就是 Symbol 和 BigInt 的包装对象，但是没有使用的意义。
+注意，目前在 TypeScript 里面，`symbol`和`Symbol`两种写法没有差异，`bigint`和`BigInt`也是如此，不知道是否属于官方的疏忽。建议始终使用小写的`symbol`和`bigint`，不使用大写的`Symbol`和`BigInt`。
+
## Object 类型与 object 类型
TypeScript 的对象类型也有大写`Object`和小写`object`两种。
From 6bea4615cd2525dfd72052defaea3b417e4564e7 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 19 Aug 2023 08:10:21 +0800
Subject: [PATCH 08/78] docs(object): fixed #58
---
docs/object.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/docs/object.md b/docs/object.md
index cc37590..05d1165 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -504,11 +504,11 @@ function draw({
只要对象 B 满足 对象 A 的结构特征，TypeScript 就认为对象 B 兼容对象 A 的类型，这称为“结构类型”原则（structural typing）。
```typescript
-const A = {
+type A = {
x: number;
};
-const B = {
+type B = {
x: number;
y: number;
};
From cdbbab46f370ad51a4eb70ee4340e1f9e19ee322 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 19 Aug 2023 14:54:05 +0800
Subject: [PATCH 09/78] docs(class): fixed #59
---
docs/class.md | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/docs/class.md b/docs/class.md
index 9d5f052..162a0e0 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1409,9 +1409,7 @@ class B extends A {
上面示例中，抽象类`A`定义了抽象属性`foo`，子类`B`必须实现这个属性，否则会报错。
-下面是抽象方法的例子。
-
-如果抽象类的属性前面加上`abstract`，就表明子类必须给出该方法的实现。
+下面是抽象方法的例子。如果抽象类的方法前面加上`abstract`，就表明子类必须给出该方法的实现。
```typescript
abstract class A {
From 77bfab0b4a18cbd25d51297b3e229b8b5f8aabaf Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 19 Aug 2023 15:43:03 +0800
Subject: [PATCH 10/78] docs(types): fixed #55
---
docs/types.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/types.md b/docs/types.md
index e8d63b7..dac280c 100644
--- a/docs/types.md
+++ b/docs/types.md
@@ -455,7 +455,7 @@ x = y; // 报错
y = x; // 正确
```
-上面示例中，变量`x`属于子类型，变量`y`属于父类型。`y`不能赋值为子类型`x`，但是反过来是可以的。
+上面示例中，变量`x`属于子类型，变量`y`属于父类型。子类型`x`不能赋值为父类型`y`，但是反过来是可以的。
如果一定要让子类型可以赋值为父类型的值，就要用到类型断言（详见《类型断言》一章）。
From eff43ce88935ea4ce283ce6c7106c84ff791af66 Mon Sep 17 00:00:00 2001
From: Ayaka <26200808+KiritaniAyaka@users.noreply.github.com>
Date: Sat, 19 Aug 2023 20:05:36 +0800
Subject: [PATCH 11/78] docs(class): add extra description for class and
interface merging
---
docs/class.md | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/docs/class.md b/docs/class.md
index 162a0e0..66e5da9 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -498,7 +498,7 @@ interface Swimmable {
### 类与接口的合并
-TypeScript 不允许两个同名的类，但是如果一个类和一个接口同名，那么接口会被合并进类。
+TypeScript 不允许两个同名的类，但是如果一个类和一个接口同名，那么接口会被合并进类。值得注意的是，合并进类的非空属性，在实际使用中可能为空。
```typescript
class A {
@@ -510,6 +510,8 @@ interface A {
}
let a = new A();
+a.y // undefined
+
a.y = 10;
a.x // 1
From a39a9547166627ead974f1130bbdb05097e394e1 Mon Sep 17 00:00:00 2001
From: biubiubiu999 <houshengaaa@gmail.com>
Date: Sat, 19 Aug 2023 23:58:34 +0800
Subject: [PATCH 12/78] fix:typo
---
docs/object.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/object.md b/docs/object.md
index 05d1165..8151363 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -713,7 +713,7 @@ const obj:Options = opts; // 报错
报错原因是，如果某个类型的所有属性都是可选的，那么该类型的对象必须至少存在一个可选属性，不能所有可选属性都不存在。这就叫做“最小可选属性规则”。
-如果想规避这条规则，要么在类型里面增加一条索性属性（`[propName: string]: someType`），要么使用类型断言（`opts as Options`）。
+如果想规避这条规则，要么在类型里面增加一条索引属性（`[propName: string]: someType`），要么使用类型断言（`opts as Options`）。
## 空对象
From 947d40e393a509275bb5e9e7364d02cbccb344b3 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 20 Aug 2023 17:23:24 +0800
Subject: [PATCH 13/78] docs(enum): fix enum overhaul
---
docs/enum.md | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git a/docs/enum.md b/docs/enum.md
index d0e101b..4f9ddf1 100644
--- a/docs/enum.md
+++ b/docs/enum.md
@@ -107,7 +107,7 @@ compute(Operator.ADD, 1, 3) // 4
上面示例中，Enum 结构`Operator`的四个成员表示四则运算“加减乘除”。代码根本不需要用到这四个成员的值，只用成员名就够了。
-Enum 作为类型有一个缺点，就是输入任何数值都不报错。
+[TypeScript 5.0](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-0.html#enum-overhaul) 之前，Enum 有一个 Bug，就是 Enum 类型的变量可以赋值为任何数值。
```typescript
enum Bool {
@@ -119,10 +119,10 @@ function foo(noYes:Bool) {
// ...
}
-foo(33); // 不报错
+foo(33); // TypeScript 5.0 之前不报错
```
-上面代码中，函数`foo`的参数`noYes`只有两个可用的值，但是输入任意数值，编译都不会报错。
+上面示例中，函数`foo`的参数`noYes`是 Enum 类型，只有两个可用的值。但是，TypeScript 5.0 之前，任何数值作为函数`foo`的参数，编译都不会报错，TypeScript 5.0 纠正了这个问题。
另外，由于 Enum 结构编译后是一个对象，所以不能有与它同名的变量（包括对象、函数、类等）。
From e0cd6ed70f6e85e14dfe4f981bb831219b28070b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 20 Aug 2023 18:45:38 +0800
Subject: [PATCH 14/78] docs(class): fix #60
---
docs/class.md | 21 ++++++++++++++++++---
1 file changed, 18 insertions(+), 3 deletions(-)
diff --git a/docs/class.md b/docs/class.md
index 66e5da9..c399e66 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -498,7 +498,7 @@ interface Swimmable {
### 类与接口的合并
-TypeScript 不允许两个同名的类，但是如果一个类和一个接口同名，那么接口会被合并进类。值得注意的是，合并进类的非空属性，在实际使用中可能为空。
+TypeScript 不允许两个同名的类，但是如果一个类和一个接口同名，那么接口会被合并进类。
```typescript
class A {
@@ -510,8 +510,6 @@ interface A {
}
let a = new A();
-a.y // undefined
-
a.y = 10;
a.x // 1
@@ -520,6 +518,23 @@ a.y // 10
上面示例中，类`A`与接口`A`同名，后者会被合并进前者的类型定义。
+注意，合并进类的非空属性（上例的`y`），如果在赋值之前读取，会返回`undefined`。
+
+```typescript
+class A {
+ x:number = 1;
+}
+
+interface A {
+ y:number;
+}
+
+let a = new A();
+a.y // undefined
+```
+
+上面示例中，根据类型定义，`y`应该是一个非空属性。但是合并后，`y`有可能是`undefined`。
+
## Class 类型
### 实例类型
From 885e90611899c5526a6a848246adbd981e0da173 Mon Sep 17 00:00:00 2001
From: VikydZhang <zwj_fhys@qq.com>
Date: Mon, 21 Aug 2023 15:46:58 +0800
Subject: [PATCH 15/78] Update interface.md
---
docs/interface.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/interface.md b/docs/interface.md
index cf2943f..223d143 100644
--- a/docs/interface.md
+++ b/docs/interface.md
@@ -516,7 +516,7 @@ s.area; // bigint | number
`interface`命令与`type`命令作用类似，都可以表示对象类型。
-很多对象类型即可以用 interface 表示，也可以用 type 表示。而且，两者往往可以换用，几乎所有的 interface 命令都可以改写为 type 命令。
+很多对象类型既可以用 interface 表示，也可以用 type 表示。而且，两者往往可以换用，几乎所有的 interface 命令都可以改写为 type 命令。
它们的相似之处，首先表现在都能为对象类型起名。
From ec0a6ded25fa874eac55d957846cfb1a997874ca Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 21 Aug 2023 23:26:48 +0800
Subject: [PATCH 16/78] docs(operator): fix keyof
---
docs/operator.md | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/docs/operator.md b/docs/operator.md
index 15e096a..b7c0d38 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -148,7 +148,8 @@ function prop(obj, key) {
```javascript
function prop(
- obj:object, key:string
+ obj: { [p:string]: any },
+ key: string
):any {
return obj[key];
}
From abcc074a2cad08661f87d02bd08b47e4a2cc2d74 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 21 Aug 2023 23:46:26 +0800
Subject: [PATCH 17/78] docs(mapping): fix typo
---
docs/mapping.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/mapping.md b/docs/mapping.md
index 8cf9bb2..91eec1f 100644
--- a/docs/mapping.md
+++ b/docs/mapping.md
@@ -342,7 +342,7 @@ type MyEvents<Events extends { kind: string }> = {
[E in Events as E['kind']]: (event: E) => void;
}
-type Config = MyEvent<S|C>;
+type Config = MyEvents<S|C>;
// 等同于
type Config = {
square: (event:S) => void;
From 5459b3c348f3faa6b2f95a27f9c3406b2376f29d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 22 Aug 2023 00:06:03 +0800
Subject: [PATCH 18/78] docs(types): fixed #64
---
docs/types.md | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
diff --git a/docs/types.md b/docs/types.md
index dac280c..c05c8d1 100644
--- a/docs/types.md
+++ b/docs/types.md
@@ -129,9 +129,11 @@ const x:null = null;
上面示例中，变量`x`就属于 null 类型。
-注意，如果没有声明类型的变量，被赋值为`undefined`或`null`，它们的类型会被推断为`any`。
+注意，如果没有声明类型的变量，被赋值为`undefined`或`null`，在关闭编译设置`noImplicitAny`和`strictNullChecks`时，它们的类型会被推断为`any`。
```typescript
+// 关闭 noImplicitAny 和 strictNullChecks
+
let a = undefined; // any
const b = undefined; // any
@@ -143,6 +145,7 @@ const d = null; // any
```typescript
// 打开编译设置 strictNullChecks
+
let a = undefined; // undefined
const b = undefined; // undefined
From 22ec0daf9539cc767bbf2886d2fb422d9e4109a4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 22 Aug 2023 00:21:58 +0800
Subject: [PATCH 19/78] docs(tsconfig.json): fix jsx
---
docs/tsconfig.json.md | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index 3f48c12..02a887a 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -347,11 +347,13 @@ obj.foo = undefined; // 报错
### jsx
-`jsx`设置如何处理`.tsx`文件。它一般以下三个值。
+`jsx`设置如何处理`.tsx`文件。它可以取以下五个值。
-- `preserve`：保持 jsx 语法不变，输出的文件名为 jsx。
+- `preserve`：保持 jsx 语法不变，输出的文件名为`.jsx`。
- `react`：将`<div />`编译成`React.createElement("div")`，输出的文件名为`.js`。
- `react-native`：保持 jsx 语法不变，输出的文件后缀名为`.js`。
+- `react-jsx`：将`<div />`编译成`_jsx("div")`，输出的文件名为`.js`。
+- `react-jsxdev`：跟`react-jsx`类似，但是为`_jsx()`加上更多的开发调试项，输出的文件名为`.js`。
```javascript
{
From 7a4164fabf9e39baac6be8b3623b7e4d7610c867 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 23 Aug 2023 09:39:02 +0800
Subject: [PATCH 20/78] docs(tuple): modify text
---
docs/tuple.md | 36 ++++++++++++++++++++++++++----------
1 file changed, 26 insertions(+), 10 deletions(-)
diff --git a/docs/tuple.md b/docs/tuple.md
index 8bff1d8..2f33475 100644
--- a/docs/tuple.md
+++ b/docs/tuple.md
@@ -4,7 +4,7 @@
元组（tuple）是 TypeScript 特有的数据类型，JavaScript 没有单独区分这种类型。它表示成员类型可以自由设置的数组，即数组的各个成员的类型可以不同。
-元组必须明确声明每个成员的类型。
+由于成员的类型可以不一样，所以元组必须明确声明每个成员的类型。
```typescript
const s:[string, string, boolean]
@@ -13,24 +13,26 @@ const s:[string, string, boolean]
上面示例中，元组`s`的前两个成员的类型是`string`，最后一个成员的类型是`boolean`。
-元组类型的写法，与上一章的数组有一个重大差异。数组的成员类型写在方括号外面（`number[]`），元组的成员类型是写在方括号里面（`[number]`）。
-
-TypeScript 的区分方法是，成员类型写在方括号里面的就是元组，写在外面的就是数组。
+元组类型的写法，与上一章的数组有一个重大差异。数组的成员类型写在方括号外面（`number[]`），元组的成员类型是写在方括号里面（`[number]`）。TypeScript 的区分方法就是，成员类型写在方括号里面的就是元组，写在外面的就是数组。
```typescript
-let a:[number] = [1];
+// 数组
+let a:number[] = [1];
+
+// 元组
+let t:[number] = [1];
```
-上面示例中，变量`a`是一个元组，只有一个成员，类型是`number`。
+上面示例中，变量`a`和`t`的值都是`[1]`，但是它们的类型是不一样的。`a`是一个数组，成员类型`number`写在方括号外面；`t`是一个元组，成员类型`number`写在方括号里面。
使用元组时，必须明确给出类型声明（上例的`[number]`），不能省略，否则 TypeScript 会把一个值自动推断为数组。
```typescript
-// a 的类型为 (number | boolean)[]
+// a 的类型被推断为 (number | boolean)[]
let a = [1, true];
```
-上面示例中，变量`a`的值其实是一个元组，但是 TypeScript 会将其推断为一个联合类型的数组，即`a`的类型为`(number | boolean)[]`。
+上面示例中，变量`a`的值其实是一个元组，但是 TypeScript 会将其推断为一个联合类型的数组，即`a`的类型为`(number | boolean)[]`。所以，元组必须显式给出类型声明。
元组成员的类型可以添加问号后缀（`?`），表示该成员是可选的。
@@ -77,7 +79,7 @@ const b:NamedNums = ['B', 1, 2, 3];
上面示例中，元组类型`NamedNums`的第一个成员是字符串，后面的成员使用扩展运算符来展开一个数组，从而实现了不定数量的成员。
-扩展运算符用在元组的任意位置都可以，但是它后面只能是数组或元组。
+扩展运算符（`...`）用在元组的任意位置都可以，它的后面只能是一个数组或元组。
```typescript
type t1 = [string, number, ...boolean[]];
@@ -85,7 +87,7 @@ type t2 = [string, ...boolean[], number];
type t3 = [...boolean[], string, number];
```
-上面示例中，扩展运算符分别在元组的尾部、中部和头部。
+上面示例中，扩展运算符分别在元组的尾部、中部和头部，`...`的后面是一个数组`boolean[]`。
如果不确定元组成员的类型和数量，可以写成下面这样。
@@ -95,6 +97,20 @@ type Tuple = [...any[]];
上面示例中，元组`Tuple`可以放置任意数量和类型的成员。但是这样写，也就失去了使用元组和 TypeScript 的意义。
+元组的成员可以添加成员名，这个成员名是说明性的，可以任意取名，没有实际作用。
+
+```typescript
+type Color = [
+ red: number,
+ green: number,
+ blue: number
+];
+
+const c:Color = [255, 255, 255];
+```
+
+上面示例中，类型`Color`是一个元组，它有三个成员。每个成员都有一个名字，写在具体类型的前面，使用冒号分隔。这几个名字可以随便取，没有实际作用，只是用来说明每个成员的含义。
+
元组可以通过方括号，读取成员类型。
```typescript
From 238fd3184a5c5c5680c7ac293d2dd7defe12444a Mon Sep 17 00:00:00 2001
From: nocodeempire <tioy102@gmail.com>
Date: Wed, 23 Aug 2023 10:14:44 +0800
Subject: [PATCH 21/78] fix: typo
---
docs/operator.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/operator.md b/docs/operator.md
index b7c0d38..edae897 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -376,7 +376,7 @@ type T2 = RegExp extends Animal ? number : string;
上面示例中，`Dog`是`Animal`的子类型，所以`T1`的类型是`number`。`RegExp`不是`Animal`的子类型，所以`T2`的类型是`string`。
-一般来说，调换`extends`两侧类型，会返回相反的结果。举例来说，有两个类`Dog`和`Animal`，前者是后者的子类型，那么`Cat extends Animal`就为真，而`Animal extends Cat`就为伪。
+一般来说，调换`extends`两侧类型，会返回相反的结果。举例来说，有两个类`Cat`和`Animal`，前者是后者的子类型，那么`Cat extends Animal`就为真，而`Animal extends Cat`就为伪。
如果需要判断的类型是一个联合类型，那么条件运算符会展开这个联合类型。
From 5a1467469fb065992eab30456a5627d39f6b0d54 Mon Sep 17 00:00:00 2001
From: nocodeempire <tioy102@gmail.com>
Date: Wed, 23 Aug 2023 14:22:14 +0800
Subject: [PATCH 22/78] fix: typo
---
docs/mapping.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/mapping.md b/docs/mapping.md
index 91eec1f..6a9d44d 100644
--- a/docs/mapping.md
+++ b/docs/mapping.md
@@ -39,7 +39,7 @@ type B = {
- `prop`：属性名变量，名字可以随便起。
- `in`：运算符，用来取出右侧的联合类型的每一个成员。
-- `Keyof A`：返回类型`A`的每一个属性名，组成一个联合类型。
+- `keyof A`：返回类型`A`的每一个属性名，组成一个联合类型。
下面是复制原始类型的例子。
From 0b265d2ca506a3f0b9c4324e72cd7df5e1073ab1 Mon Sep 17 00:00:00 2001
From: nocodeempire <tioy102@gmail.com>
Date: Wed, 23 Aug 2023 14:34:06 +0800
Subject: [PATCH 23/78] fix: typo
---
docs/mapping.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/mapping.md b/docs/mapping.md
index 6a9d44d..603ca9c 100644
--- a/docs/mapping.md
+++ b/docs/mapping.md
@@ -237,7 +237,7 @@ type A<T> = {
};
// 等同于
-type B<T> = {
+type A<T> = {
readonly [P in keyof T]?: T[P];
};
```
From 2e99e7459d2003fe8c25fd2b7eb940747e73b049 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 23 Aug 2023 15:39:31 +0800
Subject: [PATCH 24/78] docs(operator): add satisfies operator fixed #66
---
docs/operator.md | 70 ++++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 70 insertions(+)
diff --git a/docs/operator.md b/docs/operator.md
index b7c0d38..67edfa3 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -624,3 +624,73 @@ type V = `${T}${U}`;
上面示例中，`T`和`U`都是联合类型，各自有两个成员，模板字符串里面引用了这两个类型，最后得到的就是一个4个成员的联合类型。
+## satisfies 运算符
+
+`satisfies`运算符用来检测某个值是否符合指定类型。有时候，不方便将某个值指定为某种类型，但是希望这个值符合类型条件，这时候就可以用`satisfies`运算符对其进行检测。[TypeScript 4.9](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-9.html#the-satisfies-operator)添加了这个运算符。
+
+举例来说，有一个对象的属性名拼写错误。
+
+```typescript
+const palette = {
+ red: [255, 0, 0],
+ green: "#00ff00",
+ bleu: [0, 0, 255] // 属性名拼写错误
+};
+```
+
+上面示例中，对象`palette`的属性名拼写错了，将`blue`拼成了`bleu`，我们希望通过指定类型，发现这个错误。
+
+```typescript
+type Colors = "red" | "green" | "blue";
+type RGB = [number, number, number];
+
+const palette: Record<Colors, string|RGB> = {
+ red: [255, 0, 0],
+ green: "#00ff00",
+ bleu: [0, 0, 255] // 报错
+};
+```
+
+上面示例中，变量`palette`的类型被指定为`Record<Colors, string|RGB>`，这是一个类型工具，用来返回一个对象，详细介绍见《类型工具》一章。简单说，它的第一个类型参数指定对象的属性名，第二个类型参数指定对象的属性值。
+
+本例的`Record<Colors, string|RGB>`，就表示变量`palette`的属性名应该符合类型`Colors`，属性值应该符合类型`string|RGB`，要么是字符串，要么是元组`RGB`。属性名`bleu`不符合类型`Colors`，所以就报错了。
+
+这样的写法，虽然可以发现属性名的拼写错误，但是带来了新的问题。
+
+```typescript
+const greenComponent = palette.green.substring(1, 6); // 报错
+```
+
+上面示例中，`palette.green`属性调用`substring()`方法会报错，原因是这个方法只有字符串才有，而`palette.green`的类型是`srting|RGB`，除了字符串，还可能是元组`RGB`，而元组并不存在`substring()`方法，所以报错了。
+
+如果要避免报错，要么精确给出变量`palette`每个属性的类型，要么对`palette.green`的值进行类型缩小。两种做法都比较麻烦，也不是很有必要。
+
+这时就可以使用`statisfies`运算符，对`palette`进行类型检测，但是不改变 TypeScript 对`palette`的类型推断。
+
+```typescript
+type Colors = "red" | "green" | "blue";
+type RGB = [number, number, number];
+
+const palette = {
+ red: [255, 0, 0],
+ green: "#00ff00",
+ bleu: [0, 0, 255] // 报错
+} satisfies Record<Colors, string|RGB>;
+
+const greenComponent = palette.green.substring(1); // 不报错
+```
+
+上面示例中，变量`palette`的值后面增加了`satisfies Record<Colors, string|RGB>`，表示该值必须满足`Record<Colors, string|RGB>`这个条件，所以能够检测出属性名`bleu`的拼写错误。同时，它不会改变`palette`的类型推断，所以，TypeScript 知道`palette.green`是一个字符串，对其调用`substring()`方法就不会报错。
+
+`statisfies`也可以检测属性值。
+
+```typescript
+const palette = {
+ red: [255, 0, 0],
+ green: "#00ff00",
+ blue: [0, 0] // 报错
+} satisfies Record<Colors, string|RGB>;
+```
+
+上面示例中，属性`blue`的值只有两个成员，不符合元组`RGB`必须有三个成员的条件，从而报错了。
+
From a3ca89fcb25612385c4926f3b3d96702a7d4cf52 Mon Sep 17 00:00:00 2001
From: nocodeempire <tioy102@gmail.com>
Date: Wed, 23 Aug 2023 16:56:49 +0800
Subject: [PATCH 25/78] fix: typo
---
docs/operator.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/docs/operator.md b/docs/operator.md
index e7596a3..56fffdf 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -665,7 +665,7 @@ const greenComponent = palette.green.substring(1, 6); // 报错
如果要避免报错，要么精确给出变量`palette`每个属性的类型，要么对`palette.green`的值进行类型缩小。两种做法都比较麻烦，也不是很有必要。
-这时就可以使用`statisfies`运算符，对`palette`进行类型检测，但是不改变 TypeScript 对`palette`的类型推断。
+这时就可以使用`satisfies`运算符，对`palette`进行类型检测，但是不改变 TypeScript 对`palette`的类型推断。
```typescript
type Colors = "red" | "green" | "blue";
@@ -682,7 +682,7 @@ const greenComponent = palette.green.substring(1); // 不报错
上面示例中，变量`palette`的值后面增加了`satisfies Record<Colors, string|RGB>`，表示该值必须满足`Record<Colors, string|RGB>`这个条件，所以能够检测出属性名`bleu`的拼写错误。同时，它不会改变`palette`的类型推断，所以，TypeScript 知道`palette.green`是一个字符串，对其调用`substring()`方法就不会报错。
-`statisfies`也可以检测属性值。
+`satisfies`也可以检测属性值。
```typescript
const palette = {
From 7a31fb834909c0a711151b1c9110d0de531163c7 Mon Sep 17 00:00:00 2001
From: Jacky Song <savesong@hotmail.com>
Date: Fri, 25 Aug 2023 16:19:28 +0800
Subject: [PATCH 26/78] docs(basic): fix typo
---
docs/basic.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/basic.md b/docs/basic.md
index d86437f..4b943aa 100644
--- a/docs/basic.md
+++ b/docs/basic.md
@@ -69,7 +69,7 @@ function toString(num:number) {
上面示例中，函数`toString()`没有声明返回值的类型，但是 TypeScript 推断返回的是字符串。正是因为 TypeScript 的类型推断，所以函数返回值的类型通常是省略不写的。
-从这里可以看到，TypeScript 的设计思想是，类型声明是可选的，你可以加，也可以不加。即使不加类型声明，依然是有效的 TypeScript 代码，只是这时不能保证 TypeScript 会正确推断出类型。由于这个原因。所有 JavaScript 代码都是合法的 TypeScript 代码。
+从这里可以看到，TypeScript 的设计思想是，类型声明是可选的，你可以加，也可以不加。即使不加类型声明，依然是有效的 TypeScript 代码，只是这时不能保证 TypeScript 会正确推断出类型。由于这个原因，所有 JavaScript 代码都是合法的 TypeScript 代码。
这样设计还有一个好处，将以前的 JavaScript 项目改为 TypeScript 项目时，你可以逐步地为老代码添加类型，即使有些代码没有添加，也不会无法运行。
From 80afd4cf5c5d91fcdf5faa0e150063fc46855e00 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 26 Aug 2023 22:38:21 +0800
Subject: [PATCH 27/78] docs(function): modify never type
---
docs/function.md | 34 ++++++++++++++++++++++++++++++++--
1 file changed, 32 insertions(+), 2 deletions(-)
diff --git a/docs/function.md b/docs/function.md
index 48f456f..1d95ad5 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -546,7 +546,7 @@ function f():void {
}
```
-需要特别注意的是，如果变量、对象方法、函数参数的类型是 void 类型的函数，那么并不代表不能赋值为有返回值的函数。恰恰相反，该变量、对象方法和函数参数可以接受返回任意值的函数，这时并不会报错。
+需要特别注意的是，如果变量、对象方法、函数参数是一个返回值为 void 类型的函数，那么并不代表不能赋值为有返回值的函数。恰恰相反，该变量、对象方法和函数参数可以接受返回任意值的函数，这时并不会报错。
```typescript
type voidFunc = () => void;
@@ -556,7 +556,7 @@ const f:voidFunc = () => {
};
```
-上面示例中，变量`f`的类型是`voidFunc`，是一个没有返回值的函数类型。但是实际上，`f`的值是一个有返回值的函数（返回`123`），编译时不会报错。
+上面示例中，变量`f`的类型是`voidFunc`，是一个没有返回值的函数。但是实际上，`f`的值可以是一个有返回值的函数（返回`123`），编译时不会报错。
这是因为，这时 TypeScript 认为，这里的 void 类型只是表示该函数的返回值没有利用价值，或者说不应该使用该函数的返回值。只要不用到这里的返回值，就不会报错。
@@ -601,6 +601,16 @@ const f3 = function ():void {
上面示例中，函数字面量声明了返回`void`类型，这时只要有返回值（除了`undefined`和`null`）就会报错。
+函数的运行结果如果是抛错，也允许将返回值写成`void`。
+
+```typescript
+function throwErr():void {
+ throw new Error('something wrong');
+}
+```
+
+上面示例中，函数`throwErr()`会抛错，返回值类型写成`void`是允许的。
+
除了函数，其他变量声明为`void`类型没有多大意义，因为这时只能赋值为`undefined`或者`null`（假定没有打开`strictNullChecks`) 。
```typescript
@@ -636,6 +646,8 @@ function fail():Error {
上面示例中，函数`fail()`返回一个 Error 对象，所以返回值类型是 Error。
+另外，由于抛错的情况属于`never`类型或`void`类型，所以无法从返回值类型中获知，抛出的是哪一种错误。
+
（2）无限执行的函数。
```typescript
@@ -684,6 +696,24 @@ function f(
上面示例中，函数`f()`的参数`x`的类型为`string|undefined`。但是，`x`类型为`undefined`时，调用了`neverReturns()`。这个函数不会返回，因此 TypeScript 可以推断出，判断语句后面的那个`x`，类型一定是`string`。
+一个函数如果某些条件下有正常返回值，另一些条件下抛错，这时它的返回值类型可以省略`never`。
+
+```typescript
+function sometimesThrow():number {
+ if (Math.random() > 0.5) {
+ return 100;
+ }
+
+ throw new Error('Something went wrong');
+}
+
+const result = sometimesThrow();
+```
+
+上面示例中，函数`sometimesThrow()`的返回值其实是`number|never`，但是一般都写成`number`，包括最后一行的变量`result`的类型，也是被推断为`number`。
+
+原因是前面章节提到过，`never`是 TypeScript 的唯一一个底层类型，所有其他类型都包括了`never`。从集合论的角度看，`number|never`等同于`number`。这也提示我们，函数的返回值无论是什么类型，都可能包含了抛出错误的情况。
+
## 局部类型
函数内部允许声明其他类型，该类型只在函数内部有效，称为局部类型。
From 49850193149202c8c538b3df191fa1a65c310146 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 27 Aug 2023 00:14:14 +0800
Subject: [PATCH 28/78] docs(class): fix indexed property
---
docs/class.md | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git a/docs/class.md b/docs/class.md
index c399e66..7ad78d9 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -287,19 +287,19 @@ class MyClass {
}
```
-属性存取器等同于方法，也必须包括在属性索引里面。
+属性存取器视同属性。
```typescript
class MyClass {
[s:string]: boolean;
- get(s:string) { // 报错
- return this[s] as boolean;
+ get isInstance() {
+ return true;
}
}
```
-上面示例中，属性索引没有给出方法的类型，导致`get()`方法报错。正确的写法就是本节一开始的那个例子。
+上面示例中，属性`inInstance`的读取器虽然是一个函数方法，但是视同属性，所以属性索引虽然没有涉及方法类型，但是不会报错。
## 类的 interface 接口
From a56d4e1928df1e959a4267352000164ce23a2b6c Mon Sep 17 00:00:00 2001
From: 95cc <71340227+95cc@users.noreply.github.com>
Date: Sun, 27 Aug 2023 14:54:03 +0800
Subject: [PATCH 29/78] docs(tsconfig.json): fix typo
---
docs/tsconfig.json.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index 02a887a..7a86b4b 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -645,7 +645,7 @@ TypeScript 内置的类型描述文件，主要有以下一些，完整的清单
`strictBindCallApply`设置是否对函数的`call()`、`bind()`、`apply()`这三个方法进行类型检查。
-如果不打开`strictBindCallApply`编译选项，编译器不会对以三个方法进行类型检查，参数类型都是`any`，传入任何参数都不会产生编译错误。
+如果不打开`strictBindCallApply`编译选项，编译器不会对以上三个方法进行类型检查，参数类型都是`any`，传入任何参数都不会产生编译错误。
```typescript
function fn(x: string) {
From 0d4d9586cbaed64658de1a511b3a8c7dc6aff09c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 27 Aug 2023 20:10:31 +0800
Subject: [PATCH 30/78] docs(enum): fix typo
---
docs/enum.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/enum.md b/docs/enum.md
index 4f9ddf1..fed20c8 100644
--- a/docs/enum.md
+++ b/docs/enum.md
@@ -153,7 +153,7 @@ const Bar = {
C: 2,
} as const;
-if （x === Foo.A）{}
+if (x === Foo.A) {}
// 等同于
if (x === Bar.A) {}
```
From 2c46d5a72a95f133b341ff3bc6d91bf06e159f8d Mon Sep 17 00:00:00 2001
From: alex12306 <zxc5305138@126.com>
Date: Tue, 29 Aug 2023 13:27:55 +0800
Subject: [PATCH 31/78] =?UTF-8?q?docs(interface):=E9=94=99=E5=88=AB?=
=?UTF-8?q?=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
docs/interface.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/interface.md b/docs/interface.md
index 223d143..b6dd5bc 100644
--- a/docs/interface.md
+++ b/docs/interface.md
@@ -113,7 +113,7 @@ const obj:A = ['a', 'b', 'c'];
同样的，一个接口中最多只能定义一个数值索引。数值索引会约束所有名称为数值的属性。
-如果一个 interface 同时定义了字符串索引和数值索引，那么数值索性必须服从于字符串索引。因为在 JavaScript 中，数值属性名最终是自动转换成字符串属性名。
+如果一个 interface 同时定义了字符串索引和数值索引，那么数值索引必须服从于字符串索引。因为在 JavaScript 中，数值属性名最终是自动转换成字符串属性名。
```typescript
interface A {
From eb982513008d8cceb43c21ab616d4ba98731bfc0 Mon Sep 17 00:00:00 2001
From: thinkasany <480968828@qq.com>
Date: Wed, 30 Aug 2023 09:55:33 +0800
Subject: [PATCH 32/78] docs: perfect title
---
docs/es6.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/es6.md b/docs/es6.md
index 1229e84..c9acdf8 100644
--- a/docs/es6.md
+++ b/docs/es6.md
@@ -44,7 +44,7 @@ async function fn(): Promise<number> {
}
```
-## `Iterable<>`
+## `Iterable<T>`
对象只要部署了 Iterator 接口，就可以用`for...of`循环遍历。Generator 函数（生成器）返回的就是一个具有 Iterator 接口的对象。
From 2fdbc00d73f6b1bcd741d057b3e346007f170e4c Mon Sep 17 00:00:00 2001
From: alex12306 <zxc5305138@126.com>
Date: Wed, 30 Aug 2023 14:43:03 +0800
Subject: [PATCH 33/78] =?UTF-8?q?docs:=20=E8=AE=A2=E6=AD=A3=EF=BC=9A?=
=?UTF-8?q?=E7=AC=94=E8=AF=AF=E3=80=81=E5=85=A8=E8=A7=92=E5=88=86=E5=8F=B7?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
docs/mapping.md | 4 ++--
docs/utility.md | 2 +-
2 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/docs/mapping.md b/docs/mapping.md
index 603ca9c..ae1c0d7 100644
--- a/docs/mapping.md
+++ b/docs/mapping.md
@@ -113,7 +113,7 @@ type MyObj = {
上面示例中，`[p in string]`就是属性名索引形式`[p: string]`的映射写法。
-通过映射，可以某个对象的所有属性改成可选属性。
+通过映射，可以把某个对象的所有属性改成可选属性。
```typescript
type A = {
@@ -262,7 +262,7 @@ type B = {
type B = {
fooID: number;
barID: number;
-}；
+};
```
上面示例中，类型`B`是类型`A`的映射，但在映射时把属性名改掉了，在原始属性名后面加上了字符串`ID`。
diff --git a/docs/utility.md b/docs/utility.md
index 62bdd64..46c64a0 100644
--- a/docs/utility.md
+++ b/docs/utility.md
@@ -660,7 +660,7 @@ type ThisParameterType<T> =
T extends (
this: infer U,
...args: never
- ) => any ? U : unknown；
+ ) => any ? U : unknown;
```
## `ThisType<Type>`
From f78c771b24739092b08cc6c30887252064a01a58 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 31 Aug 2023 16:47:25 +0800
Subject: [PATCH 34/78] docs(module): fixed #76
---
docs/module.md | 8 --------
1 file changed, 8 deletions(-)
diff --git a/docs/module.md b/docs/module.md
index ea6cc32..622f223 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -56,14 +56,6 @@ $ tsc b.ts
上面命令发现`b.ts`依赖`a.ts`，就会自动寻找`a.ts`，也将其同时编译，因此编译产物还是`a.js`和`b.js`两个文件。
-如果想将`a.ts`和`b.ts`编译成一个文件，可以使用`--outFile`参数。
-
-```typescript
-$ tsc --outFile result.js b.ts
-```
-
-上面示例将`a.ts`和`b.ts`合并编译为`result.js`。
-
## import type 语句
import 在一条语句中，可以同时输入类型和正常接口。
From 2b97ba6959d2ede2aa239a9cdc0f78410781043c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Fri, 1 Sep 2023 22:08:25 +0800
Subject: [PATCH 35/78] chore: modify chapter title
---
chapters.yml | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/chapters.yml b/chapters.yml
index 14a2ffe..b1c1825 100644
--- a/chapters.yml
+++ b/chapters.yml
@@ -18,7 +18,7 @@
- decorator-legacy.md: 装饰器（旧语法）
- declare.md: declare 关键字
- d.ts.md: d.ts 类型声明文件
-- operator.md: 运算符
+- operator.md: 类型运算符
- mapping.md: 类型映射
- utility.md: 类型工具
- comment.md: 注释指令
From 663f3bfa049c45755427a4c62115544adedb528e Mon Sep 17 00:00:00 2001
From: thinkasany <480968828@qq.com>
Date: Sat, 2 Sep 2023 15:37:46 +0800
Subject: [PATCH 36/78] docs: perfect description
---
docs/any.md | 2 +-
docs/function.md | 10 +++++-----
2 files changed, 6 insertions(+), 6 deletions(-)
diff --git a/docs/any.md b/docs/any.md
index 6026996..067e6e1 100644
--- a/docs/any.md
+++ b/docs/any.md
@@ -240,7 +240,7 @@ let v2:string = f(); // 不报错
let v3:boolean = f(); // 不报错
```
-上面示例中，函数`f()`会抛错，所以返回值类型可以写成`never`，即不可能返回任何值。各种其他类型的变量都可以赋值为`f()`的运行结果（`never`类型）。
+上面示例中，函数`f()`会抛出错误，所以返回值类型可以写成`never`，即不可能返回任何值。各种其他类型的变量都可以赋值为`f()`的运行结果（`never`类型）。
为什么`never`类型可以赋值给任意其他类型呢？这也跟集合论有关，空集是任何集合的子集。TypeScript 就相应规定，任何类型都包含了`never`类型。因此，`never`类型是任何其他类型所共有的，TypeScript 把这种情况称为“底层类型”（bottom type）。
diff --git a/docs/function.md b/docs/function.md
index 1d95ad5..f92e4c3 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -601,7 +601,7 @@ const f3 = function ():void {
上面示例中，函数字面量声明了返回`void`类型，这时只要有返回值（除了`undefined`和`null`）就会报错。
-函数的运行结果如果是抛错，也允许将返回值写成`void`。
+函数的运行结果如果是抛出错误，也允许将返回值写成`void`。
```typescript
function throwErr():void {
@@ -609,7 +609,7 @@ function throwErr():void {
}
```
-上面示例中，函数`throwErr()`会抛错，返回值类型写成`void`是允许的。
+上面示例中，函数`throwErr()`会抛出错误，返回值类型写成`void`是允许的。
除了函数，其他变量声明为`void`类型没有多大意义，因为这时只能赋值为`undefined`或者`null`（假定没有打开`strictNullChecks`) 。
@@ -634,7 +634,7 @@ function fail(msg:string):never {
}
```
-上面示例中，函数`fail()`会抛错，不会正常退出，所以返回值类型是`never`。
+上面示例中，函数`fail()`会抛出错误，不会正常退出，所以返回值类型是`never`。
注意，只有抛出错误，才是 never 类型。如果显式用`return`语句返回一个 Error 对象，返回值就不是 never 类型。
@@ -646,7 +646,7 @@ function fail():Error {
上面示例中，函数`fail()`返回一个 Error 对象，所以返回值类型是 Error。
-另外，由于抛错的情况属于`never`类型或`void`类型，所以无法从返回值类型中获知，抛出的是哪一种错误。
+另外，由于抛出错误的情况属于`never`类型或`void`类型，所以无法从返回值类型中获知，抛出的是哪一种错误。
（2）无限执行的函数。
@@ -696,7 +696,7 @@ function f(
上面示例中，函数`f()`的参数`x`的类型为`string|undefined`。但是，`x`类型为`undefined`时，调用了`neverReturns()`。这个函数不会返回，因此 TypeScript 可以推断出，判断语句后面的那个`x`，类型一定是`string`。
-一个函数如果某些条件下有正常返回值，另一些条件下抛错，这时它的返回值类型可以省略`never`。
+一个函数如果某些条件下有正常返回值，另一些条件下抛出错误，这时它的返回值类型可以省略`never`。
```typescript
function sometimesThrow():number {
From 65e5cbac3356f6b2e9f4cd2ba4dedc8bd9605774 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 2 Sep 2023 19:42:49 +0800
Subject: [PATCH 37/78] docs(tsconfig): moduleResolution add bundler
---
docs/module.md | 26 +++++++++++++++++---------
docs/tsconfig.json.md | 3 ++-
2 files changed, 19 insertions(+), 10 deletions(-)
diff --git a/docs/module.md b/docs/module.md
index 622f223..fdbce43 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -223,17 +223,21 @@ console.log(obj.foo); // 123
## 模块定位
-模块定位（module resolution）指的是确定 import 语句和 export 语句里面的模块文件位置。
+模块定位（module resolution）指的是一种算法，用来确定 import 语句和 export 语句里面的模块文件位置。
```typescript
+// 相对模块
import { TypeA } from './a';
+
+// 非相对模块
+import * as $ from "jquery";
```
-上面示例中，TypeScript 怎么确定`./a`到底是指哪一个模块，这就叫做“模块定位”。
+上面示例中，TypeScript 怎么确定`./a`或`jquery`到底是指哪一个模块，具体位置在哪里，用到的算法就叫做“模块定位”。
-模块定位有两种方法，一种称为 Classic 方法，另一种称为 Node 方法。可以使用编译参数`moduleResolution`，指定使用哪一种方法。
+编译参数`moduleResolution`，用来指定具体使用哪一种定位算法。常用的算法有两种：`Classic`和`Node`。
-没有指定定位方法时，就看原始脚本采用什么模块格式。如果模块格式是 CommonJS（即编译时指定`--module commonjs`），那么模块定位采用 Node 方法，否则采用 Classic 方法（模块格式为 es2015、 esnext、amd, system, umd 等等）。
+如果没有指定`moduleResolution`，它的默认值与编译参数`module`有关。`module`设为`commonjs`时（项目脚本采用 CommonJS 模块格式），`moduleResolution`的默认值为`Node`，即采用 Node.js 的模块定位算法。其他情况下（`module`设为 es2015、 esnext、amd, system, umd 等等），就采用`Classic`定位算法。
### 相对模块，非相对模块
@@ -245,26 +249,30 @@ import { TypeA } from './a';
- `import { DefaultHeaders } from "../constants/http";`
- `import "/mod";`
+相对模块的定位，是根据当前脚本的位置进行计算的，一般用于保存在当前项目目录结构中的模块脚本。
+
非相对模块指的是不带有路径信息的模块。下面 import 语句加载的模块，都是非相对模块。
- `import * as $ from "jquery";`
- `import { Component } from "@angular/core";`
+非相对模块的定位，是由`baseUrl`属性或模块映射而确定的，通常用于加载外部模块。
+
### Classic 方法
Classic 方法以当前脚本的路径作为“基准路径”，计算相对模块的位置。比如，脚本`a.ts`里面有一行代码`import { b } from "./b"`，那么 TypeScript 就会在`a.ts`所在的目录，查找`b.ts`和`b.d.ts`。
-至于非相对模块，也是以当前脚本的路径作为起点，一层层查找上级目录。比如，脚本`a.ts`里面有一行代码`import { b } from "b"`，那么就会查找`b.ts`和`b.d.ts`。
+至于非相对模块，也是以当前脚本的路径作为起点，一层层查找上级目录。比如，脚本`a.ts`里面有一行代码`import { b } from "b"`，那么就会依次在每一级上层目录里面，查找`b.ts`和`b.d.ts`。
### Node 方法
-Node 方法就是模拟 Node.js 的模块加载方法。
+Node 方法就是模拟 Node.js 的模块加载方法，也就是`require()`的实现方法。
相对模块依然是以当前脚本的路径作为“基准路径”。比如，脚本文件`a.ts`里面有一行代码`let x = require("./b");`，TypeScript 按照以下顺序查找。
-1. 当前目录是否包含`b.ts`、`b.tsx`、`b.d.ts`。
-1. 当前目录是否有子目录`b`，该子目录是否存在文件`package.json`，该文件的`types`字段是否指定了入口文件，如果是的就加载该文件。
-1. 当前目录的子目录`b`是否包含`index.ts`、`index.tsx`、`index.d.ts`。
+1. 当前目录是否包含`b.ts`、`b.tsx`、`b.d.ts`。如果不存在就执行下一步。
+1. 当前目录是否存在子目录`b`，该子目录里面的`package.json`文件是否有`types`字段指定了模块入口文件。如果不存在就执行下一步。
+1. 当前目录的子目录`b`是否包含`index.ts`、`index.tsx`、`index.d.ts`。如果不存在就报错。
非相对模块则是以当前脚本的路径作为起点，逐级向上层目录查找是否存在子目录`node_modules`。比如，脚本文件`a.js`有一行`let x = require("b");`，TypeScript 按照以下顺序进行查找。
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index 7a86b4b..76de0f4 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -449,8 +449,9 @@ TypeScript 内置的类型描述文件，主要有以下一些，完整的清单
`moduleResolution`确定模块路径的算法，即如何查找模块。它可以取以下四种值。
- `node`：采用 Node.js 的 CommonJS 模块算法。
-- `node16`或`nodenext`：采用 Node.js 的 ECMAScript 模块算法，从 TypeScript 4.7 开始支持。
+- `node16`或`nodenext`：采用 Node.js 的 ECMAScript 模块算法，从 TypeScript 4.7 开始支持。
- `classic`：TypeScript 1.6 之前的算法，新项目不建议使用。
+- `bundle`：TypeScript 5.0 新增的选项，表示当前代码会被其他打包器（比如 Webpack、Vite、esbuild、Parcel、rollup、swc）处理，从而放宽加载规则，它要求`module`设为`es2015`或更高版本，详见加入该功能的 [PR 说明](https://github.com/microsoft/TypeScript/pull/51669)。
它的默认值与`module`属性有关，如果`module`为`AMD`、`UMD`、`System`或`ES6/ES2015`，默认值为`classic`；如果`module`为`node16`或`nodenext`，默认值为这两个值；其他情况下,默认值为`Node`。
From 87034e4fcf34968e9111c3b3b60bee8625226a15 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 2 Sep 2023 19:44:28 +0800
Subject: [PATCH 38/78] docs(tsconfig): moduleResolution add bundler
---
docs/tsconfig.json.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index 76de0f4..7323e7d 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -451,7 +451,7 @@ TypeScript 内置的类型描述文件，主要有以下一些，完整的清单
- `node`：采用 Node.js 的 CommonJS 模块算法。
- `node16`或`nodenext`：采用 Node.js 的 ECMAScript 模块算法，从 TypeScript 4.7 开始支持。
- `classic`：TypeScript 1.6 之前的算法，新项目不建议使用。
-- `bundle`：TypeScript 5.0 新增的选项，表示当前代码会被其他打包器（比如 Webpack、Vite、esbuild、Parcel、rollup、swc）处理，从而放宽加载规则，它要求`module`设为`es2015`或更高版本，详见加入该功能的 [PR 说明](https://github.com/microsoft/TypeScript/pull/51669)。
+- `bundler`：TypeScript 5.0 新增的选项，表示当前代码会被其他打包器（比如 Webpack、Vite、esbuild、Parcel、rollup、swc）处理，从而放宽加载规则，它要求`module`设为`es2015`或更高版本，详见加入该功能的 [PR 说明](https://github.com/microsoft/TypeScript/pull/51669)。
它的默认值与`module`属性有关，如果`module`为`AMD`、`UMD`、`System`或`ES6/ES2015`，默认值为`classic`；如果`module`为`node16`或`nodenext`，默认值为这两个值；其他情况下,默认值为`Node`。
From 5732aca414709ce908ca4448277621ddcbf9d94a Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 9 Sep 2023 12:32:58 +0800
Subject: [PATCH 39/78] docs(function): edit function overload
---
docs/function.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/function.md b/docs/function.md
index f92e4c3..fd46274 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -889,7 +889,7 @@ type CreateElement = {
}
```
-由于重载是一种比较复杂的类型声明方法，为了降低复杂性，一般来说，如果可以的话，应该优先使用联合类型替代函数重载。
+由于重载是一种比较复杂的类型声明方法，为了降低复杂性，一般来说，如果可以的话，应该优先使用联合类型替代函数重载，除非多个参数之间、或者某个参数与返回值之间，存在对应关系。
```typescript
// 写法一
From 4583162ae56d0a2bc6ad08c9af1352d20b0ebafd Mon Sep 17 00:00:00 2001
From: biubiubiu999 <houshengaaa@gmail.com>
Date: Sun, 10 Sep 2023 00:13:09 +0800
Subject: [PATCH 40/78] Update operator.md
fix typo
---
docs/operator.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/operator.md b/docs/operator.md
index 56fffdf..e892636 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -466,7 +466,7 @@ type Flatten<Type, Item> =
Type extends Array<Item> ? Item : Type;
```
-上面是不使用`infer`的写法，每次调用`Fleatten`的时候，都要传入两个参数，就比较麻烦。
+上面是不使用`infer`的写法，每次调用`Flatten`的时候，都要传入两个参数，就比较麻烦。
下面的例子使用`infer`，推断函数的参数类型和返回值类型。
From 5d83ec0e8b59d929d7dbf50bd868e682cd3966d4 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 10 Sep 2023 16:32:45 +0800
Subject: [PATCH 41/78] docs(tsconfig.json): edit typeRoots & types
---
docs/tsconfig.json.md | 10 ++++++++--
1 file changed, 8 insertions(+), 2 deletions(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index 7323e7d..daaed15 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -791,7 +791,9 @@ class User {
### typeRoots
-`typeRoots`设置类型模块所在的目录，默认是`node_modules/@types`。
+`typeRoots`设置类型模块所在的目录，默认是`node_modules/@types`，该目录里面的模块会自动加入编译。一旦指定了该属性，就不会再用默认值`node_modules/@types`里面的类型模块。
+
+该属性的值是一个数组，数组的每个成员就是一个目录，它们的路径是相对于`tsconfig.json`位置。
```typescript
{
@@ -803,7 +805,7 @@ class User {
### types
-`types`设置`typeRoots`目录下需要包括在编译之中的类型模块。默认情况下，该目录下的所有类型模块，都会自动包括在编译之中。
+默认情况下，`typeRoots`目录下所有模块都会自动加入编译，如果指定了`types`属性，那么只有其中列出的模块才会自动加入编译。
```typescript
{
@@ -813,6 +815,10 @@ class User {
}
```
+上面的设置表示，默认情况下，只有`./node_modules/@types/node`、`./node_modules/@types/jest`和`./node_modules/@types/express`会自动加入编译，其他`node_modules/@types/`目录下的模块不会加入编译。
+
+如果`"types": []`，就表示不会自动将所有`@types`模块加入编译。
+
### useUnknownInCatchVariables
`useUnknownInCatchVariables`设置`catch`语句捕获的`try`抛出的返回值类型，从`any`变成`unknown`。
From b567a611d4d66ded89f886f2cb76f1d4758add43 Mon Sep 17 00:00:00 2001
From: Cui Yang <cuiyang673308817@gmail.com>
Date: Fri, 15 Sep 2023 12:09:07 +0800
Subject: [PATCH 42/78] docs(function): fix typo
---
docs/function.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/function.md b/docs/function.md
index fd46274..1224f1c 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -571,7 +571,7 @@ const ret = [];
src.forEach(el => ret.push(el));
```
-上面示例中，`push()`有返回值，表示新插入的元素在数组里面的位置。但是，对于`forEach()`方法来说，这个返回值是没有作用的，根本用不到，所以 TypeScript 不会报错。
+上面示例中，`push()`有返回值，表示插入新元素后数组的长度。但是，对于`forEach()`方法来说，这个返回值是没有作用的，根本用不到，所以 TypeScript 不会报错。
如果后面使用了这个函数的返回值，就违反了约定，则会报错。
From 0e8f8a92fab6fe5955e3842ed2e6f580c7b0e6d4 Mon Sep 17 00:00:00 2001
From: weishen-hong <57124685+weihenHong@users.noreply.github.com>
Date: Fri, 15 Sep 2023 18:04:48 +0800
Subject: [PATCH 43/78] fix typo
---
docs/interface.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/interface.md b/docs/interface.md
index b6dd5bc..a3b3a3f 100644
--- a/docs/interface.md
+++ b/docs/interface.md
@@ -526,7 +526,7 @@ type Country = {
capital: string;
}
-interface Coutry {
+interface Country {
name: string;
capital: string;
}
From 8ad5fc69f7e19dd117ddfc60b3dee299afca0180 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 22 Nov 2023 00:07:23 +0800
Subject: [PATCH 44/78] docs(decorator): fixed #84
---
docs/decorator.md | 27 ++++++++++++++++-----------
1 file changed, 16 insertions(+), 11 deletions(-)
diff --git a/docs/decorator.md b/docs/decorator.md
index c8d0805..8aea41c 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -818,6 +818,9 @@ class T {
@d('实例属性')
instanceField = log('实例属性值');
+
+ @d('静态方法装饰器')
+ static fn(){}
}
```
@@ -826,16 +829,18 @@ class T {
它的运行结果如下。
```typescript
-// "评估 @d(): 类装饰器"
-// "评估 @d(): 静态属性装饰器"
-// "评估 @d(): 原型方法"
-// "计算方法名"
-// "评估 @d(): 实例属性"
-// "应用 @d(): 原型方法"
-// "应用 @d(): 静态属性装饰器"
-// "应用 @d(): 实例属性"
-// "应用 @d(): 类装饰器"
-// "静态属性值"
+评估 @d(): 类装饰器
+评估 @d(): 静态属性装饰器
+评估 @d(): 原型方法
+计算方法名
+评估 @d(): 实例属性
+评估 @d(): 静态方法装饰器
+应用 @d(): 静态方法装饰器
+应用 @d(): 原型方法
+应用 @d(): 静态属性装饰器
+应用 @d(): 实例属性
+应用 @d(): 类装饰器
+静态属性值
```
可以看到，类载入的时候，代码按照以下顺序执行。
@@ -846,7 +851,7 @@ class T {
（2）装饰器应用：实际执行装饰器函数，将它们与对应的方法和属性进行结合。
-原型方法的装饰器首先应用，然后是静态属性和静态方法装饰器，接下来是实例属性装饰器，最后是类装饰器。
+静态方法装饰器首先应用，然后是原型方法的装饰器和静态属性装饰器，接下来是实例属性装饰器，最后是类装饰器。
注意，“实例属性值”在类初始化的阶段并不执行，直到类实例化时才会执行。
From 68962e8a1adfcb6573c51509c4ab1d86bf1eefab Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 23 Nov 2023 20:53:20 +0800
Subject: [PATCH 45/78] docs(enum): fix #85
---
docs/enum.md | 7 +++----
1 file changed, 3 insertions(+), 4 deletions(-)
diff --git a/docs/enum.md b/docs/enum.md
index fed20c8..f9656b3 100644
--- a/docs/enum.md
+++ b/docs/enum.md
@@ -512,15 +512,14 @@ type Foo = keyof typeof MyEnum;
上面示例中，`keyof typeof MyEnum`可以取出`MyEnum`的所有成员名，所以类型`Foo`等同于联合类型`'A'|'B'`。
-注意，这里的`typeof`是必需的，否则`keyof MyEnum`相当于`keyof number`。
+注意，这里的`typeof`是必需的，否则`keyof MyEnum`相当于`keyof string`。
```typescript
type Foo = keyof MyEnum;
-// "toString" | "toFixed" | "toExponential" |
-// "toPrecision" | "valueOf" | "toLocaleString"
+// number | typeof Symbol.iterator | "toString" | "charAt" | "charCodeAt" | ...
```
-上面示例中，类型`Foo`等于类型`number`的所有原生属性名组成的联合类型。
+上面示例中，类型`Foo`等于类型`string`的所有原生属性名组成的联合类型。这是`MyEnum`为字符串 Enum 的结果，如果`MyEnum`是数值 Enum，那么`keyof MyEnum`相当于`keyof number`。
这是因为 Enum 作为类型，本质上属于`number`或`string`的一种变体，而`typeof MyEnum`会将`MyEnum`当作一个值处理，从而先其转为对象类型，就可以再用`keyof`运算符返回该对象的所有属性名。
From a30b9442fc024a77c1a3a60478deb42194d5e8dc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E6=9D=8E=E6=98=BE?= <lixian@yuanian.com>
Date: Wed, 29 Nov 2023 16:39:41 +0800
Subject: [PATCH 46/78] fix: delete Superfluous words
---
docs/tsconfig.json.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index daaed15..ce618c7 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -579,7 +579,7 @@ TypeScript 内置的类型描述文件，主要有以下一些，完整的清单
### rootDirs
-`rootDirs`把多个不同目录，合并成一个目虚拟目录，便于模块定位。
+`rootDirs`把多个不同目录，合并成一个虚拟目录，便于模块定位。
```typescript
{
From abad608483dc32f7983b5141acbc57ae6eef5774 Mon Sep 17 00:00:00 2001
From: hermia <HQQhouqinqin0612@outlook.com>
Date: Thu, 30 Nov 2023 15:21:29 +0800
Subject: [PATCH 47/78] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E5=AF=B9=E8=B1=A1?=
=?UTF-8?q?=E7=B1=BB=E5=9E=8B=E4=B8=AD=E5=B1=9E=E6=80=A7=E5=90=8D=E7=9A=84?=
=?UTF-8?q?=E7=B4=A2=E5=BC=95=E7=B1=BB=E5=9E=8B=E4=B8=AD=E7=9A=84=E8=AF=AD?=
=?UTF-8?q?=E4=B9=89=E9=94=99=E8=AF=AF=EF=BC=8C=E5=B0=86=E5=A6=82=E6=9E=9C?=
=?UTF-8?q?=E5=8D=95=E4=B8=AA=E5=B1=9E=E6=80=A7=E5=90=8D=E7=AC=A6=20?=
=?UTF-8?q?=E5=90=88=E5=B1=9E=E6=80=A7=E5=90=8D=E7=B4=A2=E5=BC=95=E7=9A=84?=
=?UTF-8?q?=E8=8C=83=E5=9B=B4=EF=BC=8C=E4=B8=A4=E8=80=85=E4=B8=8D=E8=83=BD?=
=?UTF-8?q?=E6=9C=89=E5=86=B2=E7=AA=81=EF=BC=8C=E5=90=A6=E5=88=99=E6=8A=A5?=
=?UTF-8?q?=E9=94=99=E3=80=82=E4=BF=AE=E6=94=B9=E6=88=90=E5=A6=82=E6=9E=9C?=
=?UTF-8?q?=E5=8D=95=E4=B8=AA=E5=B1=9E=E6=80=A7=E5=90=8D=E4=B8=8D=E7=AC=A6?=
=?UTF-8?q?=E5=90=88=E5=B1=9E=E6=80=A7=E5=90=8D=E7=B4=A2=E5=BC=95=E7=9A=84?=
=?UTF-8?q?=E8=8C=83=E5=9B=B4=EF=BC=8C=E4=B8=A4=E8=80=85=E5=8F=91=E7=94=9F?=
=?UTF-8?q?=E5=86=B2=E7=AA=81=EF=BC=8C=E5=B0=B1=E4=BC=9A=E6=8A=A5=E9=94=99?=
=?UTF-8?q?=E3=80=82?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
docs/object.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/object.md b/docs/object.md
index 8151363..3eb9bcb 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -423,7 +423,7 @@ type MyType = {
上面示例中，类型`MyType`同时有两种属性名索引，但是数值索引与字符串索引冲突了，所以报错了。由于字符属性名的值类型是`string`，数值属性名的值类型只有同样为`string`，才不会报错。
-同样地，可以既声明属性名索引，也声明具体的单个属性名。如果单个属性名符合属性名索引的范围，两者不能有冲突，否则报错。
+同样地，可以既声明属性名索引，也声明具体的单个属性名。如果单个属性名不符合属性名索引的范围，两者发生冲突，就会报错。
```typescript
type MyType = {
From d8b2606434740847951c9ee3ff5497203e6c575f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 7 Dec 2023 10:34:26 +0800
Subject: [PATCH 48/78] docs(decorator): fix example
---
docs/decorator.md | 11 +++++++----
1 file changed, 7 insertions(+), 4 deletions(-)
diff --git a/docs/decorator.md b/docs/decorator.md
index 8aea41c..821a988 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -251,10 +251,10 @@ inst1.count // 1
```typescript
function functionCallable(
- value as any, {kind} as any
-) {
+ value:any, {kind}:any
+):any {
if (kind === 'class') {
- return function (...args) {
+ return function (...args:any) {
if (new.target !== undefined) {
throw new TypeError('This function can’t be new-invoked');
}
@@ -265,10 +265,13 @@ function functionCallable(
@functionCallable
class Person {
- constructor(name) {
+ name:string;
+ constructor(name:string) {
this.name = name;
}
}
+
+// @ts-ignore
const robin = Person('Robin');
robin.name // 'Robin'
```
From f77f8d1b129acab42ac515e8981130ba9281fcab Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 11 Dec 2023 14:03:19 +0800
Subject: [PATCH 49/78] docs(declare): fixed #91
---
docs/declare.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/docs/declare.md b/docs/declare.md
index f1eb9b9..fde7dca 100644
--- a/docs/declare.md
+++ b/docs/declare.md
@@ -296,13 +296,13 @@ String.prototype.toSmallString = ():string => {
这个示例第一行的空导出语句`export {}`，作用是强制编译器将这个脚本当作模块处理。这是因为`declare global`必须用在模块里面。
-下面的示例是为 window 对象添加一个属性`myAppConfig`。
+下面的示例是为 window 对象（类型接口为`Window`）添加一个属性`myAppConfig`。
```typescript
export {};
declare global {
- interface window {
+ interface Window {
myAppConfig:object;
}
}
From eb048a350909811c793a9aee6b3e53faaf3e5fbb Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 13 Dec 2023 13:53:59 +0800
Subject: [PATCH 50/78] docs: fixed #92
---
docs/tsconfig.json.md | 2 +-
docs/utility.md | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index ce618c7..b31d427 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -156,7 +156,7 @@ $ yarn add --dev @tsconfig/deno
}
```
-## compileOptions
+## compilerOptions
`compilerOptions`属性用来定制编译行为。这个属性可以省略，这时编译器将使用默认设置。
diff --git a/docs/utility.md b/docs/utility.md
index 46c64a0..0182f97 100644
--- a/docs/utility.md
+++ b/docs/utility.md
@@ -467,7 +467,7 @@ type Mutable<T> = {
上面代码中，`-readonly`表示去除属性的只读标志。
-相应地，`+readonly`就表示增加只读标志，等同于`readonly`。因此，`ReadOnly<Type>`的实现也可以写成下面这样。
+相应地，`+readonly`就表示增加只读标志，等同于`readonly`。因此，`Readonly<Type>`的实现也可以写成下面这样。
```typescript
type Readonly<T> = {
From 838b2f69f4ad91f907feaf20d7c39997713df56b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 13 Dec 2023 14:19:00 +0800
Subject: [PATCH 51/78] docs(declare): fixed wrong example
---
docs/declare.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/declare.md b/docs/declare.md
index fde7dca..ec85094 100644
--- a/docs/declare.md
+++ b/docs/declare.md
@@ -206,7 +206,7 @@ declare 关键字的另一个用途，是为外部模块添加属性和方法时
import { Foo as Bar } from 'moduleA';
declare module 'moduleA' {
- interface Bar extends Foo {
+ interface Bar {
custom: {
prop1: string;
}
From d21f77eebbc767596b185255b0459cd0a3917ed7 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 16 Dec 2023 11:14:14 +0800
Subject: [PATCH 52/78] docs(declare): fixed error
---
docs/declare.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/docs/declare.md b/docs/declare.md
index ec85094..960c20d 100644
--- a/docs/declare.md
+++ b/docs/declare.md
@@ -206,7 +206,7 @@ declare 关键字的另一个用途，是为外部模块添加属性和方法时
import { Foo as Bar } from 'moduleA';
declare module 'moduleA' {
- interface Bar {
+ interface Foo {
custom: {
prop1: string;
}
@@ -214,7 +214,7 @@ declare module 'moduleA' {
}
```
-上面示例中，从模块`moduleA`导入了`Foo`接口，将其重命名为`Bar`，并用 declare 关键字为`Bar`增加一个属性`custom`。
+上面示例中，从模块`moduleA`导入了类型`Foo`，它是一个接口（interface），并将其重命名为`Bar`，然后用 declare 关键字为`Foo`增加一个属性`custom`。这里需要注意的是，虽然接口`Foo`改名为`Bar`，但是扩充类型时，还是扩充原始的接口`Foo`，因为同名 interface 会自动合并类型声明。
下面是另一个例子。一个项目有多个模块，可以在一个模块中，对另一个模块的接口进行类型扩展。
From ef7d6197955c55eaa2c364114eaf04d3074b08eb Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 16 Dec 2023 14:51:21 +0800
Subject: [PATCH 53/78] docs: fixed typos
---
docs/comment.md | 2 +-
docs/tsconfig.json.md | 2 +-
docs/utility.md | 2 +-
3 files changed, 3 insertions(+), 3 deletions(-)
diff --git a/docs/comment.md b/docs/comment.md
index 38ddfa7..126cbe7 100644
--- a/docs/comment.md
+++ b/docs/comment.md
@@ -55,8 +55,8 @@ function doStuff(abc: string, xyz: string) {
// do some stuff
}
-// @ts-expect-error
expect(() => {
+ // @ts-expect-error
doStuff(123, 456);
}).toThrow();
```
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index b31d427..93f7add 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -629,7 +629,7 @@ TypeScript 内置的类型描述文件，主要有以下一些，完整的清单
- strictPropertyInitialization
- noImplicitAny
- noImplicitThis
-- useUnknownInCatchVaria
+- useUnknownInCatchVariables
打开`strict`的时候，允许单独关闭其中一项。
diff --git a/docs/utility.md b/docs/utility.md
index 0182f97..d177337 100644
--- a/docs/utility.md
+++ b/docs/utility.md
@@ -644,7 +644,7 @@ type ReturnType<
`ThisParameterType<Type>`提取函数类型中`this`参数的类型。
```typescript
-function toHex(this: Number) {
+function toHex(this:number) {
return this.toString(16);
}
From 68da0fb373aa5b82900d76340e5f1fcd0144458b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 21 Dec 2023 22:48:08 +0800
Subject: [PATCH 54/78] docs(decorator): fixed #93
---
docs/decorator.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/decorator.md b/docs/decorator.md
index 821a988..8696b0e 100644
--- a/docs/decorator.md
+++ b/docs/decorator.md
@@ -691,7 +691,7 @@ class C {
}
```
-上面示例中，`accessor`修饰符等同于为属性`x`自动生成取值器和存值器，它们作用于私有属性`x`。也就是说，上面的代码等同于下面的代码。
+上面示例中，`accessor`修饰符等同于为公开属性`x`自动生成取值器和存值器，它们作用于私有属性`x`。（注意，公开的`x`与私有的`x`不是同一个属性。）也就是说，上面的代码等同于下面的代码。
```typescript
class C {
From 0299aa9604f775b673dfc9d69251ed2027a181bb Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 26 Dec 2023 22:37:03 +0800
Subject: [PATCH 55/78] docs(interface): fixed typo
---
docs/interface.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/interface.md b/docs/interface.md
index a3b3a3f..e0169f8 100644
--- a/docs/interface.md
+++ b/docs/interface.md
@@ -394,7 +394,7 @@ interface Box {
这样的设计主要是为了兼容 JavaScript 的行为。JavaScript 开发者常常对全局对象或者外部库，添加自己的属性和方法。那么，只要使用 interface 给出这些自定义属性和方法的类型，就能自动跟原始的 interface 合并，使得扩展外部类型非常方便。
-举例来说，Web 网页开发经常会对`windows`对象和`document`对象添加自定义属性，但是 TypeScript 会报错，因为原始定义没有这些属性。解决方法就是把自定义属性写成 interface，合并进原始定义。
+举例来说，Web 网页开发经常会对`window`对象和`document`对象添加自定义属性，但是 TypeScript 会报错，因为原始定义没有这些属性。解决方法就是把自定义属性写成 interface，合并进原始定义。
```typescript
interface Document {
From 84474db9268b8c8f721a64f1a0584c80a914b121 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 9 Jan 2024 10:45:30 +0800
Subject: [PATCH 56/78] docs(module): fixed #96
---
docs/module.md | 6 ++++--
1 file changed, 4 insertions(+), 2 deletions(-)
diff --git a/docs/module.md b/docs/module.md
index fdbce43..f481bc3 100644
--- a/docs/module.md
+++ b/docs/module.md
@@ -84,17 +84,19 @@ import { type A, a } from './a';
上面示例中，import 语句输入的类型`A`前面有`type`关键字，表示这是一个类型。
-第二个方法是使用 import type 语句，这个语句只能输入类型，不能输入正常接口。
+第二个方法是使用 import type 语句，这个语句只用来输入类型，不用来输入正常接口。
```typescript
// 正确
import type { A } from './a';
+let b:A = 'hello';
// 报错
import type { a } from './a';
+let b = a;
```
-上面示例中，import type 输入类型`A`是正确的，但是输入正常接口`a`就会报错。
+上面示例中，import type 输入类型`A`是正确的，可以把`A`当作类型使用。但是，输入正常接口`a`，并把`a`当作一个值使用，就会报错。这就是说，看到`import type`，你就知道它输入的肯定是类型。
import type 语句也可以输入默认类型。
From 4c7a0cbbebbb22ff84a9606934954fe552d6ac2b Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 18 Mar 2024 18:05:05 +0800
Subject: [PATCH 57/78] docs(assert): fixed #100
---
docs/assert.md | 9 ---------
1 file changed, 9 deletions(-)
diff --git a/docs/assert.md b/docs/assert.md
index 5c6659c..64aad74 100644
--- a/docs/assert.md
+++ b/docs/assert.md
@@ -114,15 +114,6 @@ const s2:string = value as string; // 正确
上面示例中，unknown 类型的变量`value`不能直接赋值给其他类型的变量，但是可以将它断言为其他类型，这样就可以赋值给别的变量了。
-另外，类型断言也适合指定联合类型的值的具体类型。
-
-```typescript
-const s1:number|string = 'hello';
-const s2:number = s1 as number;
-```
-
-上面示例中，变量`s1`是联合类型，可以断言其为联合类型里面的一种具体类型，再将其赋值给变量`s2`。
-
## 类型断言的条件
类型断言并不意味着，可以把某个值断言为任意类型。
From 5d4a2f1484facd2b4234e83f9e7ed851519e5797 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 19 Mar 2024 16:28:18 +0800
Subject: [PATCH 58/78] docs(operator): fixed #101
---
docs/operator.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/operator.md b/docs/operator.md
index e892636..5416439 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -588,7 +588,7 @@ type Greeting = `hello ${World}`;
上面示例中，类型`Greeting`是一个模板字符串，里面引用了另一个字符串类型`world`，因此`Greeting`实际上是字符串`hello world`。
-注意，模板字符串可以引用的类型一共6种，分别是 string、number、bigint、boolean、null、undefined。引用这6种以外的类型会报错。
+注意，模板字符串可以引用的类型一共7种，分别是 string、number、bigint、boolean、null、undefined、Enum。引用这7种以外的类型会报错。
```typescript
type Num = 123;
From d5e0f47a20d1f2769dce610671a08033ac610d8e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 21 Mar 2024 21:29:42 +0800
Subject: [PATCH 59/78] docs(function): fixed #102
---
docs/function.md | 2 ++
1 file changed, 2 insertions(+)
diff --git a/docs/function.md b/docs/function.md
index 1224f1c..9badcf1 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -498,6 +498,8 @@ function arraySum(
上面示例中，参数`arr`的类型是`readonly number[]`，表示为只读参数。如果函数体内部修改这个数组，就会报错。
+注意，`readonly`关键字目前只允许用在数组和元组类型的参数前面，如果用在其他类型的参数前面，就会报错。
+
## void 类型
void 类型表示函数没有返回值。
From 57cdc82253554a4eaff53cb2fcf8d2ed06b87b34 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Wed, 10 Apr 2024 16:54:05 +0800
Subject: [PATCH 60/78] docs(function): fixed typo
---
docs/function.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/function.md b/docs/function.md
index 9badcf1..6795e59 100644
--- a/docs/function.md
+++ b/docs/function.md
@@ -374,7 +374,7 @@ function f(x = 456) {
return x;
}
-f2(undefined) // 456
+f(undefined) // 456
```
具有默认值的参数如果不位于参数列表的末尾，调用时不能省略，如果要触发默认值，必须显式传入`undefined`。
From ae9bea9a37872b5dcdca75800aa2dd211450d86f Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 23 May 2024 23:16:41 +0800
Subject: [PATCH 61/78] =?UTF-8?q?docs(declare):=20=E4=BF=AE=E6=94=B9?=
=?UTF-8?q?=E4=B8=8D=E8=83=BD=E5=8D=95=E7=8B=AC=E5=86=99=E5=87=BD=E6=95=B0?=
=?UTF-8?q?=E7=B1=BB=E5=9E=8B=E5=A3=B0=E6=98=8E=E7=9A=84=E7=A4=BA=E4=BE=8B?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
docs/declare.md | 7 +++++--
1 file changed, 5 insertions(+), 2 deletions(-)
diff --git a/docs/declare.md b/docs/declare.md
index 960c20d..ca7665a 100644
--- a/docs/declare.md
+++ b/docs/declare.md
@@ -82,7 +82,7 @@ declare function sayHello(
sayHello('张三');
```
-上面示例中，declare 命令给出了`sayHello()`的类型描述，因此可以直接使用它。
+上面示例中，declare 命令给出了`sayHello()`的类型描述，表示这个函数是由外部文件定义的，因此这里可以直接使用该函数。
注意，这种单独的函数类型声明语句，只能用于`declare`命令后面。一方面，TypeScript 不支持单独的函数类型声明语句；另一方面，declare 关键字后面也不能带有函数的具体实现。
@@ -91,7 +91,10 @@ sayHello('张三');
function sayHello(
name:string
):void;
-function sayHello(name) {
+
+let foo = 'bar';
+
+function sayHello(name:string) {
return '你好，' + name;
}
```
From 1605a244987f8e669e36662bb28b73530bd69ffb Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 8 Jun 2024 16:32:28 +0800
Subject: [PATCH 62/78] refactor: update dependencies
---
package.json | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/package.json b/package.json
index 9848fbb..18efa39 100644
--- a/package.json
+++ b/package.json
@@ -20,8 +20,8 @@
"author": "Ruan Yifeng",
"license": "CC-BY-SA-4.0",
"dependencies": {
- "gh-pages": "^5.0.0",
+ "gh-pages": "6.x",
"loppo": "^0.6.25",
- "loppo-theme-wangdoc": "^0.6.6"
+ "loppo-theme-wangdoc": "^0.7.1"
}
}
From 22904d3e2db8be745d69f0f2f75c4b1c13e19ede Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 8 Jun 2024 16:38:16 +0800
Subject: [PATCH 63/78] refactor: update github action script
---
.github/workflows/wangdoc.yml | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/.github/workflows/wangdoc.yml b/.github/workflows/wangdoc.yml
index 29b9a5b..8b652ac 100644
--- a/.github/workflows/wangdoc.yml
+++ b/.github/workflows/wangdoc.yml
@@ -10,11 +10,11 @@ jobs:
runs-on: ubuntu-latest
steps:
- name: Checkout
- uses: actions/checkout@v3
+ uses: actions/checkout@v4
with:
persist-credentials: false
- name: Setup Node.js
- uses: actions/setup-node@v3
+ uses: actions/setup-node@v4
with:
node-version: 'latest'
- name: Install dependencies
From f665b3f262b9d4922c95f30f428568183c6fff75 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 8 Jun 2024 16:40:18 +0800
Subject: [PATCH 64/78] docs(utility): fixed #107
---
docs/utility.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/utility.md b/docs/utility.md
index d177337..af454c2 100644
--- a/docs/utility.md
+++ b/docs/utility.md
@@ -44,7 +44,7 @@ type Awaited<T> =
} ? F extends (
value: infer V,
...args: infer _
- ) => any ? Awaited<...> : never:
+ ) => any ? Awaited<V> : never:
T;
```
From 73e9fdc014eaa82a0ecfc05ee5485f64a7d20881 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 10 Jun 2024 07:47:18 +0800
Subject: [PATCH 65/78] docs(utility): edit text
---
docs/utility.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/utility.md b/docs/utility.md
index af454c2..02a03f9 100644
--- a/docs/utility.md
+++ b/docs/utility.md
@@ -2,7 +2,7 @@
TypeScript 提供了一些内置的类型工具，用来方便地处理各种类型，以及生成新的类型。
-TypeScript 内置了17个类型工具，可以直接使用。
+这些类型工具都是语言本身提供的，可以直接使用。
## `Awaited<Type>`
From 066605460981d30e3afea06ceab6b3df41737b09 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 22 Jun 2024 20:12:43 +0800
Subject: [PATCH 66/78] docs(object): fixed #109
---
docs/object.md | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/docs/object.md b/docs/object.md
index 3eb9bcb..3141870 100644
--- a/docs/object.md
+++ b/docs/object.md
@@ -489,8 +489,7 @@ let { x: foo, y: bar }
```typescript
function draw({
shape: Shape,
- xPos: number = 100,
- yPos: number = 100
+ xPos: number = 100
}) {
let myShape = shape; // 报错
let x = xPos; // 报错
From a7d9796ed5f544880fc03e2192ecf61f9789fa88 Mon Sep 17 00:00:00 2001
From: LOUSANPANG <36870764+LOUSANPANG@users.noreply.github.com>
Date: Thu, 27 Jun 2024 22:08:42 +0800
Subject: [PATCH 67/78] docs(class):correction words
"MotoVehicle" -> "MotorVehicle"
---
docs/class.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/docs/class.md b/docs/class.md
index 7ad78d9..fe3b971 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -471,7 +471,7 @@ interface Swimmable {
// ...
}
-interface SuperCar extends MotoVehicle,Flyable, Swimmable {
+interface SuperCar extends MotorVehicle,Flyable, Swimmable {
// ...
}
@@ -570,7 +570,7 @@ const c1:Car = new Car();
const c2:MotorVehicle = new Car();
```
-上面示例中，变量的类型可以写成类`Car`，也可以写成接口`MotorVehicle`。它们的区别是，如果类`Car`有接口`MotoVehicle`没有的属性和方法，那么只有变量`c1`可以调用这些属性和方法。
+上面示例中，变量的类型可以写成类`Car`，也可以写成接口`MotorVehicle`。它们的区别是，如果类`Car`有接口`MotorVehicle`没有的属性和方法，那么只有变量`c1`可以调用这些属性和方法。
作为类型使用时，类名只能表示实例的类型，不能表示类的自身类型。
From bbde4688b44bda3e4390d4755e0648cec26a1505 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 1 Jul 2024 18:24:12 +0800
Subject: [PATCH 68/78] docs(class): modify useDefineForClassFields, fixed #113
---
docs/class.md | 193 +++++++++++++++++++++++++++++-------------
docs/tsconfig.json.md | 6 ++
2 files changed, 140 insertions(+), 59 deletions(-)
diff --git a/docs/class.md b/docs/class.md
index fe3b971..947c510 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -954,65 +954,6 @@ class Test extends getGreeterBase() {
上面示例中，例一和例二的`extends`关键字后面都是构造函数，例三的`extends`关键字后面是一个表达式，执行后得到的也是一个构造函数。
-对于那些只设置了类型、没有初值的顶层属性，有一个细节需要注意。
-
-```typescript
-interface Animal {
- animalStuff: any;
-}
-
-interface Dog extends Animal {
- dogStuff: any;
-}
-
-class AnimalHouse {
- resident: Animal;
-
- constructor(animal:Animal) {
- this.resident = animal;
- }
-}
-
-class DogHouse extends AnimalHouse {
- resident: Dog;
-
- constructor(dog:Dog) {
- super(dog);
- }
-}
-```
-
-上面示例中，类`DogHouse`的顶层成员`resident`只设置了类型（`Dog`），没有设置初值。这段代码在不同的编译设置下，编译结果不一样。
-
-如果编译设置的`target`设成大于等于`ES2022`，或者`useDefineForClassFields`设成`true`，那么下面代码的执行结果是不一样的。
-
-```typescript
-const dog = {
- animalStuff: 'animal',
- dogStuff: 'dog'
-};
-
-const dogHouse = new DogHouse(dog);
-
-console.log(dogHouse.resident) // undefined
-```
-
-上面示例中，`DogHouse`实例的属性`resident`输出的是`undefined`，而不是预料的`dog`。原因在于 ES2022 标准的 Class Fields 部分，与早期的 TypeScript 实现不一致，导致子类的那些只设置类型、没有设置初值的顶层成员在基类中被赋值后，会在子类被重置为`undefined`，详细的解释参见《tsconfig.json》一章，以及官方 3.7 版本的[发布说明](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#the-usedefineforclassfields-flag-and-the-declare-property-modifier)。
-
-解决方法就是使用`declare`命令，去声明顶层成员的类型，告诉 TypeScript 这些成员的赋值由基类实现。
-
-```typescript
-class DogHouse extends AnimalHouse {
- declare resident: Dog;
-
- constructor(dog:Dog) {
- super(dog);
- }
-}
-```
-
-上面示例中，`resident`属性的类型声明前面用了`declare`命令，这样就能确保在编译目标大于等于`ES2022`时（或者打开`useDefineForClassFields`时），代码行为正确。
-
## 可访问性修饰符
类的内部成员的外部可访问性，由三个可访问性修饰符（access modifiers）控制：`public`、`private`和`protected`。
@@ -1278,6 +1219,140 @@ class A {
}
```
+## 顶层属性的处理方法
+
+对于类的顶层属性，TypeScript 早期的处理方法，与后来的 ES2022 标准不一致。这会导致某些代码的运行结果不一样。
+
+类的顶层属性在 TypeScript 里面，有两种写法。
+
+```typescript
+class User {
+ // 写法一
+ age = 25;
+
+ // 写法二
+ constructor(private currentYear: number) {}
+}
+```
+
+上面示例中，写法一是直接声明一个实例属性`age`，并初始化；写法二是顶层属性的简写形式，直接将构造方法的参数`currentYear`声明为实例属性。
+
+TypeScript 早期的处理方法是，先在顶层声明属性，但不进行初始化，等到运行构造方法时，再完成所有初始化。
+
+```typescript
+class User {
+ age = 25;
+}
+
+// TypeScript 的早期处理方法
+class User {
+ age: number;
+
+ constructor() {
+ this.age = 25;
+ }
+}
+```
+
+上面示例中，TypeScript 早期会先声明顶层属性`age`，然后等到运行构造函数时，再将其初始化为`25`。
+
+ES2022 标准里面的处理方法是，先进行顶层属性的初始化，再运行构造方法。这在某些情况下，会使得同一段代码在 TypeScript 和 JavaScript 下运行结果不一致。
+
+这种不一致一般发生在两种情况。第一种情况是，顶层属性的初始化依赖于其他实例属性。
+
+```typescript
+class User {
+ age = this.currentYear - 1998;
+
+ constructor(private currentYear: number) {
+ // 输出结果将不一致
+ console.log('Current age:', this.age);
+ }
+}
+
+const user = new User(2023);
+```
+
+上面示例中，顶层属性`age`的初始化值依赖于实例属性`this.currentYear`。按照 TypeScript 的处理方法，初始化是在构造方法里面完成的，会输出结果为`25`。但是，按照 ES2022 标准的处理方法，初始化在声明顶层属性时就会完成，这时`this.currentYear`还等于`undefined`，所以`age`的初始化结果为`NaN`，因此最后输出的也是`NaN`。
+
+第二种情况与类的继承有关，子类声明的顶层属性在父类完成初始化。
+
+```typescript
+interface Animal {
+ animalStuff: any;
+}
+
+interface Dog extends Animal {
+ dogStuff: any;
+}
+
+class AnimalHouse {
+ resident: Animal;
+
+ constructor(animal:Animal) {
+ this.resident = animal;
+ }
+}
+
+class DogHouse extends AnimalHouse {
+ resident: Dog;
+
+ constructor(dog:Dog) {
+ super(dog);
+ }
+}
+```
+
+上面示例中，类`DogHouse`继承自`AnimalHouse`。它声明了顶层属性`resident`，但是该属性的初始化是在父类`AnimalHouse`完成的。不同的设置运行下面的代码，结果将不一致。
+
+```typescript
+const dog = {
+ animalStuff: 'animal',
+ dogStuff: 'dog'
+};
+
+const dogHouse = new DogHouse(dog);
+
+console.log(dogHouse.resident) // 输出结果将不一致
+```
+
+上面示例中，TypeScript 的处理方法，会使得`resident`属性能够初始化，所以输出参数对象的值。但是，ES2022 标准的处理方法是，顶层属性的初始化先于构造方法的运行。这使得`resident`属性不会得到赋值，因此输出为`undefined`。
+
+为了解决这个问题，同时保证以前代码的行为一致，TypeScript 从3.7版开始，引入了编译设置`useDefineForClassFields`。这个设置设为`true`，则采用 ES2022 标准的处理方法，否则采用 TypeScript 早期的处理方法。
+
+它的默认值与`target`属性有关，如果输出目标设为`ES2022`或者更高，那么`useDefineForClassFields`的默认值为`true`，否则为`false`。关于这个设置的详细说明，参见官方 3.7 版本的[发布说明](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#the-usedefineforclassfields-flag-and-the-declare-property-modifier)。
+
+如果希望避免这种不一致，让代码在不同设置下的行为都一样，那么可以将所有顶层属性的初始化，都放到构造方法里面。
+
+```typescript
+class User {
+ age: number;
+
+ constructor(private currentYear: number) {
+ this.age = this.currentYear - 1998;
+ console.log('Current age:', this.age);
+ }
+}
+
+const user = new User(2023);
+```
+
+上面示例中，顶层属性`age`的初始化就放在构造方法里面，那么任何情况下，代码行为都是一致的。
+
+对于类的继承，还有另一种解决方法，就是使用`declare`命令，去声明子类顶层属性的类型，告诉 TypeScript 这些属性的初始化由父类实现。
+
+```typescript
+class DogHouse extends AnimalHouse {
+ declare resident: Dog;
+
+ constructor(dog:Dog) {
+ super(dog);
+ }
+}
+```
+
+上面示例中，`resident`属性的类型声明前面用了`declare`命令。这种情况下，这一行代码在编译成 JavaScript 后就不存在，那么也就不会有行为不一致，无论是否设置`useDefineForClassFields`，输出结果都是一样的。
+
## 静态成员
类的内部可以使用`static`关键字，定义静态成员。
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index 93f7add..ad4009a 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -819,6 +819,12 @@ class User {
如果`"types": []`，就表示不会自动将所有`@types`模块加入编译。
+### useDefineForClassFields
+
+`useDefineForClassFields`这个设置针对的是，在类（class）的顶部声明的属性。TypeScript 早先对这一类属性的处理方法，与写入 ES2022 标准的处理方法不一致。这个设置设为`true`，就用来开启 ES2022 的处理方法，设为`false`就是 TypeScript 原有的处理方法。
+
+它的默认值跟`target`属性有关，如果编译目标是`ES2022`或更高，那么`useDefineForClassFields`默认值为`true`，否则为`false`。
+
### useUnknownInCatchVariables
`useUnknownInCatchVariables`设置`catch`语句捕获的`try`抛出的返回值类型，从`any`变成`unknown`。
From 8f59ef87cf9fd37259a7e041251664718cc2c8fa Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 1 Jul 2024 18:29:04 +0800
Subject: [PATCH 69/78] docs(class): add reference link
---
docs/class.md | 1 +
1 file changed, 1 insertion(+)
diff --git a/docs/class.md b/docs/class.md
index 947c510..26c094d 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -1670,4 +1670,5 @@ class FileSystemObject {
## 参考链接
- [TypeScript Constructor in Interface](http://fritzthecat-blog.blogspot.com/2018/06/typescript-constructor-in-interface.html)
+- [TypeScript: useDefineForClassFields – How to avoid future Breaking Changes](https://angular.schule/blog/2022-11-use-define-for-class-fields)
From dd06fc53e10ba25a83c24602a1ee438d0d5be58e Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 3 Aug 2024 01:19:54 +0800
Subject: [PATCH 70/78] docs(class): add override keyword #114
---
docs/class.md | 42 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
diff --git a/docs/class.md b/docs/class.md
index 26c094d..0ac8567 100644
--- a/docs/class.md
+++ b/docs/class.md
@@ -954,6 +954,48 @@ class Test extends getGreeterBase() {
上面示例中，例一和例二的`extends`关键字后面都是构造函数，例三的`extends`关键字后面是一个表达式，执行后得到的也是一个构造函数。
+## override 关键字
+
+子类继承父类时，可以覆盖父类的同名方法。
+
+```typescript
+class A {
+ show() {
+ // ...
+ }
+ hide() {
+ // ...
+ }
+}
+class B extends A {
+ show() {
+ // ...
+ }
+ hide() {
+ // ...
+ }
+}
+```
+
+上面示例中，B 类定义了自己的`show()`方法和`hide()`方法，覆盖了 A 类的同名方法。
+
+但是有些时候，我们继承他人的类，可能会在不知不觉中，就覆盖了他人的方法。为了防止这种情况，TypeScript 4.3 引入了 [override 关键字](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-3.html#override-and-the---noimplicitoverride-flag)。
+
+```typescript
+class B extends A {
+ override show() {
+ // ...
+ }
+ override hide() {
+ // ...
+ }
+}
+```
+
+上面示例中，B 类的`show()`方法和`hide()`方法前面加了 override 关键字，明确表明作者的意图，就是要覆盖 A 类里面的这两个同名方法。这时，如果 A 类没有定义自己的`show()`方法和`hide()`方法，就会报错。
+
+但是，这依然没有解决，子类无意中覆盖父类同名方法的问题。因此，TypeScript 又提供了一个编译参数`noImplicitOverride`。一旦打开这个参数，子类覆盖父类的同名方法就会报错，除非使用了 override 关键字。
+
## 可访问性修饰符
类的内部成员的外部可访问性，由三个可访问性修饰符（access modifiers）控制：`public`、`private`和`protected`。
From b376397025c99b596a20b7d318f9ac8eed36e348 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 23 Sep 2024 11:08:00 +0800
Subject: [PATCH 71/78] docs(assert): fixed #119
---
docs/assert.md | 11 +----------
1 file changed, 1 insertion(+), 10 deletions(-)
diff --git a/docs/assert.md b/docs/assert.md
index 64aad74..7026698 100644
--- a/docs/assert.md
+++ b/docs/assert.md
@@ -490,18 +490,9 @@ function assertIsDefined<T>(
上面示例中，工具类型`NonNullable<T>`对应类型`T`去除空类型后的剩余类型。
-如果要将断言函数用于函数表达式，可以采用下面的写法。
+如果要将断言函数用于函数表达式，可以采用下面的写法。根据 TypeScript 的[要求](https://github.com/microsoft/TypeScript/pull/33622)，这时函数表达式所赋予的变量，必须有明确的类型声明。
```typescript
-// 写法一
-const assertIsNumber = (
- value:unknown
-):asserts value is number => {
- if (typeof value !== 'number')
- throw Error('Not a number');
-};
-
-// 写法二
type AssertIsNumber =
(value:unknown) => asserts value is number;
From f68cdbc9108f332ab1b78f4d1ac95059e9945edb Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Mon, 23 Sep 2024 11:12:42 +0800
Subject: [PATCH 72/78] docs(assert): edit reference link
---
docs/assert.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/assert.md b/docs/assert.md
index 7026698..f816bab 100644
--- a/docs/assert.md
+++ b/docs/assert.md
@@ -490,7 +490,7 @@ function assertIsDefined<T>(
上面示例中，工具类型`NonNullable<T>`对应类型`T`去除空类型后的剩余类型。
-如果要将断言函数用于函数表达式，可以采用下面的写法。根据 TypeScript 的[要求](https://github.com/microsoft/TypeScript/pull/33622)，这时函数表达式所赋予的变量，必须有明确的类型声明。
+如果要将断言函数用于函数表达式，可以采用下面的写法。根据 TypeScript 的[要求](https://github.com/microsoft/TypeScript/pull/33622#issuecomment-575301357)，这时函数表达式所赋予的变量，必须有明确的类型声明。
```typescript
type AssertIsNumber =
From 5c56fd550e31dddfa3a735acdc9569a63d454e53 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sun, 29 Sep 2024 19:29:11 +0800
Subject: [PATCH 73/78] docs(enum): fixed #122
---
docs/enum.md | 2 +-
package.json | 2 +-
2 files changed, 2 insertions(+), 2 deletions(-)
diff --git a/docs/enum.md b/docs/enum.md
index f9656b3..9b4127d 100644
--- a/docs/enum.md
+++ b/docs/enum.md
@@ -312,7 +312,7 @@ enum Foo {
// 等同于
enum Foo {
A,
- B = 1，
+ B = 1,
C = 2
}
```
diff --git a/package.json b/package.json
index 18efa39..f7f09b8 100644
--- a/package.json
+++ b/package.json
@@ -22,6 +22,6 @@
"dependencies": {
"gh-pages": "6.x",
"loppo": "^0.6.25",
- "loppo-theme-wangdoc": "^0.7.1"
+ "loppo-theme-wangdoc": "^0.7.3"
}
}
From e7e1a775c8ea9610876ae9e736d1731aec220e83 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 3 Oct 2024 22:16:29 +0800
Subject: [PATCH 74/78] docs(tsconfig.json): edit strictNullChecks
---
docs/tsconfig.json.md | 40 ++++++++++++++++++++++++++--------------
1 file changed, 26 insertions(+), 14 deletions(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index ad4009a..a6b82db 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -677,28 +677,40 @@ let func:StringOrNumberFunc = fn;
### strictNullChecks
-`strictNullChecks`设置对`null`和`undefined`进行严格类型检查。如果打开`strict`属性，这一项就会自动设为`true`，否则为`false`。
+不打开`strictNullChecks`的情况下，变量可以设为`undefined`或`null`，而不管其类型是什么。
-```bash
-let value:string;
+```typescript
+// 不打开 strictNullChecks 的情况
+let x:number;
-// strictNullChecks:false
-// 下面语句不报错
-value = null;
+x = undefined; // 不报错
+x = null; // 不报错
```
-它可以理解成只要打开，就需要显式检查`null`或`undefined`。
+上面示例中，变量`x`的类型是`number`，但是赋值为`undefined`或`null`都不会报错。这是为了继承 JavaScript 的设定：当变量没有赋值时，它的值就为`undefined`。
+
+一旦打开`strictNullChecks`，就相当于从变量的值里面，排除了`undefined`和`null`，除非变量的类型是这两种类型。
```typescript
-function doSomething(x:string|null) {
- if (x === null) {
- // do nothing
- } else {
- console.log("Hello, " + x.toUpperCase());
- }
-}
+// 打开 strictNullChecks 的情况
+let x:number;
+
+x = undefined; // 报错
+x = null; // 报错
```
+下面是一个例子。
+
+```typescript
+// 打开 strickNullChecks 时，类型 A 为 number
+// 不打开时，类型 A 为 string
+type A = unknown extends {} ? string : number;
+```
+
+上面示例中，`{}`代表了 Object 类型，不打开`strictNullChecks`时，它包括了`undefined`和`null`，就相当于包括了所有类型的值，所以这时`unknown`类型可以赋值给`{}`类型，类型`A`就为`number`。打开`strictNullChecks`时，`{}`就排除掉了`undefined`和`null`，这时`unknown`类型就不能赋值给`{}`类型后，类型`A`就为`string`。
+
+另外，`strict`属性包含了`strictNullChecks`，如果打开`strict`属性，就相当于打开了`strictNullChecks`。
+
### strictPropertyInitialization
`strictPropertyInitialization`设置类的实例属性都必须初始化，包括以下几种情况。
From 5361b8c9484da37e647681935236356f4b3a9509 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Thu, 3 Oct 2024 22:44:55 +0800
Subject: [PATCH 75/78] docs(declare): edit text
---
docs/declare.md | 12 ++++++++++++
docs/tsconfig.json.md | 4 +++-
2 files changed, 15 insertions(+), 1 deletion(-)
diff --git a/docs/declare.md b/docs/declare.md
index ca7665a..a9b4bd0 100644
--- a/docs/declare.md
+++ b/docs/declare.md
@@ -252,6 +252,7 @@ const a:A = { x: 0, y: 0 };
某些第三方模块，原始作者没有提供接口类型，这时可以在自己的脚本顶部加上下面一行命令。
```typescript
+// 语法
declare module "模块名";
// 例子
@@ -371,6 +372,17 @@ declare module "path" {
上面示例中，`url`和`path`都是单独的模块脚本，但是它们的类型都定义在`node.d.ts`这个文件里面。
+另一种情况是，使用`declare module`命令，为模块名指定加载路径。
+
+```typescript
+declare module "lodash" {
+ export * from "../../dependencies/lodash";
+ export default from "../../dependencies/lodash";
+}
+```
+
+上面示例中，`declare module "lodash"`为模块`lodash`，指定具体的加载路径。
+
使用时，自己的脚本使用三斜杠命令，加载这个类型声明文件。
```typescript
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index a6b82db..4312c11 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -536,7 +536,9 @@ TypeScript 内置的类型描述文件，主要有以下一些，完整的清单
}
```
-它还可以使用通配符“*”。
+上面示例中，paths 设置的是执行`require('b')`时，即加载的是`./bar/b`。
+
+它还可以使用通配符“*”，表明模块名与模块位置的对应关系。
```typescript
{
From 635a5fadebf813bdc3feb582c310eccc46e1739c Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Sat, 12 Oct 2024 10:51:00 +0800
Subject: [PATCH 76/78] docs(tsconfig.json): fixed #124
---
docs/tsconfig.json.md | 12 +++++++-----
1 file changed, 7 insertions(+), 5 deletions(-)
diff --git a/docs/tsconfig.json.md b/docs/tsconfig.json.md
index 4312c11..e94a7c2 100644
--- a/docs/tsconfig.json.md
+++ b/docs/tsconfig.json.md
@@ -679,7 +679,7 @@ let func:StringOrNumberFunc = fn;
### strictNullChecks
-不打开`strictNullChecks`的情况下，变量可以设为`undefined`或`null`，而不管其类型是什么。
+不打开`strictNullChecks`的情况下，一个变量不管类型是什么，都可以赋值为`undefined`或`null`。
```typescript
// 不打开 strictNullChecks 的情况
@@ -689,9 +689,9 @@ x = undefined; // 不报错
x = null; // 不报错
```
-上面示例中，变量`x`的类型是`number`，但是赋值为`undefined`或`null`都不会报错。这是为了继承 JavaScript 的设定：当变量没有赋值时，它的值就为`undefined`。
+上面示例中，不打开`strictNullChecks`时，变量`x`的类型是`number`，但是赋值为`undefined`或`null`都不会报错。这是为了继承 JavaScript 的设定：当变量没有赋值时，它的值就为`undefined`。
-一旦打开`strictNullChecks`，就相当于从变量的值里面，排除了`undefined`和`null`，除非变量的类型是这两种类型。
+一旦打开`strictNullChecks`，就使用严格类型，禁止变量赋值为`undefined`和`null`，除非变量原本就是这两种类型。它相当于从变量的值里面，排除了`undefined`和`null`。
```typescript
// 打开 strictNullChecks 的情况
@@ -701,6 +701,8 @@ x = undefined; // 报错
x = null; // 报错
```
+上面示例中，打开`strictNullChecks`时，变量`x`作为`number`类型，就不能赋值为`undefined`和`null`。
+
下面是一个例子。
```typescript
@@ -709,9 +711,9 @@ x = null; // 报错
type A = unknown extends {} ? string : number;
```
-上面示例中，`{}`代表了 Object 类型，不打开`strictNullChecks`时，它包括了`undefined`和`null`，就相当于包括了所有类型的值，所以这时`unknown`类型可以赋值给`{}`类型，类型`A`就为`number`。打开`strictNullChecks`时，`{}`就排除掉了`undefined`和`null`，这时`unknown`类型就不能赋值给`{}`类型后，类型`A`就为`string`。
+上面示例中，`{}`代表了 Object 类型，不打开`strictNullChecks`时，它包括了`undefined`和`null`，就相当于包括了所有类型的值，所以这时`unknown`类型可以赋值给`{}`类型，类型`A`就为`string`。打开`strictNullChecks`时，`{}`就排除掉了`undefined`和`null`，这时`unknown`类型就不能赋值给`{}`类型后，类型`A`就为`number`。
-另外，`strict`属性包含了`strictNullChecks`，如果打开`strict`属性，就相当于打开了`strictNullChecks`。
+最后，`strict`属性包含了`strictNullChecks`，如果打开`strict`属性，就相当于打开了`strictNullChecks`。
### strictPropertyInitialization
From 1725cbbcd1cfbd9bf7110fd6ead3edb5ff9ed180 Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 15 Oct 2024 19:08:17 +0800
Subject: [PATCH 77/78] docs(operator/extends): fixed #125
---
docs/operator.md | 19 +++++++++----------
1 file changed, 9 insertions(+), 10 deletions(-)
diff --git a/docs/operator.md b/docs/operator.md
index 5416439..7a51d4b 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -378,18 +378,17 @@ type T2 = RegExp extends Animal ? number : string;
一般来说，调换`extends`两侧类型，会返回相反的结果。举例来说，有两个类`Cat`和`Animal`，前者是后者的子类型，那么`Cat extends Animal`就为真，而`Animal extends Cat`就为伪。
-如果需要判断的类型是一个联合类型，那么条件运算符会展开这个联合类型。
+如果对泛型使用 extends 条件运算，有一个地方需要注意。当泛型的类型参数是一个联合类型时，那么条件运算符会展开这个类型参数，即`T<A|B> = T<A> | T<B>`，所以 extends 对类型参数的每个部分是分别计算的。
```typescript
-(A|B) extends U ? X : Y
+type Cond<T> = T extends U ? X : Y;
-// 等同于
-
-(A extends U ? X : Y) |
-(B extends U ? X : Y)
+type MyType = Cond<A|B>;
+// 等同于 Cond<A> | Cond<B>
+// 等同于 (A extends U ? X : Y) | (B extends U ? X : Y)
```
-上面示例中，`A|B`是一个联合类型，进行条件运算时，相当于`A`和`B`分别进行运算符，返回结果组成一个联合类型。
+上面示例中，泛型`Cond`的类型参数`A|B`是一个联合类型，进行条件运算时，相当于`A`和`B`分别进行条件运算，返回结果组成一个联合类型。也就是说，如果类型参数是联合类型，条件运算的返回结果依然是一个联合类型。
如果不希望联合类型被条件运算符展开，可以把`extends`两侧的操作数都放在方括号里面。
@@ -398,18 +397,18 @@ type T2 = RegExp extends Animal ? number : string;
type ToArray<Type> =
Type extends any ? Type[] : never;
-// string[]|number[]
+// 返回结果 string[]|number[]
type T = ToArray<string|number>;
// 示例二
type ToArray<Type> =
[Type] extends [any] ? Type[] : never;
-// (string | number)[]
+// 返回结果 (string | number)[]
type T = ToArray<string|number>;
```
-上面的示例一，传入`ToArray<Type>`的类型参数是一个联合类型，所以会被展开，返回的也是联合类型。示例二是`extends`两侧的运算数都放在方括号里面，所以传入的联合类型不会展开，返回的是一个数组。
+上面的示例一，泛型`ToArray<Type>`的类型参数`string|number`是一个联合类型，所以会被展开，返回的也是联合类型`string[]|number[]`。示例二是`extends`两侧的运算数都放在方括号里面，左侧是`[Type]`，右侧是`[any]`，这时传入的联合类型不会展开，返回的是一个数组`(string|number)[]`。
条件运算符还可以嵌套使用。
From 1f5e92981ab36601ee9b473642ba59f434a73e9d Mon Sep 17 00:00:00 2001
From: ruanyf <yifeng.ruan@gmail.com>
Date: Tue, 31 Dec 2024 09:56:43 +0800
Subject: [PATCH 78/78] docs(operator): fixed typo
---
docs/operator.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/docs/operator.md b/docs/operator.md
index 7a51d4b..b19ec56 100644
--- a/docs/operator.md
+++ b/docs/operator.md
@@ -660,7 +660,7 @@ const palette: Record<Colors, string|RGB> = {
const greenComponent = palette.green.substring(1, 6); // 报错
```
-上面示例中，`palette.green`属性调用`substring()`方法会报错，原因是这个方法只有字符串才有，而`palette.green`的类型是`srting|RGB`，除了字符串，还可能是元组`RGB`，而元组并不存在`substring()`方法，所以报错了。
+上面示例中，`palette.green`属性调用`substring()`方法会报错，原因是这个方法只有字符串才有，而`palette.green`的类型是`string|RGB`，除了字符串，还可能是元组`RGB`，而元组并不存在`substring()`方法，所以报错了。
如果要避免报错，要么精确给出变量`palette`每个属性的类型，要么对`palette.green`的值进行类型缩小。两种做法都比较麻烦，也不是很有必要。