Arisaka.ETH

Arisaka.ETH 博客简介

Tue, 29 Sep 2026 00:00:00 GMT

起因

最开始的 Arisaka.ETH 其实就是一个普通的个人博客。
基于 Fuwari 修改，使用 Astro 构建静态页面。

后来陆续加上了 Arweave、ENS、文章加密、Live2D、MIDI、Telegram Moment、CTF、MoeQ、AI 聊天、在线写作等功能，单纯把所有东西继续塞在博客仓库里已经不太合适。

因此现在项目主要拆成两个仓库：

TomorrowX6/arisaka.eth：博客本体、文章和前端。
TomorrowX6/arisaka.eth-workers：Cloudflare Workers、API、D1、R2 和后台任务。

简单来说就是：

arisaka.eth
    ↓
博客 / 内容 / 前端
    ↓
Cloudflare Workers
    ↓
D1 / R2 / Telegram / GitHub / AI / Ethereum

静态的东西尽量保持静态，需要实时处理的东西全部拆到 Worker。

arisaka.eth 主站

主站目前使用 Astro 5 + Svelte，博客的文章、About、友链、Moment 页面以及大部分前端交互都放在这里。

主要技术栈：

Astro / Svelte
TypeScript
Tailwind CSS
Swup
Pagefind
Arweave
ENS
GitHub Actions

文章依然以 Markdown 为主：

Markdown
   ↓
Astro
   ↓
dist/

不过生成 dist/ 后，并不是直接上传到普通静态托管。

Arweave + ENS

博客目前主要通过 Arweave 永久发布，再由 ENS 指向当前版本。

发布流程大概是：

Markdown
   ↓
Astro Build
   ↓
dist/
   ↓
Arweave
   ↓
Path Manifest
   ↓
ENS contenthash
   ↓
arisaka.eth

构建完成后会对文件计算 SHA-256。

如果一个文件的内容之前已经上传过，就直接复用原来的 Arweave Transaction，不需要每次发布都重新上传整个博客。

也就是：

旧文件
→ 复用原 Transaction

修改过的文件
→ 上传新的 Transaction

最终再生成新的 Path Manifest。

Manifest 可以理解成当前博客版本的文件表：

/
→ index.html

/posts/example/
→ posts/example/index.html

/_entry/example.js
→ 对应的 Arweave Transaction

然后将 Manifest 写入 arisaka.eth 的 ENS contenthash。

因此实际上访问链路是：

arisaka.eth
    ↓
ENS
    ↓
Arweave Manifest
    ↓
具体页面文件

相比每次整个站点重新上传，这种方式能少传不少重复资源。

发布验证

Arweave 返回 Transaction ID 不代表公共网关一定已经可以立即读取。

所以在更新 ENS 之前，还会先验证新版本。

主要检查：

Manifest 是否可以读取。
页面和静态资源是否可以读取。
文件大小是否正确。
SHA-256 是否一致。
MIME 类型是否正确。
页面路由是否正常。

流程大概是：

上传 Arweave
      ↓
生成 Manifest
      ↓
公网验证
      ↓
全部通过
      ↓
更新 ENS

如果验证失败，就不会切换 ENS。

旧版本仍然继续工作。

这样至少不会因为新版本刚上传但网关还没有同步完成，直接把线上站点切到一个不可访问的版本。

ENS Gas

更新 ENS 本质上还是一笔 Ethereum 交易，自然也要考虑 Gas。

平时博客更新并没有必要为了立即上线，在 Base Fee 很高的时候硬发一笔交易。

因此部署流程设置了 Base Fee 上限。

Arweave 上传完成
        ↓
检查 Base Fee
        ↓
费用较低
        ↓
更新 ENS

如果费用超过设置值，则：

Arweave 上传完成
        ↓
暂不更新 ENS
        ↓
release-watch
        ↓
继续等待
        ↓
费用满足条件
        ↓
激活新版本

也就是把“上传”和“上线”拆成两个阶段。

Arweave 上的新版本可以已经准备完成，但 ENS 仍然保持旧版本。

GitHub Actions

上面的发布过程主要通过 GitHub Actions 自动完成。

现在一次完整发布涉及：

安装依赖。
Astro 检查。
TypeScript 检查。
构建博客。
恢复 Arweave 上传缓存。
对比文件 SHA-256。
增量上传文件。
生成 Manifest。
验证公网 Arweave 内容。
检查 Ethereum Base Fee。
更新 ENS。
保存上传缓存和 outbox。

因此现在 GitHub Actions 已经不只是简单的：

pnpm build

而更接近完整的发布流水线。

文章加密

博客支持直接发布加密文章。

没有采用密码直接加密正文的方式，而是拆成 KEK / DEK 两层。

密码
 ↓
scrypt
 ↓
KEK
 ↓
AES-256-GCM
 ↓
DEK
 ↓
AES-256-GCM
 ↓
正文 HTML

其中：

KEK：由用户密码通过 scrypt 派生。
DEK：每次构建随机生成。
KEK 只负责加密 DEK。
DEK 才真正负责加密文章正文。

这样密码派生和正文加密是分开的。

加密文章的正文不会进入：

首页摘要。
RSS 正文。
Pagefind 搜索。
初始文章目录。

用户输入密码后才会在浏览器内完成解密。

页面切换时已经解密的 DOM 也会清理。

当然，这种设计依然不能解决弱密码被离线爆破的问题，所以真要使用还是得设置高强度密码。

Provenance

既然文章经过：

ENS
 ↓
Manifest
 ↓
Arweave File

那么也可以反过来查询当前看到的页面到底来自哪次发布。

因此文章底部加入了 Provenance 信息。

大概会显示：

ENS contenthash
        ↓
Arweave Manifest TX
        ↓
文章 File TX
        ↓
Content Digest
        ↓
App Version

主要就是方便确认：

当前网页到底对应哪一个 Arweave Transaction 和哪一次博客发布。

并不是什么完整的密码学证明，只是把原本隐藏在发布流程里的信息展示出来。

Live2D

博客桌面端还放了一个 Live2D Roro。

最开始只是单纯的桌宠，后面又给它加上了聊天和文章话题功能。

AI 请求不会直接从浏览器调用模型 API，而是：

Browser
   ↓
live2d-chat Worker
   ↓
AI API

API Key 只保存到 Worker Secret。

Worker 负责请求检查、额度限制和模型调用。

在公开文章中，还可以根据文章内容生成相关话题。

首页、About、Friends 等非文章页面则主要播放动漫语录。

所以 Roro 现在已经不只是页面装饰，也算一个独立的交互入口了。

MIDI

侧栏播放器使用 SpessaSynth 在浏览器直接合成 MIDI。

支持：

.mid
.midi
.rmi
顺序播放
随机播放
单曲循环
播放列表
进度拖动

合成器、AudioWorklet 和 SoundFont 都会等用户真正开始播放以后再加载，没必要刚打开博客就全部下载。

虚拟终端

Live2D 菜单里还能打开一个虚拟终端。

终端不是简单打印几行固定文字，而是做了基本的命令解析、历史记录、Tab 补全和虚拟文件系统。

例如：

ls
cd
pwd
cat
open
whoami
uname
date
neofetch
history
clear
exit

里面的部分文件直接来源于博客真实内容。

例如：

~/README/
~/posts/
~/about.md

open 还可以直接打开博客文章。

Moment

Moment 是后来加的一个 Telegram 动态页面。

主要展示 @azusabot0 中的：

文字。
图片。
视频封面。
原 Telegram 帖子链接。

最开始很容易想到直接用 GitHub Actions 定时同步：

Telegram
   ↓
GitHub Actions
   ↓
生成数据
   ↓
重新构建博客

但这样最大的问题就是：

发一条 Telegram，就得把整个博客重新构建和发布一次。

感觉多少有点抽象。

所以后来把同步完全拆到了 arisaka.eth-workers。

现在变成：

Telegram
   ↓
Moment Worker
   ↓
D1 + R2
   ↓
moment.000.moe
   ↓
博客 Moment 页面

帖子信息保存到 D1。

图片和视频封面保存到 R2。

博客只请求：

https://moment.000.moe/api/posts

然后在浏览器里动态显示。

这样 Telegram 新增一条动态和博客构建就完全没关系了。

arisaka.eth-workers

随着动态服务越来越多，最后将 Cloudflare Workers 单独拆到了：

TomorrowX6/arisaka.eth-workers

它现在更像整个博客的后端 Monorepo。

目前主要包括：

blog-proxy/
ctf-game/
live2d-chat/
moment/
release-watch/
waline/
randimg/
writer/
docs/

每个 Worker 都有自己的依赖、配置和部署流程。

blog-proxy

blog-proxy 负责把 Arweave 上的博客通过：

000.moe
www.000.moe

提供出来。

Worker 会读取 arisaka.eth 当前的 ENS contenthash，找到对应的 Arweave Manifest。

