使用Koa2实现服务端的文件上传下载



```js
const Koa = require("koa")
const router = require("koa-router")();
const cors = require("koa2-cors")
const fs = require('fs');
const path = require('path');
const {koaBody} = require('koa-body');
console.log(koaBody);
const {saveFile,getFileStream,readFile} = require("./utils/file")

const app = new Koa()


/** 文件上传 */
router.post("/upload",function(ctx,next){
  const file = ctx.request.files.file;
  const uniqueFilename = saveFile(file);
  ctx.body = { filename: uniqueFileName };
})

/** 文件下载 */
router.get("/download/:filename",async function(ctx,next){

  const filename = ctx.params.filename;
  //request里面切出标识符字符串
  let requestUrl = ctx.request.originalUrl;
  //获取资源文件的绝对路径
  let filePath = path.resolve(__dirname + "/uploads/" + decodeURI(filename));
  let resHred = readFile(ctx.headers.range, filePath);
  ctx.status = resHred.code
  ctx.set(resHred.head);
  ctx.set('Content-Disposition', `attachment; filename=${encodeURIComponent(filename)}`);
  ctx.set('Content-Type', 'application/octet-stream');
  let stream = fs.createReadStream(filePath, resHred.code == 200 ? {} : { start: resHred.start, end: resHred.end });
  stream.pipe(ctx.res);
  // //也可使用这种方式。
  // stream.on('data', e => ctx.res.write(e));
  // // 接收完毕
  // stream.on('end', e => ctx.res.end());
  ctx.respond = false;
  return
})
router.post("/index",function(ctx,next){
    ctx.body = {
        data:"token....",
        message:"获取token成功"
    }
})
// app.use(async (ctx) => {
//     ctx.body = "token....."
// })
// app.use(
//     cors({
//         origin: function(ctx){
//             return "*"  //解决跨域
//         },
//         maxAge:5,
//         credentials:true,//是否携带cookie
//         allowMethods:["GET","POST","PUT","DELETE"]
//     })
// )

// koa-body 中间件来解析包含文件的 multipart/form-data 表单数据
app.use(koaBody({ multipart: true }));
app.use(router.routes())
//app.use(router.allowedMethods())
app.listen(3000)
```

关于文件操作的工具函数file.js

```js
const fs = require('fs');
const path = require('path');

function saveFile(file) {
    const reader = fs.createReadStream(file.path);
    const fileExtension = path.extname(file.name);
    const uniqueFileName = `${Date.now()}${fileExtension}`;
    const writer = fs.createWriteStream(path.join(__dirname, 'uploads', uniqueFileName));
    reader.pipe(writer);
    return uniqueFileName;
}

function getFileStream(filename) {
    return fs.createReadStream(path.join(__dirname, '../uploads', filename));
}



  /**
 * [读文件]
 * @param  {String} range        [数据起始位]
 * @param  {String} filePath     [文件路径]
 * @param  {Number} chunkSize    [每次请求碎片大小 （900kb 左右）]
 */
function readFile(range, filePath, chunkSize = 499999 * 2) {
    //mime类型
    const mime = {
        "css": "text/css",
        "gif": "image/gif",
        "html": "text/html",
        "ico": "image/x-icon",
        "jpeg": "image/jpeg",
        "jpg": "image/jpeg",
        "js": "text/javascript",
        "json": "application/json",
        "pdf": "application/pdf",
        "png": "image/png",
        "svg": "image/svg+xml",
        "swf": "application/x-shockwave-flash",
        "tiff": "image/tiff",
        "txt": "text/plain",
        "mp3": "audio/mp3",
        "wav": "audio/x-wav",
        "wma": "audio/x-ms-wma",
        "wmv": "video/x-ms-wmv",
        "xml": "text/xml",
        "mp4": "video/mp4"
    };
    // 获取后缀名
    let ext = path.extname(filePath);
    ext = ext ? ext.slice(1) : 'unknown';
    //未知的类型一律用"text/plain"类型
    let contentType = mime[ext.toLowerCase()];
 
    //建立流对象，读文件
    let stat = fs.statSync(filePath)
    let fileSize = stat.size;
    let head = {
        code: 200,
        head: {
            'Content-Length': fileSize,
            'content-type': contentType,
        }
 
    };
    console.log("range: ",range);
    if (range) {
        // 大文件分片
        let parts = range.replace(/bytes=/, "").split("-");
        let start = parseInt(parts[0], 10);
        let end = parts[1] ? parseInt(parts[1], 10) : start + chunkSize;
        end = end > fileSize - 1 ? fileSize - 1 : end;
        chunkSize = (end - start) + 1;
        head = {
            code: 206,
            filePath,
            start,
            end,
            head: {
                'Content-Range': `bytes ${start}-${end}/${fileSize}`,
                'content-type': contentType,
                'Content-Length': chunkSize,
                'Accept-Ranges': 'bytes'
            }
        }
 
    }
    return head;
}


module.exports = {
    saveFile,
    getFileStream,
    readFile
}

```

