💄 文档样式修改

Author: exploitationExplorers

docs/challenges/medium/Absolute.md

@@ -4,7 +4,7 @@ title: 实现Absolute
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 实现一个接收 string,number 或 bigInt 类型参数的`Absolute`类型,返回一个正数字符串。
 
@@ -15,7 +15,7 @@ type Test = -100;
 type Result = Absolute<Test>; // expected to be "100"
 ```
 
-## 分析
+## 🔍 分析
 
 这个题本质也是字符的推断匹配，但是由于入参是 number 类型的，所以在进行推断匹配前需要进行一次转化，对于 ts 来讲，也非常简单：
 
@@ -28,7 +28,7 @@ type Case1 = NumberToString<100>;
 
 转换成字符后，可以直接进行 `-` 号的匹配，有 `-` 号，就只保留剩余的字符，否则全部保留即可。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer S}`
@@ -38,7 +38,7 @@ type Absolute<T extends number | string | bigint> = `${T}` extends `-${infer S}`
     `${T}`;
 ```
 
-## 知识点
+## 💡 知识点
 
 1. number 转 string
 2. 字符推断匹配套路： `` A extends `-${infer R}`  ``

docs/challenges/medium/AnyOf.md

@@ -4,7 +4,7 @@ title: AnyOf
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 在类型系统中实现类似于 Python 中 `any` 函数。类型接收一个数组，如果数组中任一个元素为真，则返回 `true`，否则返回 `false`。如果数组为空，返回 `false`。
 
@@ -15,7 +15,7 @@ type Sample1 = AnyOf<[1, '', false, [], {}]>; // expected to be true.
 type Sample2 = AnyOf<[0, '', false, [], {}]>; // expected to be false.
 ```
 
-## 分析
+## 🔍 分析
 
 这个题目看起来只需要遍历一次元组，遇到 false 元素，就继续递归判断剩余元素，否则就返回 true，直到遍历结束，那么就返回 false。
 
@@ -25,7 +25,7 @@ type Sample2 = AnyOf<[0, '', false, [], {}]>; // expected to be false.
 
 可以通过定义一个 Zerolist 的类型，`A extends Zerolist` 就简单认为这个元素是 false。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 export type Equal<X, Y> = (<T>() => T extends X ? 1 : 2) extends <
@@ -46,6 +46,6 @@ type AnyOf<T extends readonly any[]> = T extends [infer F, ...infer R]
   : false;
 ```
 
-## 知识点
+## 💡 知识点
 
 1. `[] ｜ Function | { a: any } extends {}` 为 true

docs/challenges/medium/AppendToObject.md

@@ -4,7 +4,7 @@ title: AppendToObject
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 实现一个为接口添加一个新字段的类型。该类型接收三个参数，返回带有新字段的接口类型。
 
@@ -15,11 +15,11 @@ type Test = { id: '1' };
 type Result = AppendToObject<Test, 'value', 4>; // expected to be { id: '1', value: 4 }
 ```
 
-## 分析
+## 🔍 分析
 
