Posts on My Blog

iPhone手动更新IPCC(运营商配置文件)指南

Ice-Hazymoon@example.com (Ice-Hazymoon) — Thu, 25 Dec 2025 14:15:00 +0800

详细指南：如何手动提取和更新 iPhone 运营商配置文件（IPCC）以获取最新网络设置，无需升级 iOS 系统。

Tor + Clash 自动IP轮换器：实现匿名安全上网

Ice-Hazymoon@example.com (Ice-Hazymoon) — Fri, 12 Dec 2025 00:00:00 +0800

自动轮换 IP 地址，实现匿名安全上网

点击下方按钮即可一键复制文件内容或配置命令

📥 工具下载

工具名称	下载链接	备注
Tor 专家包	https://www.torproject.org/zh-CN/download/tor/	官方下载
Windows 版 Clash	https://www.clashforwindows.net/clash-for-windows-download/	图形界面版
GitHub 下载 Clash	https://github.com/lantongxue/clash_for_windows_pkg/releases	开源版本
Python	https://www.python.org/downloads/windows/	编程环境

⚙️ 配置文件

Global.txt

port: 7890
socks-port: 7891
allow-lan: false
mode: Global
log-level: info
external-controller: 127.0.0.1:9090

proxies:
  - name: "Tor"
    type: socks5
    server: 127.0.0.1
    port: 9050  

proxy-groups:
  - name: "PROXY"
    type: select
    proxies:
      - "Tor"

rules:
  - MATCH,PROXY

torrc - Tor 配置文件

SocksPort 9050
ControlPort 9061
HashedControlPassword 16:
CookieAuthentication 0

🐍 Rotator.py - 主程序代码

Rotator.py

🚀 永久免费谷歌云服务器搭建指南 📈

Ice-Hazymoon@example.com (Ice-Hazymoon) — Tue, 09 Dec 2025 00:00:00 +0800

本指南详细介绍了如何获取并配置谷歌云的永久免费服务器，包括账号准备、实例创建、面板安装和流量监控等完整流程。

健腹轮使用终极指南

Ice-Hazymoon@example.com (Ice-Hazymoon) — Mon, 10 Nov 2025 16:44:10 +0800

💪 健腹轮使用终极指南：科学塑形·高效燃脂 · 练出马甲线！

🏋️ 一、器械选择与基础准备

想高效训练不踩坑？选对装备是第一步！

✅ 装备挑选指南

轮体材质：选高密度塑料/金属轮芯（如特步XTEP自动回弹款），耐磨抗摔，稳定性拉满！
手柄设计：宽5cm+防滑硅胶手柄，握感舒适不滑手，告别“手忙脚乱”~
适配体重：普通款承重100kg+；大体重小伙伴（＞100kg）直接冲专业承重款（≥300斤）！

⚠️ 训练前必做

动态热身：5分钟「猫牛式」（拱背-塌腰交替）激活核心，「手臂绕环」（前后各10圈）松肩关节。
场地防护：瑜伽垫/防滑地垫铺好，避免硬地硌关节，新手建议面墙练习（距离1米内），安全感UP！

🎯 二、5大黄金动作模式（附发力口诀）

从新手到高手，一套覆盖全核心的训练方案！

全球最土豪网红：MrBeast如何靠“烧钱”建立商业帝国？

Ice-Hazymoon@example.com (Ice-Hazymoon) — Wed, 04 Jun 2025 20:10:00 +0800

MrBeast 通过极端“烧钱”的方式打造爆款视频，不仅积累了海量订阅，更成功孵化出多个估值数十亿美元的品牌帝国，彻底改变了内容创作者的商业边界。

全球最土豪网红：MrBeast（野兽先生）

Ice-Hazymoon@example.com (Ice-Hazymoon) — Wed, 04 Jun 2025 19:58:00 +0800

MrBeast，全球最有钱的YouTuber，通过“送钱、慈善、爆款内容”打造出估值数十亿美元的品牌帝国。即使是亿万富豪，也曾为婚礼向母亲借钱。他的成功背后，是极致投入内容与商业闭环的策略。

Mermaid短代码使用指南

Ice-Hazymoon@example.com (Ice-Hazymoon) — Thu, 29 May 2025 01:30:50 +0800

本文介绍了如何在Markdown中使用Mermaid短代码来生成各种图表，包括流程图、序列图、甘特图、类图、Git图和状态图等

Mermaid学习笔记

Ice-Hazymoon@example.com (Ice-Hazymoon) — Wed, 28 May 2025 08:00:18 +0800

合并初识、流程图、甘特图三篇Mermaid学习笔记，系统介绍Mermaid的基本用法与进阶技巧。

Hugo支持的ASCII图表生成方式

Ice-Hazymoon@example.com (Ice-Hazymoon) — Tue, 27 May 2025 19:59:13 +0800

Hugo支持的ASCII图表生成方式

GoAT是一个基于markdeep.mini.js的语言实现，能够将ASCII文本转换为精美的SVG图表，支持树形图、网格、节点连接等多种图表类型，是技术文档可视化的理想工具。