koa2 文件上传下载

KeepAlive 是 Vue3 中的一个内置组件，用于缓存动态组件，避免重复渲染和销毁，从而提升应用性能。当组件在 KeepAlive 内切换时，被切换的组件不会被销毁，而是被缓存起来，下次激活时直接从缓存中恢复。




# 1.相关概念

## 1.1 ShapeFlags 标志位

KeepAlive 使用 ShapeFlags 枚举来标记组件的状态：

```typescript
export enum ShapeFlags {
  // ... 其他标志
  COMPONENT_SHOULD_KEEP_ALIVE = 1 << 8,  // 组件应该被 keep-alive
  COMPONENT_KEPT_ALIVE = 1 << 9,         // 组件已被 keep-alive
}
```

## 1.2 KeepAlive 组件属性

```typescript
export interface KeepAliveProps {
  include?: string | RegExp | (string | RegExp)[]  // 包含的组件名
  exclude?: string | RegExp | (string | RegExp)[]  // 排除的组件名
  max?: number | string                           // 最大缓存数量
}
```

# 2. 实现原理
## 2.1 KeepAlive 组件结构

```typescript
const KeepAliveImpl: ComponentOptions = {
  name: `KeepAlive`,
  __isKeepAlive: true,  // 特殊标记，用于渲染器识别
  props: {
    include: [String, RegExp, Array],
    exclude: [String, RegExp, Array],
    max: [String, Number],
  },
  setup(props: KeepAliveProps, { slots }: SetupContext) {
    // 核心实现
  }
}
```
## 2.2 缓存机制

KeepAlive 使用 Map 和 Set 来管理缓存：

```typescript
type CacheKey = PropertyKey | ConcreteComponent
type Cache = Map<CacheKey, VNode>
type Keys = Set<CacheKey>

const cache: Cache = new Map()  // 缓存 VNode
const keys: Keys = new Set()    // 记录缓存键的顺序
let current: VNode | null = null // 当前活动的 VNode
```

# 3. 核心实现流程

## 3.1 组件挂载阶段

### 3.1.1 渲染器注入

在组件挂载时，渲染器会向 KeepAlive 实例注入渲染相关的方法：

```typescript
// renderer.ts 中的 mountComponent 函数
if (isKeepAlive(initialVNode)) {
  (instance.ctx as KeepAliveContext).renderer = internals
}
```

### 3.1.2 初始化上下文

```typescript
const sharedContext = instance.ctx as KeepAliveContext

// 注入 activate 和 deactivate 方法
sharedContext.activate = (vnode, container, anchor, namespace, optimized) => {
  const instance = vnode.component!
  move(vnode, container, anchor, MoveType.ENTER, parentSuspense)
  // 更新组件并调用激活钩子
  patch(/* ... */)
  queuePostRenderEffect(() => {
    instance.isDeactivated = false
    if (instance.a) {
      invokeArrayFns(instance.a)
    }
  }, parentSuspense)
}

sharedContext.deactivate = (vnode: VNode) => {
  const instance = vnode.component!
  invalidateMount(instance.m)
  invalidateMount(instance.a)
  move(vnode, storageContainer, null, MoveType.LEAVE, parentSuspense)
  queuePostRenderEffect(() => {
    if (instance.da) {
      invokeArrayFns(instance.da)
    }
    instance.isDeactivated = true
  }, parentSuspense)
}
```

## 3.2 渲染函数实现