不过不会让每一个访问请求都实时查询 Ethereum RPC。

ENS 解析结果会缓存在 Cloudflare Edge，缓存过期后再后台刷新。

大概就是：

用户
 ↓
000.moe
 ↓
Cloudflare Worker
 ↓
缓存的 ENS Manifest
 ↓
Arweave

这样 ENS 仍然是博客版本的来源，但不会直接卡在每一个用户请求的关键路径上。

moment

moment 负责 Telegram 频道同步。

Worker 定时读取 Telegram getUpdates：

Telegram
   ↓
Worker
   ├─ D1
   └─ R2
   ↓
Moment API

D1 保存帖子和同步状态。

R2 保存图片以及视频封面。

主站只负责展示。

live2d-chat

live2d-chat 主要负责 Roro 聊天以及相关 AI 功能。

包括：

AI 对话。
文章话题生成。
话题缓存。
请求来源检查。
调用额度限制。
MoeQ 桌宠相关接口。

模型 API Key 全部放在 Worker 后端。

release-watch

release-watch 主要负责博客版本激活和状态监控。

当一次部署已经把内容上传到 Arweave，但因为：

Arweave 网关尚未完全可读。
Ethereum Base Fee 太高。

暂时不能更新 ENS 时，就由它继续跟踪。

新版本
 ↓
Arweave 已上传
 ↓
等待可用
 ↓
等待低 Gas
 ↓
触发激活
 ↓
ENS 更新

同时也会对相关站点进行监控。

waline

评论系统也迁到了 Worker。

前端仍然使用 Waline 客户端，但后端数据保存在 D1。

Blog
 ↓
Waline
 ↓
Worker
 ↓
D1

这样评论功能就不再需要单独维护传统服务器。

randimg

随机图片服务以前使用：

FastAPI
+
nginx
+
SQLite

现在已经迁移成：

Cloudflare Worker
+
R2
+
D1

WebP 图片保存到 R2。

图片索引保存到 D1。

并且旧的图片 ID 和 URL 结构继续保持兼容，所以博客里已有的链接不需要因为迁移重新修改。

Writer

writer 用来解决写博客的问题。

目前同时为 Android Writer 和 Web Writer 提供后端。

登录使用 GitHub App。

编辑完成后可以直接把 Markdown 提交到：

TomorrowX6/arisaka.eth

的 main 分支。

整个过程就变成了：

Writer
   ↓
GitHub
   ↓
arisaka.eth
   ↓
GitHub Actions
   ↓
Astro
   ↓
Arweave
   ↓
ENS

也就是说，不一定非要在电脑上：

git clone
vim
git add
git commit
git push

才能更新文章。

在 Writer 里写完也可以直接发布。

Web Writer 本身还包括文章列表、Markdown 编辑、实时预览、标题大纲、字数统计、命令面板等功能。

CTF

CTF 后来基本已经从博客本体独立出来了。

博客中主要留下入口，而实际游戏运行在 ctf-game 中。

包括：

Plasma 风格浏览器桌面。
CTF 关卡。
运行时 Worker。
存档。
自动化测试。
部署流程。

主站负责：

展示入口

Worker 负责：

真正运行

MoeQ

MoeQ 也放在 ctf-game 相关服务中。

包含题库、媒体处理和运行时逻辑。

目前题目不再只是单纯的文字选择题，还涉及角色、声优、音乐、语录、图片等不同类型。

题库及媒体处理本身比较重，因此和博客内容构建分开维护会方便很多。

不然更新一次题库就重新跑整个 Arweave 博客发布，多少有点离谱。

support/blog

ctf-game/support/blog/ 保存 CTF 和博客之间真正需要共享的最小公开内容。

也就是说没有为了 CTF 再把博客整个复制进 Workers 仓库。

部署流程只导出需要更新的入口文件，然后再交给博客仓库。

两个项目之间尽量保持低耦合。

docs

CTF 和 MoeQ 原本有一部分运行、维护和实现说明放在博客仓库。

拆分 Worker 后，相应文档也一起迁到了 arisaka.eth-workers/docs/。

这样 Worker 的代码、部署方式和对应运维说明都放在同一个仓库里。

现在的架构

现在整体关系大概是：

                    ┌──────────────────┐
                    │   arisaka.eth    │
                    │ Astro / Svelte   │
                    └────────┬─────────┘
                             │
                 GitHub Actions
                             │
                             ▼
                    ┌──────────────────┐
                    │     Arweave      │
                    │ Manifest / Files │
                    └────────┬─────────┘
                             │
                             ▼
                           ENS
                             │
                             ▼
                    ┌──────────────────┐
                    │    blog-proxy    │
                    │     000.moe      │
                    └──────────────────┘


arisaka.eth
     │
     ├── Moment ───────── moment Worker ───── D1 / R2 / Telegram
     │
     ├── Roro ─────────── live2d-chat ─────── AI API
     │
     ├── Comments ─────── waline ──────────── D1
     │
     ├── Random Image ─── randimg ─────────── D1 / R2
     │
     ├── Writer ───────── writer ───────────── GitHub
     │
     └── CTF / MoeQ ───── ctf-game

博客本体基本只负责内容和前端。

需要状态、数据库、第三方 API 或定时任务的功能则交给 Workers。

为什么拆开

最明显的好处就是各部分不再互相绑死。

以前可能是：

Telegram 更新
      ↓
博客数据变化
      ↓
重新构建
      ↓
重新上传 Arweave
      ↓
更新 ENS

现在：

Telegram 更新
      ↓
Moment Worker
      ↓
D1 / R2

结束。

评论也是一样：

新增评论
↓
D1

不影响博客。

AI 出问题：

live2d-chat

出问题。

静态文章照样可以正常访问。

随机图片服务出问题，也不会影响 Arweave 上的文章。

最终把整个项目分成两种东西：

静态内容
→ arisaka.eth

动态服务
→ arisaka.eth-workers

各自独立部署，也各自独立维护。

总结

Arisaka.ETH 最开始只是想做一个自己的博客。

后来慢慢变成：

Astro
+
Svelte
+
GitHub Actions
+
Arweave
+
ENS
+
Ethereum
+
Cloudflare Workers
+
D1
+
R2
+
Telegram
+
GitHub
+
AI

很多东西并不是一开始就计划好的。

基本都是遇到问题以后再慢慢改。

比如：

不想依赖传统服务器
→ Arweave

想使用链上域名
→ ENS

不想重复上传文件
→ SHA-256 增量缓存

Gas 太贵
→ release-watch

Telegram 更新不想重建博客
→ Moment Worker

不想继续维护图片服务器
→ R2 + D1

AI Key 不能放前端
→ live2d-chat

想随时写文章
→ Writer

做着做着，最后就成现在这样了。

不过目前两个仓库的职责已经比较清楚：

arisaka.eth 负责博客本身，arisaka.eth-workers 负责博客背后的动态服务。

至少相比以前什么都塞在一起，现在维护起来舒服多了。

图片预览

记录一次PiliPlus PR贡献

Thu, 10 Sep 2026 00:00:00 GMT

问题原因

部分特定视频，如：BV1bW411P7k9 可以发现上述视频有1080P 60帧画质，但是实际无法播放。
对源码进行分析，发现播放器请求未强制指定 qn，会静默回退到 80。因此无法获取高画质1080P 60帧画质。
播放接口返回的 support_formats 只是服务端声明的画质列表，真正可播放的画质应以 dash.video 中的实际流为准。
部分视频会根据请求的 qn 分批返回视频流。例如 BV1bW411P7k9：

请求高画质时，support_formats 包含 116/80/64/32/16，但 dash.video 仅返回 116。
请求 80 时，dash.video 才返回 80/64/32/16。

修复内容

将 VideoHttp.videoUrl 的 qn 改为必传参数，避免隐式回退。
首次请求显式请求高画质流。
使用 dash.video 中的实际画质 ID 判断画质是否可用。
当高画质响应缺少低画质流时：
- 仅额外请求一次缺失画质；
- 合并并去重两个响应中的视频流。
播放和下载均只从实际存在的 DASH 流中选择画质。
对空视频流增加保护，避免后续 first 等操作抛出异常。
使用 try/finally 确保请求结束后恢复 isQuerying 状态。
修正播放器内及详情页画质菜单的可用状态判断。

总结

这或许是b站陈年代码所遗留的屎山，具体是什么原因导致的就无从得知了。

Link: PR #2828

术曲制作之路

Sun, 09 Aug 2026 00:00:00 GMT

起因

悠闲品鉴音乐时听到的纯萌新制作的术曲，闲来无事尝试下
<iframe width="100%" height="468" src="https://www.youtube.com/embed/yYa-sOw924U" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

基础乐理

学音乐当然要懂一些乐理，虽然目前只会一些基础的

大调
全全半全全全半
小调
全半全全半全全

和弦

