chore: update

Author: 142vip.cn

docs/manuscripts/server-end/typescript/README.md

@@ -0,0 +1 @@
+# TypeScript

docs/manuscripts/server-end/typescript/typescript.sidebar.ts

@@ -0,0 +1,40 @@
+export const TypescriptSidebar = [
+  {
+    text: '基础教程',
+    prefix: '基础教程',
+    children: [
+      {
+        text: '快速入门',
+        link: '快速入门.md'
+      },
+      {
+        text: '基础类型',
+        link: '基础类型.md'
+      },
+      {
+        text: '变量声明',
+        link: '变量声明.md'
+      },
+      {
+        text: '接口',
+        link: '接口.md'
+      },
+      {
+        text: '泛型',
+        link: '泛型.md'
+      },
+      {
+        text: '类',
+        link: '类.md'
+      },
+      {
+        text: '高级类型',
+        link: '高级类型.md'
+      },
+      {
+        text: '装饰器',
+        link: '装饰器.md'
+      }
+    ]
+  }
+]

docs/manuscripts/server-end/typescript/基础教程/变量声明.md

@@ -0,0 +1,58 @@
+# 变量声明
+
+const是对let的一个增强，它能阻止对一个变量再次赋值
+
+## 块级作用域
+
+```ts
+// 块级作用域
+function testResult(input: boolean) {
+  let a = 100;
+
+  if (input) {
+    // 这里能获取到变量a的值
+    let b = a + 1;
+    return b;
+  }
+
+  // 编译器会提醒变量不存在
+  return b;
+}
+```
+
+## 数组解构
+
+```ts
+const result = [1, 2]
+const [resultA, resultB] = result
+console.log(resultA, resultB)
+
+// 数据交换
+// [resultA, resultB] = [resultB, resultA]
+
+// 对剩余变量的获取
+const res = [1, 3, 4, 5, 6]
+const [resA, ...rest] = res
+console.log(resA, rest)
+```
+
+## 对象解构
+
+```ts
+const boy = {
+  name: 'chufan',
+  gender: 'man',
+  age: 14
+}
+const {name, age} = boy
+console.log(name, age)
+const {gender, ...restBoy} = boy
+console.log(gender, restBoy)
+
+// 解构变量重命名
+const {name: newName} = boy
+console.log(nerName)
+
+// 默认值
+const {defaultA, defaultB = 1001} = {defaultA: 100}
+```

docs/manuscripts/server-end/typescript/基础教程/基础类型.md

@@ -0,0 +1,104 @@
+# 基础类型
+
+## 布尔类型
+
+```ts
+// 布尔类型
+const isSuccess: boolean = true
+console.log(isSuccess)
+```
+
+## 数字
+
+和`JavaScript`一样，`TypeScript`里的所有数字都是浮点数。 这些浮点数的类型是 number
+
+```ts
+// number类型
+const a: number = 123
+console.log(a)
+```
+
+## 字符串
+
+```ts
+// string类型
+const name = "chufan"
+console.log(name)
+
+// 模板字符串
+const sister: string = `hello,${name}`
+console.log(sister)
+```
+
+## 数组
+
+`TypeScript`像`JavaScript`一样可以操作数组元素。 有两种方式可以定义数组：
+
+- 可以在元素类型后面接上 `[]`，表示由此类型元素组成的一个数组
+- 使用数组泛型，`Array<元素类型>`
+
+```ts
+// 数组
+const list: number[] = [1, 2, 3, 4]
+const arrayList: Array<number> = [1, 2, 3, 4]
+console.log(list, arrayList)
+```
+
+## 元组
+
+元组类型允许表示一个已知元素数量和类型的数组，各元素的类型不必相同
+
+```ts
+const tupleResult: [string, number] = ['chufan', 23]
+console.log(tupleResult)
+```
+
+## 枚举
+
+```ts
+// 枚举颜色
+enum COLOR {
+  RED = 0,
+  GREEN = 1,
+  BLUE = 3
+}
+
+// 枚举人名
+enum NAME {
+  zhangSan = 'zhangSan',
+  liSi = 'liSi'
+}
+
+console.log(COLOR.BLUE, NAME.zhangSan)
+```
+
+## Void和Any
+
+某种程度上来说，void类型像是与any类型相反。
+
+- void表示没有任何类型。 当一个函数没有返回值时，你通常会见到其返回值类型是 void
+- any表示任意类型，一般写any就直接绕过ts编译等同于js代码
+
+```ts
+// 函数返回值为空
+function testVoid(a: number): void {
+  console.log(a)
+}
+
+// 声明一个void类型的变量没有什么大用，你只能为它赋予undefined和null
+const aVoid: void = null
+const bVoid: void = undefined
+console.log(aVoid, bVoid)
+```
+
+## Null 和 Undefined
+
+TypeScript里，undefined和null两者各自有自己的类型分别叫做undefined和null。 和 void相似，它们的本身的类型用处不是很大：
+
+```ts
+let u: undefined = undefined;
+let n: null = null;
+```
+
+默认情况下null和undefined是所有类型的子类型。 就是说你可以把 null和undefined赋值给number类型的变量。
+然而，当指定了--strictNullChecks标记，null和undefined只能赋值给void和它们各自。 这能避免 很多常见的问题