```typescript
return () => {
  pendingCacheKey = null

  if (!slots.default) {
    return (current = null)
  }

  const children = slots.default()
  const rawVNode = children[0]
  
  // 验证子节点
  if (children.length > 1) {
    if (__DEV__) {
      warn(`KeepAlive should contain exactly one component child.`)
    }
    current = null
    return children
  }

  // 获取内部子节点（处理 Suspense）
  let vnode = getInnerChild(rawVNode)
  
  // 处理注释节点
  if (vnode.type === Comment) {
    current = null
    return vnode
  }

  const comp = vnode.type as ConcreteComponent
  
  // 获取组件名称（处理异步组件）
  const name = getComponentName(
    isAsyncWrapper(vnode)
      ? (vnode.type as ComponentOptions).__asyncResolved || {}
      : comp,
  )

  const { include, exclude, max } = props

  // 组件过滤检查
  if (
    (include && (!name || !matches(include, name))) ||
    (exclude && name && matches(exclude, name))
  ) {
    vnode.shapeFlag &= ~ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE
    current = vnode
    return rawVNode
  }

  const key = vnode.key == null ? comp : vnode.key
  const cachedVNode = cache.get(key)

  // 克隆已存在的 vnode
  if (vnode.el) {
    vnode = cloneVNode(vnode)
    if (rawVNode.shapeFlag & ShapeFlags.SUSPENSE) {
      rawVNode.ssContent = vnode
    }
  }
  
  pendingCacheKey = key

  if (cachedVNode) {
    // 从缓存恢复
    vnode.el = cachedVNode.el
    vnode.component = cachedVNode.component
    
    // 处理过渡动画
    if (vnode.transition) {
      setTransitionHooks(vnode, vnode.transition!)
    }
    
    // 设置缓存标志
    vnode.shapeFlag |= ShapeFlags.COMPONENT_KEPT_ALIVE
    
    // 更新最近使用顺序
    keys.delete(key)
    keys.add(key)
  } else {
    // 新增缓存
    keys.add(key)
    
    // LRU 缓存淘汰
    if (max && keys.size > parseInt(max as string, 10)) {
      pruneCacheEntry(keys.values().next().value!)
    }
  }
  
  // 标记为需要 keep-alive
  vnode.shapeFlag |= ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE

  current = vnode
  return isSuspense(rawVNode.type) ? rawVNode : vnode
}
```

## 3.3 缓存管理

### 3.3.1 缓存清理

```typescript
function pruneCache(filter: (name: string) => boolean) {
  cache.forEach((vnode, key) => {
    const name = getComponentName(vnode.type as ConcreteComponent)
    if (name && !filter(name)) {
      pruneCacheEntry(key)
    }
  })
}

function pruneCacheEntry(key: CacheKey) {
  const cached = cache.get(key) as VNode
  if (cached && (!current || !isSameVNodeType(cached, current))) {
    unmount(cached)
  } else if (current) {
    resetShapeFlag(current)
  }
  cache.delete(key)
  keys.delete(key)
}
```

### 3.3.2 属性变化监听

```typescript
watch(
  () => [props.include, props.exclude],
  ([include, exclude]) => {
    include && pruneCache(name => matches(include, name))
    exclude && pruneCache(name => !matches(exclude, name))
  },
  { flush: 'post', deep: true }
)
```

## 3.4 生命周期钩子

### 3.4.1 activated 和 deactivated

```typescript
export function onActivated(
  hook: Function,
  target?: ComponentInternalInstance | null,
): void {
  registerKeepAliveHook(hook, LifecycleHooks.ACTIVATED, target)
}

export function onDeactivated(
  hook: Function,
  target?: ComponentInternalInstance | null,
): void {
  registerKeepAliveHook(hook, LifecycleHooks.DEACTIVATED, target)
}

function registerKeepAliveHook(
  hook: Function & { __wdc?: Function },
  type: LifecycleHooks,
  target: ComponentInternalInstance | null = currentInstance,
) {
  const wrappedHook =
    hook.__wdc ||
    (hook.__wdc = () => {
      // 检查是否在非激活分支中
      let current: ComponentInternalInstance | null = target
      while (current) {
        if (current.isDeactivated) {
          return
        }
        current = current.parent
      }
      return hook()
    })
  injectHook(type, wrappedHook, target)
}
```

# 4. 渲染器处理逻辑

## 4.1 组件处理流程