和弦	公式	C为根音
Major 大三	`1 3 5`	C E G
minor 小三	`1 ♭3 5`	C E♭ G
dim 减三	`1 ♭3 ♭5`	C E♭ G♭
aug 增三	`1 3 ♯5`	C E G♯
maj7 大七	`1 3 5 7`	C E G B
m7 小七	`1 ♭3 5 ♭7`	C E♭ G B♭
7 属七	`1 3 5 ♭7`	C E G B♭

常用和弦进行

级数	和弦	用途/感觉
`4536`	F-G-Em-Am	日系常用、流动感
`1564`	C-G-Am-F	流行、开阔
`6415`	Am-F-C-G	感伤、循环感强
`6451`	Am-F-G-C	感伤后回家
`251`	Dm-G-C	经典解决
`451`	F-G-C	直接回家
`6251`	Am-Dm-G-C	很顺的回归
`3625`	Em-Am-Dm-G	强循环感

旋律不跑调情况下自由发挥啦，毕竟本人也是萌新

试做样品

当然，还没配人声捏，毕竟试做品

Crack

如有条件请入正

FL Studio
https://4download.net/3283-fl-studio-digital-audio-workstation.html
Image-Line FLEX Complete Expansion Bundle
https://4download.net/3966-image-line-flex-complete-expansion-bundle.html
VOICEVOX
https://hatsunemiku.download/
Synthesizer V Studio
https://synthv.me/
https://github.com/sy3c4ll/obsidian

Go语言基础与速查表

Sat, 25 Jul 2026 00:00:00 GMT

为何选GO

Go是 Google 在 2009 年发布的编程语言，也被称为“21世纪的C语言”

性能均衡，且易上手

Go 的运行速度通常明显快于 Python、JavaScript 等解释型语言。
并且Go 的语法比 Rust、C++、Java 更精简，关键字少，代码结构统一。

自带GC(垃圾回收)

Go 程序创建对象后，不需要手动释放。Go 运行时会检查哪些内存已经没有人使用，然后自动回收。
相较于Rust的GC(所有权,借用,生命周期)，学习成本低。

代码风格统一

gofmt会自动整理缩进和代码格式，团队成员写出来的代码风格基本一致。
降低了屎山代码概率。

并发编程简单

Go 内置了 goroutine，可以方便地同时执行多个任务。

<br>

Go语言基础与速查表

引用自Quick Reference 该备忘单提供了帮助您使用 Golang 的基本语法和方法。

入门

hello.go

package main
import "fmt"
func main() {
    fmt.Println("Hello, world!")
}

直接运行

$ go run hello.go
Hello, world!

或者在 Go repl 中尝试一，go 命令参考

变量

var s1 string
s1 = "Learn Go!"
// 一次声明多个变量
var b, c int = 1, 2
var d = true
// 匿名赋值
_ , e = 10, 20

简短声明

s1 := "Learn Go!"        // string
b, c := 1, 2             // int
d := true                // bool

参见：基本类型

函数

package main
import "fmt"
// 程序的入口点
func main() {
  fmt.Println("Hello world!")
  say("Hello Go!")
}
func say(message string) {
  fmt.Println("You said: ", message)
}

参见：函数(Functions)

注释

// 单行注释
/* 这是
多行注释 */

if 语句

if true {
  fmt.Println("Yes!")
}

参见：条件控制

Golang 基本类型

字符串 Strings

s1 := "Hello" + "World"
s2 := `A "raw" string literal
can include line breaks.`
// 输出：10
fmt.Println(len(s1))
// 输出：Hello
fmt.Println(string(s1[0:5]))

字符串的类型为 字符串

数字 Numbers

num := 3             // int
num := 3.            // float64
num := 3 + 4i        // complex128
num := byte('a')     // byte (alias: uint8)
var u uint = 7       // uint (unsigned)
var p float32 = 22.7  // 32-bit float

操作符 Operators

x := 5
x++
fmt.Println("x + 4 =", x + 4)
fmt.Println("x * 4 =", x * 4)

参见：更多操作符

布尔值 Booleans

isTrue   := true
isFalse  := false

操作符

fmt.Println(true && true)   // true 
fmt.Println(true && false)  // false
fmt.Println(true || true)   // true
fmt.Println(true || false)  // true
fmt.Println(!true)          // false

参见：更多操作符

数组 Arrays

┌────┬────┬────┬────┬─────┬─────┐
| 2  | 3  | 5  | 7  | 11  | 13  |
└────┴────┴────┴────┴─────┴─────┘
  0    1    2    3     4     5

primes := [...]int{2, 3, 5, 7, 11, 13}
fmt.Println(len(primes)) // => 6
// 输出：[2 3 5 7 11 13]
fmt.Println(primes)
// 与 [:3] 相同，输出：[2 3 5]
fmt.Println(primes[0:3])

var a [2]string
a[0] = "Hello"
a[1] = "World"
fmt.Println(a[0], a[1]) //=> Hello World
fmt.Println(a)   // => [Hello World]

2d array

var twoDimension [2][3]int
for i := 0; i < 2; i++ {
    for j := 0; j < 3; j++ {
        twoDimension[i][j] = i + j
    }
}
// => 2d:  [[0 1 2] [1 2 3]]
fmt.Println("2d: ", twoDimension)

指针(Pointers)

func main () {
  b := *getPointer()
  fmt.Println("Value is", b)
}

func getPointer () (myPointer *int) {
  a := 234
  return &a
}
//申明指针的时候，如果没有指向某个变量，默认值为nil
//不能直接进行操作，包括读写
var p *int
*p = 123      // panic   nil pointer

//而用new返回的是有默认值的指针, 为数据类型的默认值
func main(){
  //有一块内存存放了10，它的地址由系统自动分配，别名是a
  a := 10
  //内存存放的10变成了20
  a = 20
  var p *int
  p = &a   //或者直接写 p := &a
  //上面的p是一个指针，通过 *p 的方式同样可以访问 变量a指向 的内存

  /*当你动态申请内存的时候，指针的存在意义之一就被体现出来了*/ 
  ptr := new(int)   
  //申请了一块内存空间，没有办法指定别名，new()返回内存地址，用指针接收
  //此时并没有变量能直接指向这块内存，所以只能通过内存地址来访问
}

参见：指针(Pointers)

切片(Slices)

s := make([]string, 3)
s[0] = "a"
s[1] = "b"
s = append(s, "d")
s = append(s, "e", "f")
fmt.Println(s)
fmt.Println(s[1])
fmt.Println(len(s))
fmt.Println(s[1:3])
slice := []int{2, 3, 4}

另见：切片示例

常量(Constants)

const s string = "constant"
const Phi = 1.618
const n = 500000000
const d = 3e20 / n

常量声明可以使用 iota常量生成器初始化，它用于生成一组以相似规则初始化的常量，但是不用每行都写一遍初始化表达式。注意：

在一个const声明语句中，在第一个声明的常量所在的行，iota被置为0，然后在每一个有常量声明的行加一。
写在同一行的值是相同的

const (
    a = iota
    b
    c
)
// a = 0, b = 1, c = 2

类型转换

Go语言中不允许隐式转换，所有类型转换必须显式声明（强制转换），而且转换只能发生在两种相互兼容的类型之间。

i := 90
f := float64(i)
u := uint(i)
// 将等于字符Z
s := string(i)

字符串与其他类型的相互转换

// 字符串转其他类型
str := "90"
// 整数类型
i, err := strconv.Atoi(str)
if err != nil {
    fmt.Println("转换错误:", err)
} else {
    fmt.Println(i)
}
// 浮点类型
f, err := strconv.ParseFloat(str, 64)
// []byte 类型
bytes := []byte(str)
// 其他类型转字符串
str = strconv.Itoa(i)
str = strconv.FormatFloat(f, 'f', 2, 64)
str = string(bytes[:])

Golang 字符串

字符串函数

package main
import (
        "fmt"
        s "strings"
)
func main() {
    /* 需要将字符串导入为 s */
        fmt.Println(s.Contains("test", "e"))
    /* 内置 */
    fmt.Println(len("hello"))  // => 5
    // 输出: 101
        fmt.Println("hello"[1])
    // 输出: e
        fmt.Println(string("hello"[1]))
}

fmt.Printf

