标准项目结构

my-project/
├── cmd/                    # 主应用程序入口
│   └── myapp/              # 可执行文件名称
│       └── main.go         # 程序入口点
├── internal/               # 内部模块（不可被外部引用）
│   ├── models/             # 数据模型
│   ├── repositories/       # 数据访问层
│   ├── services/           # 业务逻辑层
│   └── utils/              # 工具函数
├── pkg/                    # 公共模块（可被外部引用）
│   ├── api/                # API接口定义
│   └── client/             # 客户端库
├── configs/                # 配置文件模板
├── scripts/                # 脚本文件
├── tests/                  # 集成测试
├── docs/                   # 文档
├── vendor/                 # 依赖包（Go 1.14+ 推荐使用go mod代替）
├── go.mod                  # 模块依赖定义
├── go.sum                  # 依赖校验文件
└── Makefile                # 构建脚本

关键目录说明

1. cmd/ - 应用程序入口

存放项目的主程序入口文件，每个子目录对应一个可执行文件。

// cmd/myapp/main.go
package main

import "my-project/internal/app"

func main() {
    app.Run()
}

2. internal/ - 内部模块

Go 语言特有的目录，其中的包不能被外部项目导入，适合存放私有代码。

• models/：定义数据结构和数据库模型。
• repositories/：处理数据访问（如数据库操作）。
• services/：实现业务逻辑。
• controllers/（可选）：处理 HTTP 请求（适用于 Web 应用）。

3. pkg/ - 公共模块

存放可被外部引用的公共代码，如工具库、客户端 API 等。

4. configs/ - 配置文件

存放配置模板或示例文件，例如：

# configs/config.yaml
database:
  host: localhost
  port: 5432

5. scripts/ - 脚本文件

存放构建、部署或测试的脚本，如：

# scripts/setup_db.sh
#!/bin/bash
psql -U postgres -c "CREATE DATABASE mydb;"

6. tests/ - 测试代码

存放集成测试或端到端测试，单元测试通常放在各模块的*_test.go文件中。

Go Modules 管理依赖

Go 1.11+ 引入了模块系统，使用go.mod文件管理依赖：

# go.mod
module github.com/username/my-project

go 1.20

require (
    github.com/gin-gonic/gin v1.9.0
    gorm.io/gorm v1.25.1
)

工具与构建

推荐使用Makefile简化常用命令：

# Makefile
build:
    go build -o bin/myapp cmd/myapp/main.go

test:
    go test ./...

run:
    go run cmd/myapp/main.go

Web 应用扩展结构

如果是 Web 应用，可增加以下目录：

my-project/
├── web/                    # Web相关资源
│   ├── static/             # 静态文件（CSS、JS、图片）
│   └── templates/          # 模板文件
├── api/                    # API接口定义
│   ├── v1/                 # 版本1
│   │   ├── handlers/       # HTTP处理函数
│   │   └── routes/         # 路由定义
│   └── docs/               # API文档

最佳实践

1. 单一职责原则：每个包专注于单一功能。
2. 最小化依赖：避免包之间的循环依赖。
3. 测试优先：为每个功能编写单元测试。
4. 配置外部化：通过环境变量或配置文件管理参数。
5. 使用标准库：优先使用 Go 标准库，减少第三方依赖。

通过遵循这些结构和原则，你的 Go 项目将更易于理解、维护和扩展。如果需要针对特定类型的项目（如微服务、CLI 工具）的结构建议，可以进一步说明！

自己开发的用于提取文本中的四则运算进行自动化计算的程序，方便平时记账使用。
举例，当你输入：

早餐 -6
奶茶 -19 -21
兰湘子 -92 -3.7
冰淇淋 -6
+(
-79 桑葚
-75 八宝茶
-97 牛肉干
) * 3

则会自动提取计算并显示：

-6-19-21-92-3.7-6+(-79-75-97)*3 = -900.7

tips:可以提取的计算符号为 +, -, *, / 和括号 (, )，并且支持小数点。

相关信息

• 开发工具
• 学习资源
• API 接口
• 读书笔记
• 实用网站
  影视 ，音乐 图片
  工具使用教程等
  如 VSCode，Git 等工具类

相关信息

• 关于我
• 关于本站
• 留言板
• 友情链接
• 站点地图
• 站点更新日志
• 站点使用说明

等

相关信息

• 随笔感悟
• 学习心得
• 最近明白的道理

散文、生活感悟
草稿与临时记录
未分类内容
临时笔记
草稿记录

程序员是世界上最酷的一群人。

• 编程语言
  • JavaScript/TypeScript
  • Go
  • Python
  • Shell
  • Zig
• 框架与工具
  • Vue/VuePress
  • Uni-app
  • Bun
  • Nginx
  • Redis
  • PostgreSQL
• 开发教程
  • go-zero 教程
  • ECharts 使用指南
  • VSCode 扩展开发
  • 算法学习笔记
• 系统运维
  • Linux 管理
  • Shell 脚本
  • BitLocker 相关
  • 服务器配置

技术研究
技术研究笔记，编程语言学习笔记，语言运行环境搭建等

技术应用
利用技术来解决实际问题
比如小脚本，小程序啥的

业务领域
和具体的业务以及工作相关的内容

和编程有关的一切

相关信息

• 健康管理
  • 运动计划
  • 饮食建议
• 时间管理
  • 任务清单
  • 计划安排

方法论，如个人效率提升，学习方法，减肥等

某一个具体问题的解决方案等

相关信息

学习资源整理，理论知识，基础概念等。

好吧，更快的执行和启动速度，完全兼容旧模组，听起来很是完美。
并且， Vue 、 Vite 、 VitePress 官方文档已经出现了 Bun 命令启动示例。也就是说，Vue 生态已经全面拥抱 Bun 。

并且，Bun 没有历史负担，社区和 Github 非常活跃。我们没有任何理由拒绝学习这么一个全新的，可以投入生产的，优先的 JavaScript RunTime 。

官方文档: https://bun.sh
中文文档: https://bun.dev.org.tw

下面是 Vue、Vite、VitePress 最新的安装文档，可以看到全部支持了 Bun，并且可用于生产

Vue: https://cn.vuejs.org/guide/quick-start.html
Vite: https://cn.vitejs.dev/guide
VitePress: https://vitepress.dev/zh/guide/getting-started

安装

macOS and Linux

Linux 内核版本 >= 5.6 , 并且需要 unzip 套件

curl -fsSL https://bun.sh/install | bash

Windows( >=Win10 )

powershell -c "irm bun.sh/install.ps1|iex"

npm

npm install -g bun

一般推荐使用 npm 安装，因为现阶段是无法完全脱离 NodeJs 环境的。需要学习 Bun 的人，设备上一定会有 NodeJs

官方安装文档 https://bun.dev.org.tw/docs/installation

Cli 命令详解

命令行输入 run 可以看到常用命令

我们可以发现， bun 不需要用到 npm yarn 或者是 pnpm 这些 包管理器，它直接使用
bun run, bun install, bun add 等命令来管理项目依赖。

而且可以直接使用 bun xxx.ts 来解析和执行 Typescript 文件，不需要安装其它依赖。

使用 bun x 或者 bunx 来替代 npx 命令。 bunx

而且内置 bun test 命令来执行单元测试，不需要安装Jest等模块 。bun test

还有 bun build 命令，可以直接将一整个 js 项目进行离线打包，不需要安装webpack、rollup 等模块。

更多的 cli 命令和文档可以参照: 超越 Node.js：Bun 的创新与突破

在学习 Bun 的 Cli 命令过程中，它给我一种非常熟悉的感觉，那就是 Go 语言。
众所周知，Go 现在是一门非常成熟的编程语言，它的设计者更是大名鼎鼎，没有任何一门语言比 Go 语言更简单易学。
之前一直在使用 NodeJs ，自它诞生以来出现了形形色色的补丁和工具以及生态，天下苦 Js 久已，于是 TypeScript 大火。
但是 Bun 的问世和设计让我觉得，这才是一个真正的 Js 运行时该有的样子。

Bun 使用国内镜像：

~/.bunfig.toml 文件中写入如下内容：

[install]
registry="https://registry.npmmirror.com"

实测，使用翻墙工具进行代理比使用 国内镜像 要流畅很多。

将 Bun 用于生产环境

2023 年 9 月，bun 发布 1.0
2024 年 3 月发布 1.1 支持 Windows
直到 2024 年 12 月 17 日，Bun 的最新版本号为 1.1.38 ，bun-releases上显示它几乎是一个月发布一个新版本，每次更新都会修复大量的已知 BUG，而且会有多位开源贡献大佬参与其中，社区也非常跃度。
主分支的代码几乎是每天都在提交和更新。

再加上 Vue 生态对 bun 的全面拥抱，以及 1.1 之后的 近一年时间的迭代与修复，我觉得当下就是使用 bun 最好的时机。

我自己试了一下，将手头现有的两个 Vue 项目换成了 Bun。几乎是无缝切换，目前没出现啥问题。

具体做法如下:

1. 删除 node_modules 和 pnpm-lock.yaml
2. pnpm install 换成 bun install
3. pnpm add <package> 换成 bun add <package>
4. pnpm run dev/build 换成 bun run dev/build
5. pnpm dlx <package> 换成 bunx <package>

我想吐槽一下子，这里第一次执行 bun install 时感觉比 pnpm install 慢很多，直到我开启了代理后 速度直接秒杀 pnpm install
而且 dev/build 的速度明显提升了非常多。

如果在遇到 bun install 和 bun add 命令卡住的时候，可以加上 --no-cache 参数。(我觉得这是一个官方 BUG)

bun install --no-cache
bun add <package> --no-cache

# 也可以选择清除缓存
bun pm cache rm

遇到异常可以直接手动删除 ~/.bun/install/cache 目录，这是 bun install <package> 的全局缓存目录。

R-阅读

阅读并摘录原文。
遇到某一个启发片段，停下来，划出来。

I-加深理解

针对摘录的原文，用自己的话进行复述，写出自己的理解。

A-致用

针对自己的理解

A1： 写下和这个知识有关的自己的经验，回顾自己有没有过类似的经历或见闻。通过反思自己的相关经验，让这个知识真的和自己有关。
A2：写下针对这个知识自己可以如何进行下一步行动今后如何应用，让知识真的在自己的生活中发挥作用。

新学的方法与我以前的方法有何异同？
结合新方法接下来我可以在哪些方面做提升？
我如何应用新学到的理论方法来分析某一事件？(如热点等)

结合费曼学习法

1. 发现一个概念，并写下来；
   • 新建一个 Markdown 写下标题和主旨
   • 拿出一张纸写下标题
2. 把概念教给别人，讲出来；
   • 找个学习搭子
   • 对着小黄鸭讲(小黄鸭调试法)
   • 录音，视频等
3. 回顾自己的经验，继续梳理概念；带着问题去不断推导。
   • 口述概念的时候遇到问题了，就进行回顾
   • 回顾完毕继续讲
4. 找出难以理解的地方，简化输出
   • 比如整理成这册，写一篇文章并发表

简化一下就是： 学习 -> 输出 -> 回顾 -> 凝练 -> 存档

总结

阅读一本书的步骤就可以拆分为：

1. 通读并标记原文
2. 问题总结(书籍本身可以帮你解决什么问题)
3. 核心概念和观点提炼
4. 结合每一个小概念进行费曼学习
5. 输出凝练观点

https://cloud.tencent.com/developer/article/2342050

https://pkg.go.dev/std

https://studygolang.com/pkgdoc

https://go.p2hp.com/doc/

我叫『墨七』，一名非典型程序员。热爱编程，喜欢拥抱新技术，妄图改变世界，企图让世界因我而美好。

一名全站工程师，在多个开发领域都有着比较丰富的开发经验。

墨七 , mo7 , Mo7

关于爱好

写代码给我带来过很多快乐，也曾在我内心最悲伤的时候陪伴我走出阴影。

经常会突发奇想，喜欢自己设计构想，然后自己动手实现的那种成就感。写出来的东西被大家认可也会给我带来极大的满足感。

编码上头时，可以十几个小时不吃不睡依然精神；但也会一口气睡上十几个小时雷打不动(睡眠质量特别高，躺床上 10 分钟就没了意识，深度睡眠基本都在 4 小时往上)。

喜欢篮球，曾是校队成员；喜欢电影、游戏、美食、阅读和思考。喜欢创造，喜欢看着自己亲手建立的东西一点点完善。

喜欢玩原神、星际争霸、在 Steam 上体验各种大作。曾经的暴雪粉。

关于理想

愿世界和平，愿所有的种子都能开花结果，愿有情人终成眷属，愿好人一生平安。

但愿望终归只是愿望，我唯一能做的事情就是在目之所及之处做到最好，在自己能力范围之内发挥自己所长帮助更多的人。

关于本站

关于更多信息可阅读 关于本站

在日常的工作和学习当中我积累了大量的经验、知识和技巧，他们被我用 md 记录了下来存储在 Github 的私人仓库之上。

并且还有一些想法，想要表达的思想和观点等。我不太愿意将这些东西公布在各种公众平台之上，因为当我的知识变成了数据，那么这些数据的安全和版权应当由我自己负责。

写博客，并不仅仅只是为了表达，更是一种记忆和修身养性的方式，让自己浮躁的生活跟心情沉淀下来的一种手段。我希望过个七年八年的，再回首打开这个站点的时候，它能变成一种财富和寄托。