```typescript
// renderer.ts 中的 processComponent 函数
if (n1 == null) {
  if (n2.shapeFlag & ShapeFlags.COMPONENT_KEPT_ALIVE) {
    // 调用激活方法
    (parentComponent!.ctx as KeepAliveContext).activate(
      n2,
      container,
      anchor,
      namespace,
      optimized,
    )
  } else {
    // 正常挂载组件
    mountComponent(/* ... */)
  }
} else {
  // 更新组件
  updateComponent(n1, n2, optimized)
}
```

## 4.2 挂载后处理

```typescript
// 组件挂载完成后的 activated 钩子处理
if (
  initialVNode.shapeFlag & ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE ||
  (parent &&
    isAsyncWrapper(parent.vnode) &&
    parent.vnode.shapeFlag & ShapeFlags.COMPONENT_SHOULD_KEEP_ALIVE)
) {
  instance.a && queuePostRenderEffect(instance.a, parentSuspense)
}
```

# 5. 关键技术细节

## 5.1 缓存键生成策略

```typescript
const key = vnode.key == null ? comp : vnode.key
```

如果没有显式指定 key，则使用组件构造函数作为缓存键。

## 5.2 VNode 克隆机制

```typescript
if (vnode.el) {
  vnode = cloneVNode(vnode)
  if (rawVNode.shapeFlag & ShapeFlags.SUSPENSE) {
    rawVNode.ssContent = vnode
  }
}
```

克隆 VNode 是为了防止修改原始的 VNode 结构。

## 5.3 LRU 缓存淘汰

当缓存数量超过 max 限制时，会淘汰最早使用的组件：

```typescript
if (max && keys.size > parseInt(max as string, 10)) {
  pruneCacheEntry(keys.values().next().value!)
}
```

## 5.4 异步组件处理

```typescript
const name = getComponentName(
  isAsyncWrapper(vnode)
    ? (vnode.type as ComponentOptions).__asyncResolved || {}
    : comp,
)
```

对于异步组件，使用已解析的内部组件名称进行匹配。

# 6. 性能优化

## 6.1 避免不必要的重新渲染

通过 `ShapeFlags.COMPONENT_KEPT_ALIVE` 标志，渲染器可以识别哪些组件是从缓存中恢复的，避免重新创建 DOM 元素。

## 6.2 批量更新

使用 `queuePostRenderEffect` 将钩子调用推迟到渲染完成后执行，确保 DOM 操作的批量处理。

## 6.3 内存管理

通过 max 属性和 LRU 算法控制缓存大小，防止内存泄漏。

# 7. 使用注意事项

## 7.1 适用场景

- 频繁切换的组件（如标签页、路由组件）
- 创建成本较高的组件
- 需要保持组件状态的场景

## 7.2 不适用场景

- 简单的展示组件
- 数据实时性要求很高的组件
- 占用大量内存的组件（除非严格控制缓存数量）

## 7.3 常见问题

1. **缓存键冲突**：确保不同组件使用不同的 key
2. **内存泄漏**：合理设置 max 属性
3. **状态不一致**：注意组件在激活/停用时的状态管理

Vue3.5 KeepAlive实现细节

本篇文章主要介绍的是和go底层相关的并且非常重要的知识点，拿起小本本开始吧



# 逃逸分析
Go 语言中的逃逸分析（Escape Analysis）是编译器在编译阶段进行的一项关键优化。它的核心目的是决定一个变量应该分配在栈（stack）上还是堆（heap）上，以提升程序性能。

🎯 核心目的：提升性能

栈分配：内存分配和释放的开销极小，速度非常快，由编译器自动管理。
堆分配：内存分配开销较大，且需要依赖垃圾回收器（GC）来回收，会给程序带来额外负担。

逃逸分析的目标就是尽可能将变量分配在栈上，从而减少堆内存分配的次数，降低 GC 压力，最终提升程序运行效率。

⚙️ 分析原理：变量是否“逃逸”

编译器会分析变量的作用域和生命周期。如果一个变量的生命周期超出了它被创建的函数作用域，就被认为发生了“逃逸”，必须分配到堆上。

简单来说，判断标准是：这个变量在函数返回后，是否还有可能被访问到？

是 → 发生逃逸，分配到堆。
否 → 未逃逸，分配到栈。

📝 常见的逃逸场景

根据分析，以下几种情况会导致变量逃逸到堆上：

1. 返回局部变量的指针