package main
import (
        "fmt"
        "os"
)
type point struct {
        x, y int
}
func main() {
        p := point{1, 2}
        fmt.Printf("%v\n", p)                        // => {1 2}
        fmt.Printf("%+v\n", p)                       // => {x:1 y:2}
        fmt.Printf("%#v\n", p)                       // => main.point{x:1, y:2}
        fmt.Printf("%T\n", p)                        // => main.point
        fmt.Printf("%t\n", true)                     // => TRUE
        fmt.Printf("%d\n", 123)                      // => 123
        fmt.Printf("%b\n", 14)                       // => 1110
        fmt.Printf("%c\n", 33)                       // => !
        fmt.Printf("%x\n", 456)                      // => 1c8
        fmt.Printf("%f\n", 78.9)                     // => 78.9
        fmt.Printf("%e\n", 123400000.0)              // => 1.23E+08
        fmt.Printf("%E\n", 123400000.0)              // => 1.23E+08
        fmt.Printf("%s\n", "\"string\"")             // => "string"
        fmt.Printf("%q\n", "\"string\"")             // => "\"string\""
        fmt.Printf("%x\n", "hex this")               // => 6.86578E+15
        fmt.Printf("%p\n", &p)                       // => 0xc00002c040
        fmt.Printf("|%6d|%6d|\n", 12, 345)           // => |    12|   345|
        fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)     // => |  1.20|  3.45|
        fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)   // => |1.20  |3.45  |
        fmt.Printf("|%6s|%6s|\n", "foo", "b")        // => |   foo|     b|
        fmt.Printf("|%-6s|%-6s|\n", "foo", "b")      // => |foo   |b     |
        s := fmt.Sprintf("a %s", "string")
        fmt.Println(s)
        fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

另见：fmt

函数实例

实例	Result
Contains("test", "es")	true
Count("test", "t")	2
HasPrefix("test", "te")	true
HasSuffix("test", "st")	true
Index("test", "e")	1
Join([]string{"a", "b"}, "-")	a-b
Repeat("a", 5)	aaaaa
Replace("foo", "o", "0", -1)	f00
Replace("foo", "o", "0", 1)	f0o
Split("a-b-c-d-e", "-")	[a b c d e]
ToLower("TEST")	test
ToUpper("test")	TEST

Golang 条件控制

有条件的

a := 10
if a > 20 {
    fmt.Println(">")
} else if a < 20 {
    fmt.Println("<")
} else {
    fmt.Println("=")
}

if 中的语句

x := "hello go!"
if count := len(x); count > 0 {
    fmt.Println("Yes")
}

if _, err := doThing(); err != nil {
    fmt.Println("Uh oh")
}

Switch

x := 42.0
switch x {
  case 0:
  case 1, 2:
      fmt.Println("Multiple matches")
  case 42:   // Don't "fall through".
      fmt.Println("reached")
  case 43:
      fmt.Println("Unreached")
  default:
      fmt.Println("Optional")
}

参见：Switch

For loop

for i := 0; i <= 10; i++ {
  fmt.Println("i: ", i)
}

对于 Range 循环

nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
  sum += num
}
fmt.Println("sum:", sum)

For 循环

i := 1
for i <= 3 {
  fmt.Println(i)
  i++
}

Continue 关键字

for i := 0; i <= 5; i++ {
  if i % 2 == 0 {
      continue
  }
  fmt.Println(i)
}

Break 关键字

for {
  fmt.Println("loop")
  break
}

Golang 结构和Maps

定义

package main
import (
        "fmt"
)
type Vertex struct {
        X int
        Y int
}
func main() {
        v := Vertex{1, 2}
        v.X = 4
        fmt.Println(v.X, v.Y) // => 4 2
}

参见：结构(Structs)

字面量

v := Vertex{X: 1, Y: 2}
// Field names can be omitted
v := Vertex{1, 2}
// Y is implicit
v := Vertex{X: 1}

您还可以输入字段名

Maps

m := make(map[string]int)
m["k1"] = 7
m["k2"] = 13
fmt.Println(m) // => map[k1:7 k2:13]
v1 := m["k1"]
fmt.Println(v1)     // => 7
fmt.Println(len(m)) // => 2
delete(m, "k2")
fmt.Println(m) // => map[k1:7]
_, prs := m["k2"]
fmt.Println(prs) // => false
n := map[string]int{"foo": 1, "bar": 2}
fmt.Println(n) // => map[bar:2 foo:1]

指向结构的指针

v := &Vertex{1, 2}
v.X = 2

Doing v.X is the same as doing (*v).X, when v is a pointer.

Golang 函数

多个参数

func plus(a int, b int) int {
    return a + b
}
func plusPlus(a, b, c int) int {
    return a + b + c
}
fmt.Println(plus(1, 2))
fmt.Println(plusPlus(1, 2, 3))

多返回值

func vals() (int, int) {
  return 3, 7
}
a, b := vals()
fmt.Println(a)    // => 3
fmt.Println(b)    // => 7

匿名函数

r1, r2 := func() (string, string) {
    x := []string{"hello", "world"}
    return x[0], x[1]
}()
// => hello world
fmt.Println(r1, r2)

命名返回值

func split(sum int) (x, y int) {
  x = sum * 4 / 9
  y = sum - x
  return
}
x, y := split(17)
fmt.Println(x)   // => 7
fmt.Println(y)   // => 10

可变参数函数

func sum(nums ...int) {
  fmt.Print(nums, " ")
  total := 0
  for _, num := range nums {
      total += num
  }
  fmt.Println(total)
}
sum(1, 2)     // => [1 2] 3
sum(1, 2, 3)  // => [1 2 3] 6
nums := []int{1, 2, 3, 4}
sum(nums...)  // => [1 2 3 4] 10
// 不定参在内存中是连续存储的
// 不定参内部再传递的时候，参数也要是不定的

初始化函数

import --> const --> var --> init()

var num = setNumber()
func setNumber() int {
  return 42
}
func init() {
  num = 0
}
func main() {
  fmt.Println(num) // => 0
}

作为值的函数

func main() {
  // 将函数赋给名称
  add := func(a, b int) int {
      return a + b
  }
  // 使用名称调用函数
  fmt.Println(add(3, 4)) // => 7
}

闭包

func outer() (func() int, int) {
    outer_var := 2
    inner := func() int {
        outer_var += 99
        return outer_var
    }
    inner()
    return inner, outer_var
}
inner, val := outer()
fmt.Println(val)
// => 101
fmt.Println(inner())
// => 200，这里涉及到golang中闭包和内存逃逸的概念，inner()实际上执行了两次，outer()中一次，fmt又一次，
//但为什么是200呢，编译器不能确定outer_var在后续会不会使用，
//所以outer_var不会随着outer()结束而释放它的栈（Stack）空间，
//而会‘逃逸到’堆（Heap）上，那么第二次的inner()中outer_var就会是101。

关闭 1

func scope() func() int{
  outer_var := 2
  foo := func() int {return outer_var}
  return foo
}
// Outpus: 2
fmt.Println(scope()())

Golang 包(Packages)

导入

import "fmt"
import "math/rand"

等同于

import (
  "fmt"        // 给 fmt.Println
  "math/rand"  // 给 rand.Intn
)

另见：导入

别名

import r "math/rand"

import (
    "fmt"
    r "math/rand"
)

r.Intn()

Packages

package main
// 一个内部包只能被另一个包导入
// 那是在以内部目录的父级为根的树内
package internal

另见：内部包

导出名称

// 以大写字母开头
func Hello () {
  ···
}

另见：导出的名称

Golang 并发

协程

package main
import (
    "fmt"
    "time"
)
func f(from string) {
    for i := 0; i < 3; i++ {
            fmt.Println(from, ":", i)
    }
}
func main() {
    f("direct")
    go f("goroutine")
    go func(msg string) {
            fmt.Println(msg)
    }("going")
    time.Sleep(time.Second)
    fmt.Println("done")
}

参见：Goroutines, Channels

WaitGroup

package main
import (
    "fmt"
    "sync"
    "time"
)
func w(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    fmt.Printf("%d starting\n", id)
    time.Sleep(time.Second)
    fmt.Printf("%d done\n", id)
}
func main() {
    var wg sync.WaitGroup
    for i := 1; i <= 5; i++ {
            wg.Add(1)
            go w(i, &wg)
    }
    wg.Wait()
}

参见：WaitGroup

Closing channels

ch <- 1
ch <- 2
ch <- 3
close(ch) // 关闭频道

// 迭代通道直到关闭
for i := range ch {
  ···
}

// Closed if `ok == false`
v, ok := <- ch

参见：范围和关闭

缓冲通道

ch := make(chan int, 2)
ch <- 1
ch <- 2
ch <- 3
// 致命错误：
// 所有 goroutine 都处于休眠状态 - 死锁

参见：缓冲通道

Context

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    // 创建根 context
    ctx := context.Background() // 空 context，通常作为根 context
    todo := context.TODO()      // 当不确定使用哪个 context 时使用

    // 创建带取消功能的 context
    ctx, cancel := context.WithCancel(context.Background())
    defer cancel() // 确保所有路径都调用取消函数

    // 创建带超时的 context
    ctx, cancel = context.WithTimeout(context.Background(), 100*time.Millisecond)
    defer cancel()

    // 创建带截止时间的 context
    deadline := time.Now().Add(200 * time.Millisecond)
    ctx, cancel = context.WithDeadline(context.Background(), deadline)
    defer cancel()

    // 创建带值的 context
    ctx = context.WithValue(context.Background(), "key", "value")
    
    // 从 context 获取值
    value := ctx.Value("key")
    fmt.Println(value)
    
    // 检查 context 是否已取消
    select {
    case <-ctx.Done():
        fmt.Println("Context canceled:", ctx.Err())
    default:
        fmt.Println("Context still valid")
    }
}