我基于 ThemeHope 这款主题做了一些魔改，包括样式以及功能。每一处修改均以插件的形式进行了封装，现在已经开源并发布。
Github 仓库地址: https://github.com/mo7cc/blog-source

注: 本站并非开源，但是我写了一个同步脚本，会定期将博客的源码同步至上述公开仓库中。通过上述仓库中的源码可以顺畅编译出本博客的全部公开内容。

本博客搭建的技术细节可以参考: 本博客搭建指南

顶栏和音乐播放器

这是顶部的一些下拉菜单，其中画板下拉菜单可以更改主题和全屏浏览。

我基于 APlayer 开发了一款全局的音乐播放器。可以通过顶部导航栏右上角的

还做了一个站点地图页面，可以直接访问本站已经发布的所有文章列表。

宽屏兼容

因为家里的屏幕是 21:9 的，但是主题的内容部分却依然是 窄窄的 一长条，空白地方留了很多，感觉很空旷，所以自己做了一个内容部分的宽屏兼容，适配更大的分辨率。

夜晚模式

尝试了很多很多的背景，调色，这一版的夜晚模式我非常满意。在白天模式和夜晚模式使用了不同的动态背景。第一版背景切换非常消耗性能。后来做了优化，现在切换非常流畅，内存占用非常低。

评论区

评论区设置了发布频率限制，允许不登录匿名留言，支持 Markdown 语法，支持图片上传，支持预览和 Emoji 表情。

缘起

我最初学编程的目的就是为了能够拥有一个属于自己的网站，我觉得那会很酷，仿佛自己的心声可以被全世界所听到。我觉得程序员很酷，因为我觉得每一个程序员都拥有足以改变世界的力量。

时代变化如此之快，还没等我自己的第一行代码上线运行，微博，知乎，简书等各大平台如同雨后春笋一样拔地而起，互联网时代就在我身边悄然而至，这些应用也在悄然的改变我们每一个人的思考和生活方式。
虽然后面也在各大互联网头部企业担任过技术骨干，回头再望发现自己只不过是沧海一粟。

缘落

我们细数一下，在当前时代如果你想从零搭建一个自己可以完全操控的稳定的站点，需要哪些知识和技巧:

1. 通过域名商购买符合自己心意的域名。
2. 通过云计算服务商购买符合自己心意的服务器（此时你需要最基本的计算机基础知识，和 Linux 最基本的操作技巧以及处理操作系统常见问题的能力。）
3. 了解基本的 HTTP 原理。
4. 掌握 HTML、javascript、css 网页编辑语言，掌握常见的开发调试技巧。
5. 如果你想让数据流动起来，你需要掌握一门服务器编程语言和最基本的数据库操作使用方法。

除此之外，网站的运营还涉及到 SEO ，流量推广，PWA 等等知识。如果你在中国大陆，想让自己的站点稳定的运行，还得了解基本的法律法规和管理条例以及备案技巧。

如果你想让它变得内容变得更加丰富，界面变得更加生动，访问速度更快，或者功能性更强。
你还得深入掌握更多更加专业的知识或者技巧。如果想要让站点能够与时俱进，得保证技术的更迭和软件的维护。随着功能越来越多，所需要的各种专业知识也将更多。

当然我们这里的讨论排除掉各种站点的速成框架以及集成化的方案，这种囫囵吞枣式的搭建方式都带有铜臭味。毕竟作为程序员，对技术还是需要一点点小资品位的。

大到淘宝、Facebook，小到个人站点，他们所需要的最基本的技术和配置都差不多，只是所需要的深浅不太一样。随着技术大牛们的努力和开源世界的慷慨，这些事情都会越来越容易的。

需求

在最初，我是采用下面这种方式去记录自己的日常工作和学习的:

后来还用过飞书、Excel、各种 ToDo 软件等。还是觉得 Vscode + Markdown 的方式最好(吊打一切笔记软件)。方便阅读、方便修改、简单、兼容性好。一次编写可以很轻松的在各种格式下进行转换，属于文档当中的【基本单元】。不管是 Word、还是 Excel，如果没有特定的软件读取则无法访问。并且由于商业竞争，它们对其它软件的兼容性都很差强人意，格式转换时也会出现排版混乱等情况。 Markdown 则不同，它排版简单，使用方便，长什么样子完全取决于如何解析，不同主题下可以可以拥有不同的观感，排版也不会混乱。包括我的个人资料，文件，文档，心得体会，和一些日常的小记录等我全都采用 md 去记录的。

Markdown 中图片的处理会比较麻烦，传统的例如 word 等文件格式它会将图片一起打包到文件中，但是在 md 当中图片更像是文档的依赖文件，是游离于文字之外的东西，除非你使用网络图片。我研究了各种图床，但是都存在各种限制。免费的图床很多，但是想要使用方便、免费、访问速度，稳定安全等因素兼得，实在是太难了。于是我最终选择了自己开发一个图床服务。

Hexo

Hexo ，这是我在经过认真对比后采用的博客构建工具，主题丰富，生态完善，采用 md 编写内容，基于 node 和 npm ，上手简单快捷。但是用起来总有不舒服的点:

热更新速度慢，静态资源路径的识别无法跟编辑器很好的兼容，框架想要进行二次编码和修改只能使用最原始的 css 和 js 覆盖，想要集成 less 或者 ts 等现代前端工具需要自己编写和配置很多东西。

Hexo 博客项目源码

VuePress

后来发现了 VuePress ，在仔细体验后，大爱！ 因为是基于 vite ，所以可以做到在编写 md 时几乎无感的热更新速度，保存之后页面无刷新渲染，使用体验媲美 VSCode 的本地预览！

基于 Vue 渲染引擎，Vite 的编译和打包，TypeScript，Sass 支持，包括 Vue 组件等。博客的开发体验跟 WebApp 达成了一致，比 Hexo 高出了好几个档次。虽然生态尚不成熟，但是却无法挡住其锋芒。

缺点是主题和插件稀少，很多东西都得自己手动开发。

VuePress Theme Hope

自己编写一款主题需要的细节和工作量是巨大的，我并不想投入那么多的时间和精力在这个上面。但是 VuePress 原本的默认主题又太过简陋。

在找寻许久后，我相中了 ThemeHope 这款主题，它的作者是 VuePress 团队的成员，其更新速度和稳定性以及扩展性从基因层面就得到了保证。

于是基于 Hope 主题进行了一些细微的调教，自己写了一些功能模块，才有了本站当前的模样。

在这里感谢 𝓜𝓻.𝓗𝓸𝓹𝓮 为我们带来这么棒的主题及其配套的插件。

™

基于知乎的一篇回答建了一个群，拉起了一支团队，
并成立了一个 Github 组织 ，
然后大家一起研发了OtterTrade.com ，
在最开始进行产品定位的时候，就要求主站必须精简、美观、大方、易使用。但是再怎么易使用，必要的文档说明是无法避免的。
于是计划所有的解释说明的工作全部交给一个独立的文档站去承担。

文档站中包含了平台介绍，快速上手，系列教程，团队介绍，起源，愿景，规划等等等。可以说现阶段文档站的重要程度不亚于 OtterTrade.com 主站。在运营设计上，文档站有三个地址:

文档站(Github Pages)
https://otter-trade.github.io

文档站(新加坡备用地址)
https://doc.OtterTrade.com

文档站(国内备用地址)
https://ot-doc.mo7.cc

文档站是导航，是回家的路，所以安全可靠的访问途径非常重要。

文档站的构成

文档站的源码存放于 https://github.com/otter-trade/doc-otter-trade ，是个开源仓库，主体由 vuepress-hope 搭建。

其编译结果存放于 https://github.com/otter-trade/otter-trade.github.io 仓库，因此可以直接利用 Github Pages 的特性。

然后通过 Webhooks 机制同时部署在两台不同的服务器之上。

所以文档站的基本工作流就是:

1. 向 墨七 申请 doc-otter-trade 和 otter-trade.github.io 这两个仓库的权限；
2. 利用 git clone 命令下载文档站源码；
3. 在编写完对应文档之后，编译打包并推送至 otter-trade.github.io 仓库完成发布。

# 克隆 文档站 源码到本地
git clone git@github.com:otter-trade/doc-otter-trade.git
# 用 Vscode 打开
code ./doc-otter-trade

然后你就获得了如下界面

除此之外你可能还需要安装如下插件

然后你就可以愉快的开始编写文档了！

命令介绍

在项目目录的 ./package.json 文件中我提前编写了如下指令

{
  // ....
  "scripts": {
    "dev": "vuepress-vite dev src",
    "build": "vuepress-vite build src",
    "clean-dev": "vuepress-vite dev src --clean-cache",
    "update-package": "pnpm dlx vp-update",
    "sync": "./.vscode/shell/GitSync.sh",
    "deploy": "./.vscode/shell/Deploy.sh"
  }
  // ....
}

使用方法如下:

pnpm run dev
# 在本地启动该项目

pnpm run build
# 编译该项目

pnpm run clean-dev
# 清除所有的编译缓存，并启动项目，如果一些配置或者编写的文章没有生效则可以使用该指令

pnpm run update-package
# 更新项目依赖

pnpm run sync
# 拉取 Github 上的最新改动，并保存和提交当前改动 同时 推送至 Github ，需要仓库权限

pnpm run  deploy
# 编译本项目并同时推送至  otter-trade.github.io 仓库， 然后将会自动完成项目的部署与发布, 需要仓库权限

其它

如果你想编写出华丽的可交互的文档可以查看和学习如下教程
https://theme-hope.vuejs.press/zh/guide/markdown/intro.html

如果你想让文档具有更多功能可以学习如下教程
https://theme-hope.vuejs.press/zh/guide/component/built-in.html

另外一种更新文档的方式

拖延并不在外在的行为，而是深藏内心的恐惧与焦虑。
拖延实际上是一种心理防御机制用于保护自己免受失败或压力的打击。
当你面对一个重要的任务迟迟不愿开始时，可能并不是因为懒惰，而是因为害怕失败，担心无法达到自己或他人的期望。
这种对失败的恐惧趋驱使自己选择逃避。
拖延就成了一种暂时的减轻压力的方式。

完美主义者尤其容易陷入拖延的陷阱

完美主义者往往对自己设定了极高的标准，害怕自己无法达到这些标准而害怕被他人否定。
为了避免面对可能的失败，选择拖延甚至宁愿不做，也不愿做的不够完美。
这种要么不做，要么做到最好的心态，进一步加剧了拖延行为。

家庭环境

父母的高压要求和批评，会导致孩子对失败产生过度的敏感。
成长以成功为导向的孩子可能会感到巨大的压力，害怕自己无法达到父母的期望，从而选择通过拖延来逃避这些压力。
这种心理机制，随着年龄增长逐渐内化，成为成年后拖延行为的根源之一。

社会环境

在这个高度重视成功的社会，人们往往被灌输成功等于个人价值的观念。
当个体无法达到社会所设定的高标准时，拖延便再一次成为了逃避失败 保护自尊的手段。
当面对那些看似无法完成的任务时，拖延成了一种应对压力和不确定性的 本能反应 。

过高的期望和目标

如果你本身很勤劳，有计划有目标，但是对自己的期望过高， 或者目标定的过于宏大，也会导致你丧失行动力。

如何打破拖延

我们一边责备自己，一边在无尽的拖延循环中沉沦。

要想摆脱拖延的恶性循环，单靠意志力远远不够。

需要从认知和行为两个方面入手，重新构建自己的思维方式，并采取切实可行的行动策略。

1. 正视内心的恐惧与焦虑

   我们要认识到拖延背后的恐惧，要学会更加理性和积极的方式看待这些情绪。
   当你因害怕失败而拖延时，提醒自己 ，失败只是学习和成长的一部分，是成功的必经之路。
   改变对失败的认知，可以帮助自己减轻心理负担，进而更加轻松的开始行动。

2. 制定明确、可操作的目标

   模糊的目标往往令人无从下手，容易导致拖延，将宏大的目标分解成具体的小任务。
   将目标分解成具体的步骤，给每个步骤设定必须完成的时间期限。比如把 30 分钟花在做某件事上，并保证不改变这个时间。
   具体，合理，务实的目标不仅更容易上手，也能下逐步完成任务的过程中建立成就感。打破拖延的循环。

3. 列出自己的非计划表格

   合理的时间管理对克服拖延至关重要，制定一个详细的时间表，将任务按优先级排序，并为每项任务分配具体的时间段，在表中列出接下来的一周里所有你必须做的事情。
   把各项活动需要占用的时长标示出来，这张飞计划表中空白的部分就是还没有被安排的时间，就知道还有多少时间可以利用。通过这个表格可以慢慢学会确的预测一件事情需要花费多少时间。

4. 学会拒绝与聚焦

   学会拒绝那些不符合核心目标的任务，将精力集中在真正重要的事情上。拖延有时是因为我们试图承担太多任务，学会优先处理重要的任务将有助于你减少不必要的拖延。

5. 用正念减轻压力

   我们把注意力放在自己的呼吸上，这时我们就会主动去感受呼吸的过程，并留意呼吸的感受以及我们的反应，我们还会注意到自己是否正在专心呼吸，一旦发现自己走神，我们就要有意识的把注意力带回到呼吸的过程。若没有保持正念，表面上我们安静的呼吸。但意识已经神游天际了。