这是最典型的逃逸场景。函数返回后，局部变量本应被销毁，但如果返回了它的地址，为了保证指针有效，编译器必须将其分配到堆上。
```golang
func newInt() *int {
    x := 10       // x 是局部变量
    return &x     // 返回 x 的地址，x 逃逸到堆
}
```

2. 向接口赋值

接口变量在底层存储的是一个动态类型和一个动态值。当把一个具体类型的值赋给接口时，这个值需要被“装箱”，通常会分配到堆上。
```golang
func printValue() {
    x := 100
    var i interface{} = x // x 被赋值给接口 i，x 逃逸到堆
    fmt.Println(i)
}
```

3. 在闭包中引用外部变量

如果一个闭包（匿名函数）引用了其外部函数的局部变量，并且这个闭包的生命周期可能超过外部函数，那么被引用的变量就会逃逸到堆上。
```golang
func counter() func() int {
    count := 0
    // 匿名函数引用了外部变量 count
    // 当 counter 函数返回后，匿名函数仍可能被调用，所以 count 必须存活
    return func() int {
        count++
        return count
    }
}
```

4. 创建 slice 或 map 等动态数据结构

虽然 slice 或 map 的头部结构体可能分配在栈上，如果在make时，初始容量很大，这是会分配到堆上
```golang
package main

func main() {
	s := make([]int, 100000000) // 底层数组会分配在堆上
	s[0] = 100
}
```
查看逃逸分析
```shell
go build -gcflags="-m" other/t1/main.go
# command-line-arguments
other/t1/main.go:3:6: can inline main
other/t1/main.go:4:11: make([]int, 100000000) escapes to heap
```
如果我们将容量该小一点
```golang
package main

func main() {
	s := make([]int, 1000) // 底层数组会分配在堆上
	s[0] = 100
}
```
查看逃逸分析
```shell
go build -gcflags="-m" other/t1/main.go
# command-line-arguments
other/t1/main.go:3:6: can inline main
other/t1/main.go:4:11: make([]int, 1000) does not escape
```
这时就没有逃逸了

5. 使用fmt.Println
```golang
package main

import "fmt"

func main() {
    str := "hello world"
    fmt.Println(str)
}
```
查看逃逸分析结果
```shell
go build -gcflags="-m" other/t1/main.go
# command-line-arguments
other/t1/main.go:7:13: inlining call to fmt.Println
other/t1/main.go:7:13: ... argument does not escape
other/t1/main.go:7:14: "hello world" escapes to heap
```
这里可能有很多人会疑惑？
原因在 `fmt.Println` 接收参数类型是 `...interface{}`（空接口）

Go 需要把 传入的参数装箱到 interface {}；这里就和第2个场景一样了

关于go,你必须要知道的小知识

Vue 3 的 customRef API 允许创建自定义 ref，提供对依赖项跟踪和更新的显式控制。它可以用于实现防抖、节流、自定义计算属性及性能优化。customRef 与 ref 的主要区别在于定制化程度，ref 更适合常规场景，而 customRef 提供更细粒度的控制。customRef 应用场景包括在获取和设置值时执行额外操作，例如与本地存储交互或实现防抖功能。本文利用customRef实现全局loading效果



# customRef
customRef() 是 Vue 3 中新增的 API，用于创建自定义 ref，并对其依赖项跟踪和更新触发进行显式控制。

## 用途:

- 实现防抖/节流：通过控制依赖项收集和更新触发时机，可以实现防抖/节流功能。
- 自定义计算属性：可以根据特定逻辑计算值，并控制何时更新视图。
- 优化性能：可以避免不必要的更新，提升性能。


## 工作原理

customRef() 接收一个工厂函数作为参数，该函数接收 track 和 trigger 两个函数作为参数，并返回一个带有 get 和 set 方法的对象。

- track：用于收集依赖项。在 get 方法中调用，收集该 ref 所依赖的响应式数据。
- trigger：用于触发更新。在 set 方法中调用，通知依赖项更新视图。

```
const count = customRef((track, trigger) => {
  let num = 0;

  return {
    get: () => num,
    set: (val) => {
      num = val;
      trigger();
    },
  };
});

const update = () => {
  count.value++;
};

```
解释
- track 和 trigger 函数分别用于收集依赖项和触发更新。
- get 方法返回当前值。
- set 方法更新值并触发更新。




# gloadingRef