-这题操作的类型时对象，在对象上新增属性，相比较之前的 [实现 Omit](/medium/实现Omit.md) 要简单很多，只需要根据传入的参数生成新的类型，同当前类型交叉即可得到结果。
+这题操作的类型时对象，在对象上新增属性，相比较之前的 [实现 Omit](./Omit.md) 要简单很多，只需要根据传入的参数生成新的类型，同当前类型交叉即可得到结果。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type Merge<T> = {
@@ -66,7 +66,7 @@ type Case1 = Equal<A, B> extends true ? true : false;
 type Case2 = Equal<A, Merge<B>> extends true ? true : false;
 ```
 
-## 知识点
+## 💡 知识点
 
 1. 对象交叉
 2. 交叉后的对象 Merge

docs/challenges/medium/Capitalize.md

@@ -4,7 +4,7 @@ title: 实现Capitalize
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 实现 `Capitalize<T>` 它将字符串的第一个字母转换为大写，其余字母保持原样。
 
@@ -14,22 +14,22 @@ title: 实现Capitalize
 type capitalized = Capitalize<'hello world'>; // expected to be 'Hello world'
 ```
 
-## 分析
+## 🔍 分析
 
 思路其实比较简单，就是找到第一个字符，大写之后和其余字符拼接即可。
 
 这里值得一提的是 ts 本身自带这个方法，可以参考 官方文档 `uppercasestringtype`，但是其定义的地方是 intrinsic，我们看不到。
 
 同时 Ts 还自带了大写整个字符的方法 Uppercase， 想要实现本题目，可以通过推断匹配的方式选出第一个字符后，大写该字符，并和原字符拼接即可。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type MyCapitalize<S extends string> = S extends `${infer F}${infer R}`
   ? `${Uppercase<F>}${R}`
   : '';
 ```
 
-## 知识点
+## 💡 知识点
 
 1. 字符串推断匹配： `` A extends `${infer F}${infer R}`  ``

docs/challenges/medium/DeepReadonly.md

@@ -4,7 +4,7 @@ title: 实现DeepReadonly
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 实现一个通用的`DeepReadonly<T>`，它将对象的每个参数及其子对象递归地设为只读。
 
@@ -32,7 +32,7 @@ type Expected = {
 type Todo = DeepReadonly<X>; // should be same as `Expected`
 ```
 
-## 分析
+## 🔍 分析
 
 ```ts
 type DeepReadonly<T> = {
@@ -79,7 +79,7 @@ type Case5 = keyof (() => {});
 
 所以对于此题，只需要增加函数的额外处理即可。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type DeepReadonly<T> = {
@@ -93,7 +93,7 @@ type DeepReadonly<T> = {
 
 增加函数的场景判断即可。
 
-## 知识点
+## 💡 知识点
 
 1. 递归处理嵌套问题
 2. 元组可以使用遍历对象的方法进行遍历

docs/challenges/medium/Diff.md

@@ -4,7 +4,7 @@ title: 实现Diff
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 获取两个接口类型中的差值属性。
 
@@ -22,13 +22,13 @@ type Result1 = Diff<Foo, Bar>; // { b: number, c: boolean }
 type Result2 = Diff<Bar, Foo>; // { b: number, c: boolean }
 ```
 
-## 分析
+## 🔍 分析
 
 这道题目其实就比较宽泛了，获取只存在于 A 或 只存在于 B 中的属性，网上有很多借助 `Omit`, `Exclude`, `&` 的解法，我认为都不太直观，其实借助 `as` 非常好实现。关于 `as` 可以参考 [实现 Omit](/medium/实现Omit.md) 中介绍的部分。
 
 首先通过 `keyof A | keyof B` 可以获取所有的属性，接下来只需要让即存在于 A 中的属性 又存在于 B 中的属性为 never 即可去除该属性，也就是 `P extends keyof A & keyof B ? never : P`。讲到这里题解基本就出来了。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type Diff<O, O1> = {
@@ -39,6 +39,6 @@ type Diff<O, O1> = {
 };
 ```
 
-## 知识点
+## 💡 知识点
 
 1. 同 [实现 Omit](/medium/实现Omit.md)。

docs/challenges/medium/Flatten.md

@@ -4,7 +4,7 @@ title: 实现Flatten
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 在这个挑战中，你需要写一个接受数组的类型，并且返回扁平化的数组类型。
 
@@ -14,13 +14,13 @@ title: 实现Flatten
 type flatten = Flatten<[1, 2, [3, 4], [[[5]]]]>; // [1, 2, 3, 4, 5]
 ```
 
-## 分析
+## 🔍 分析
 
 这题又回到了元组，flatten 的逻辑本身也比较简单，就是遍历元组，当元素还是元组时，继续递归处理，直到元素非元组结束。
 
 元组的遍历方法可以通过匹配推断：`A extends [infer F, ...infer R]`。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type Flatten<T> =
@@ -40,7 +40,7 @@ type Flatten<T> =
 
 同时可以留意下最后的 空元组，不理解的可以查看 [实现 Pop](/medium/实现Pop.md) 中提到的边界条件。
 
-## 知识点
+## 💡 知识点
 
 1. 元组遍历套路： `T extends [infer F, ...infer R]`
 2. 元组遍历边界条件：推断的类型有两个，当入参没有元素时，会走 false 逻辑

docs/challenges/medium/KebabCase.md

@@ -4,7 +4,7 @@ title: 实现Merge
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 将两个类型合并成一个类型，第二个类型的键会覆盖第一个类型的键。
 
@@ -24,7 +24,7 @@ type coo = {
 type Result = Merge<foo, coo>; // expected to be {name: string, age: number, sex: string}
 ```
 
-## 分析
+## 🔍 分析
 
 这个题如果不要求后者同名属性覆盖前者的话，直接交叉即可解决问题。
 
@@ -48,7 +48,7 @@ type Merge<T, S> = {
 
 还有没有其他思路？其实也有，就是不借助交叉，直接遍历 `keyof T | keyof S`，然后在取值的时候先取后者的类型即可。可以直接看题解。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type Merge<F, S> = {
@@ -65,6 +65,6 @@ type Merge<F, S> = {
 };
 ```
 
-## 知识点
+## 💡 知识点
 
 1. 同 [实现 Omit](/medium/实现Omit.md)。

docs/challenges/medium/Merge.md

@@ -4,7 +4,7 @@ title: 实现Omit
 
 # {{ $frontmatter.title }}
 
-## 题目描述
+## 🎯 题目描述
 
 不使用 `Omit` 实现 TypeScript 的 `Omit<T, K>` 泛型。
 
@@ -26,7 +26,7 @@ const todo: TodoPreview = {
 };
 ```
 
-## 分析
+## 🔍 分析
 
 Omit 是 ts 自带的一个工具类，其原本的内部实现如下：
 
@@ -76,7 +76,7 @@ type Case1 = Copy<{ a: 1; b: 2 }>;
 
 通过强制声明键值为 never，其结果就是该键值就会被忽略掉。到这一步了，题解也呼之欲出，只需要判断当前键值是否是目标键值的一员，如果是，就忽略掉。
 
-## 题解
+## 🛠️ 题解
 
 ```ts
 type MyOmit<T, K extends keyof T> = {
@@ -86,7 +86,7 @@ type MyOmit<T, K extends keyof T> = {
 
 其核心就是利用 `as` 强制转换键值类型，又借助条件表达式将符合条件的键值改为 never，从而达到目标。
 
-## 知识点
+## 💡 知识点
 
 1. 对象遍历的方式： `{ [P in keyof T]: T[P] }`
 2. `as` 表达式在对象遍历时的用途