拖延是一种普遍的行为，尽管我们可以通过各种策略应对拖延。但也不是一朝一夕就能彻底消除的，不过也不必过于苛责自己。我们要学会接受自己，理解拖延背后的心理机制并与之和平相处，按照自己的价值观去生活而不是强迫自己追求完美，或消除一切不完美

当一个时间赌徒

就是咋吃一段时间内，只选一件事，然后下重注，压上自己所有的时间，不顾一切地去做。
比如，截止日期是下个月，那么就压上你这一个月所有的时间，孤注一掷的去完成。不需要任何花里胡哨的时间管理方法，因为最简单的时间管理就是完全不管理。
花尽一切可能的时间专心做好一件事情。
只有时间上压倒性的投入，才能换来结果上压倒性的胜利。
太多目标太多欲望，只会造成选择模糊和动力损耗。这是阻碍一个人行动力的根源。即便我们有能力实现所有目标，但是也几乎不可能达成所有目标。
因为想要得到异于常人的结果，就得拥有异于常人的专注。这种专注分为【短时专注】和【长期专注】。
短时专注就是当下的专注，做一件事时专心致志，心无旁骛。
长期专注是指在较长的一段时间内，将核心的时间都投入到一件事，对目标的结果和信念坚定不移。
想要做成一件事，这两种专注缺一不可，必须形成合力。
很多人考研失败是因为缺乏对于学习任务的短时专注。很多人创业失败，是因为缺乏对于一个赛道的长期专注。
拥有专心当下的能力很重要，而具备长期专一的定力更重要，因为我们付出的行动和我们得到的结果之间是有延迟的。想要的结果越好，需要等待的时间就越久。
大多数人都期望得到期望的结果，有没有耐心等待。总是一边做，一边怀疑，短时间内得不到正反馈，就立刻陷入情绪内耗。
所以，你一旦开始发疯式的开始做，用焚膏继晷的决心持续做其实赛道一点都不拥挤问题一点都不难。

当时间赌徒意味着你要放弃一些东西。
比如，你决定了要好好学英语，可以彻底放弃公司的绩效奖金，每天到点下班，通勤路上随时随地看外快刊和听 TED，在午休时间被语料，那么你的英文水准一定会突飞猛进。

只要你不顾一切，把自己一个时期内的时间都压在一件核心事情上，孤注一掷，买定离手，不设退路，就在这件事情上死磕到底，在过程中不断精进与历练，就一定会带来革新性的改变。

用自己的行动去见证时间的强大力量。所谓流水不争先，争的是涛涛不绝，坚定选择一条河道，用自己最大最强的势能，汹涌澎湃地奔向大海吧。
本段来源: https://www.bilibili.com/video/BV1kcSZYwE8Q

行动

人的基因有一种设定，对模糊不清、不可名状的东西感到害怕。
现实生活中行动力很糟糕的人。并不是懒惰，也并不是害怕要处理的事情本身。
他们的恐惧是来自于任务的模糊性。
行动力不足都来源于精确性的不足。
普通人生活中几乎所有的不行都是由精确性的丧失开始的。

如果需要一件事情的发生，就需要去集齐这件事情发生的所有要素就行了。
当你提高了对客观世界评估的精准性，一切你觉得遥不可及的事情都会变的很简单。

10%目标定律

无论在生活中想要什么，都要做 10 次尝试。大多数人连一次都不想尝试。
而 10% 目标定律的意义就在于学会面对 90%的失败。
如果今后做任何事情都愿意先尝试 10 次，那么其中一个必然会成功。

爱具体的人

做具体的事

愿意选择乐观，哪怕是错的，也不想选择悲观，即使是对的。

努力成为想成为的那种人，就算不成功，至少喜欢现在努力的自己。

番茄工作法 wiki

25 分钟专注做一件事情 ， 休息 5 分钟 为一个 番茄时间 或者称之为 一个 番茄钟。
完成 4 个番茄时间 休息 15-30 分钟，被称为 一组番茄时间 或者 一组番茄钟。
这就是 番茄工作法 。

你需要一个计时器，或者闹钟，用于记录你的番茄时间。
一份随时写下待办事项的活动清单，用于记录你所有你需要要做的事情或者计划。
另外再准备一份今日待办工作计划表，用于记录你今天要完成的工作。
一份用于记录原始数据的记录表。

除此之外，一个完整的番茄工作法体系有 6 个流程或者是目标

1. 必须制定 今日待办

   在第一个番茄时间里，明确自己要完成哪些任务，任务的优先顺序，先做什么，后做什么。
   每个任务需要多少番茄时间。
   超过一个番茄时间的大任务需要拆分成许多单独的番茄时间，不满一个番茄时间的多个小任务可以合并成一个番茄时间。

2. 执行 今日待办

   这个过程中要对抗各种内部或者外部的干扰，尽量完成完整的番茄时间
   如果被打断了，这个番茄时间就不成立，称之为一个 烂番茄。
   打开计时器设定一个 25 分钟的倒计时，从 今日待办 中的第一个任务开始工作。
   这 25 分钟内不可以做当前任务外的任何事情， 也不可以被其他人或事打断或者打扰，否则这就是一个 烂番茄 ，你需要重新开始计时。
   一个番茄时间结束后在后面打上一个 x ，接下来的 3-5 分钟不可以做任何根当前工作相关的事情。可以喝点儿，吃点，走一走，和周围人聊聊天。
   休息完成后重复以上步骤，开始第二个番茄时间，直到第四个番茄结束开始进入长时间休息。休息 15-30 分钟，这期间不能给大脑增加任何负担。
   今日待办 中完成一项任务就划掉这个任务。
   如果当前番茄时间没有结束，那就回顾和检查刚才的工作。
   如果任务结束当前的番茄才进行了不到 5 分钟，那就把这个番茄时间作废。
   如此往复直到一天的工作结束。

3. 需要根据任务完成情况，记录每个任务实际使用的番茄时间。

   最好是在任务开始之前先估测将要使用的番茄数，然后再任务完成之后记录实际使用的番茄数，然后在统计出差值，包括任务的开始时间，结束时间，中间被打断了几次等。并把这些数据统计到 记录表 中 。

4. 复盘

   需要结合自己在第一步中制定的番茄工作计划，以及在第三步中实际记录的番茄时间对比、复盘、分析对改进自己的工作有用的信息。
   比如我在哪些地方花费了比原先计划更多的番茄时间，哪些任务超时了，超时的原因是什么。
   产生了多少烂番茄。 烂番茄 是内因还是外因造成的。

5. 根据复盘中得出的经验，灵活的制定你的番茄时间计划表。

   比如，你发现自己下午效率更高上午其实一般，可以把上午做的番茄时间移动两个到下午。
   这种调整也是可以根据具体的事情。或者实际可以利用的时间来调整，从而形成一段时间内的 番茄工作计划表 。

6. 在完成了前面任务的情况下寻找到个人目标，并且利用番茄工作法节省出来的时间来实现。

   这个是最近几年番茄工作法官方加上的一些额外内容。这个和番茄工作法本身是无关的，但是它使得番茄工作法 更加完善。

整个番茄工作法可以区分为 计划 -> 执行 -> 复盘 三个不断循环的环节，从而形成了一个完整的番茄工作体系。
这其中我认为制定计划和进行复盘对于番茄工作法来说是更加重要的。

时间具有生成性和事件的连续性两个特点。我们有了具体的日期，时、分、秒的定义，才有了迟到、DeadLine 等概念，也才有了随之而来的时间流逝感、焦虑感。
如果我们用一个个的具体事件去衡量，吃饭、洗澡、背一篇文章 时间的连续性带来的焦虑感就会减少。

番茄时钟就是利用这种基本原理来减少焦虑感。

还有一部分焦虑来自内外部的频繁打断。

内部因素主要来自于自己。神奇的大脑和身体机能有的时候会突然冒出一个奇妙的想法，比如突然饿了，或者突然想知道陈奕迅的下一场演唱会什么时候开，那么就在 活动清单 中记录一下 想法。
如果这件事情今天或者待会儿就得完成，在今日待办中的 今日待办 里面添加一行，然后继续当前的工作。
如果这件事不一定要今天做，那就写进 活动清单 并标注截止日期。
如果是来自于外部的打断，我们需要做的就是快速记录，推迟打断你的这件事。

为每一个 活动清单 来进行番茄时间的估算，如果一项任务需要 5-7 个番茄数，那就拆分为小任务。
如果多个任务估算值小于一个番茄数，则可以酌情整合在一个番茄时间内完成。
更精确的番茄数估算，可以方便我们把 活动清单 的任务合理安排到 今日待办 中。
总体任务不超过当日可用番茄数，完成一个番茄，打上一个 x，完成一项任务划掉它。
如果一项任务完成后发现预估番茄数还有剩余，那么就记录一下留作复盘。

一天的工作结束后，记得复盘。长期坚持尽量让预估越来越准确。

番茄工作法与拖延症

在上一篇 拖延症与行动力 一文中，我们知道想要带打破拖延有五个行动策略：

1. 正视内心的恐惧与焦虑
2. 制定明确、可操作的目标
3. 列出自己的非计划表格
4. 学会拒绝与聚焦
5. 用正念减轻压力

抛开第一条不谈，番茄工作法仿佛是专门针对 第 2~5 条 进行设计的。而且我们一旦开始按照番茄工作法开始执行了，那么第一条也会随着时间得以缓解。

番茄工作法需要罗列 活动清单 ;
番茄工作法需要划分出今天需要明确执行的任务也就是 今日待办 ;
番茄工作法在执行过程中需要集中注意力并且不允许被打断 ;
番茄工作法在执行过程中要求你必须 专注与聚焦 ，哪怕是胡思乱想也算是打断 ;
番茄工作法每 25 分钟要求你休息一次，并且这期间不允许进行和思考任何与工作相关的事情。

这在我看来，番茄工作法简直就是专为 拖延症 而设计的。

制定良好的合适的 番茄计划 ，把一个任务拆分成多个步骤，并且预估好合适的工作时间，可以有效的帮助我们更好的去协调自己的生活和理想。尤其是面对一大堆的琐碎的任务，一张合理的 番茄计划表 可以让我们不再焦虑，并提高工作效率。

按照 番茄工作法 一条条的去执行。在一个个 番茄时间 中不断的树立信心与积累 成就感，从而让我们做事越来越主动和高效。
当现实的问题全部被转换成一条条 番茄计划表 的时候，我们就只需按照番茄工作法严格执行，那么现实问题自然而然也会得到解决。
当你专注于手头的 今日待办 时 ，焦虑与不安自然而然也会一并消失。日积月累之下，你会感觉自己正在逐步成长。

如果你有一个非常远大的目标，将它拆分成一个个的 “小番茄”，然后不断的吃掉这些 “番茄” ，你离自己的目标也会越来越近。

番茄工作法常见问题

1. 内部因素 和 外部因素 的打断。

   内部因素：主要是我们自己的注意力或者是情绪引起的。比如，你刚刚分手，然后让你专注的学习两个番茄时间，绝大多数人肯定都做不到的。还有突如其来的思想抛锚，想入非非，突然发生的奇思妙想等。
   外部因素：手机电话，同事领导时不时找你有事，快递，外卖等等。如果你所处的环境会时常会被打断，是你无法做到专注，那你就得考虑番茄工作法可能并不适合你。

2. 另外一个问题是，25 分钟的番茄时间可能不太合适。

   一个番茄钟开始了，可能刚刚找一点点状态，就要开始休息，然后又要重新找状态。 一个 25 分钟的番茄时间大部分都用来进入状态了。
   一个网课大多数都是 1 个小时或者更长的，好不容易跟上思路结果就因为番茄时间到了要休息 5 分钟。
   对于逻辑性比较强的一些工作，可能得花个十几分钟才能理清楚做题的思路，不可能做题做到一半就休息 5 分钟。

3. 有的时候 5 分钟的休息时间感觉可能也不太够。

   整个番茄法的原理认为，我们的注意力会随着时间下降的，所以每学习 25 分钟休息 5 分钟，就能让你注意力水平恢复到最高的状态。
   但实际的情况可能有变，比如注意力下降的比较快，休息 5 分钟注意力可能只恢复到一半。

4. 刚开始使用番茄工作法时，可能会不知不觉的追求番茄工作法的数量，而不是工作的质量。

   当工具本身变成了任务就失去了它的价值。如果只是把问题拆分成番茄时间，可能会给人一种 “达到了数量就解决了问题的错觉” ，这个就是心理学上的 “计数器陷阱” 。
   所以很多时候完成的往往是量的积累而不是质的改变，看不到明显的提升效果，后面就不太想要坚持了。

番茄工作法的升级建议

1. 要个性化你的番茄时间。

   一个番茄时钟不一定非得是工作 25 分钟 休息 5 分钟。这种可能比较适合普通人或者是搬砖的简单工作。
   如果工作本身逻辑性和推理性比较强，可能更加适合比较长的周期。 比如工作 50 分钟休息 10 分钟就比较适合专注类的工作。
   或者我们将任务进行分类，比如简单一点的重复性劳作，就 25-3 的番茄钟；学习类的任务，可以根据课时进行动态划分，比如番茄钟可以设置为 40-5；如果是研发类的，需要专注思考的，可以设置为 60-10。
   这个需要花上几周的时间，不断的进行番茄钟的 复盘 ，来找到适合自己的节奏。
   可以给 自己的日常任务进行 分类 ，不同类型的任务使用不同的 番茄时间 。