```
import { customRef } from 'vue';
 export const gloadingRef = () => {
    return customRef((track, trigger) => {
        let loadingCount = 0;
        return {
            get: () => {
                track()
                return loadingCount > 0
            },
            set: (val) => {
                loadingCount += val ? 1 : -1;
                loadingCount = Math.max(0,loadingCount)
                trigger();
            },
        };
    })
}
```

使用
```
// element-ui这样写 import PopupManager from 'element-ui/lib/utils/popup/popup-manager.js'
// PopupManager 统一处理遮罩层的z-index,防止Message,Dialog层级乱序
import PopupManager from '@element-plus/utils/popup-manager'
<div v-loading="true" class="ploading" v-if="initConfig.gloading.value" :style="loadStyle"></div>

const gloading = gloadingRef()

const loadStyle = reactive({
      zIndex: 1000,
})

watch(() => gloading.value,
      (val) => {
       if(val){
         loadStyle.zIndex = PopupManager.nextZIndex()
       }
      },{immediate:true})

const getApi = () => {
    gloading.value = true
    
    setTimeout(() => {
    gloading.value = false
    },100)
}
```
gloadingRef建议在axios里使用
```
// 创建axios实例
const service = axios.create({
  // axios中请求配置有baseURL选项，表示请求URL公共部分
  baseURL: process.env.VUE_APP_BASE_API,
  // 超时
  timeout: 1000 * 60 * 5
})
// request拦截器
service.interceptors.request.use(config => {
  gloading.value = true
  return config
}, error => {
    console.log(error)
    Promise.reject(error)
})

// 响应拦截器
service.interceptors.response.use(res => {
  gloading.value = false
  return res
  },
  error => {
    
    Message({ message: message, type: 'error', duration: 5 * 1000 })
    return Promise.reject(error)
  }
)
```

Vue3 customRef 实现全局loading

那些你忽略的typescript小技巧



# 运算符
## 空值合并运算符 ??

?? 与 || 功能很相似，不同的是 ??在左侧表达式为 `null` 或 `undefined` 时，才会右侧表达式。

```
const num = a ?? 10;

// 上面的写法等价于下面的写法

const num2 = ( a !== null && a !== void 0) ? a : 10;

```
在这里科普一下，`void 0` 会返回 `undefined`,那这里为什么不直接写`undefined`呢，是因为undefined是全局作用域中的一个变量，undefined的最初值就是原始数据类型undefined。
ES5之后的标准中，规定了全局变量下的undefined值为只读，不可改写的，但是局部变量中依然可以对之进行改写。
所以使用void 0来代替undefined就比较稳妥，防止出错。

## 非空断言运算符 !

这个运算符可以用在变量名或者函数名之后，用来强调对应的元素是非 null|undefined 的

```js
function clickHandle(){
    this.domRef!.open()  // ! 告诉编译器 变量不为null 或 undefinded
}
```

## 可选链运算符 ?.

相比上面!作用于编译阶段的非空判断，?.这个是开发者最需要的运行时(当然编译时也有效)的非空判断。

obj?.prop obj?.[index] func?.(args)

?.用来判断左侧的表达式是否是 null | undefined，如果是则会停止表达式运行，可以减少我们大量的&&运算。
比如我们写出a?.b时，编译器会自动生成如下代码

a === null || a === void 0 ? void 0 : a.b;

# 操作符

## 键值获取 keyof

keyof 可以获取一个类型所有键值，返回一个联合类型

```ts
type Person = {
  name: string;
  age: number;
}
type PersonKey = keyof Person; 
// PersonKey得到的类型为 'name' | 'age'

```
keyof 的一个典型用途是限制访问对象的 key 合法化，因为 any 做索引是不被接受的

```ts
function getValue (p: Person, k: keyof Person) {
  return p[k];  // 如果k不如此定义，则无法以p[k]的代码格式通过编译
}

```

## 实例类型获取 typeof

typeof 是获取一个对象/实例的类型

```ts
const me: Person = { name: 'gzx', age: 16 };
type P = typeof me;  // { name: string, age: number | undefined }
const you: typeof me = { name: 'mabaoguo', age: 69 }  // 可以通过编译

```

## 遍历属性 in
 
 in 只能用在类型的定义中，可以对枚举类型进行遍历