docs/manuscripts/server-end/typescript/基础教程/快速入门.md

@@ -0,0 +1,6 @@
+---
+title: 简介
+permalink: /manuscripts/server-end/typescript/quick-start.html
+---
+
+# 快速入门

docs/manuscripts/server-end/typescript/基础教程/接口.md

@@ -0,0 +1,146 @@
+# 接口
+
+接口的作用就是为这些类型命名和为代码或第三方代码定义契约
+
+接口可以限制类的结构
+
+```ts
+// 定义接口类型
+interface LabelledValue {
+  label: string
+}
+
+// 定义函数
+function printLabel(labelledObj: LabelledValue) {
+  console.log(labelledObj.label);
+}
+
+let labelObj = {size: 10, label: "Size 10 Object"}
+printLabel(labelObj)
+
+// 可选属性
+interface SquareConfig {
+  color?: string
+  width?: number
+}
+
+// 只读属性
+interface Point {
+  readonly x: number;
+  readonly y: number;
+}
+
+// 接口中的所有属性都不能有实际的值
+// 接口只定义对象的结构，不考虑实际的值
+// 在接口中，所有的方法都是抽象方法
+interface myInter {
+  name: string
+
+  sayHello(): string
+}
+
+class Inter implements myInter {
+  name: string;
+
+  sayHello(): string {
+    return ''
+  }
+}
+```
+
+对于只读，const支持变量的只读，readonly支持属性的只读
+
+- 抽象类中可以有抽象方法和普通方法，抽象方法就是需要自己实现的方法
+- 接口中只有抽象方法，对方法进行约束定义。使用implements后，实现抽象方法
+
+## 函数类型
+
+```ts
+
+// 接口的函数类型
+interface SearchFunc {
+  say: (name: string, age: number) => string;
+  sex: boolean;
+}
+
+const searchTest: SearchFunc = {
+  sex: true,
+  say: (name: string, age: number) => {
+    return name
+  }
+}
+console.log(searchTest)
+
+
+// 通过接口来约束函数类型
+interface myFunc {
+  (name: string): string
+}
+
+const func: myFunc = (name: string) => {
+  return name
+}
+console.log(func('储凡'))
+```
+
+## 可索引类型
+
+指定索引类型，例如，指定对象key的类型
+
+```ts
+interface StrArray {
+// 索引为number类型，值为字符串类型
+  [index: number]: string;
+}
+
+let myArray: StrArray;
+myArray = ["储凡", "chufan"];
+
+let myStr: string = myArray[0];
+
+console.log(myStr)
+```
+
+## 类类型
+
+```ts
+// 类类型
+interface Plan {
+  food: string
+  eat: (something: string) => boolean
+
+}
+
+// 通过接口来约束类的属性、方法
+class PlanA implements Plan {
+  food: string;
+
+  eat(something: string): boolean {
+    return false;
+  }
+}
+```
+
+## 继承接口
+
+```ts
+interface FairyA {
+  name: string
+}
+
+interface FairyB {
+  age: number
+}
+
+interface Fairy extends FairyA, FairyB {
+  gender: number
+}
+
+const fairy: Fairy = {
+  name: "储凡",
+  age: 18,
+  gender: 0
+}
+
+console.log(fairy)
+```