2. 计划 和 复盘 很重要

   计划的作用是在于让我们分清楚事情的重要程度，排好优先级，否则可能 小事情忙了一天，大事一样没做。
   复盘的作用是让我们知道哪里做的好哪里做的不好，从而形成快速的、可执行的迭代方案，才能帮助我们快速成长。
   同时也可以不断的提高我们对 番茄时间 的预估精准度，更快的找到适合自己的番茄时间。
   同时也可以提高下次 番茄时间 的效率，让自己的番茄时间更加均匀，更加自主可控。更加合理高效的安排一天的工作和学习任务。

3. 使用番茄工作法的前提，是这些时间是你能够完全自主可控的。

   如果你是学生党，那么你的课余时间都可以是自己的。
   如果你是上班族，上班的时间又经常会被打断，那么番茄工作法很难起到作用。
   所以可以判断一下，如果接下来的几个小时自己可以全完全做主，那么就可以使用番茄工作法。
   如果工作中打断只是偶然发生的事件，那么就可以快速记录一下，把打断外的事件立即标记到 计划外紧急事件 中，并做好时间记录，然后立即重新投入到当前番茄时间里面去。尽量让自己的番茄钟更加完整。

4. 排除环境干扰，在开始之前给自己制造一个安静的环境。

   在开始 “吃番茄” 之前找一个尽量不会被其他人打扰的时间和地点来进行。
   然后给自己创造一个专注的环境，比如可以去图书馆，或者把桌面的杂物清理掉，把干扰因素提前排除。如:手机调成免打扰模式等等。

5. 番茄计时器的使用

   尽量不要使用手机，因为手机本身就是一个很大的干扰。
   可以买一个专门的计时器。
   更加推荐使用手表或者手环。
   我现在就用的小米手环，它本身也带有倒计时功能，时间到了就振动两下。这样休息时间我可以不带手机在公司里面到处溜达，做一做拉伸运动，倒计时结束后返回工位继续下一个番茄时间。

6. 珍惜心流的状态

   如果一旦进入心流状态，就不要再管什么番茄时间了，好好把握这种状态，专注做好自己手里面的事情，直到感觉到疲累或者心流的状态消失。再继续番茄钟。
   根据我以往的经验，一个心流的时间不宜太长。就比如我，一个有效的心流时长不会超过 1 个小时，一旦超过思维敏捷度就会下降，甚至会开始钻牛角尖，导致思路打不开。
   所以还是更加建议隔一段时间就去休息一下，休息的过程中可以四处走一走，喝一喝水，看看四周的人事物，尽量减少对工作的思考。不过在开始休息之前可以做好记录，方便休息结束后更快的回到工作当中去。
   如果是非常需要深度的工作，休息的时间可以稍微定短一点，比如 3 分钟，让自己可以缓一缓，同时也不至于忘了之前推理的内容。

7. 学会休息

   番茄工作法休息时间和工作时间一样重要。休息的不好可能会无法回到之前的注意力水平。
   所以休息的时候最好不要思考任何和任务相关的事情，也不要刷视频刷朋友圈，因为这些事情会偷偷占用你的注意力或者影响你的情绪。
   休息时多看看远处，或者多看看绿色的植物可以缓解视疲劳，或者深呼吸几次甚至闭上眼睛用一下 全身扫描放松法 来放松身体。 或者做一点拉伸运动等等。
   一个番茄时间加上休息是 30 分钟，一组四个番茄钟也就是两个小时。一组番茄结束之后可以找个舒服的地方睡 10 分钟。
   每个小番茄之间的休息间隔也不一定非得是 5 分钟，比如你可以放下手头的工作来调整自己的状态，当你的状态调整好了之后你再进入下一个番茄时间 效果可能会更好一些。

工具推荐

专注清单App：

https://www.focustodo.cn

这是我前不久发现的一款神器，它基于番茄工作法设计的。

• 每个任务可以单独设定番茄时间的时长和番茄数，休息时长等都可以自定义。
• 任务完成后会自动归类到完成列表中。点击任务详情可以直接查看开始时间和消耗的番茄数。
• 它会在每个任务下面直接显示你的预估番茄数，和实际使用的番茄数。
• 它支持将一个大的任务拆分成多个子任务，并且单独的番茄钟计算。
• 它不会记录你的休息时间，但是会记录你每一个番茄钟的开始时间和耗时。
• 它支持给每个任务添加备注。
• 它兼容几乎所有平台，Android、ios、Mac、Windows，以及 Chrome 插件，而且完全免费，全端数据互通。
• 它提供了 番茄工作法 的所有核心功能。

因为我的工作大多数都是在电脑端完成的，所以开着 专注清单App 去工作，到时间了自动弹出提醒界面，非常方便。

另外一个就是 带有倒计时功能的 手表 、 手环。直接开启 25 分钟倒计时，工作完了设定一个 5 分钟倒计时即可。

番茄清单可以理解为是一个全平台通用的带有倒计时功能的 ToDoList。 秒杀市面上的各种 ToDo 软件。

结束语

我们每天的第一个番茄钟必然是 整理今日待办 ，每天最后一个番茄钟必然是 今日总结与分析 。
总结分析的第一件事情就是统计 今日待办 。

PS: 整理今日待办 和 今日总结与分析 大概 10 分钟左右足矣。

我根据自身情况设定的常规番茄钟是 30-5，也就是工作 30 分钟休息 5 分钟。

我们来大致估算一下:
早上 9:00 到 11:30 一共 150 分钟，也就是 4 个番茄钟，刚好完成一组。开始午休。
下午 14 - 18 点，最多容纳 6 个番茄钟，也就是刚好一组番茄钟外加一个番茄时间。
如果你很勤奋，晚上回家还想学习一会儿，最多也就腾出来 一组番茄钟。

换句话说，如果设定番茄钟为 30-5。
在没有烂番茄干扰的情况下，每天理论可以完成 3 组番茄时间 共计 12 个番茄钟。

如果你不上班，是个自由工作者，或者你是个独立开发者，你全程在家办公，拥有大量的无人打扰的时间。而且你还是个超人，能够长时间进行专注的学习和工作，那么你一天的有效番茄钟大概也就 16 个了，也就是 4-5 组番茄钟。如果一个人真的能持续不断的做到这一步，再加上方向正确和一点点机遇，再加上时间沉淀，你一定可以完成任何你想完成的事情 。

我归纳和整理这篇文章，专注清单App 显示花了大概 10 个番茄钟，也就是完完整整的一天时间都在整理和归纳这篇文章。

包括各大视频博主自媒体博主等，他们可能第一天录制视频，第二天剪辑视频，第三天发布，充其量也就两天一个视频出炉。随着熟练度增高，可能速度会越来越快，但一天最多也就一个观感完美的视频出炉。

所以你看，时间真的很宝贵也很不经用。当你开始专注于某一件事情的时候它一晃就过去了。所以当你真正的开始做实事的时候才会明确感觉到时间的宝贵。

你可以根据自身的情况设计属于自己的 番茄列表 ，甚至可以使用 Excel 设计成表格。

墨七的 番茄列表 展示

上图是就是我根据 番茄工作法 重新设计的 番茄列表 工作区的演示。通过之前的脚本可以一键生成 基础模板。然后每天第一件事情就是在里面填空，然后就是按照番茄工作法去执行和复盘就好了。
最终产生的 Markdown 文件通过 VSCode 的 Markmap 插件可以很好的渲染成脑图。这样一来，远比之前的 任务列表 清晰很多。

我们把整理好的今日待办输入到 专注清单App 中，然后按照番茄工作法去执行。执行的过程中，内因打断就记一下想法，事件打断就记一下吐槽，任务穿插就在 今日待办 中新增一个额外事项并列一下优先级 。
当一天结束时，可以在 今日已完 成中回顾每天的任务，整合到 今日待办 中，可以非常方便的回顾今天一天的 “番茄情况”。 然后改进工作方式，以待下次做得更好。

你可以自行修改脚本和模板来满足自身的需求。

项目开源地址: https://github.com/mo7cc/blog-source/tree/main/_shell

番茄工作法 七天使用心得

在开始做事情之前，点击一下开始计时按钮，意味着要开始专心干活了。保持注意力集中。
计时结束，表示你该休息了，然后进入休息计时。这个时候可以处理一下聊天列表，邮件，四处走一走，闭目养神，做两个瑜伽动作。做好迎接下一个番茄钟的准备。
如果工作的状态正酣但是进入休息计时了，则可以直接点击 完成休息 立马开始下一个番茄钟。直到感觉自己状态逐渐无法集中的时候，可以立即点击 暂停 ，然后手环设置一个 5 分钟的倒计时，开始四处溜达直到自己状态恢复。
状态恢复后，回到电脑前，点击 继续 然后继续开始工作。

这样使用 番茄工作法 的好处是十分灵活。

也就是说，干杂活的时候每 30 分钟休息一会儿，然后再继续专注 30 分钟，可以让自己持续性的高效。
做需要深入思考的工作时，提醒休息的闹钟响起，立即点击结束休息，然后再次立即点击开始计时，直接跳过休息立马进入下一个番茄钟，直到自己下一次闹钟响起或者自己注意力涣散。

专注清单App5 分钟的休息计时我基本上很少用到，休息计时基本上都是用 手环倒计时 功能完成的。

如此一来，每项任务花了多少个番茄钟，专注清单App都帮我做了很好的记录，方便估算自己的效率。然后看着任务列表一项项的任务被完成非常具有成就感。
早上先整理一下今日待办，然后把今日待办输入到 专注清单App 里面去，然后定时休息。开始工作前点一下开始计时。如果状态好就跳过休息立即开始下一个番茄钟。休息的时候也不用非得严格限定时间，等到自己的状态好的时候就可以开始下一个番茄了。

如此使用七天，工作和生活效率得到了质的飞跃，简直就像打游戏一样: 不断的完成任务获得成就，然后开始挑战下一个任务，不断的积累成就。让自身越来越高效，同时离目标也越来越近。

然后我还把每天必须要做的事情，比如：今日总结、打扫卫生、更换床单被罩、锻炼身体等都设定了 任务循环，每天要干的事情就是清空任务列表，每天的生活非常充实且自律，而且很有成就感。

提示

肥胖是许多慢性疾病的主要风险因素，如高血压、糖尿病、冠心病等等，不利于自身健康。
而减轻体重可以降低身体耗氧量，提升身体运转能力，有效地降低这些疾病的患病风险，改善身体的健康状况，并减缓衰老。
减脂不是一种方法，而是一种生活方式。

方案总结

早餐一杯牛奶咖啡，然后刷牙洗漱。做一些运动(可以是走路上下班，可以是跑步，俯卧撑，跳绳都行)。
午餐正常吃，四菜一汤一饭，自己估摸着 8 分饱即可，注意营养搭配，总结一下就是要吃饱吃好。(大脑感受是存在延迟的，你觉得饱了，其实胃已经撑了)
晚餐戒掉，如果感觉很饿就来一杯牛奶。如果非常想吃东西，牛奶+咖啡。
一杯咖啡下肚，食欲什么的直接就没了，搭配牛奶效果很好，不仅好喝而且可以有效压制食欲。
上述的饮食之外，除了纯净水，其余的一概不要进嘴。
晚上可以适当加一些空腹运动，但是运动前最好一来杯牛奶补充一下。
中途如果很饿想吃东西，就喝水，或者来一杯蔬菜汁(芹菜，黄瓜，大西红柿)。
保持空腹入睡。

核心理念

我自己试了一下，在 60 小时内(两天三夜)一共只喝了一瓶牛奶，饿了就只是喝纯净水。尽量去适应空腹和饥饿的感觉。在此期间会伴随着四肢无力，双手无力发抖的情况，但是我本人并没有出现任何问题，正常的打游戏，刷剧，敲代码，看书，学习。然后从第三天早上开始，一杯牛奶下肚，然后直到 12 点午餐正常吃，然后晚餐也只是一瓶牛奶。如此的饮食习惯坚持了一个周就适应了，而且不会再出现什么无力感。

完全不要担心自己被饿坏了或者营养不良，也不要怕会养成胃病之类的。事实上大多数胃病都是因为吃的太多暴饮暴食，给胃的负担太大造成的。

坚持一段时间后，我还会担心自己会不会有厌食症的倾向，发现完全没问题，因为自己看到美食还是会很想吃，不过这个时候我会专心去做其它事情并喝一大口水。

所以不要害怕饥饿，要学会享受和适应饥饿感。

虽然饥饿，但是也要营养要均衡。中午那顿只要吃好一天所需能量就完全足够了。然后牛奶和纯净水(5.5L 纯净水不足 10 元人民币，够喝很多天)是作为蛋白质以及空腹时期消化物的替代品。当然，也可以用一个鸡蛋来替代牛奶，总之就是要吃得少，而且得保证足够优质蛋白的摄入。

也不要担心长此以往会让自己状态下降，一旦身体适应了这个饮食节奏，你的身体和精神状态不会有任何变化，甚至精神状态会更好。

这么做的本质上其实就是屏蔽大脑信号并按时按量的饮食，然后用优质蛋白和纯净水来充当空腹时期的消化物，并给予身体额外的养分。

每个人的日常生活情况可能不太一样，但是核心理念是一样的，就是饿，并且要学会享受和习惯饥饿感。然后每天规律并且定时定量的饮食，同时还要注意营养均衡。