```ts
// 这个类型可以将任何类型的键值转化成number类型
type TypeToNumber<T> = {
  [key in keyof T]: number
}

```
keyof返回泛型 T 的所有键枚举类型，key是自定义的任何变量名，中间用in链接，外围用[]包裹起来(这个是固定搭配)，冒号右侧number将所有的key定义为number类型。

于是可以这样使用了：

const obj: TypeToNumber<Person> = { name: 10, age: 10 }
    
总结起来 in 的语法格式如下：
    
```
[ 自定义变量名 in 枚举类型 ]: 类型
```
    
# 内置高级类型
    
## Parameters
Parameters 用于提取函数类型的参数类型。
```ts
type Parameters<T extends (...args: any) => any> 
    = T extends (...args: infer P) => any 
        ? P 
        : never;

```
类型参数 T 为待处理的类型，通过 extends 约束为函数，参数和返回值任意。
通过 extends 匹配一个模式类型，提取参数的类型到 infer 声明的局部变量 P 中返回。

![image.png](/static/img/48d5664024a9d8af3c30ed5b78ffaf5a.image.webp)

## ReturnType
ReturnType 用于提取函数类型的返回值类型
```ts
type ReturnType<T extends (...args: any) => any> 
    = T extends (...args: any) => infer R 
        ? R 
        : any;

```
类型参数 T 为待处理的类型，通过 extends 约束为函数类型，参数和返回值任意。

用 T 匹配一个模式类型，提取返回值的类型到 infer 声明的局部变量 R 里返回。

![image.png](/static/img/b712dbdbe10c23e1353dd38bc65d40f6.image.webp)
    
    
## ConstructorParameters
    
构造器类型和函数类型的区别就是可以被 new。

Parameters 用于提取函数参数的类型，而 ConstructorParameters 用于提取构造器参数的类型。
```ts   
type ConstructorParameters<T extends abstract new (...args: any) => any> 
    = T extends abstract new (...args: infer P) => any 
        ? P 
        : never;
```
类型参数 T 是待处理的类型，通过 extends 约束为构造器类型，加个 abstract 代表不能直接被实例化（其实不加也行）。

用 T 匹配一个模式类型，提取参数的部分到 infer 声明的局部变量 P 里，返回 P。
    

![image.png](/static/img/65784f68e2342dc564b6c4342b05b4c5.image.webp)
    
## InstanceType
    
提取了构造器参数的类型，自然也可以提取构造器返回值的类型，就是 InstanceType。
```ts
type InstanceType<T extends abstract new (...args: any) => any> 
    = T extends abstract new (...args: any) => infer R 
        ? R 
        : any;
  
```
整体和 ConstructorParameters 差不多，只不过提取的不再是参数了，而是返回值。

通过模式匹配提取返回值的类型到 infer 声明的局部变量 R 里返回。
    
   
![image.png](/static/img/eecda1fbf807256a833f98ce4a6cab59.image.webp)
    
## ThisParameterType
    
函数里可以调用 this，这个 this 的类型也可以约束
```ts
 type ThisParameterType<T> = 
    T extends (this: infer U, ...args: any[]) => any 
        ? U 
        : unknown;
  
```
## Partial
将泛型中全部属性变为可选

```TS
type Partial<T> = {
    [P in keyof T]?: T[P]
}

```
    
```ts
 type Animal = {
  name: string,
  category: string,
  age: number,
  eat: () => number
}
// 用Partial包裹一下
type PartOfAnimal = Partial<Animal>;
const ww: PartOfAnimal = { name: 'ww' }; // 属性全部可选后，可以只赋值部分属性了
    
```

![image.png](/static/img/f7349a1be65f34a3f5426d5e8f7391ea.image.webp)
    
## Required
作用：将类型 T 中所有的属性变为必选项。
```ts
type Required<T> = {
  [P in keyof T]-?: T[P]
}  
```
这里有一个很有意思的语法-?，你可以理解为就是 TS 中把?可选属性减去的意思。

![image.png](/static/img/743f470bc73ebfa3b3aa5a47ea5d69ed.image.webp)
    
## Readonly
将所有属性变为只读
```ts
 type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};
   
```

![image.png](/static/img/c2107290ee84556d0552df8daee40b88.image.webp)
    