Golang 错误控制

延迟函数

func main() {
  defer func() {
    fmt.Println("Done")
  }()
  fmt.Println("Working...")
}

Lambda defer

func main() {
  var d = int64(0)
  defer func(d *int64) {
    fmt.Printf("& %v Unix Sec\n", *d)
  }(&d)
  fmt.Print("Done ")
  d = time.Now().Unix()
}

defer 函数使用当前值d，除非我们使用指针在 main 末尾获取最终值

Defer

func main() {
  defer fmt.Println("Done")
  fmt.Println("Working...")
}

参见：Defer, panic and recover

Golang 方法(Methods)

接收器

//Go语言中的方法（Method）是一种作用于特定类型变量的函数。
//这种特定类型变量叫做接收者（Receiver）。
//接收者的概念就类似于其他语言中的 this 或者 self。
//方法的定义格式如下：
func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
    函数体
}
// 其中，
//     1.接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名
//的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量
// 应该命名为 p，Connector类型的接收者变量应该命名为c等。
//     2.接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
//     3.方法名、参数列表、返回参数：具体格式与函数定义相同。
type Vertex struct {
  X, Y float64
}

func (v Vertex) Abs() float64 {
  return math.Sqrt(v.X * v.X + v.Y * v.Y)
}
func (v Vertex) valuechange() float64 {
  v.X += 1
  return v.X
}
func (v *Vertex) pointerchange() float64 {
  v.X += 1
  return v.X
}
func main() {
  v := Vertex{1, 2}
  v.Abs()

  v = Vertex{1, 2}
  fmt.Println(v.valuechange())  // 2
  fmt.Println(v)                // {1 2}

  v = Vertex{1, 2}
  fmt.Println(v.pointerchange())// 2
  fmt.Println(v)                // {2 2}
}
//如果在方法里修改receiver的值要对caller生效，使用 pointer receiver。

参见：Methods，指针接收器

方法表达式

方法表达式相当于提供一种语法将类型方法调用显式地转换为函数调用，接收者(receiver)必须显式地传递进去。

func (t T) Get(){
    return t.a
}
func (t *T) Set(i int){
    t.a = i
}
//表达式`T.Get`和`(*T).Set`被称为方法表达式，
//需要注意的是在方法表达式中编译器不会做自动转换。
//值调用会自动转换，表达式调用则不会，例如：
type Data struct{}
func (Data) TestValue () {}
func (*Data) TestPointer () {} 
//声明一个类型变量a
var a Data= struct{}{}
//表达式调用编译器不会进行自动转换
Data.TestValue(a) 
//Data.TestValue(&a) 
(*Data).TestPointer (&a) 
//Data.TestPointer(&a) //type Data has no method TestPointer 
//值调用编译器会进行自动转换
y : = (&a).TestValue //编译器帮助转换a.TestValue
g : = a.TestPointer //会转换为(&a).TestPointer

组合结构的方法集

内嵌字段的访问不需要使用全路径，只要保证命名是唯一的就可以，尽量避免同名。如果外层字段和内层字段有相同的方法，则使用简化模式访问外层方法会覆盖内层的方法。

x : = X{a: 1} 
y : = Y{ 
    X : x , 
    b : 2 , 
}
z : = z { 
    Y : y , 
    c : 3 ,
}//组合结构，内嵌字段

组合结构的方法集有如下规则：

若类型 T 包含匿名字段 S ，则 T 的方法集包含S的方法集
若类型 T 包含匿名字段 S ，则 T 的方法集包含 S 和S方法集
不管类型 T 中嵌入的匿名字段是 S 还是 *S ，*T 方法集总是包含 S 和 *S 方法集

Golang 接口(Interfaces)

基本接口(Interfaces)

type Shape interface {
  Area() float64
  Perimeter() float64
}

结构(Struct)

type Rectangle struct {
  Length, Width float64
}

结构 Rectangle 通过实现其所有方法隐式实现接口 Shape

方法(Methods)

func (r Rectangle) Area() float64 {
  return r.Length * r.Width
}
func (r Rectangle) Perimeter() float64 {
  return 2 * (r.Length + r.Width)
}

在 Shape 中定义的方法在Rectangle中实现

接口实例

func main() {
  var r Shape = Rectangle{Length: 3, Width: 4}
  fmt.Printf("Type of r: %T, Area: %v, Perimeter: %v.", r, r.Area(), r.Perimeter())
}

Golang Embed (Go version >= 1.16)

嵌入为string

package main

import (
    _ "embed"
    "fmt"
)

//go:embed version.txt
var version string

func main() {
    fmt.Printf("version %q\n", version)
}

嵌入为[]byte

package main
import (
    _ "embed"
    "fmt"
)

//go:embed version.txt
var versionByte []byte

func main() {
    fmt.Printf("version %q\n", string(versionByte))
}

嵌入为embed.FS

//go:embed hello.txt
var f embed.FS
func main() {
  data, _ := f.ReadFile("hello.txt")
  fmt.Println(string(data))
}

嵌入多个文件

//go:embed hello.txt
//go:embed hello2.txt
var f embed.FS
func main() {
  data, _ := f.ReadFile("hello.txt")
  fmt.Println(string(data))
  data, _ = f.ReadFile("hello2.txt")
  fmt.Println(string(data))
}

嵌入子文件夹下的文件

//go:embed p/hello.txt p/hello2.txt
var f embed.FS
func main() {
  data, _ := f.ReadFile("p/hello.txt")
  fmt.Println(string(data))
  data, _ = f.ReadFile("p/hello2.txt")
  fmt.Println(string(data))
}

同一个文件嵌入为多个变量

//go:embed hello.txt
var s string
//go:embed hello.txt
var s2 string
func main() {
  fmt.Println(s)
  fmt.Println(s2)
}

匹配模式

//go:embed p/*
var f embed.FS
func main() {
  data, _ := f.ReadFile("p/.hello.txt")
  fmt.Println(string(data))
  data, _ = f.ReadFile("p/q/.hi.txt") // 没有嵌入 p/q/.hi.txt
  fmt.Println(string(data))
}

Golang 泛型 (Go version >= 1.18)

泛型类型

type S[T int|float32|float64 ] []T
       ┬  ────────┬──────── 
       ┆          ╰─── 2. 类型约束
       ╰────────────── 1. 类型形参

可以使用类型实参 int 或 string 实例化

type MyMap[K int|string, V float32 | float64] map[K]V

var a MyMap[string, float64] = map[string]float64{
    "jack_score": 9.6,
    "bob_score":  8.4,
}

匿名结构体不支持泛型
匿名函数不支持泛型

泛型函数

任意类型

func Add[T any](a,b T) T {
    return  a+b
}

对类型进行约束

func Add[T string | int | int8](a,b T) T {
    return  a+b
}

类型嵌套

type WowStruct[T int | float32, S []T] struct {
    Data     S
    MaxValue T
    MinValue T
}

var ws WowStruct[int, []int]

泛型函数中进行类型声明 (go version >= 1.20)

func F[T1 any]() {
    type x struct{} 
    type y = x      
}

泛型约束

通过接口实现

type Addable interface{
    type int, int8, int16, int32, int64, uint, uint8, uint16, uint32, uint64, uintptr, float32, float64, complex64, complex128, string 
}

func Add[T Addable](a,b T) T {
    return  a+b
}

使用 ~ 符号

type Int interface {
    ~int | ~int8 | ~int16 | ~int32 | ~int64
}

type Uint interface {
    ~uint | ~uint8 | ~uint16 | ~uint32
}
type Float interface {
    ~float32 | ~float64
}

type Slice[T Int | Uint | Float] []T 

var s Slice[int] // 正确

type MyInt int
var s2 Slice[MyInt]  // MyInt底层类型是int，所以可以用于实例化

type MyMyInt MyInt
var s3 Slice[MyMyInt]  // 正确。MyMyInt 虽然基于 MyInt ，但底层类型也是int，所以也能用于实例化

type MyFloat32 float32  // 正确
var s4 Slice[MyFloat32]

使用 ~ 时的限制：

~后面的类型不能为接口
~后面的类型必须为基本类型

泛型 Receiver

定义普通类型支持泛型

type MySlice[T int | float32] []T

func (s MySlice[T]) Sum() T {
    var sum T
    for _, value := range s {
        sum += value
    }
    return sum
}

结构体支持泛型

type A[T int | float32 | float64] struct {
}

func (receiver A[T]) Add(a T, b T) T {
    return a + b
}

泛型接口

type Uint interface { // 接口 Uint 中有类型，所以是一般接口
    ~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64
}