循序渐进的做法，长久的坚持

第一阶段：戒零食
第二阶段：减小饭量
第三阶段：早晚餐换成优质蛋白
第四阶段：加入运动

每个阶段根据个人情况不同可能会持续 1-2 周甚至是几个月。
比如我，第一阶段的完成花了 3 个多月的时间，第一阶段+第二阶段足足花了半年多。直到现在，我的生活中再也没出现过任何零食。每天只有 1-2 顿有主食。

当然优质蛋白也不仅仅是牛奶鸡蛋，优质蛋白十佳食物排行榜，原理基本一样，根据自身口味需求混搭也都可以。

肥胖从某种角度来说本身就是不健康的生活习惯和生活理念造成的，所以一定得注重习惯的养成和理念的精确。

所谓的精确就是：这顿饭我不能吃，不吃就是不吃，没有中间选项；我现在饿了那么我就只能喝水，没有其它选项；我早餐就只喝牛奶，或者鸡蛋，没有其它选项。

一开始可以试着把零食彻底戒掉。什么奶茶，甜品，辣条，小零食之类的统统不要。
适应没有零食的饮食之后，下一步试着减小饭量，饿了就喝水；
每顿饭坚持 8 分饱，然后试着适应和享受饥饿感，8 分饱就是 8 分饱，多一分都不行，下午四五点会很饿，饿就对了；
适应没有晚餐的生活之后，可以试着把早餐换成一个鸡蛋或者牛奶。
最后再试着开始加入一些运动在你的日常生活中。

试着找一个拥有相同理念的健身搭子，并记录习惯养成结果。这样做的好处是，不会一口气瘦太快，而且给了身体一个很长的适应期。循序渐进也不会太过痛苦。最主要的是做法简单，容易坚持。

你吃进胃里的任何东西本质上都会变成身体的负担，少吃等于是在给身体 减负。

相信我，作为一个成年人，每天仅有的一顿 大餐 已经足够养成你的身体了。

不过，我是个上班族每天上班就是坐在办公室敲键盘，每天中午有安静的 2 小时午休，公司食堂的午餐非常安全丰盛且搭配合理。每个人情况不同，所以第三阶段可以自己根据自己的情况去调整，但是第一、二、四 阶段是必经之路。

运动只能增长你的肌肉，只有减少饮食才能让你真正的减少脂肪。

当你很饿的时候，不妨找点事情来做，比如打游戏，思考问题，看书或者是学习，当你沉浸到某一件事情之后你会完全忘记饥饿这件事情，等时间到了就按照规划好的去计划饮食就好了。

困了就去睡，别和疲劳做对抗，不要留恋和让无聊的事情占据你的大脑，自然而然就能做到早睡了。
午休很重要，一定要睡好睡足。
无聊了，就去找事情干，制定自己的 To Do List，一项项的去完成。
情绪不好了就去做适合自己的运动，任何运动都可以，一定要发泄出来。
饿了就去喝咖啡牛奶，补充优质蛋白，而不是吃一大堆乱七八糟的东西。一天一顿的美食奖励还不够吗？莫贪心。
提升和改变都是一点点的事情，一定要把这种进步当作是日常。

减脂这种事情本身就是在和自身欲望以及懒惰做对抗，不要小瞧任何原本肥胖但是靠自己减肥成功的人，他们都拥有绝对的自信和毅力以及坚定且正确的信念，还具有很强的计划和目标管理能力，同时还拥有强大的执行力。

一些延伸阅读和必要的知识储备

间歇性断食如何起作用？好处、风险以及如何安全地进行断食

也就是说，饥饿其实并没那么恐惧，尤其是现在这个物质发达的年代，吃太多很容易，管住嘴反而更不容易。

食品、药品、保健品的标志有哪些？

东西千万不要乱吃。商人为了逐利什么事情都敢做，现在的各种商品都参杂着各种 科技与狠活，主打一个只要吃不死人就随便给你吃。假的鸭血，假的腐竹，假的粉丝粉条，假的牛肉等等等。一日三餐简单而纯粹，不仅省钱还健康。
我目前把大多数的二次加工产品都从自己的日常饮食中剔除了:
比如鸭血，我干嘛不吃鸭肉呢？ 想吃牛肉那么就一定得去好一点的店铺或者自己去菜市场买新鲜牛肉，而不是各种二次的肉制品等等。相信我，哪怕仅仅只是用原材料也能 100%满足你的味蕾。

人在感到饥饿时，是因为胃里没有食物了，还是没有「热量」了?

一个胖子如果一直不吃饭，是会直接饿死还是会变瘦？

人体所需的营养物质都有哪些？

脂肪是人体的「战略储备」，那么胖子就一定比瘦子耐饿吗？同等情况下谁先饿死？

所以不能不吃饭，得营养均衡并且依据自身情况科学的减少饭量。

一天只吃一顿饭能瘦吗? - 离愁的回答

瘦到什么样算是成功的？

成人体重指数

免费在线 BMI 计算器

BMI 測試

BMI=体重÷身高的平方， 现在大多数的体重秤，体脂秤都自带 BMI 计算。
一般体重处于正常范围内的人是不需要减脂的。只要保持好现在的饮食和生活节奏就好了。如果觉得体弱就适当加一点运动。

微软爸爸真好，居然出了官方文档。将开发环境从 Mac 改为 Windows 的指南

❀ 下面是我整理的使用频率非常高的快捷键。

| 操作 | macOS | Windows |
|

但是拼音输入法也存在很多局限性， 因为汉语中同音字实在是太多了， 也就是拼音输入法的重码率很高， 导致输入一个拼音很多时候需要翻很久很久才能找到想输入的汉字。
大多数拼音包含的字母都在 3-6 位， 也就是说为了打出一个汉字， 再加上重码率 需要敲击 3-8 次键盘才能完成一个拼音的输入(比如:shuang,zhuang,rang)， 短短一句话可能就得按键上百次。
相反， 五笔输入法一句话可能只需要按 4-8 次就能完成， 这落差十分巨大。但是随着智能词库和云数据库的发展， 简单易学的拼音输入法也越来越高效。相比较而言， 五笔输入法上手难度太高了， 直到今天已经已经没人愿意学习五笔输入法了。

拼音， 是用 26 个字母的拼读来表示汉语发音。拼音是由 23个声母， 24个韵母 ， 16个整体认读音节 组成的。
如果按一次 按键 表示声母， 再按一次 就表示韵母， 那么任何汉字的拼音就只需要按两次就能完成了输入了， 所以命名为 双拼输入法 。

而且 双拼输入法 还能和现有的拼音提示词库完美结合。

常用文档

好的东西应该共享

好用的在线工具

豆瓣读书-行为科学统计

这是本极佳的统计学入门书籍，不单讲理论，还会让你明白为什么要这么做，应该怎么做。

《 深入浅出数据分析 》

豆瓣读书-深入浅出数据分析

够浅白，然后还会讲一下为什么要这么做。唯一不好就是废话比较多吧，对有基础的人，不是很合适。

《 数据挖掘导论 》

豆瓣读书-数据挖掘导论

这个主要用于挖掘数据之间的内在联系。和传统意义上的统计学不太一样。比起另外一本黑色的数据挖掘教材要新一点。

《 金融市场与金融机构基础 》

豆瓣读书-金融市场与金融机构基础

讲金融体系的扫盲书籍

书不厚但是作为一个完全的金融外行来说我觉得啃掉他至少需要半年时间。
刚刚看完引论觉得浅显易懂，每章节前后都有引导和总结，十分适合入门。

《 投资学 》

豆瓣读书-投资学

金融领域必读书籍

Go 语言书单

Go 语言中文开源图书、资料或文档

在线工具书，随用随查，社区翻译的最佳版本

日常读书笔记记录

『 生活就像一盒巧克力 』

电影改编自美国作家温斯顿·格鲁姆于 1986 年出版的同名小说，描绘了先天智障的小镇男孩福瑞斯特·甘自强不息，最终“傻人有傻福”地得到上天眷顾，在多个领域创造奇迹的励志故事 [1] 。电影上映后，于 1995 年获得奥斯卡最佳影片奖、最佳男主角奖、最佳导演奖等 6 项大奖 。

2014 年 9 月 5 日，在该片上映 20 周年之际，《阿甘正传》IMAX 版本开始在全美上映

单曲循环一整天

支持 http 以及 https 。

HTML 和 Markdown 使用

<img src="//file.mo7.cc/api/public/bz" />

<img src="//file.mo7.cc/api/public/bz?idx=3" />