## Pick
映射类型的语法用于构造新的索引类型，在构造的过程中可以对索引和值做一些修改或过滤
```ts
type Pick<T, K extends keyof T> = {
    [P in K]: T[P];
};
  
```
类型参数 T 为待处理的类型，类型参数 K 为要过滤出的索引，通过 extends 约束为只能是 T 的索引的子集。

构造新的索引类型返回，索引取自 K，也就是 P in K，值则是它对应的原来的值，也就是 T[P]。

![image.png](/static/img/c6157550038747aa604a1346359952a1.image.webp)
       
## Record<K, T>
作用：将K中所有属性值转化为T类型，常用来声明一个普通object对象。
```ts
 type Record<K extends keyof any,T> = {
  [key in K]: T
}   
```
这里特别说明一下，keyof any对应的类型为number | string | symbol，也就是可以做对象键(专业说法叫索引 index)的类型集合。

![image.png](/static/img/c2321661ba107a69a370fada7929d916.image.webp)

举例如下
    
const obj: Record<string, string> = { 'name': 'zhangsan', 'tag': '打工人' }

![image.png](/static/img/267053d69f3d93f24417655c6c851265.image.webp)

![image.png](/static/img/8fc69739d3347064b253bf9588e535f0.image.webp)


## Exclude<T, U>
作用：在 T 类型中，去除 T 类型和 U 类型的交集，返回剩余的部分。
    
当想从一个联合类型中去掉一部分类型时，可以用 Exclude 类型
```ts
type Exclude<T, U> = T extends U ? never : T
```
注意这里的 extends 返回的 T 是原来的 T 中和 U 无交集的属性，而任何属性联合 never 都是自身
    
联合类型中的每个类型都是相互独立的，TypeScript 对它做了特殊处理，也就是遇到字符串类型、条件类型的时候会把每个类型单独传入做计算，最后把每个类型的计算结果合并成联合类型。

条件类型左边是联合类型的时候就会触法这种处理，叫做分布式条件类型
```ts
   type T0 = Exclude<"a" | "b" | "c", "a" | "f">
            = "a" extends "a"|"f" ? never : "a" | //never
              "b" extends "a"|"f" ? never : "b" |   //"b"
              "c" extends "a"|"f" ? never : "c"     //"c"
            = "b"|"c" 
 ```
    
## Extract
可以过滤掉，自然也可以保留，Exclude 反过来就是 Extract，也就是取交集
```ts
type Extract<T, U> = T extends U ? T : never;
 
```

![image.png](/static/img/a3c5693e36f9e2db89e0a73e6a00cc38.image.webp)

## Omit<T, K>
    
我们知道了 Pick 可以取出索引类型的一部分索引构造成新的索引类型，那反过来就是去掉这部分索引构造成新的索引类型。
    
作用：适用于键值对对象的 Exclude，它会去除类型 T 中包含 K 的键值对。
```ts
type Omit = Pick<T, Exclude<keyof T, K>>
```

![image.png](/static/img/a6fc848312c033a8cc83db8c3939ce20.image.webp)

    
## Awaited
获取多层嵌套Promise的返回值
```ts
 type Awaited<T> =
    T extends null | undefined
        ? T 
        : T extends object & { then(onfulfilled: infer F): any }
            ? F extends ((value: infer V, ...args: any) => any)
                ? Awaited<V>
                : never 
            : T;
   
```
类型参数 T 是待处理的类型。

如果 T 是 null 或者 undefined，就返回 T。

如果 T 是对象并且有 then 方法，那就提取 then 的参数，也就是 onfulfilled 函数的类型到 infer 声明的局部变量 F。

继续提取 onfullfilled 函数类型的第一个参数的类型，也就是 Promise 返回的值的类型到 infer 声明的局部变量 V。

递归的处理提取出来的 V，直到不再满足上面的条件。

![image.png](/static/img/def88e2b465873dc22658c3f0e27f046.image.webp)
    
## Uppercase、Lowercase、Capitalize、Uncapitalize
    
这四个类型是分别实现大写、小写、首字母大写、去掉首字母大写的。

    
    
    

# 模式匹配
## 字符串
### StartsWith
判断字符串是否以某个前缀开头
 ```ts
    type StartsWith<Str extends string, Prefix extends string> = 
    Str extends `${Prefix}${string}` ? true : false;
 ```
 eg: 16进制颜色值
 ```ts
    const color: `#${string}` = "#fff"
  ```