这是一个 markdeep.mini.js 的 ASCII 图表生成功能的语言实现。

使用示例

使用方法

树形图

       .               .                .              .--- 1          .-- 1     / 1
      / \              |                |          .---+            .-+         +
     /   \         .---+---.         .--+--.       |   '--- 2      |   '-- 2   / \ 2
    +     +        |       |        |       |   ---+            ---+          +
   / \   / \     .-+-.   .-+-.     .+.     .+.     |   .--- 3      |   .-- 3   \ / 3
  /   \ /   \    |   |   |   |    |   |   |   |    '---+            '-+         +
  1   2 3   4    1   2   3   4    1   2   3   4        '--- 4          '-- 4     \ 4

1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4

重叠图形

        .-.           .-.           .-.           .-.           .-.           .-.
       |   |         |   |         |   |         |   |         |   |         |   |
    .---------.   .--+---+--.   .--+---+--.   .--|   |--.   .--+   +--.   .------|--.      
   |           | |           | |   |   |   | |   |   |   | |           | |   |   |   |
    '---------'   '--+---+--'   '--+---+--'   '--|   |--'   '--+   +--'   '--|------'
       |   |         |   |         |   |         |   |         |   |         |   |
        '-'           '-'           '-'           '-'           '-'           '-'

线条装饰

                ________                            o        *          *   .--------------.
   *---+--.    |        |     o   o      |         ^          \        /   |  .----------.  |
       |   |    '--*   -+-    |   |      v        /            \      /    | |  <------.  | |
       |    '----->       .---(---'  --->*<---   /      .+->*<--o----'     | |          | | |
   <--'  ^  ^             |   |                 |      | |  ^    \         |  '--------'  | |
          \/        *-----'   o     |<----->|   '-----'  |__|     v         '------------'  |
          /\                                                               *---------------'

线条端点

   o--o    *--o     /  /   *  o  o o o o   * * * *   o o o o   * * * *      o o o o   * * * *
   o--*    *--*    v  v   ^  ^   | | | |   | | | |    \ \ \ \   \ \ \ \    / / / /   / / / /
   o-->    *-->   *  o   /  /    o * v '   o * v '     o * v \   o * v \  o * v /   o * v /
   o---    *---
                                 ^ ^ ^ ^   . . . .   ^ ^ ^ ^   \ \ \ \      ^ ^ ^ ^   / / / /
   |  |   *  o  \  \   *  o      | | | |   | | | |    \ \ \ \   \ \ \ \    / / / /   / / / /
   v  v   ^  ^   v  v   ^  ^     o * v '   o * v '     o * v \   o * v \  o * v /   o * v /
   *  o   |  |    *  o   \  \

   <--o   <--*   <-->   <---      ---o   ---*   --->   ----      *<--   o<--   -->o   -->*

点阵网格

  o o o o o  * * * * *  * * o o *    o o o      * * *      o o o     · * · · ·     · · ·
  o o o o o  * * * * *  o o o o *   o o o o    * * * *    * o * *    · * * · ·    · · · ·
  o o o o o  * * * * *  o * o o o  o o o o o  * * * * *  o o o o o   · o · · o   · · * * ·
  o o o o o  * * * * *  o * o o o   o o o o    * * * *    o * o o    · · · · o    · · * ·
  o o o o o  * * * * *  * * * * o    o o o      * * *      o * o     · · · · ·     · · *

· · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · · ·

大型节点

   .---.       .-.        .-.       .-.                                       .-.
   | A +----->| 1 +<---->| 2 |<----+ 4 +------------------.                  | 8 |
   '---'       '-'        '+'       '-'                    |                  '-'
                           |         ^                     |                   ^
                           v         |                     v                   |
                          .-.      .-+-.        .-.      .-+-.      .-.       .+.       .---.
                         | 3 +---->| B |<----->| 5 +---->| C +---->| 6 +---->| 7 |<---->| D |
                          '-'      '---'        '-'      '---'      '-'       '-'       '---'

A 1 2 3 4 B 5 C 6 8 7 D

小型网格

       ___     ___      .---+---+---+---+---.     .---+---+---+---.  .---.   .---.
   ___/   \___/   \     |   |   |   |   |   |    / \ / \ / \ / \ /   |   +---+   |
  /   \___/   \___/     +---+---+---+---+---+   +---+---+---+---+    +---+   +---+
  \___/ b \___/   \     |   |   | b |   |   |    \ / \a/ \b/ \ / \   |   +---+   |
  / a \___/   \___/     +---+---+---+---+---+     +---+---+---+---+  +---+ b +---+
  \___/   \___/   \     |   | a |   |   |   |    / \ / \ / \ / \ /   | a +---+   |
      \___/   \___/     '---+---+---+---+---'   '---+---+---+---'    '---'   '---'

a b a b a b a b