type ReadWriter interface {  // ReadWriter 接口既有方法也有类型，所以是一般接口
    ~string | ~[]rune

    Read(p []byte) (n int, err error)
    Write(p []byte) (n int, err error)
}

一般接口类型不能用来定义变量，只能用于泛型的类型约束中

杂项

关键字(Keywords)

break
default
func
interface
select
case
defer
go
map
struct
chan
else
goto
package
switch
const
fallthrough
if
range
type
continue
for
import
return
var

运算符和标点符号


`+`	`&`	`+=`	`&=`	`&&`	`==`	`!=`	`(`	`)`
`-`	`\|`	`-=`	`\|=`	`\|\|`	`<`	`<=`	`[`	`]`
`*`	`^`	`*=`	`^=`	`<-`	`>`	`>=`	`{`	`}`
`/`	`<<`	`/=`	`<<=`	`++`	`=`	`:=`	`,`	`;`
`%`	`>>`	`%=`	`>>=`	`--`	`!`	`...`	`.`	`:`
	`&^`	`&^=`

Go 命令

Go 编译器命令

:-	--
`go command [参数]`	go 命令 [参数]
`go build`	编译包和依赖包
`go clean`	移除对象和缓存文件
`go doc`	显示包的文档
`go env`	打印go的环境变量信息
`go bug`	报告bug
`go fix`	更新包使用新的api
`go fmt`	格式规范化代码
`go generate`	通过处理资源生成go文件
`go get`	下载并安装包及其依赖
`go install`	编译和安装包及其依赖
`go list`	列出所有包
`go run`	编译和运行go程序
`go test`	测试
`go tool`	运行给定的go工具
`go version`	显示go当前版本
`go vet`	发现代码中可能的错误

ENV

:-	--
`GOOS`	编译系统
`GOARCH`	编译arch
`GO111MODULE`	gomod开关
`GOPROXY`	go代理 https://goproxy.io https://goproxy.cn https://mirrors.aliyun.com/goproxy/
`GOSSAFUNC`	生成 `SSA.html` 文件，展示代码优化的每一步 `GOSSAFUNC=func_name go build`
<!--rehype:className=style-list-arrow-->

Module

:-	--
`go mod init`	初始化当前文件夹，创建go.mod文件
`go mod download`	下载依赖的module到本地
`go mod tidy`	增加缺少的module，删除无用的module
`go mod vendor`	将依赖复制到vendor下
文件 `go.mod`	依赖列表和版本约束
文件 `go.sum`	记录 `module` 文件 `hash` 值，用于安全校验
<!--rehype:className=style-list-arrow-->

另见

Devhints (devhints.io)
A tour of Go (tour.golang.org)
Golang wiki (github.com)
Effective Go (golang.org)
Go by Example (gobyexample.com)
Awesome Go (awesome-go.com)
JustForFunc Youtube (youtube.com)
Style Guide (github.com)

利用AxisNow + Cloudflare实现国内自建CDN分流

Fri, 24 Jul 2026 00:00:00 GMT

简介

AxisNow 是一个企业级边缘应用代理，为网站、应用程序和 API 提供安全，性能和连通性 — 所有这些都在您控制的基础设施上运行。<br> 免费用户拥有最多 3 个边缘，最多 10 个资源，最多 100 个别名，足够个人用户使用。<br> 首先你要有一台国内优化VPS，两个域名，一张外币卡（用于订阅Cloudflare Saas免费版），如果准备好了那就让我们开始<br>

名词解释

我们先来理解一下本文用到的一些名词术语。

代理域：是您提供给客户端访问的业务域名，也是实际在边缘进行反向代理的主机名。
虚拟域：该域名是专为 Cloudflare 创建的配置载体。需将 DNS 托管至 CF。
回源域：此域名在虚拟域中配置解析记录指向您的源服务器，并开启小黄云。
调度域：是工作在 DNS 层的解析域名。对于客户端/访客来说，并不需要知道该域名。

设置虚拟域（Cloudflare）

以我自己为例，我有两个域名（000.moe，746434.xyz），000.moe是用于访问的域名，746434.xyz是用于回源的域名

将域名全部托管到Cloudflare
添加一个虚拟域，在746434.xyz的DNS记录中添加A记录(source.746434.xyz)并指向你的VPS地址，并且打开小黄云
进入Saas界面（依次点击746434.xyz - SSL/TLS - 自定义主机名），如果你第一次使用，需要先进行外币卡验证
在回退源填入虚拟域（source.746434.xyz），等待验证成功

安装边缘节点（AxisNow）