![](//file.mo7.cc/api/public/bz?idx=1)
![](//file.mo7.cc/api/public/bz?idx=3)
![](//file.mo7.cc/api/public/bz)

当 idx 参数小于 1 时，则会随机返回一张壁纸

api 接口返回当日 json 数据

axios({
  method: 'get',
  url: '//file.mo7.cc/api/public/url',
  params: {},
}).then((response) => {
  const imgList = response.data.Data;
  console.log(imgList);
});

API 完整地址:
https://file.mo7.cc/api/public/url

唯愿此景与汝共

与高手相比，你只是缺一件趁手的兵器而已。

分享和就一些自己平时觉得好用的工具。

相见恨晚的 PC 端工具集

当我搞明白这货的使用方法和运行逻辑之后，不仅效率提升了很多，我还卸载了十几个软件。

本文重点

https://open.u-tools.cn/445779.html

基于 nodejs 开发的跨平台工具集合。
横跨 Mac、Windows、Linux 三大平台，设计体验一致。它使得你的工具软件不再零碎。
有了它，你的电脑只需要安装必要的核心软件就可以了。

一个截屏翻译软件引发惨案

在 windows 下有一个神器： 有道词典
我少数几个允许开机启动且后台常驻的软件。我的英文阅读水平一般，但我的工作经常会用到各种英文文档，所以翻译工具基本上是必不可少的。我一般都是把文字复制下来然后丢到软件当中去翻译，习惯了之后其实也没啥。但是有些文字是无法被复制的，这个时候是非常不方便的。

有道词典设置快捷键，直接像截图一样去识别屏幕上的英文语句，然后直接显示翻译结果，极大地提高了我的学习和工作效率。

但是！Mac 下没有这个功能。。。。

Mac 下我用的是这个玩意儿

还特么花了我 50 大洋，现在想一想，自己真是个大怨种。

嗯，这货号称 Mac 下最好的截屏翻译工具，也确实好用。但是，它采用的是 Mac 系统快捷指令实现的截屏翻译功能。但是 Mac 的 api 是不允许代理方问的。每次使用我都得关闭代理。。天呐，烦透了，但是没办法。配置其它的访问 api 都存在一定的限制或者费用。但是将就将就又不是不行。

然后前段时间 B 站发现了一个 UP 主推荐了 uTolls，好奇心驱使下就去下载体验了一下。

注：Mac 和 Windows 体验完全一致

其内部实现了一个叫做 关键字 的调用逻辑，每个插件都可以使用关键字来调用其它的关键字，一个插件可以有多个关键字。所有插件之间都是可以相互进行调用的。

于是就出现了各种组合，比如：
截图插件 + OCR 识别插件 + 翻译插件 = 截屏翻译功能
截图插件 + 二维码解析插件 = 扫码功能 (PC 能扫码了，喜极而泣)
文本提取 + 网址精灵 = 一键收藏网址
文件提取 + PDF转换器 = 一键转换 PDF 文件
文件提取 + 图片压缩 = 一键压缩本地图片
文件提取 + 搜索插件 = 一键搜索本地文件
.....

VSCode 能像如今这般如火如荼，离不开丰富的插件生态，其插件生态丰富是因为它的插件核心语言是 Javascript。
uTools 的插件语言，也是 Javascript。开发一个插件快捷而迅速，而且 uTools 软件本身磨平了一些系统 API 之间的差异。你编写的插件可以很方便的进行进行系统的各项操作。
目前 uTools 插件市场 400 + 各类插件，他们组合搭配起来基本上可以[一键]解决你 90%以上的快捷问题。

自从有了 uTools ，我把电脑上大部分快捷键都取消了，并且卸载了一大票工具类软件。后台只需要运行一个工具类软件，那就是 uTools。

虽然它的截图功能存在一些问题，但是够用。我们一般使用截图也只是方便标注和发送而已。遇到一些特殊情况的截图，可以搭配使用系统自带的截图使用。关键问题是，一堆 IM 软件和工具不用再相互打架了。节省时间就是延长生命。

截图工具并非 uTools 官方开发所以体验和功能很一般。但是官方开发的录屏工具却十分好用。可以看得出，社区出品的插件跟官方出品的插件质量上还是存在着一些差距。截图是一个很常用的功能，希望 uTools 官方能出手优化一下。

软件的使用演示

注意

注意：本文中的一些超链接你可能会打不开，那很可能是因为需要 科学上网。

一、计算机的基本组成和工作原理

先来一段计算机导论节选：

Windows

1. 将系统更新到最新，包括驱动等
2. 将系统归属地改为香港，设定好时间日期格式(设定为香港可以访问到更多有趣的内容)
3. 在系统设置中配置好 开发者选项
4. 配置好 翻墙和代理服务
5. 安装 Chrome
6. 安装并配置 Git
7. 安装并配置 VSCode
8. 安装并配置 WSL
9. 设定好 WSL 的系统代理
10. 然后在 WSL 中像 Linux 一样去使用 Windows 进行开发和编码
11. 安装并设置 uTools

macOS

1. 检查系统更新
2. 系统常规性设置，比如 在 Mac 上显示或隐藏文件扩展名
3. 配置好 翻墙和代理服务
4. 安装 Chrome
5. 检查并配置好 Terminal，并安装 oh-my-zsh
6. 安装 Homebrew
7. 检查并配置 Git 等常用命令
8. 安装并配置 VSCode
9. 安装并设置 uTools

Linux

墨七编写的 Linux 系列文档

1.机器语言：

机器语言是计算机最原始的语言，是一种指令集的体系。这种指令集称为机器码。仅由 0 和 1 组成。 CPU 在工作的时候只认识机器语言。每台机器都会存在自己的指令集。
最早计算机是以 穿孔纸带 进行编程的。带孔为 1，无孔为 0，经过光电输入到计算机当中。纸带就充当了存储介质。后面被 磁带 所取代。
机器语言的 可读性、可移植性差，编程非常繁杂。
但是直接和机器打交道，运行速度可以接近硬件的极限，资源占用少；

2.汇编语言

汇编语言，即一种低级语言，他用人类容易记忆的语言和符号来表示一组 0 和 1 的代码。相当于是 0 和 1 的一种高层次封装，一组 0 和 1 用一个单词表示。

不同的处理器有不同的汇编语言语法和编译器，编译的程序无法在不同的处理器上执行，缺乏可移植性，难于从汇编语言代码上理解程序设计意图，可维护性差，即使是完成简单的工作也需要大量的汇编语言代码，很容易产生 bug，难于调试，使用汇编语言必须对某种处理器非常了解，而且只能针对特定的体系结构和处理器进行优化，开发效率很低，周期长且单调。
能够保持机器语言的一致性，直接、简捷，并能像机器指令一样访问、控制计算机的各种硬件设备，如磁盘、存储器、CPU、I/O 端口等。使用汇编语言，可以访问所有能够被访问的软、硬件资源，目标代码简短，占用内存少，执行速度快。

所以汇编语言一般用来开发 CPU 指令集，驱动程序，逆向工程，破解，单片机，嵌入式开发，系统底层开发等。

3.高级语言

运行速度和执行效率低于汇编语言，程序大小与编译器有关。
高级语言接近 算法语言 ，易学、易掌握，提供结构化程序设计的环境和工具，使得设计出来的程序可读性好，可维护性强，可靠性高；高级语言远离机器语言，与具体的计算机硬件关系不大，可移植性好，重用率高；由于把繁杂琐碎的事务交给了编译程序去做，所以自动化程度高，开发周期短，且程序员得到解脱，可以集中时间和精力去从事对于他们来说更为重要的创造性劳动，以提高程序的质量。

高级语言按照执行方式又可以被分为 编译型语言 和 解释型语言

编译型语言：
编译语言，一般会通过编译器处理，先将代码编译为机器码，再加以执行。比如 exe 文件，以后需要运行的时候就不用再重新编译了，运行时不需要再编译，所以执行效率很高。

解释型语言：
解释型语言，一般通过 解释器 将代码一句一句直接执行，不需要像编译语言一样先编译为机器码之后再执行。在执行期，动态将代码逐句解释并执行。典型的如脚本语言。

脚本语言：
脚本语言是一种解释型语言，脚本语言是为了缩短传统的编写-编译-链接-运行（edit-compile-link-run）过程而创建的计算机编程语言。脚本语言一般都 有相应的脚本引擎来解释执行。 他们一般需要解释器才能运行。一个脚本通常是解释运行而非编译。脚本语言通常都有简单、易学、易用的特性，目的就是希望能让程序员快速完成程序的编写工作。而宏语言则可视为脚本语言的分支，两者也有实质上的相同之处。脚本语言一般都是以文本形式存在,类似于一种命令。

注意

注意：本文中的一些超链接你可能会打不开，那很可能是因为需要 科学上网。

路径-维基百科

文件路径是用于描述文件系统资源的一个文本标识。 文件系统是对文件存储设备的空间进行组织和分配，负责文件存储并对存入的文件进行保护和检索的系统。 文件存放在外部存储器中的某些位置上，经由文件系统管理后，被系统以文件路径标识，系统可以通过文件路径检索到对应文件。

放一段视频：

注意

注意：本文中的一些超链接你可能会打不开，那很可能是因为需要 科学上网。

不知道你有没有遇到过，打开一个.txt文件却发现文件乱码了？这种时候往往是因为使用了不一样的编码格式去打开文件导致的。

比如当前正在编写的这篇文章，如果采用 GBK 编码打开，就会变成一堆不认识的字符：

但是同样的一篇文章采用 UTF-8 打开则可以正常阅读：

因为这篇文章就是在 UTF-8 编码规则下编写的。 而GBK编码是 windows 系统早期的默认编码。

拓展阅读 ASCII 编码、GBK 编码，Unicode 编码和 UTF-8

注意

注意：本文中的一些超链接你可能会打不开，那很可能是因为需要 科学上网。

我觉得这里放一个视频就足以解释清楚了。

注意

注意：本文中的一些超链接你可能会打不开，那很可能是因为需要 科学上网。

当你学会命令行的基本使用之后，那么就相当于一只脚踏入了另一个世界。
除了从应用商店安装下载之外，一般情况下还可以通过 软件包管理系统 来安装各种好用的命令和工具。

Linux

一般 debian 系 的系统比如 Ubuntu 默认的包管理器都是 apt 命令

# 例如 安装git命令
apt install git

# 卸载 git命令
apt remove  git

# 查看一些可更新的包
sudo apt update

# 升级软件
sudo apt upgrade

# 安装 curl
sudo apt install curl

注意

注意：本文中的一些超链接你可能会打不开，那很可能是因为需要 科学上网。

这个系列视频讲解的非常好
https://www.bilibili.com/video/BV1HM411377j/

https://www.bilibili.com/video/BV1ug4y1571s/

注意

注意：本文中的一些超链接你可能会打不开，那很可能是因为需要 科学上网。

搜索引擎 是一个跨时代的发明，基本上我们每天都会用到。但是你真的会使用搜索引擎吗？

搜索引擎的选择

一般情况下，我推荐的搜索引擎只有两个

1. 微软出品的 必应搜索 https://www.bing.com 。 https://cn.bing.com 在国内也可以用。

不过实践证明，国内的 Bing 属于特供版，内容会不太一样。

2. 靠搜索家的 Google https://www.google.com/ 可能需要掌握一定的 科学上网 小技巧。

搜索引擎使用技巧

只需要认真阅读这篇文章即可：

盘点全球搜索引擎及其使用技巧

视频讲解

前段时间 淘宝 Steam 安装教程 事件在网上大火。就是在大多数人看来 安装Steam 这么简单的一件事情居然会难倒这么多人。大家只是想玩一个游戏而已，为什么会如此魔幻?

一方面是国内的大环境下所有厂商都在尽全力让人们把视线转向移动端，尽可能掠夺大家的时间和精力。传统 PC 相关的技能普及度正在降低。
另一方面是因为一些国家政策，GFW 的存在也让信息闭塞了起来，间接的增加了很多门槛。其中也包括了国内计算机基础知识的普及与落后。

我自己也是从编程小白一步步走过来的，我很清楚 对于一个小白来说， 想要靠自己打破认知壁垒入门编程是多么困难的一件事情。而编程在这个时代能做的事情实在是太多了太多了。掌握一定的编程技术无论是生活还是工作方便程度都能够带来质的飞跃。所以我特意花了几天时间编写了这篇 基础教程，希望可以帮助更多人。

本教程文章列表

官网地址：
https://nodejs.org/

在 macOS 和 Windows 上安装 Node.js

第一步，查看机器硬件架构类型

打开终端做如下输入并回车

arch
# 会打印显示如:  arm64 或 x86_64 或其它

第二步，下载安装包

https://nodejs.org/en/download/prebuilt-installer

然后双击运行无脑下一步。

Linux 下安装 NodeJs

Github 文档:

https://github.com/nodesource/distributions

总结下来就 3 行命令

curl -fsSL https://deb.nodesource.com/setup_lts.x -o nodesource_setup.sh
bash nodesource_setup.sh
apt-get install -y nodejs

Github 文档写的非常详细，这里就不再赘述了。

验证安装结果

重启终端做如下输入

node -v
# 会打印当前 nodejs 版本如： v20.12.2

npm -v
# 会打印当前 npm 版本如： 10.5.2

至此 nodejs 安装成功

npm 加速设置

1. 使用阿里云镜像

阿里云镜像应该是目前国内使用最普遍的 npm 镜像站了

镜像官网：
https://www.npmmirror.com/

直接执行如下命令即可完成镜像源的替换

npm config set registry https://registry.npmmirror.com

registry=https://registry.npmmirror.com

npm config delete registry

2. 使用全局的命令行代理

具体细节可参考文章 科学上网与本地代理

如果你把代理关了，使用 npm 更新依赖时会有如下显示

fnm 类似于 nvm，是一个 nodejs 版本管理工具， 他比 nvm 更加迅速，应该是目前已知最好的 nodejs 版本管理工具。

fnm 的特点是:

• 跨平台，支持 macOS、Windows、Linux。
• 使用 Rust 编写，速度快。发布为单文件，便于安装。
• 支持按应用自动切换 Node.js 版本。

fnm 的 Github 仓库地址：
https://github.com/Schniz/fnm

安装 fnm

macOS && Linux

第一步， 打开命令行执行如下操作

curl -fsSL https://fnm.vercel.app/install | bash

第二步， 添加如下环境变量配置国内镜像

#  ~/.zshenv 或 ~/.bashrc 文件中:
export FNM_NODE_DIST_MIRROR=https://npmmirror.com/mirrors/node/

fnm 的基本使用

罗列远程服务器上所有的 nodejs 版本

fnm ls-remote

在任意位置新建文件 demo.html :

<!DOCTYPE html>
<html>
  <head>
    <meta charset="UTF-8" />
    <title>Hello World</title>
    <style>
      .content {
        color: red;
        border: 3px solid black;
      }
    </style>
  </head>
  <body>
    <h1>Hello World</h1>
    <div class="content">Hello World , 这里是第一个 html 网页</div>
    <button onclick="SayHello()">点我say hello</button>
  </body>
</html>
<script>
  function SayHello() {
    alert('Hello World');
  }
</script>

保存后 浏览器打开会显示以下内容：

html 结构说明

一般来说，一个 html 文件的基本结构如下：

1. 一个基本的文档类型声明

<!DOCTYPE html>

2. <html> </html> 标签 包裹下的 <body> </body> 和 <head> </head> 标签

<!DOCTYPE html>
<html>
  <head>
    <!-- head 头声明部分， 这里一般放置一些 title 声明。引用相关的 -->
  </head>
  <body>
    <!-- 文档的内容部分，这里是文档的主体部分，主要是表明浏览器需要渲染的标签内容 -->
  </body>
</html>

大部分的标签全部都是 成对 存在的，把内容包裹在其中。标签之间可以相互嵌套。

3. css 部分

<style>
  /* css 样式内容  */
</style>

<!-- 引入外部的 css 文件: -->
<head>
  <link rel="stylesheet" type="text/css" href="./theme.css" />
</head>

CSS 又被成为 层叠样式表 ，它更像是一份声明文件，声明该以什么样的形式去绘制 标签的外观。现在大部分的过渡动画都以 CSS 的形式去进行表述。CSS 具有极高的渲染性能。

4. javascript 脚本部分

<script>
  /* javascript 脚本内容  */
</script>

<!-- 引入外部的 js 文件: -->
<script src="./main.js"></script>

javascript 是一门图灵完备的脚本语言，浏览器中的一等公民。
在 nodejs 的帮助下，它可以脱离浏览器运行在主机上面进行服务端开发。这是唯一一门 全栈 类型的编程语言。
也是目前全球使用最广泛的编程语言。 也是使用人数最多的编程语言。

它不仅仅只用于编写网页，包括服务端开发，小程序开发，在一些技术的加持下 还包括 Android 和 ios 应用开发。嗯，除此之外它还能做很多很多的事情。
虽然相比较其它编程语言它的执行效率比较低，但是它更加易于学习，用途更加广泛，上手门槛更低，开发速度更快。
得益于 各大浏览器内核的内卷，它在 解释型语言 中也属于性能最好的那一类。

javascript 是最适合小白入门的编程语言。

入门教学

因为实在是太过简单，基础部分的学习资料实在是太多了，这里我找到了一个夹带私货最少，废话最少的一个 B 站教学视频。

3 小时前端入门教程（HTML+CSS+JS）

注意

该文档有待补充和完善

阿里巴巴开源镜像站

https://developer.aliyun.com/mirror/

npm 镜像站

http://www.npmmirror.com/

Linux 设置本地代理

export ALL_PROXY=socks5://127.0.0.1:10808

一些其它指令

## npm 升级
npm -g install npm

## 清除缓存
npm cache clean --force

## 卸载

npm uninstall xxx (-g)


## 查看更新
npm -g outdated


## 其它指令

npm audit fix

npm audit fix --force

npm audit

注意

该文档有待补充和完善

#安装
npm install pm2 -g
#启动进程
pm2 start app.js
#停止进程
pm2 stop app.js
#查看进程
pm2 list

Web 前端开发

注意

该文档有待补充和完善

parse  解析
url.parse("地址","是否解析参数 [true/false]","解析没有协议的路径 [true/false]")

format 格式化
url.format("地址对象")

resolve 溶解
url.resolve("地址","目录")

LeetCode 每天一道脑筋急转弯，防止老年痴呆。

程序员版本的脑筋急转弯。

刷 LeetCode 防止老年痴呆。

个人主页：https://leetcode.cn/u/mo7cc/

国内 Wiki
https://learnku.com/go/wikis

Linux

可以无脑的依次执行以下命令:

#!/bin/bash

# 查看系统类型
arch
# 下载地址(x86_64)
DownloadUrl="https://dl.google.com/go/go1.23.6.linux-amd64.tar.gz"

# 下载地址(aarch64 arm64)
# DownloadUrl="https://dl.google.com/go/go1.23.6.linux-arm64.tar.gz"

# 其余系统类型的下载地址可以查看 https://golang.google.cn/dl/

# 开始下载
curl -o "goPackage" "${DownloadUrl}"

# 删除老版本(亲测，不删除老版本会出现各种莫名其妙的问题)
rm -rf /usr/lib/go

# 解压 goPackage 到 /usr/lib/go
sudo tar -zxvf goPackage -C /usr/lib

#  删除 goPackage
rm -rf goPackage

此时 go 已经被安装到 /usr/lib/go 中了，接下来只需要将 go 指令添加到环境变量中。

注意

该文档有待补充和完善

任务：

1. 创建一个数据库，名为：bz
2. 创建一个长度为 8 的固定集合
3. 获取地址数组插入

{
  "_id": 1,
  "url": "xxxx"
}

4. 获取地址数组进行返回与填充

db.createCollection('bingUrl', { capped: true, size: 8 });

db.bingUrl.isCapped();

db.bingUrl.insert({
  _id: 0,
  url: 'https://bing.com',
});

属性 1:对固定集合进行插入速度极快
属性 2:按照插入顺序的查询输出速度极快
属性 3:能够在插入最新数据时,淘汰最早的数据

使用文档

是一门极其优秀且发展势头迅猛的语言，豪横的生父阵容。
静态强类型，易于维护，语法简洁，特性简单。
极低的上手门槛和不亚于 Python 的开发速度。
然后还有位于第一梯队的编译和运行速度。
go 在各个方面都达到了一种非常棒的平衡。
是一门非常值得学习和用于构建的编程语言。

一、目前应用程序的主流是什么？

1. 桌面（Mac，Win，Linux）
2. 移动 App（Android，Ios）
3. Web（浏览器以各种 App、系统内套壳页面，鸿蒙，小程序 都算这一类吧~）
4. 嵌入式（各种硬件交互，传感器，硬件控制，通信）
5. 工控软件（嵌入式软件、工业控制组态软件、PLC 编程软件等）
6. ...等等等

二、开展一个项目选用一个编程语言的标准是什么

1. 待开发系统的应用领域，即项目的应用范围。
2. 应用形式（全平台，还是单平台，还是硬件集成，一体机）
3. 应用规模（toB 还是 toC ，日活多少，顶峰访问量会有多少 ）
4. 架构模式（分布式？事件总线？分层模式？有些语言在开发成熟的架构模式下，运维体系啥的）
5. 支持平台（某些平台 SDK 只支持某一部分语言，甚至是指定语言）
6. 开发周期（是可以慢工出细活，自研自控，还是说只图一个快，早上线早超生）
7. 硬件要求（单片机还是服务器？是否要上集群和规模）
8. 语言生态（生态丰富成熟的语言开发速度确实会比较快）
9. 好不好招人（也就是所谓的用工成本）

注意

该文档有待补充和完善

为什么？

https://github.com/erning/gorun

使用方式

# 安装 gorun
go install github.com/erning/gorun@latest

# 添加环境变量
sudo ln -s ~/go/bin/gorun /usr/local/bin/gorun

# 使用方式
gorun demo.go

区别

// 2>/dev/null ; gorun "$0" "$@" ; exit $?
package main

import (
	"fmt"
	"os"
)

func main() {
	fmt.Println("Hello", os.Args[1])
	os.Exit(42)
}

go run ./main.go
echo $?
# 执行的结果是 1

go build ./main.go
./main
echo $?
# 执行的结果是 42

gorun 将：
将文件写入 $TMPDIR （或 /tmp）中的安全目录下，这样就不会触及实际脚本位置（可能是只读的）
避免同一文件的并行执行之间的竞争
自动清理一段时间内未使用的旧编译文件（无竞争）
取代流程，而不是使用子流程
正确地将参数传递给已编译的应用程序
处理好 GOROOT、GOROOT_FINAL 和工具链的位置
支持嵌入的 go.mod、go.sum 和用于编译的环境变量 - 可以确保可重复构建

注意

该文档有待补充和完善

注意

该文档有待补充和完善

读取并设置配置文件

https://www.cnblogs.com/jiujuan/p/13799976.html

json to go

https://mholt.github.io/json-to-go/

go-colly 爬虫

https://zhuanlan.zhihu.com/p/76629605

https://github.com/gocolly/colly
可以用 xpath，goquery 这些选择器选中网页元素

注意

该文档有待补充和完善

https://books.studygolang.com/

大多数情况下，领导拍脑袋或靠调查报告产生一个需求，
产品凝练需求，
为了验证想法开发团队得尽快把需求落地。
然后市场反馈，不对再改，不盈利再改，反响不好再改。
所有的需求全部产生于【想法】以及【想象力】。
因此，互联网公司的程序员面对的都是各种新东西，或者拍脑袋产生的各种新需求，
所以最后试错成本大多数都在程序员头上顶着。(因为公司的最终产品形态就是程序)

传统公司是这样的：
业务员，销售去跑市场跑业务，业务跑顺了，能盈利了，投入资源继续更进一步。
与此同时反馈市场结果，然后开发团队出马，优化业务流程，凝练市场和业务需求，
有针对性的设计逻辑和工具，然后程序员根据设计结果将工具落地，发布。
然后业务员拿着新工具，效率提高了，负担减轻了。然后腾出来的资源继续 扩大市场，然后再去发现新的需求。
试错成本大多数都在市场部业余员头上顶着。
到了开发团队这里全都是真真切切的实际需求。

天才们可以靠着感觉，察觉到隐藏在市场下的需求，有针对性的一鸣惊人，不浪费一丝一毫的气力。
资本靠砸钱来试错，同时投资很多个项目，成功一个就继续加大投资做成垄断，然后砍掉其余不成功的。(相当于变相的资本对冲)
而对于大多数人来说，应该是明确需求并找到买方，再有针对性的去处理。

相关信息

虽然不我确定这是不是 ElonMusk 的名言，但这些句子的确给了我很大的力量。

关于人生低谷

人生的至暗时刻
大道理没用，鸡汤没用
蛋糕可乐奶茶火锅都没用
甚至家人和朋友们的爱
也只能减缓焦虑
却不能击退黑暗

真正把我从深渊里拉出来的
是我自己
没有人知道那段时光里
我经历了什么
分一秒熬过去之后
就已经不是从前那个自己了

这个世界上
最困难的时候
往往只有自己
能把自己从泥潭中拉出来
没有人能替你感受痛苦
也没有人能替你幸福

面对不舒服的事情，一定要有一个自洽的解释

我 30 岁养成了一个终生受益的习惯
就是每次在我遇到了
让我感觉不对劲的事情之后
冲突也好，不公正的待遇也罢
我都会用我自己的语言把它们捋顺
并且用自洽的框架解释出来
这个解释可以是对一个特定的人说出来
也可以选择写出来，自己再来看

这么做的好处就是
你会越来越有底气，智慧和勇敢
因为用自己的语言去解释一个事件
本质上做这个动作的底层逻辑
就是在塑造自我，强化自我
哥德说过:任何在积累知识的同时
却不思考如何去善加利用的人
最终都将毒害自己的生活和人类社会

如果你感觉到了不舒服却不表态
那么你就一直处于没有话语权的状态
更重要的是这些困扰在未来的生活工作
还是会迟迟不断的找上你并无限放大
每次我和我的工程师伙伴吵架的时候
我有一个让彼此都非常受用的点
就是我会保持冷静地对他说
现在请把你的感受和观点分两边写给我

即便我可能最终并不能认同他的观点
他也在这个过程当中把自己捋了一遍
我们就能在沟通当中照见彼此的感受
还原并表达底层最真实的观点和立场
不做无意义的情绪内耗
这个世界是极其复杂的，大家都会迷茫
你只有了解自己内心真正的想法和诉求
你才能抵挡住负面事物对你的侵蚀

不要混沌无序，不要觉得无所谓
不要得过且过，不要不了了之
即便你的看法是不受别人认同的
也要勇敢地去表达自己
最起码让你自己清楚
自己内心的真实所想
并且坚定地站在自己的这一边
这是你真诚而热烈地活着的底气

如何使自己变得强大优秀

你要想变得超乎常人的强大
必须在某个 3-5 年里
疯狂的行动，高密度的锻炼
这个锻炼可能包含了
你人性上的锻炼
你勇气上的锻炼
你心力上的锻炼

你专业技能上的锻炼
这些都是关系你命运最核心的锻炼
总之，
你就是千万不能停
只要你停了，你就开始凉了
能量和智商就开始下降了
在这个 3-5 年
你必须疯狂的在你专业领域

日日不断的深耕
日复一日的死磕
不要情绪化，努力干活
去犁地，去翻土
累了就变换耕作方式
直行动下去
就一定会有奇迹发生

关于行动力

人类的基因有这样一种设定
对模糊不清、不可名状的东西感到害怕
那些现实生活中行动力很糟糕的人
他们并不是懒惰、好吃懒做
也并不是害怕要处理的事情本身
他们的恐惧是来自于任务的模糊性

我从来都不相信
这个世界上有什么行动力不足的事情
因为所有的行动力的问题
其实都来源于精确性的不足
普通人生活中几乎所有的不幸
都是由精确性的丧失开始的

如果你要一件事情发生
就只需要去集齐
这件事情要发生的所有的要素就行了
就像造火箭，关键步骤也只有 27 个
当你提高了对客观世界评估的精准性
一切你觉得遥不可及的事情都会很简单

关于面对新事物

我的成功得益于养成了一种很绝的心态
它叫做 10% 目标定律
这个想法就是
无论你在生活中想要什么
你都要做 10 次尝试
但问题在于
大多数人都不会尝试次 10 次

大多数人连一次都不想尝试
让他们尝试比登天还难
而 10% 目标定律的意义就在于
学会积极面对 90% 的失败
现在我敢向你保证
如果你今后做任何事情
都愿意先尝试 10 次
那么，其中一个必定会成功

关于人生态度

一个人在任何年龄
都应提防的四大陷阱
不读书爱思考
不独立爱自由
没经济谈真爱
缺理智想发财
撑下去的方法很简单

爱具体的人
做具体的事
只有这样
才能抵抗那些宏大的、抽象的
试图让我们变消极的人东西
愿你我时刻谨记

我宁愿选择乐观，哪怕是错的
也不想选择悲观，即使那是对的

努力成为你想成为的那种人
就算不成功
至少你喜欢现在努力的自己
停止精神深处无意义的内耗
你要留点精力
去读书、去运动、去爱人
去奔赴你想要的生活

最后

愿每个人最后都能成功 ~！

日常随便写一点东西

但是想要完全用好这款工具搭建出符合自己心意的博客，必须得具有一定的知识储备和掌握必要的工具。

必要的知识储备

墨七编写的 编程基础入门

相对路径，命令行，文件编码，开发工具，Git，Github 都需要具备一定的概念才可以。

工具准备

命令行环境

Nodejs 基础环境搭建

编辑器

Visual Studio Code 使用说明

为了良好的体验，需要安装的插件：

Vue - Official
https://marketplace.visualstudio.com/items?itemName=Vue.volar

Prettier - Code formatter
https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode

官方文档说明

打开 vuepress-hope 官网

它的文档结构长这样：

一般来说，按照顺序一步步走下去就可以把项目成功启动起来。

开始

如果准备工作妥当，我们这里直接开始。

打开命令行，找一个自己心仪的目录执行以下命令：

pnpm create vuepress-theme-hope my-docs

执行完命令之后会有一些问题需要你回答一下:

完成之后当前目录就会创建一个项目目录，我们用 vscode 打开这个项目：

其中 博客的程序和配置部分全部都会存放在 src/.vuepress 目录下。
src/ 目录下除开 .vuepress 目录之外的目录和文件都会被视作文档。

node_modules 是依赖存放的目录，一般不需要去管它。

package.json 是项目描述文件，其中

"scripts": {
  "docs:build": "vuepress-vite build src",
  "docs:clean-dev": "vuepress-vite dev src --clean-cache",
  "docs:dev": "vuepress-vite dev src",
  "docs:update-package": "pnpm dlx vp-update"
}

部分是你可用的脚本。比如这里就提供了 4 个脚本，你可以这么使用它：

# 安装依赖 这个是 pnpm 提供的基本能力
pnpm install

# 将项目进行打包，准备发版 ， 对应 package.json scripts 里面的  docs:build  命令
pnpm run docs:build

# 清除缓存并启动服务
pnpm run docs:clean-dev

# 启动本地预览服务
pnpm run docs:dev

# 升级所有的依赖
pnpm run docs:update-package

对的，其基本的语法就是 pnpm run xxx 。 xxx 就是 package.json 的 scripts 属性提供的。

如果没什么问题，你应该可以成功启动项目并看到你的博客雏形了。

另一种方案

我当前的博客源码已经在 github 中开源了，地址为
https://github.com/mo7cc/blog-source

你可以直接点击下载并解压。

项目结构说明如下:

也就是说，我的博客项目 命令如下:

# 安装依赖
pnpm install

# 本地启动预览
pnpm run dev

# 打包变异准备发版
pnpm run build

# 更新依赖
pnpm run update-package

# 一条指令同步到远程仓库
pnpm run sync <同步说明>

# 一条指令发布博客
pnpm run deploy <发布说明>

# 开源博客的源码部分
pnpm run open <开源说明>

# 新建一个周工作计划表
pnpm run weekly

相关信息

觉得官方的图片预览插件点一下放大，点一下缩小太难用了，于是自己重新开发了一个图片预览插件。
【可完美适配移动端】

注意：得先在配置文件中禁用 vuepress 的图片预览。
plugins.photoSwipe: false

该插件在 VuePress 中使用的方式如下:

第一步： 导入插件源码

<script setup lang="ts">
import { onMounted, nextTick, ref } from 'vue';
import { useRouter } from 'vue-router';
import { GetDeviceInfo } from '../utils/tools';
import MyIcon from './MyIcon.vue';
// 图标需要引入 iconfont

let DeviceInfo: any = ref({});

let ImageArr: any = ref([]);
let ShowPreviewBox = ref(false);
let CurrentImgIdx = ref(0);

function ClosePreviewBox() {
  ShowPreviewBox.value = false;
  document.body.style.overflow = 'auto';
}

function zoomFunc() {
  const imgElm = document.getElementById('Mo7PreviewBox-img');
  if (!imgElm) {
    return;
  }

  let width = imgElm.clientWidth;
  let height = imgElm.clientHeight;
  width = width * 1.1;
  imgElm.style.width = width + 'px';
  height = height * 1.1;
  imgElm.style.height = height + 'px';
}

function shrinkFunc() {
  const imgElm = document.getElementById('Mo7PreviewBox-img');
  if (!imgElm) {
    return;
  }
  let width = imgElm.clientWidth;
  let height = imgElm.clientHeight;
  width = width * 0.9;
  imgElm.style.width = width + 'px';
  height = height * 0.9;
  imgElm.style.height = height + 'px';
}

function fullscreenFunc() {
  const imgElm: any = document.getElementById('Mo7PreviewBox-img');
  if (!imgElm) {
    return;
  }
  window.open(imgElm.getAttribute('src'));
}

function leftFunc() {
  if (CurrentImgIdx.value > 0) {
    CurrentImgIdx.value--;
  }
  nextTick(() => {
    ImageBoxReset();
  });
}

function rightFunc() {
  if (CurrentImgIdx.value < ImageArr.value.length - 1) {
    CurrentImgIdx.value++;
  }
  nextTick(() => {
    ImageBoxReset();
  });
}

function ImageBoxReset() {
  const boxElm = document.getElementById('Mo7PreviewBox');
  if (!boxElm) {
    return;
  }
  const boxWidth = boxElm.clientWidth;
  const boxHeight = boxElm.clientHeight;

  const imgElm = document.getElementById('Mo7PreviewBox-img');
  if (!imgElm) {
    return;
  }

  imgElm.style.width = boxWidth * 0.9 + 'px';
  imgElm.style.height = '';
  imgElm.style.maxWidth = '';
  imgElm.style.maxHeight = '';
  imgElm.style.left = '';
  imgElm.style.top = '';
  imgElm.style.cursor = '';

  const height = imgElm.clientHeight;

  if (height > boxHeight) {
    imgElm.style.width = '';
    imgElm.style.height = boxHeight * 0.9 + 'px';
  }
}

function ImageClick(e) {
  const elm = e.target;
  const src = elm.getAttribute('src');
  let index = CurrentImgIdx.value;
  for (let i = 0; i < ImageArr.value.length; i++) {
    const el: any = ImageArr.value[i];
    if (el.src === src) {
      index = i;
      break;
    }
  }
  CurrentImgIdx.value = index;
  ShowPreviewBox.value = true;
  document.body.style.overflow = 'hidden';

  nextTick(() => {
    ImageBoxReset();
  });
}

function keyUpFunc(event) {
  if (event.type == 'wheel') {
    if (event.deltaY > 0) {
      shrinkFunc();
    } else {
      zoomFunc();
    }
  }

  if (event.key === 'Enter') {
    fullscreenFunc();
  }

  if (event.key === 'Escape') {
    ClosePreviewBox();
  }
  if (event.key === 'ArrowUp') {
    zoomFunc();
  }
  if (event.key === 'ArrowDown') {
    shrinkFunc();
  }
  if (event.key === 'ArrowLeft') {
    leftFunc();
  }
  if (event.key === 'ArrowRight') {
    rightFunc();
  }
}

function InitPreviewImage(type) {
  let contentElm = document.getElementById('markdown-content');
  // let contentElm;
  // if (contentElms.length > 0) {
  //   contentElm = contentElms[0];
  // }

  if (!contentElm) {
    return;
  }

  const images = contentElm.getElementsByTagName('img');
  const imaArr: any = [];
  for (let i = 0; i < images.length; i++) {
    const elm = images[i];
    if (type === 'bind') {
      imaArr.push({
        alt: elm.getAttribute('alt'),
        src: elm.getAttribute('src'),
      });
    }

    elm.removeEventListener('click', ImageClick);
    document.removeEventListener('keyup', keyUpFunc);
    if (type === 'bind') {
      elm.addEventListener('click', ImageClick);
      document.addEventListener('keyup', keyUpFunc);
    }
  }
  ImageArr.value = imaArr;

  document.removeEventListener('keyup', keyUpFunc);
  if (type === 'bind' && DeviceInfo.isPC) {
    document.addEventListener('keyup', keyUpFunc);
  }

  document.removeEventListener('wheel', keyUpFunc);
  if (type === 'bind' && DeviceInfo.isPC) {
    document.addEventListener('wheel', keyUpFunc);
  }
}

let mouseStatus = false;
let mouseDownX = 0;
let mouseDownY = 0;
let imgElmLeft = 0;
let imgElmTop = 0;
function Mousemove(e) {
  if (!mouseStatus) {
    return;
  }

  const xDiff = e.clientX - mouseDownX;
  const yDiff = e.clientY - mouseDownY;
  const left = imgElmLeft + xDiff;
  const top = imgElmTop + yDiff;

  // 移动赋值
  const imgElm = document.getElementById('Mo7PreviewBox-img');
  if (imgElm) {
    imgElm.style.left = left + 'px';
    imgElm.style.top = top + 'px';
  }
}

function ImgMouseUp() {
  const imgElm = document.getElementById('Mo7PreviewBox-img');
  if (imgElm) {
    imgElm.style.cursor = 'default';
  }
  mouseStatus = false;
  mouseDownX = 0;
  mouseDownY = 0;
  imgElmLeft = 0;
  imgElmTop = 0;
}

function ImgMouseDown(e) {
  const imgElm: any = document.getElementById('Mo7PreviewBox-img');
  if (imgElm) {
    imgElm.style.cursor = 'move';
  }
  mouseStatus = true;

  mouseDownX = e.clientX;
  mouseDownY = e.clientY;

  let computedStyle;
  if (window.getComputedStyle) {
    computedStyle = window.getComputedStyle(imgElm, null);
  } else {
    computedStyle = (imgElm as any).currentStyle; //兼容IE的写法
  }

  imgElmLeft = parseInt(computedStyle.left);
  imgElmTop = parseInt(computedStyle.top);
}

function on_mousemove(e) {
  if (e.type === 'touchmove') {
    if (e.touches.length == 1) {
      Mousemove(e.touches[0]);
    }
  }
  if (e.type === 'mousemove') {
    Mousemove(e);
  }
}

function on_mouseup(e) {
  ImgMouseUp();
}

function on_mousedown(e) {
  if (e.type === 'touchstart') {
    if (e.touches.length == 1) {
      ImgMouseDown(e.touches[0]);
    }
  }
  if (e.type === 'mousedown') {
    ImgMouseDown(e);
  }
}

onMounted(() => {
  DeviceInfo = GetDeviceInfo();
  console.info('DeviceInfo', DeviceInfo);

  nextTick(() => {
    InitPreviewImage('bind');
  });

  const router = useRouter();
  router.beforeEach((to, from) => {
    if (to.path === from.path) {
      return;
    }
    InitPreviewImage('unbind');
  });

  router.afterEach((to, from) => {
    if (to.path === from.path) {
      return;
    }
    nextTick(() => {
      setTimeout(() => {
        InitPreviewImage('bind');
      }, 1000);
    });
  });
});
</script>
<template>
  <ClientOnly>
    <div
      v-if="ShowPreviewBox"
      id="Mo7PreviewBox"
      @mousemove="on_mousemove"
      @touchmove="on_mousemove"
      @mouseup="on_mouseup"
      @touchend="on_mouseup"
    >
      <div class="Mo7PreviewBox-topBar">
        <div class="btn" @click="leftFunc" :class="{ hide: CurrentImgIdx === 0 }">
          <MyIcon class="icon" name="xiangzuo"></MyIcon>
        </div>
        <div class="btn" @click="rightFunc" :class="{ hide: CurrentImgIdx === ImageArr.length - 1 }">
          <MyIcon class="icon" name="xiangyou"></MyIcon>
        </div>
        <div class="btn" @click.stop="zoomFunc">
          <MyIcon class="icon" name="fangda"></MyIcon>
        </div>
        <div class="btn" @click.stop="shrinkFunc">
          <MyIcon class="icon" name="suoxiao"></MyIcon>
        </div>
        <div class="btn" @click.stop="fullscreenFunc">
          <MyIcon class="icon" name="quanping"></MyIcon>
        </div>
        <a class="btn" :href="ImageArr[CurrentImgIdx].src" download>
          <MyIcon class="icon" name="xiazai"></MyIcon>
        </a>
        <div class="btn" @click.stop="ClosePreviewBox">
          <MyIcon class="icon" name="guanbi"></MyIcon>
        </div>
      </div>

      <img
        id="Mo7PreviewBox-img"
        @mousedown="on_mousedown"
        @touchstart="on_mousedown"
        :src="ImageArr[CurrentImgIdx].src"
        :alt="ImageArr[CurrentImgIdx].alt"
        srcset=""
      />

      <div class="Mo7PreviewBox-idxView">
        <div class="Mo7PreviewBox-idxView-box">
          <div class="Mo7PreviewBox-idxView-idx">{{ CurrentImgIdx + 1 }}/{{ ImageArr.length }}</div>
          <div class="Mo7PreviewBox-idxView-alt" v-if="ImageArr[CurrentImgIdx].alt">
            {{ ImageArr[CurrentImgIdx].alt }}
          </div>
          <div class="Mo7PreviewBox-idxView-key" v-if="DeviceInfo.isPC">
            快捷键:放大↑，缩小↓，上一张←，下一张→，新页面打开↵，Esc关闭预览
          </div>
        </div>
      </div>
    </div>
  </ClientOnly>
</template>

<style lang="scss">
#markdown-content {
  img {
    cursor: pointer;
  }
}

#Mo7PreviewBox {
  position: fixed;
  top: 0;
  left: 0;
  width: 100vw;
  height: 100vh;
  background-color: rgba(0, 0, 0, 0.7);
  display: flex;
  justify-content: center;
  align-items: center;
  z-index: 999;
  overflow: hidden;

  .icon {
    color: #fff;
    font-size: 24px;
    cursor: pointer;
    padding: 6px;
    display: block;
  }

  .Mo7PreviewBox-topBar {
    position: fixed;
    top: 0;
    left: 0;
    width: 100%;
    display: flex;
    align-items: center;
    justify-content: flex-end;
    box-sizing: border-box;
    padding: 10px;
    z-index: 99;
    .btn {
      display: block;
      margin-left: 10px;
      background-color: rgba(0, 0, 0, 0.4);
      &.hide {
        opacity: 0.4;
      }
    }
  }

  .Mo7PreviewBox-idxView {
    position: absolute;
    bottom: 10px;
    right: 10px;
  }

  .Mo7PreviewBox-idxView-box {
    border-radius: 10px;
    background-color: rgba(0, 0, 0, 0.4);
    padding: 8px;
    color: #fff;
    text-align: center;
  }
  .Mo7PreviewBox-idxView-idx {
    font-size: 14px;
  }
  .Mo7PreviewBox-idxView-alt {
    font-size: 20px;
  }
  .Mo7PreviewBox-idxView-key {
    font-size: 12px;
    margin-top: 10px;
  }
}

#Mo7PreviewBox-img {
  position: relative;
  user-select: none;
  -webkit-user-drag: none;
  box-shadow: rgba(0, 0, 0, 0.9) 0px 5px 15px;
}
</style>

Github 源码地址:
https://github.com/mo7cc/blog-source/blob/main/src/.vuepress/components/PreviewImage.vue

第二步：在 .vuepress/client.ts 中全局引入该插件

import { defineClientConfig } from 'vuepress/client';
import { defineAsyncComponent } from 'vue';

const PreviewImage = defineAsyncComponent(() => import('./components/PreviewImage.vue'));

export default defineClientConfig({
  // ....
  rootComponents: [
    // ....
    PreviewImage,
    // ....
  ],
  // ....
});

最终效果如下