大型网格

    .----.        .----.
   /      \      /      \            .-----+-----+-----.      
  +        +----+        +----.      |     |     |     |          .-----+-----+-----+-----+
   \      /      \      /      \     |     |     |     |         /     /     /     /     /
    +----+   B    +----+        +    +-----+-----+-----+        +-----+-----+-----+-----+
   /      \      /      \      /     |     |     |     |       /     /     /     /     /
  +   A    +----+        +----+      |     |  B  |     |      +-----+-----+-----+-----+
   \      /      \      /      \     +-----+-----+-----+     /     /  A  /  B  /     /
    '----+        +----+        +    |     |     |     |    +-----+-----+-----+-----+
          \      /      \      /     |  A  |     |     |   /     /     /     /     /
           '----'        '----'      '-----+-----+-----'  '-----+-----+-----+-----+

A B A B A B

复杂示例

+-------------------+                           ^                      .---.
|    A Box          |__.--.__    __.-->         |      .-.             |   |
|                   |        '--'               v     | * |<---        |   |
+-------------------+                                  '-'             |   |
                       Round                                       *---(-.  |
  .-----------------.  .-------.    .----------.         .-------.     | | |
 |   Mixed Rounded  | |         |  / Diagonals  \        |   |   |     | | |
 | & Square Corners |  '--. .--'  /              \       |---+---|     '-)-'       .--------.
 '--+------------+-'  .--. |     '-------+--------'      |   |   |       |        / Search /
    |            |   |    | '---.        |               '-------'       |       '-+------'
    |<---------->|   |    |      |       v                Interior                 |     ^
    '           <---'      '----'   .-----------.              ---.     .---       v     |
 .------------------.  Diag line    | .-------. +---.              \   /           .     |
 |   if (a > b)     +---.      .--->| |       | |    | Curved line  \ /           / \    |
 |   obj->fcn()     |    \    /     | '-------' |<--'                +           /   \   |
 '------------------'     '--'      '--+--------'      .--. .--.     |  .-.     +Done?+-'
    .---+-----.                        |   ^           |\ | | /|  .--+ |   |     \   /
    |   |     | Join        \|/        |   | Curved    | \| |/ | |    \    |      \ /
    |   |     +---->  o    --o--        '-'  Vertical  '--' '--'  '--  '--'        +  .---.
 <--+---+-----'       |     /|\                                                    |  | 3 |
                      v                             not:line    'quotes'        .-'   '---'
  .-.             .---+--------.            /            A || B   *bold*       |        ^
 |   |           |   Not a dot  |      <---+---<--    A dash--is not a line    v        |
  '-'             '---------+--'          /           Nor/is this.            ---

& A M S i o i q f b B x u j o e a ( - x d r a > e f R > c o C n u o b ( n r ) ) d n e e J d r o s i n N o R D t o i u a a n g d d l o i t n e D i a g o n a l s C V u e r r v t e i d c a l n o t A N C : o u l d r r i A a / I v n s i n e e h s t d - e - t r l B i h i i s i o n ' s r e q n . u * o o b t t o e l a s d ' * l i n e D o n S e e ? a r c 3 h

AI问答平台选择：技术问题12.7倍响应优势 vs 经验问题34%参考价值

Ice-Hazymoon@example.com (Ice-Hazymoon) — Tue, 27 May 2025 17:37:00 +0800

技术问题与经验问题平台选择指南

AI问诊的双面性：生理疾病筛查利器 vs 心理诊疗的三大技术瓶颈

Ice-Hazymoon@example.com (Ice-Hazymoon) — Tue, 27 May 2025 17:28:37 +0800

AI问诊的技术双面性

DeepSeek工程化调教指南：提示词优化到系统构建

Ice-Hazymoon@example.com (Ice-Hazymoon) — Tue, 27 May 2025 16:55:00 +0800

DeepSeek高效指南: 从提示词到系统构建

技术解析｜DeepSeek是否采用阿里云服务器？深度揭秘AI搜索引擎的云端架构选择

Ice-Hazymoon@example.com (Ice-Hazymoon) — Tue, 27 May 2025 16:23:37 +0800

DeepSeek云端架构技术解析

2025年科目一考试核心记忆口诀分类整理（结合新规与最新大纲）

Ice-Hazymoon@example.com (Ice-Hazymoon) — Sat, 24 May 2025 11:39:13 +0800

驾驶证考试核心记忆口诀分类整理，包含速度限制、扣分规则、驾照吊销、罚款处罚、交通标志等考点速记方法

AI思考时间控制技术: 如何精确模拟30秒思考过程?

Ice-Hazymoon@example.com (Ice-Hazymoon) — Mon, 08 May 2023 10:30:00 +0800

深入探讨AI思考时间控制技术，通过多轮提示词设计与外部机制配合，实现精确30秒的AI思考过程模拟，适用于深度推理与专家系统场景。

GoogleOne使用教程

Ice-Hazymoon@example.com (Ice-Hazymoon) — Fri, 05 May 2023 15:42:38 +0800

G1V虚拟机透明代理安装教程

0、虚拟机及虚拟系统

Windows 推荐: VMware
Mac 推荐: Parallels Desktop

虚拟系统 推荐: debian11

一、注意事项

** G1V 用户请不要开启 fake-ip.

玩转Cloud Studio

Ice-Hazymoon@example.com (Ice-Hazymoon) — Mon, 24 Apr 2023 10:19:25 +0800

Cloud Studio 体验

前言

Cloud Studio 是基于浏览器的集成式开发环境（IDE），为开发者提供了一个稳定的云端工作站；在使用 Cloud Studio 时无需安装，随时随地打开浏览器就能使用；包含代码高亮、自动补全、Git 集成、终端等 IDE 的基础功能，同时支持实时调试、插件扩展等，可以帮助开发者快速完成各种应用的开发、编译与部署工作。

Cloud Studio 现处于免费试用期间，每个账号每个月赠送 1000 分钟免费额度，超出需要付费，不过1000分钟对于我这种刚开始试用的个人用户来说已经是绰绰有余了；接下来我们就开始试用 Cloud Studio 吧

1. 登录 Cloud Studio

访问 Cloud Studio 的官网： https://cloudstudio.net/ ，目前共有三种登录方式：CODING，微信，GITHUB

短代码（Shortcodes）

Ice-Hazymoon@example.com (Ice-Hazymoon) — Mon, 02 May 2022 13:12:47 +0200

一些短代码示例

网站和数据库备份到GIT

Ice-Hazymoon@example.com (Ice-Hazymoon) — Fri, 22 Apr 2022 12:29:24 +0800

注册git.oschina
添加公钥

怎样生成ssh公钥

创建私有项目
下载脚本到服务器

git config --global user.name "你的名字或昵称"
修改脚本配置
chmod +x backup.sh #赋予权限
./backup.sh

使用 cron 设置定时脚本

crontab -e
加入 30 3 * * * /bin/bash /root/backup.sh
重启cron sudo service cron restart

完工

画廊（春）

Ice-Hazymoon@example.com (Ice-Hazymoon) — Fri, 15 Apr 2022 02:49:13 +0200

一些关于花的照片

中文排版测试

Ice-Hazymoon@example.com (Ice-Hazymoon) — Fri, 15 Apr 2022 02:49:13 +0200

中文文章排版实例：论语学而篇第一

加密文章测试

Ice-Hazymoon@example.com (Ice-Hazymoon) — Sat, 09 Apr 2022 02:49:13 +0200

Hugo 文章加密测试

借用 ShadowsocksR加速 git clone

Ice-Hazymoon@example.com (Ice-Hazymoon) — Thu, 22 Apr 2021 12:29:24 +0800

必要软件 `点击` 可下载

1. ShadowsocksR

所有版本

2. 获取SSR免费账号

点击服务器列表中的二维码

Snip20170628_12.png

打开 SSR 软件扫描二维码

Snip20170628_14.png

3. 打开终端输入下面命令.不要修改

git config --global http.proxy 'socks5://127.0.0.1:1080' && git config --global https.proxy 'socks5://127.0.0.1:1080'

百度云破解限速

Ice-Hazymoon@example.com (Ice-Hazymoon) — Wed, 22 Apr 2020 12:29:24 +0800

必要软件 `点击` 可下载

1. GoogleChrome 浏览器

2. Aria2GUI-Mac版

Aria2GUI-Wind版

3. 浏览器插件BaiduExporter `插件请用-开发者模式`加载

Go 错误处理

Ice-Hazymoon@example.com (Ice-Hazymoon) — Mon, 22 Apr 2019 12:29:24 +0800

Go 错误处理

一、错误

在Go中有一部分函数总是能成功的运行。比如strings.Contains和strconv.FormatBool函数；对于大部分函数而言，永远无法确保能否成功运行。

Go 语言通过内置的错误接口提供了非常简单的错误处理机制。

error类型是一个接口类型，这是它的定义：

1
2
3

type error interface {
    Error() string
}

我们可以在编码中通过实现 error 接口类型来生成错误信息。

函数通常在最后的返回值中返回错误信息。使用errors.New 可返回一个错误信息：

func Sqrt(f float64) (float64, error) {
    if f < 0 {
        return 0, errors.New("math: square root of negative number")
    }
    // 实现
}

这里有一个错误处理的例子：

go并发编程

Ice-Hazymoon@example.com (Ice-Hazymoon) — Mon, 22 Apr 2019 12:29:24 +0800

go并发编程

一、协程（Goroutines）

在Go语言中，每一个并发的执行单元叫作一个goroutine。，我们只需要通过 go 关键字来开启 goroutine 即可。goroutine 是轻量级线程，goroutine 的调度是由 Golang 运行时进行管理的。

goroutine 语法格式：

`1`	`go 函数名( 参数列表 )`

示例：

package main

import "fmt"

func f(from string) {
    for i := 0; i < 3; i++ {
        fmt.Println(from, ":", i)
    }
}
func main() {
    // 假设我们有一个函数叫做 f(s)。
    // 我们使用一般的方式调并同时运行。
    f("direct")
    // 使用 go f(s) 在一个 Go 协程中调用这个函数。
    // 这个新的 Go 协程将会并行的执行这个函数调用。
    go f("goroutine")
    // 你也可以为匿名函数启动一个 Go 协程。
    go func(msg string) {
        fmt.Println(msg)
    }("going")

    // 现在这两个 Go 协程在独立的 Go 协程中异步的运行，所以我们需要等它们执行结束。
    // 这里的 Scanln 代码需要我们在程序退出前按下任意键结束。
    var input string
    fmt.Scanln(&input)
    fmt.Println("done")
    // 当我们运行这个程序时，将首先看到阻塞式调用的输出，然后是两个 Go 协程的交替输出。
    // 这种交替的情况表示 Go 运行时是以异步的方式运行协程的。
}

二、通道（channel）

如果说goroutine是Go语言程序的并发体的话，那么channels则是它们之间的通信机制。通道（channel）是用来传递数据的一个数据结构。

golang常用方法

Ice-Hazymoon@example.com (Ice-Hazymoon) — Sun, 22 Apr 2018 12:29:24 +0800

golang常用方法

字符串函数

package main

import s "strings"
import "fmt"
// 我们给 fmt.Println 一个短名字的别名，我们随后将会经常用到。
var p = fmt.Println

// 标准库的 strings 包提供了很多有用的字符串相关的函数。
// 这里是一些用来让你对这个包有个初步了解的例子。
func main() {
    // 这是一些 strings 中的函数例子。
    // 注意他们都是包中的函数，不是字符串对象自身的方法，这意味着我们需要考虑在调用时传递字符作为第一个参数进行传递。
    p("Contains:  ", s.Contains("test", "es"))
    p("Count:     ", s.Count("test", "t"))
    p("HasPrefix: ", s.HasPrefix("test", "te"))
    p("HasSuffix: ", s.HasSuffix("test", "st"))
    p("Index:     ", s.Index("test", "e"))
    p("Join:      ", s.Join([]string{"a", "b"}, "-"))
    p("Repeat:    ", s.Repeat("a", 5))
    p("Replace:   ", s.Replace("foo", "o", "0", -1))
    p("Replace:   ", s.Replace("foo", "o", "0", 1))
    p("Split:     ", s.Split("a-b-c-d-e", "-"))
    p("ToLower:   ", s.ToLower("TEST"))
    p("ToUpper:   ", s.ToUpper("test"))
    // 你可以在 strings包文档中找到更多的函数
    p()
    // 虽然不是 strings 的一部分，但是仍然值得一提的是获取字符串长度和通过索引获取一个字符的机制。
    p("Len: ", len("hello"))
    p("Char:", "hello"[1])
}

字符串格式化

package main

import "fmt"
import "os"

type point struct {
    x, y int
}

func main() {
    // Go 为常规 Go 值的格式化设计提供了多种打印方式。例如，这里打印了 point 结构体的一个实例。
    p := point{1, 2}
    fmt.Printf("%v\n", p)
    // 如果值是一个结构体，%+v 的格式化输出内容将包括结构体的字段名。
    fmt.Printf("%+v\n", p)
    // %#v 形式则输出这个值的 Go 语法表示。例如，值的运行源代码片段。
    fmt.Printf("%#v\n", p)
    // 需要打印值的类型，使用 %T。
    fmt.Printf("%T\n", p)
    // 格式化布尔值是简单的。
    fmt.Printf("%t\n", true)
    // 格式化整形数有多种方式，使用 %d进行标准的十进制格式化。
    fmt.Printf("%d\n", 123)
    // 这个输出二进制表示形式。
    fmt.Printf("%b\n", 14)
    // 这个输出给定整数的对应字符。
    fmt.Printf("%c\n", 33)
    // %x 提供十六进制编码。
    fmt.Printf("%x\n", 456)
    // 对于浮点型同样有很多的格式化选项。使用 %f 进行最基本的十进制格式化。
    fmt.Printf("%f\n", 78.9)
    // %e 和 %E 将浮点型格式化为（稍微有一点不同的）科学技科学记数法表示形式。
    fmt.Printf("%e\n", 123400000.0)
    fmt.Printf("%E\n", 123400000.0)
    // 使用 %s 进行基本的字符串输出。
    fmt.Printf("%s\n", "\"string\"")
    // 像 Go 源代码中那样带有双引号的输出，使用 %q。
    fmt.Printf("%q\n", "\"string\"")
    // 和上面的整形数一样，%x 输出使用 base-16 编码的字符串，每个字节使用 2 个字符表示。
    fmt.Printf("%x\n", "hex this")
    // 要输出一个指针的值，使用 %p。
    fmt.Printf("%p\n", &p)
    // 当输出数字的时候，你将经常想要控制输出结果的宽度和精度，可以使用在 % 后面使用数字来控制输出宽度。
    // 默认结果使用右对齐并且通过空格来填充空白部分。
    fmt.Printf("|%6d|%6d|\n", 12, 345)
    // 你也可以指定浮点型的输出宽度，同时也可以通过 宽度.精度 的语法来指定输出的精度。
    fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
    // 要左对齐，使用 - 标志。
    fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
    // 你也许也想控制字符串输出时的宽度，特别是要确保他们在类表格输出时的对齐。
    // 这是基本的右对齐宽度表示。
    fmt.Printf("|%6s|%6s|\n", "foo", "b")
    // 要左对齐，和数字一样，使用 - 标志。
    fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
    // 到目前为止，我们已经看过 Printf了，它通过 os.Stdout输出格式化的字符串。
    // Sprintf 则格式化并返回一个字符串而不带任何输出。
    s := fmt.Sprintf("a %s", "string")
    fmt.Println(s)
    // 你可以使用 Fprintf 来格式化并输出到 io.Writers而不是 os.Stdout。
    fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

数字转换

package main

import "strconv"
import "fmt"

// 从字符串中解析数字在很多程序中是一个基础常见的任务，在Go 中是这样处理的。
func main() {
    // 内置的 strconv 包提供了数字解析功能。
    // 使用 ParseFloat 解析浮点数，这里的 64 表示表示解析的数的位数。
    f, _ := strconv.ParseFloat("1.234", 64)
    fmt.Println(f)
    // 在使用 ParseInt 解析整形数时，例子中的参数 0 表示自动推断字符串所表示的数字的进制。
    // 64 表示返回的整形数是以 64 位存储的。
    i, _ := strconv.ParseInt("123", 0, 64)
    fmt.Println(i)
    // ParseInt 会自动识别出十六进制数。
    d, _ := strconv.ParseInt("0x1c8", 0, 64)
    fmt.Println(d)
    // ParseUint 也是可用的。
    u, _ := strconv.ParseUint("789", 0, 64)
    fmt.Println(u)
    // Atoi 是一个基础的 10 进制整型数转换函数。
    k, _ := strconv.Atoi("135")
    fmt.Println(k)
    // 在输入错误时，解析函数会返回一个错误。
    _, e := strconv.Atoi("wat")
    fmt.Println(e)
}

时间函数

package main

import "fmt"
import "time"

func main() {
    p := fmt.Println
    // 得到当前时间。
    now := time.Now()
    p(now)
    // 通过提供年月日等信息，你可以构建一个 time。时间总是关联着位置信息，例如时区。
    then := time.Date(
        2009, 11, 17, 20, 34, 58, 651387237, time.UTC)
    p(then)
    // 你可以提取出时间的各个组成部分。
    p(then.Year())
    p(then.Month())
    p(then.Day())
    p(then.Hour())
    p(then.Minute())
    p(then.Second())
    p(then.Nanosecond())
    p(then.Location())
    // 输出是星期一到日的 Weekday 也是支持的。
    p(then.Weekday())
    // 这些方法来比较两个时间，分别测试一下是否是之前，之后或者是同一时刻，精确到秒。
    p(then.Before(now))
    p(then.After(now))
    p(then.Equal(now))
    // 方法 Sub 返回一个 Duration 来表示两个时间点的间隔时间。
    diff := now.Sub(then)
    p(diff)
    // 我们计算出不同单位下的时间长度值。
    p(diff.Hours())
    p(diff.Minutes())
    p(diff.Seconds())
    p(diff.Nanoseconds())
    // 你可以使用 Add 将时间后移一个时间间隔，或者使用一个 - 来将时间前移一个时间间隔。
    p(then.Add(diff))
    p(then.Add(-diff))

    p("################")
    // 格式化
    // 这里是一个基本的按照 RFC3339 进行格式化的例子，使用对应模式常量。
    t := time.Now()
    p(t.Format(time.RFC3339))
    // 时间解析使用同 Format 相同的形式值。
    t1, e := time.Parse(
        time.RFC3339,
        "2012-11-01T22:08:41+00:00")
    p(t1)
    // ormat 和 Parse 使用基于例子的形式来决定日期格式，
    // 一般你只要使用 time 包中提供的模式常量就行了，但是你也可以实现自定义模式。
    // 模式必须使用时间 Mon Jan 2 15:04:05 MST 2006来指定给定时间/字符串的格式化/解析方式。
    // 时间一定要按照如下所示：2006为年，15 为小时，Monday 代表星期几，等等。
    p(t.Format("3:04PM"))
    p(t.Format("Mon Jan _2 15:04:05 2006"))
    p(t.Format("2006-01-02T15:04:05.999999-07:00"))
    form := "3 04 PM"
    t2, e := time.Parse(form, "8 41 PM")
    p(t2)
    // 对于纯数字表示的时间，你也可以使用标准的格式化字符串来提出出时间值得组成。
    fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
        t.Year(), t.Month(), t.Day(),
        t.Hour(), t.Minute(), t.Second())
    // Parse 函数在输入的时间格式不正确是会返回一个错误。
    ansic := "Mon Jan _2 15:04:05 2006"
    _, e = time.Parse(ansic, "8:41PM")
    p(e)
}

JSON转换

package main

import "encoding/json"
import "fmt"
import "os"

// 下面我们将使用这两个结构体来演示自定义类型的编码和解码。
type Response1 struct {
    Page   int
    Fruits []string
}
type Response2 struct {
    Page   int      `json:"page"`
    Fruits []string `json:"fruits"`
}

func main() {
    // 首先我们来看一下基本数据类型到 JSON 字符串的编码过程。这里是一些原子值的例子。
    bolB, _ := json.Marshal(true)
    fmt.Println(string(bolB))
    intB, _ := json.Marshal(1)
    fmt.Println(string(intB))
    fltB, _ := json.Marshal(2.34)
    fmt.Println(string(fltB))
    strB, _ := json.Marshal("gopher")
    fmt.Println(string(strB))
    // 这里是一些切片和 map 编码成 JSON 数组和对象的例子。
    slcD := []string{"apple", "peach", "pear"}
    slcB, _ := json.Marshal(slcD)
    fmt.Println(string(slcB))
    mapD := map[string]int{"apple": 5, "lettuce": 7}
    mapB, _ := json.Marshal(mapD)
    fmt.Println(string(mapB))
    // JSON 包可以自动的编码你的自定义类型。
    // 编码仅输出可导出的字段，并且默认使用他们的名字作为 JSON 数据的键。
    res1D := &Response1{
        Page:   1,
        Fruits: []string{"apple", "peach", "pear"}}
    res1B, _ := json.Marshal(res1D)
    fmt.Println(string(res1B))
    // 你可以给结构字段声明标签来自定义编码的 JSON 数据键名称。
    // 在上面 Response2 的定义可以作为这个标签这个的一个例子。
    res2D := &Response2{
        Page:   1,
        Fruits: []string{"apple", "peach", "pear"}}
    res2B, _ := json.Marshal(res2D)
    fmt.Println(string(res2B))
    // 现在来看看解码 JSON 数据为 Go 值的过程。
    // 这里是一个普通数据结构的解码例子。
    byt := []byte(`{"num":6.13,"strs":["a","b"]}`)
    // 我们需要提供一个 JSON 包可以存放解码数据的变量。
    // 这里的 map[string]interface{} 将保存一个 string 为键，值为任意值的map。
    var dat map[string]interface{}
    // 这里就是实际的解码和相关的错误检查。
    if err := json.Unmarshal(byt, &dat); err != nil {
        panic(err)
    }
    fmt.Println(dat)
    // 为了使用解码 map 中的值，我们需要将他们进行适当的类型转换。
    // 例如这里我们将 num 的值转换成 float64类型。
    num := dat["num"].(float64)
    fmt.Println(num)
    // 访问嵌套的值需要一系列的转化。
    strs := dat["strs"].([]interface{})
    str1 := strs[0].(string)
    fmt.Println(str1)
    // 我们也可以解码 JSON 值到自定义类型。
    // 这个功能的好处就是可以为我们的程序带来额外的类型安全加强，并且消除在访问数据时的类型断言。
    str := `{"page": 1, "fruits": ["apple", "peach"]}`
    res := Response2{}
    json.Unmarshal([]byte(str), &res)
    fmt.Println(res)
    fmt.Println(res.Fruits[0])
    // 在上面的例子中，我们经常使用 byte 和 string 作为使用标准输出时数据和 JSON 表示之间的中间值。
    // 我们也可以和os.Stdout 一样，直接将 JSON 编码直接输出至 os.Writer流中，或者作为 HTTP 响应体。
    enc := json.NewEncoder(os.Stdout)
    d := map[string]int{"apple": 5, "lettuce": 7}
    enc.Encode(d)
}

文件写入

package main

import (
    "bufio"
    "fmt"
    "io/ioutil"
    "os"
)

// Go 写文件和我们前面看过的读操作有着相似的方式。
// 读取文件需要经常进行错误检查，这个帮助方法可以精简下面的错误检查过程。
func check(e error) {
    if e != nil {
        panic(e)
    }
}
func main() {
    d1 := []byte("hello\ngo\n")
    // 开始，这里是展示如写入一个字符串（或者只是一些字节）到一个文件。
    err := ioutil.WriteFile("D:/study/dat1", d1, 0644)
    check(err)
    // 对于更细粒度的写入，先打开一个文件。
    f, err := os.Create("D:/study/dat2")
    check(err)
    // 打开文件后，习惯立即使用 defer 调用文件的 Close操作。
    defer f.Close()
    // 你可以写入你想写入的字节切片
    d2 := []byte{115, 111, 109, 101, 10}
    n2, err := f.Write(d2)
    check(err)
    fmt.Printf("wrote %d bytes\n", n2)
    // WriteString 也是可用的。
    n3, err := f.WriteString("writes\n")
    fmt.Printf("wrote %d bytes\n", n3)
    // 调用 Sync 来将缓冲区的信息写入磁盘。
    f.Sync()
    // bufio 提供了和我们前面看到的带缓冲的读取器一样的带缓冲的写入器。
    w := bufio.NewWriter(f)
    n4, err := w.WriteString("buffered\n")
    fmt.Printf("wrote %d bytes\n", n4)
    // 使用 Flush 来确保所有缓存的操作已写入底层写入器。
    w.Flush()

}

golang的指针结构体接口

Ice-Hazymoon@example.com (Ice-Hazymoon) — Sat, 22 Apr 2017 12:29:24 +0800

golang的指针\结构体\接口

一、什么是指针

　　C语言里，变量存放在内存中，而内存其实就是一组有序字节组成的数组，每个字节有唯一的内存地址。CPU 通过内存寻址对存储在内存中的某个指定数据对象的地址进行定位。这里，数据对象是指存储在内存中的一个指定数据类型的数值或字符串，它们都有一个自己的地址，而指针便是保存这个地址的变量。也就是说：指针是一种保存变量地址的变量。

img

二、Go 指针

指针如何定义：

1
2

var ip *int        /* 指向整型*/
var fp *float32    /* 指向浮点型 */

指针使用流程：

定义指针变量。
为指针变量赋值。
访问指针变量中指向地址的值。

示例：

golang函数介绍

Ice-Hazymoon@example.com (Ice-Hazymoon) — Fri, 22 Apr 2016 12:29:24 +0800

golang函数介绍

这里也比较简单，为什么都很简单呢~！~上代码

package main

import "fmt"

func main() {
    // hello world
    fmt.Println("hello world")

    // 1. 加法
    res := plus(1, 2)
    fmt.Println("1+2 =", res)
    res = plusPlus(1, 2, 3)
    fmt.Println("1+2+3 =", res)

    // 2. 多值返回
    // 这里我们通过多赋值 操作来使用这两个不同的返回值。
    a, b := vals()
    fmt.Println(a)
    fmt.Println(b)
    // 如果你仅仅想返回值的一部分的话，你可以使用空白定义符 _。
    _, c := vals()
    fmt.Println(c)

    // 3. 可变参数
    // 变参函数使用常规的调用方式，除了参数比较特殊。
    sum(1, 2)
    sum(1, 2, 3)
    // 如果你的 slice 已经有了多个值，想把它们作为变参使用，你要这样调用 func(slice...)。
    nums := []int{1, 2, 3, 4}
    sum(nums...)

    // 4. 闭包
    // 我们调用 intSeq 函数，将返回值（也是一个函数）赋给nextInt。
    // 这个函数的值包含了自己的值 i，这样在每次调用 nextInt 时都会更新 i 的值。
    nextInt := intSeq()
    // 通过多次调用 nextInt 来看看闭包的效果。
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    fmt.Println(nextInt())
    // 为了确认这个状态对于这个特定的函数是唯一的，我们重新创建并测试一下。
    newInts := intSeq()
    fmt.Println(newInts())

    // 5. 递归
    fmt.Println(fact(7))
}

// 函数
// 这里是一个函数，接受两个 int 并且以 int 返回它们的和
func plus(a int, b int) int {
    // Go 需要明确的返回值，例如，它不会自动返回最后一个表达式的值
    return a + b
}

// (int, int) 在这个函数中标志着这个函数返回 2 个 int。
func plusPlus(a, b, c int) int {
    return a + b + c
}

// 多返回值函数
func vals() (int, int) {
    return 3, 7
}

// 变参函数
func sum(nums ...int) {
    fmt.Print(nums, " ")
    total := 0
    for _, num := range nums {
        total += num
    }
    fmt.Println(total)
}

// 闭包
// 这个 intSeq 函数返回另一个在 intSeq 函数体内定义的匿名函数。
// 这个返回的函数使用闭包的方式 隐藏 变量 i。
func intSeq() func() int {
    i := 0
    return func() int {
        i += 1
        return i
    }
}

// 递归
// face 函数在到达 face(0) 前一直调用自身。
func fact(n int) int {
    if n == 0 {
        return 1
    }
    return n * fact(n-1)
}

本主题支持大量的简写

Ice-Hazymoon@example.com (Ice-Hazymoon) — Wed, 22 Aug 2001 18:18:18 +0800

此处包含密码保护内容

分隔符

Abbr

MIT

分隔符

Color text

red text green text blue text orange text theme text custom color text

Posts on My Blog

iPhone手动更新IPCC(运营商配置文件)指南

Tor + Clash 自动IP轮换器：实现匿名安全上网

自动轮换 IP 地址，实现匿名安全上网

🚀 永久免费谷歌云服务器搭建指南 📈

健腹轮使用终极指南

全球最土豪网红：MrBeast如何靠“烧钱”建立商业帝国？

全球最土豪网红：MrBeast（野兽先生）

Mermaid短代码使用指南

Mermaid学习笔记

Hugo支持的ASCII图表生成方式

AI问答平台选择：技术问题12.7倍响应优势 vs 经验问题34%参考价值

AI问诊的双面性：生理疾病筛查利器 vs 心理诊疗的三大技术瓶颈

DeepSeek工程化调教指南：提示词优化到系统构建

技术解析｜DeepSeek是否采用阿里云服务器？深度揭秘AI搜索引擎的云端架构选择

2025年科目一考试核心记忆口诀分类整理（结合新规与最新大纲）

AI思考时间控制技术: 如何精确模拟30秒思考过程?

GoogleOne使用教程

玩转Cloud Studio

短代码（Shortcodes）

网站和数据库备份到GIT

画廊（春）

中文排版测试

加密文章测试

借用 ShadowsocksR加速 git clone

百度云破解限速

Go 错误处理

go并发编程

golang常用方法

golang的指针 结构体 接口

golang函数介绍

本主题支持大量的简写

golang的指针结构体接口