Arisaka.ETH

术曲制作之路

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

纪念硬币挑战活动

Fri, 31 Jul 2026 00:00:00 GMT

活动介绍

闲来无事，随手给博客加个彩蛋功能，然后一发不可收拾，就变成了纪念硬币挑战活动
活动共有五关，不算严格意义的CTF挑战，不过应该也是有一定的挑战性的

Tip: 20位的随机字串符是子路径哦

::coin{collection="arisaka-eth" name="Arisaka.ETH Coin" contract="0xfe19cc8a9d37e8ee2ce08e624c773f71fbf82803" edition="3"}

关卡

NO.1

NO.2

NO.3

NO.4

NO.5

二维码复原

订阅会员之什么值得买

Sun, 26 Jul 2026 00:00:00 GMT

名称	价格	支付方式	备注	可购买
Claude	14900NGN	尼日利亚 Apple Store	价格已涨价	False
ChatGPT	11GBP	借记卡	已封车，英区Team	False
OpenCode	5USD	借记卡	新号首月半价	True
Grok			X会员德国银行转账BUG，且印度区已涨价	False
Gemini			Pixel 认证/学生认证/印度Jio	True

名称	价格	支付方式	备注	可购买
Github	26.99TRY	土耳其 Apple Store		True
Termius	年付 85TRY	土耳其 Microsoft Store	需要特定版本Termius	True
MT管理器			国庆节折扣，过去价格更低	False

名称	价格	支付方式	备注	可购买
网易云音乐	5CNY	支付宝	学生认证黑胶会员	True
Apple Music	650NGN	尼日利亚 Apple Store	学生认证	True
Crunchyroll	569INR	印度 Apple Store	支持中文字幕的动漫有限，可用游戏，不可用漫画	True
Pixiv	年付 164.99TRY	土耳其 Apple Store		True
Pikpak			黑五折扣或闲鱼购买Pikpak新用户	True
小幻影视	27CNY	国区 Microsoft Store	早鸟价	False
Youtube	2800NGN	尼日利亚借记卡	风控严重，容易遣返，且只有少部分号可购买家庭会员	True
Telegram			已陨落，尼日利亚借记卡付TG BOT 英镑	False

其他

名称	价格	支付方式	备注	可购买
拼多多	半年付68CNY		百亿补贴会员，每月保底20无门槛	True
移动云盘	年付68CNY		兑换BiliBili大会员和其他权益	True

支付方式

仅统计目前持有的 Card。

平台	KYC 要求	BIN	Type
Krak / Kraken	身份证 / 护照	`532113`	`DEBIT`
Bybit	身份证 / 护照	`537872`	`PrePaid`
Fiat24	—	`548108`	`DEBIT`
ANA Pay	`+81` 手机号	`498494`	`PrePaid`
Ready	—	`533867`	`DEBIT`
Payy	—	`454924`	`DEBIT`
Avalanche	—	`454924`	`DEBIT`

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

Arisaka.ETH

术曲制作之路

起因

基础乐理

试做样品

Crack

纪念硬币挑战活动

活动介绍

关卡

NO.1

NO.2

NO.3

NO.4

NO.5

订阅会员之什么值得买

订阅

AI工具

开发工具

娱乐

其他

支付方式

Go语言基础与速查表

为何选GO

性能均衡，且易上手

自带GC(垃圾回收)

代码风格统一

并发编程简单

Go语言基础与速查表

入门

hello.go

变量

函数

注释

if 语句

Golang 基本类型

字符串 Strings

数字 Numbers

操作符 Operators

布尔值 Booleans

操作符

数组 Arrays

2d array

指针(Pointers)

切片(Slices)

常量(Constants)

类型转换

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

Golang 字符串

字符串函数

fmt.Printf

函数实例

Golang 条件控制

有条件的

if 中的语句

Switch

For loop

对于 Range 循环

For 循环

Continue 关键字

Break 关键字

Golang 结构和Maps

定义

字面量

Maps

指向结构的指针

Golang 函数

多个参数

多返回值

匿名函数

命名返回值

可变参数函数

初始化函数

作为值的函数

闭包

关闭 1

Golang 包(Packages)

导入

等同于

别名

Packages