AxisNow提供了一键安装脚本，依次点击边缘 - 新增 - 生成并复制，然后粘贴到SSH安装(注意：安装前请确保80 443端口未占用）

设置DNS路由（AxisNow）

依次点击策略 - 插件 - DNS路由<br> 选择AxisNow 托管，新增一个A记录路由（cn.alidns-3.com）<br>

点击域名进入路由规则管理，创建一条路由规则：<br>

线路配置为默认。
地址池配置为中国大陆优化的 EIP 地址。
地址监控选择默认监控模版：Default China Network 。
地址选取策略为最小延迟。

选择AxisNow 托管，新增一个CNAME记录路由（all.alidns-3.com）<br>

点击域名进入路由规则管理，创建一条路由规则:<br>

创建默认线路路由规则
地址池为 cn.alidns-3.com
地址监控关联无需选择
地址选取策略随机

再创建一条路由规则<br>

创建地域-境外线路路由规则
地址池为 source.746434.xyz
地址监控关联无需选择
地址选取策略随机

所得all.alidns-3.com即为最终调度域，我们所选择的是最简单国外CF，国内反代，边缘节点数量和其他配置自己按需添加，

设置代理域，回源域（Cloudflare）

添加一个回源域，在746434.xyz的DNS记录中添加CNAME记录(cdn.746434.xyz)并指向调度域（all.alidns-3.com），并关闭小黄云
添加一个代理域，在000.moe的DNS记录中添加CNAME记录(blog.000.moe)并指向回源域(cdn.746434.xyz)
回到Saas界面，添加自定义主机名，自定义主机名为代理域（blog.000.moe），其他默认
等待30s左右刷新，并添加TXT记录验证域名签发证书

设置反向代理（AxisNow）

点击端点 - 资源，新增资源
请求配置为代理域（blog.000.moe），协议HTTPS，端口443
转发配置为实际部署域名或IP，我的博客是放在GitHub上的，所以填miuna-pic.github.io，协议HTTPS，端口443
添加后如配置正确会自动签发证书

关闭CF IPV6(可选)

如果你的边缘节点只有IPV4，当用户使用IPV6国内网络访问时会分流到Cloudflare，所以我们需要关闭IPV6兼容性

curl https://api.cloudflare.com/client/v4/zones/${区域 ID}/settings/ipv6 \
    -X PATCH \
    -H 'Content-Type: application/json' \
    -H "X-Auth-Email: ${登录邮箱}" \
    -H "X-Auth-Key: ${API 密匙}" \
    -d '{"value": "off"}'

注意:API密匙为Global API KEY

最后，Engoy it!

Markdown Extended Features

Wed, 01 May 2024 00:00:00 GMT

GitHub Repository Cards

You can add dynamic cards that link to GitHub repositories, on page load, the repository information is pulled from the GitHub API.

::github{repo="Fabrizz/MMM-OnSpotify"}

Create a GitHub repository card with the code ::github{repo="<owner>/<repo>"}.

::github{repo="saicaca/fuwari"}

Admonitions

Following types of admonitions are supported: note tip important warning caution

:::note Highlights information that users should take into account, even when skimming. :::

:::tip Optional information to help a user be more successful. :::

:::important Crucial information necessary for users to succeed. :::

:::warning Critical content demanding immediate user attention due to potential risks. :::

:::caution Negative potential consequences of an action. :::

Basic Syntax

:::note
Highlights information that users should take into account, even when skimming.
:::

:::tip
Optional information to help a user be more successful.
:::

Custom Titles

The title of the admonition can be customized.

:::note[MY CUSTOM TITLE] This is a note with a custom title. :::

:::note[MY CUSTOM TITLE]
This is a note with a custom title.
:::

GitHub Syntax

[!TIP] The GitHub syntax is also supported.

> [!NOTE]
> The GitHub syntax is also supported.

> [!TIP]
> The GitHub syntax is also supported.

Spoiler

You can add spoilers to your text. The text also supports Markdown syntax.

The content :spoiler[is hidden ayyy]!

The content :spoiler[is hidden **ayyy**]!

Expressive Code Example

Wed, 10 Apr 2024 00:00:00 GMT

Here, we'll explore how code blocks look using Expressive Code. The provided examples are based on the official documentation, which you can refer to for further details.

Expressive Code

Syntax Highlighting

Regular syntax highlighting

console.log('This code is syntax highlighted!')

Rendering ANSI escape sequences

ANSI colors:
- Regular: [31mRed[0m [32mGreen[0m [33mYellow[0m [34mBlue[0m [35mMagenta[0m [36mCyan[0m
- Bold:    [1;31mRed[0m [1;32mGreen[0m [1;33mYellow[0m [1;34mBlue[0m [1;35mMagenta[0m [1;36mCyan[0m
- Dimmed:  [2;31mRed[0m [2;32mGreen[0m [2;33mYellow[0m [2;34mBlue[0m [2;35mMagenta[0m [2;36mCyan[0m

256 colors (showing colors 160-177):
[38;5;160m160 [38;5;161m161 [38;5;162m162 [38;5;163m163 [38;5;164m164 [38;5;165m165[0m
[38;5;166m166 [38;5;167m167 [38;5;168m168 [38;5;169m169 [38;5;170m170 [38;5;171m171[0m
[38;5;172m172 [38;5;173m173 [38;5;174m174 [38;5;175m175 [38;5;176m176 [38;5;177m177[0m

Full RGB colors:
[38;2;34;139;34mForestGreen - RGB(34, 139, 34)[0m

Text formatting: [1mBold[0m [2mDimmed[0m [3mItalic[0m [4mUnderline[0m

Editor & Terminal Frames

Code editor frames

console.log('Title attribute example')

<!-- src/content/index.html -->
<div>File name comment example</div>

Terminal frames

echo "This terminal frame has no title"

Write-Output "This one has a title!"

Overriding frame types

echo "Look ma, no frame!"

# Without overriding, this would be a terminal frame
function Watch-Tail { Get-Content -Tail 20 -Wait $args }
New-Alias tail Watch-Tail

Text & Line Markers

Marking full lines & line ranges

// Line 1 - targeted by line number
// Line 2
// Line 3
// Line 4 - targeted by line number
// Line 5
// Line 6
// Line 7 - targeted by range "7-8"
// Line 8 - targeted by range "7-8"

Selecting line marker types (mark, ins, del)

function demo() {
  console.log('this line is marked as deleted')
  // This line and the next one are marked as inserted
  console.log('this is the second inserted line')

  return 'this line uses the neutral default marker type'
}

Adding labels to line markers

// labeled-line-markers.jsx
<button
  role="button"
  {...props}
  value={value}
  className={buttonClassName}
  disabled={disabled}
  active={active}
>
  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Adding long labels on their own lines

// labeled-line-markers.jsx
<button
  role="button"
  {...props}

  value={value}
  className={buttonClassName}

  disabled={disabled}
  active={active}
>

  {children &&
    !active &&
    (typeof children === 'string' ? <span>{children}</span> : children)}
</button>

Using diff-like syntax

+this line will be marked as inserted
-this line will be marked as deleted
this is a regular line

--- a/README.md
+++ b/README.md
@@ -1,3 +1,4 @@
+this is an actual diff file
-all contents will remain unmodified
 no whitespace will be removed either

Combining syntax highlighting with diff-like syntax

  function thisIsJavaScript() {
    // This entire block gets highlighted as JavaScript,
    // and we can still add diff markers to it!
-   console.log('Old code to be removed')
+   console.log('New and shiny code!')
  }

Marking individual text inside lines

function demo() {
  // Mark any given text inside lines
  return 'Multiple matches of the given text are supported';
}

Regular expressions

console.log('The words yes and yep will be marked.')

Escaping forward slashes

echo "Test" > /home/test.txt

Selecting inline marker types (mark, ins, del)

function demo() {
  console.log('These are inserted and deleted marker types');
  // The return statement uses the default marker type
  return true;
}

Word Wrap

Configuring word wrap per block

// Example with wrap
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with wrap=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Configuring indentation of wrapped lines

// Example with preserveIndent (enabled by default)
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

// Example with preserveIndent=false
function getLongString() {
  return 'This is a very long string that will most probably not fit into the available space unless the container is extremely wide'
}

Collapsible Sections

// All this boilerplate setup code will be collapsed
import { someBoilerplateEngine } from '@example/some-boilerplate'
import { evenMoreBoilerplate } from '@example/even-more-boilerplate'

const engine = someBoilerplateEngine(evenMoreBoilerplate())

// This part of the code will be visible by default
engine.doSomething(1, 2, 3, calcFn)

function calcFn() {
  // You can have multiple collapsed sections
  const a = 1
  const b = 2
  const c = a + b

  // This will remain visible
  console.log(`Calculation result: ${a} + ${b} = ${c}`)
  return c
}

// All this code until the end of the block will be collapsed again
engine.closeConnection()
engine.freeMemory()
engine.shutdown({ reason: 'End of example boilerplate code' })

Line Numbers

Displaying line numbers per block

// This code block will show line numbers
console.log('Greetings from line 2!')
console.log('I am on line 3')

// Line numbers are disabled for this block
console.log('Hello?')
console.log('Sorry, do you know what line I am on?')

Changing the starting line number

console.log('Greetings from line 5!')
console.log('I am on line 6')

Simple Guides for Fuwari

Mon, 01 Apr 2024 00:00:00 GMT

Cover image source: Source

This blog template is built with Astro. For the things that are not mentioned in this guide, you may find the answers in the Astro Docs.

Front-matter of Posts

---
title: My First Blog Post
published: 2023-09-09
description: This is the first post of my new Astro blog.
image: ./cover.jpg
tags: [Foo, Bar]
category: Front-end
draft: false
---

Attribute	Description
`title`	The title of the post.
`published`	The date the post was published.
`description`	A short description of the post. Displayed on index page.
`image`	The cover image path of the post.<br/>1. Start with `http://` or `https://`: Use web image<br/>2. Start with `/`: For image in `public` dir<br/>3. With none of the prefixes: Relative to the markdown file
`tags`	The tags of the post.
`category`	The category of the post.
`draft`	If this post is still a draft, which won't be displayed.

Where to Place the Post Files

Your post files should be placed in src/content/posts/ directory. You can also create sub-directories to better organize your posts and assets.

src/content/posts/
├── post-1.md
└── post-2/
    ├── cover.png
    └── index.md

Markdown Example

Sun, 01 Oct 2023 00:00:00 GMT

An h1 header

Paragraphs are separated by a blank line.

2nd paragraph. Italic, bold, and monospace. Itemized lists look like:

this one
that one
the other one

Note that --- not considering the asterisk --- the actual text content starts at 4-columns in.

Block quotes are written like so.

They can span multiple paragraphs, if you like.

Use 3 dashes for an em-dash. Use 2 dashes for ranges (ex., "it's all in chapters 12--14"). Three dots ... will be converted to an ellipsis. Unicode is supported. ☺

An h2 header

Here's a numbered list:

first item
second item
third item

Note again how the actual text starts at 4 columns in (4 characters from the left side). Here's a code sample:

# Let me re-iterate ...
for i in 1 .. 10 { do-something(i) }

As you probably guessed, indented 4 spaces. By the way, instead of indenting the block, you can use delimited blocks, if you like:

define foobar() {
    print "Welcome to flavor country!";
}

(which makes copying & pasting easier). You can optionally mark the delimited block for Pandoc to syntax highlight it:

import time
# Quick, count to ten!
for i in range(10):
    # (but not *too* quick)
    time.sleep(0.5)
    print i

An h3 header

Now a nested list:

First, get these ingredients:
- carrots
- celery
- lentils
Boil some water.

Dump everything in the pot and follow this algorithm:

 find wooden spoon
 uncover pot
 stir
 cover pot
 balance wooden spoon precariously on pot handle
 wait 10 minutes
 goto first step (or shut off burner when done)

Do not bump wooden spoon or it will fall.

Notice again how text always lines up on 4-space indents (including that last line which continues item 3 above).

Here's a link to a website, to a local doc, and to a section heading in the current doc. Here's a footnote [^1].

[^1]: Footnote text goes here.

Tables can look like this:

size material color

9 leather brown 10 hemp canvas natural 11 glass transparent

Table: Shoes, their sizes, and what they're made of

(The above is the caption for the table.) Pandoc also supports multi-line tables:

keyword text

red Sunsets, apples, and other red or reddish things.

green Leaves, grass, frogs and other things it's not easy being.

A horizontal rule follows.

Here's a definition list:

apples : Good for making applesauce. oranges : Citrus! tomatoes : There's no "e" in tomatoe.

Again, text is indented 4 spaces. (Put a blank line between each term/definition pair to spread things out more.)

Here's a "line block":

| Line one | Line too | Line tree

and images can be specified like so:

Inline math equations go in like so: $\omega = d\phi / dt$. Display math should get its own line and be put in in double-dollarsigns:

$$I = \int \rho R^{2} dV$$

$$ \begin{equation*} \pi =3.1415926535 ;8979323846;2643383279;5028841971;6939937510;5820974944 ;5923078164;0628620899;8628034825;3421170679;\ldots \end{equation*} $$

And note that you can backslash-escape any punctuation characters which you wish to be displayed literally, ex.: `foo`, *bar*, etc.

Include Video in the Posts

Tue, 01 Aug 2023 00:00:00 GMT

Just copy the embed code from YouTube or other platforms, and paste it in the markdown file.

---
title: Include Video in the Post
published: 2023-10-19
// ...
---

<iframe width="100%" height="468" src="https://www.youtube.com/embed/5gIf0_xpFPI?si=N1WTorLKL0uwLsU_" title="YouTube video player" frameborder="0" allowfullscreen></iframe>

YouTube

Bilibili

Exhentai里站共享账户

Thu, 08 Dec 2022 00:00:00 GMT

简介

E-Hentai，又称E站、E绅士、熊猫网，是一个非营利性质的网络图片分享网站，其网站的主要内容为对日本动漫以及电子游戏等插画、漫画、同人志等内容中截取的电子图片，收录内容偏向于色情成人内容，[2]此网站除公开可以任意访客使用的该站点外，还拥有一个访问受限的隐藏站点Exhentai。(摘选自维基百科)

大多数的本子都是从这里搬运的，例如:众所周知的PicAcg、喵绅士等

官网

表站
 里站

账号注册与分享

重点来了啊，没有账号的看这里

自己注册

需要搭建欧美私人V:P!И后访问。一定要有欧美私人IP，不能多人共用同IP。
公共IP如果有人注册过，E站数据库会有记录，再有人注册会把两个账号都拉黑，永远无法获得里区权限。
使用中国、日本等亚洲IP注册的账号，也无法获得里区权限。务必选对V:P!И位置，用欧美地区节点。
建议用Gmail邮箱注册，使用新浪、搜狐、163、QQ等国内邮箱注册的账号，无法获得里区权限。

图解

详细请看:注册里站教程

公用账号

注意:请不要对公用账号进行破坏，我也其他没有多余的账号，且用且珍惜吧

帐号cookie
ipb_member_id=4520928
ipb_pass_hash=925cc4de040051f7024333fb45f63a2a
igneous=5c521e916

安卓使用教程

目前安卓主流E站分为3个应用
彩色E站(推荐)

点我下载
白色E站

点我下载
绿色E站(老机型推荐)

点我下载

使用方法大部分相同，进去应用点击cookie登录，剪贴板复制或者分别填入数值

PC端使用方法

以Chromium(Chrome开源版)为例
首先在Chrome拓展商店下载Cookie Editor
点我跳转

之后登录exhentai.org
分别填入账号的3个数值，刷新即可

IOS苹果系统

如果你已经越狱，可以尝试安装ipa文件
大熊猫
下载地址

感谢某大佬的支持

再次提醒:请不要对公用账号进行破坏！！！，例如乱修改设置等

温馨提示:请不要过度手冲

哔哩漫游(开启BiliBili新世界)

Sat, 08 Oct 2022 00:00:00 GMT

简介

哔哩漫游，解除B站客户端番剧区域限制的Xposed模块，并且提供其他小功能。
当你有了这个模块，你甚至可以在b站看回复术士的重来人生

功能

解除B站番剧区域限制
缓存番剧
关闭青少年模式弹窗
自定义屏启动图
多次点击版本号可打开隐藏功能

注意

多次点击版本号可打开隐藏功能

使用方法

未root用户
你可以使用内置哔哩漫游版安装包

下载地址

已root用户(LSPosed)
请参考此github地址
传送门

截图

轻小说文库

Sat, 07 May 2022 00:00:00 GMT

简介

轻小说文库是收录最全更新最快的动漫sf轻小说网站,提供轻小说在线阅读,TXT与电子书下载,支持手机WAP访问.

注意

你需要先注册一个账号，请忽略本站关闭及关闭注册的通知，这只是个障眼法，登录后正常使用
注册和登录地址:
点击访问

运行安卓10虚拟机并安装面具

Fri, 06 May 2022 00:00:00 GMT

前言

虚拟机想必大家都用过，比如市面上十分流行的VMOS Pro,光速虚拟机,两仪等等,每个应用都有每个应用的优点，今天就重点讲讲内测的光速虚拟机安卓10版

对比

两仪: 不推荐

支持安卓8
支持Root
用起来略卡

VMOS Pro: 推荐

第一款安卓虚拟机
支持自定义ROM安装
支持安卓9，安卓7.1，安卓5.1
支持Root，xp模块，运行流畅
目前安卓9不支持Root

光速虚拟机: 推荐

开机快
支持安卓7.1和安卓10(内测)
支持Root，可以自己装面具模块

光速虚拟机内测包下载

下载地址

安装面具

首先需要下载OpenHub+来刷入面具
下载地址
打开应用和Root权限
点击Yeap

弹出关闭Root提示后关闭Root权限并重启
打开面具应用，并安照提示重启
安装成功，你可以使用面具模块了

ATRI -My Dear Moments

Wed, 04 May 2022 00:00:00 GMT

简介

在不远的未来，海平面原因不明地急速上升,导致了地表多数都沉入海中。

小时候因为事故而失去一条腿的少年・斑鸠夏生，

厌倦了都市的生活，移居到了海边的乡村小镇。

曾经身为海洋地质学家的祖母留给他的、

就只有船、潜水艇还有债务。

夏生为了取回“失去的未来”，与迷之讨债人凯瑟琳一起，

潜海前往据说保存着祖母遗产的海底仓库。

在那里，

他遇到了一位沉睡在如同棺材一般装置中不可思议的少女――亚托莉。

她是一位构造精密到与人类别无二致，而又丰富感情的机器人。

从海底被打捞起来的亚托莉如是说到。

「我想完成主人留给我的最后的命令。

在此之前，我会成为夏生先生的腿！」

在一个逐渐沉入海中的平和小镇，

少年和机器人少女的难忘夏日就这么开始了

百科链接

萌娘百科
 维基百科

入正链接

STEAM

非入正链接

PC
KRKR

图片

游戏为全年龄GAL游戏

Joiplay

Sun, 01 May 2022 00:00:00 GMT

简介

随处组织和玩RPG Maker *，Ren’Py **，TyranoBuilder和HTML游戏。
JoiPlay是RPG Maker XP / VX / VX Ace / MV *，Ren’Py **，TyranoBuilder和基于HTML的游戏的游戏解释器和启动器。
*必须安装用于JoiPlay的RPG Maker插件才能玩RPG Maker XP，VX和VX Ace游戏。
**必须安装用于JoiPlay的Ren’Py插件才能玩Ren’Py游戏。

功能

->跨平台保存文件支持。
->游戏类型的高级设置。
->内置的作弊菜单，用于支持的游戏类型。
->易于使用的现代用户界面。

兼容性

JoiPlay无法模拟Windows或任何操作系统，因此依赖Windows API或不常见的Node.js类/功能的游戏将无法正常工作。对于RPG Maker XP / VX / VX Ace游戏，估计的兼容性率为70％，对于其他游戏类型，则为90％。

下载地址

Google Play

ZeroTermux

Sun, 01 May 2022 00:00:00 GMT

简介

Termux 是一个 Android 下一个高级的终端模拟器，开源且不需要 root，支持 apt 管理软件包，十分方便安装软件包，完美支持 Python、 PHP、 Ruby、 Nodejs、 MySQL等。随着智能设备的普及和性能的不断提升，如今的手机、平板等的硬件标准已达到了初级桌面计算机的硬件标准，用心去打造 DIY 的话完全可以把手机变成一个强大的极客工具。

功能

一键切换国内源，容器切换，备份恢复，Mod全能，QEMU，自定义命令，美化，悬浮窗口，下载站等

下载地址

点我下载

部署系统

这里推荐使用Mod全能来部署，支持多系统选择和美化终端
无需教程，我知道你可以的
安装桌面后使用vncstart打开远程桌面

系统截图

部署博客

可以在终端中部署Hexo博客,具体步骤以后更新

Arcaea全曲包破解版

Mon, 25 Apr 2022 00:00:00 GMT

简介

三维立体节奏游戏

“和蔼的纯白色光芒，正在那失落世界的旋律斗争中等待着你。”

在这个挑战性十足的街机风格音乐游戏中随着旋律而触碰、按压与滑动；聆听来自以日本为首的世界各地作曲者所写的歌曲！

体验全新的音符种类「音弧」：淋漓尽致地利用屏幕空间来滑动并跟随流动的旋律。在这光芒与斗争相互纠缠的失落世界中遗失自我。(摘选自Taptap)

修改内容

全曲包解锁(包括世界、活动的曲包)
内置人物更换
美化界面

缺点:不能登录账号

游戏截图

下载地址

百度网盘提取码:60og

百度网盘不限速下载及秒链解析

Mon, 25 Apr 2022 00:00:00 GMT

极下解析(百度网盘不限速下载)

原理

解析原理就是一个百度网盘中转站，对方使用百度网盘会员下载后并传输给用户
因此，如果你是想赞助的话，请购买捐赠版