技术文章 Archives - 原立方 https://www.atomic-cube.cn/category/技术文章/ 技术栈的流动-从零到∞ Wed, 03 Jun 2026 04:42:10 +0000 zh-Hans hourly 1 https://wordpress.org/?v=7.0 多合一macOS系统安装U盘制作教程-终端篇 https://www.atomic-cube.cn/%e5%a4%9a%e5%90%88%e4%b8%80macos%e7%b3%bb%e7%bb%9f%e5%ae%89%e8%a3%85u%e7%9b%98%e5%88%b6%e4%bd%9c%e6%95%99%e7%a8%8b-%e7%bb%88%e7%ab%af%e7%af%87/ https://www.atomic-cube.cn/%e5%a4%9a%e5%90%88%e4%b8%80macos%e7%b3%bb%e7%bb%9f%e5%ae%89%e8%a3%85u%e7%9b%98%e5%88%b6%e4%bd%9c%e6%95%99%e7%a8%8b-%e7%bb%88%e7%ab%af%e7%af%87/#respond Wed, 03 Jun 2026 04:42:09 +0000 https://www.atomic-cube.cn/?p=2104 前排提示： 终端篇是在 Mac OS 系统环境制作 下列教程前提是你已经知道了怎么在 Mac 系统下通过终端命 […]

The post 多合一macOS系统安装U盘制作教程-终端篇 appeared first on 原立方.

]]> 前排提示：

终端篇是在 Mac OS 系统环境制作

下列教程前提是你已经知道了怎么在 Mac 系统下通过终端命令制作U启动盘，知道原理后才能进阶学习多合一制作。

为啥需要多合一？：

对于技术员来说，macOS的系统版本众多，一个U盘制作一个系统的话需要多个U盘，且不利于维护，往往都不知道哪个U盘是哪个版本，如果有一个大容量的U盘的，是否可以一次性把多个 macOS 写入进去呢，答案是可以的，下面教程就说说如何利用终端工具，一个U盘多个分区，逐个写入每个分区

注意：目前官方最新提供的 macOS 10.12 不知道存在什么原因，无法终端写入，只能工具写，我也会跟进这个问题，不断获取最新的 macOS 10.12，希望早日也能终端写入，旧版的10.12就不再发布了，虽然可以终端写入，但是存在证书问题和有效负载报错问题，推荐用10.13代替，10.12和10.13支持的机型一模一样，Mac尽量保持能装新就装新原则

根据上面原则，推荐制作顺序：10.7、10.11、10.13、10.15，重复配置安装最新 macOS

制作过程

分区：

首先需要一个大容量U盘，最好64G以上，我们将U盘分区，格式 GUID ，分几个区则要看你想要制作几个 macOS 。

然后分区：

除了第一个叫upan外，其他暂时先用默认的用 未命名 名称，后面再改

制作第一个 macOS ：

没有看到0-100进度条的，请耐心等待。。。

等待上面完成后，继续制作第二个：

把第二个的未命名名字改成 upan

然后继续终端写入，我这里写入10.14

最后成品图：

剩下的以此类推。

The post 多合一macOS系统安装U盘制作教程-终端篇 appeared first on 原立方.

]]> https://www.atomic-cube.cn/%e5%a4%9a%e5%90%88%e4%b8%80macos%e7%b3%bb%e7%bb%9f%e5%ae%89%e8%a3%85u%e7%9b%98%e5%88%b6%e4%bd%9c%e6%95%99%e7%a8%8b-%e7%bb%88%e7%ab%af%e7%af%87/feed/ 0 Go深度指南：从基础到高级的全面解析 https://www.atomic-cube.cn/go%e6%b7%b1%e5%ba%a6%e6%8c%87%e5%8d%97%ef%bc%9a%e4%bb%8e%e5%9f%ba%e7%a1%80%e5%88%b0%e9%ab%98%e7%ba%a7%e7%9a%84%e5%85%a8%e9%9d%a2%e8%a7%a3%e6%9e%90/ https://www.atomic-cube.cn/go%e6%b7%b1%e5%ba%a6%e6%8c%87%e5%8d%97%ef%bc%9a%e4%bb%8e%e5%9f%ba%e7%a1%80%e5%88%b0%e9%ab%98%e7%ba%a7%e7%9a%84%e5%85%a8%e9%9d%a2%e8%a7%a3%e6%9e%90/#respond Sat, 23 May 2026 07:25:58 +0000 https://www.atomic-cube.cn/?p=2098 Go 语言自推出以来，因其简洁性、并发支持和高效性能，在云计算、微服务和分布式系统中广泛应用。作为开发者，面试 […]

The post Go深度指南：从基础到高级的全面解析 appeared first on 原立方.

]]> Go 语言自推出以来，因其简洁性、并发支持和高效性能，在云计算、微服务和分布式系统中广泛应用。作为开发者，面试时往往需要面对一系列技术问题，这些常被称为“八股文”的题目，虽然有时显得高级特性，力求每个解释都严谨实用，避免空话套话。让我们从最基础的部分开始。

第一章：基础概念与语法

变量与类型系统

Go 是静态类型语言，类型安全且编译时检查。变量声明使用 var 关键字，或短变量声明 :=。基础类型包括整型、浮点型、布尔型和字符串等。理解零值概念至关重要：未初始化的变量会赋予其类型的零值，例如整型为 0，字符串为空字符串””。

package main

import "fmt"

func main() {
    var a int      // 声明整型变量，零值为0
    b := 10        // 短变量声明，类型推断为int
    var s string   // 字符串零值为""
    fmt.Printf("a: %d, b: %d, s: %s\n", a, b, s) // 输出: a: 0, b: 10, s: 
}

类型转换必须是显式的，Go 不支持隐式类型转换。例如，将 int 转换为 float64 需要使用 float64(x)。这有助于避免意外错误。

控制结构

Go 的控制结构包括 if、for、switch 等，设计简洁。for 循环是唯一的循环结构，但可以模拟 while 循环。if 语句可以包含初始化语句，增强可读性。

package main

import "fmt"

func main() {
    // for循环示例
    for i := 0; i < 5; i++ {
        fmt.Println(i)
    }
    // 类似while循环
    j := 0
    for j < 3 {
        fmt.Println(j)
        j++
    }
    // if带初始化
    if x := 10; x > 5 {
        fmt.Println("x大于5")
    }
}

switch 语句在 Go 中更为灵活，case 表达式可以是常量、变量或函数调用，且默认不需要 break。

函数

函数是 Go 的一等公民，支持多返回值，这在错误处理中尤为常见。函数可以定义为方法，与类型关联。理解值传递和引用传递的区别很重要：Go 中所有参数都是值传递，但对于切片、映射和通道等引用类型，传递的是底层数据的引用。

package main

import "fmt"

// 多返回值函数
func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("除数不能为零")
    }
    return a / b, nil
}

func main() {
    result, err := divide(10, 2)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result) // 输出: 结果: 5
    }
}

第二章：并发编程核心

Go 的并发模型基于 goroutine 和 channel，是其最强大的特性之一。面试中常深入探讨这方面。

goroutine

goroutine 是轻量级线程，由 Go 运行时管理。使用 go 关键字启动，开销小，可轻松创建成千上万个。但需要注意，goroutine 的执行顺序不确定，依赖于调度器。

package main

import (
    "fmt"
    "time"
)

func sayHello(name string) {
    for i := 0; i < 3; i++ {
        fmt.Println("Hello,", name)
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
    go sayHello("Alice")  // 启动goroutine
    go sayHello("Bob")
    time.Sleep(1 * time.Second) // 等待goroutine完成，实际应用中应使用同步机制
}

channel

channel 是 goroutine 间的通信管道，可以传递数据并同步执行。分为有缓冲和无缓冲两种。无缓冲 channel 要求发送和接收同时就绪，否则会阻塞；有缓冲 channel 在缓冲区满或空时阻塞。

package main

import "fmt"

func main() {
    // 无缓冲channel
    ch := make(chan int)
    go func() {
        ch <- 42 // 发送数据
    }()
    value := <-ch // 接收数据
    fmt.Println("接收值:", value) // 输出: 接收值: 42

    // 有缓冲channel
    bufferedCh := make(chan string, 2)
    bufferedCh <- "hello"
    bufferedCh <- "world"
    fmt.Println(<-bufferedCh, <-bufferedCh) // 输出: hello world
}

同步原语

除了 channel，Go 的 sync 包提供了 Mutex、WaitGroup 等同步工具。在共享资源访问时，使用 Mutex 避免数据竞争。WaitGroup 用于等待一组 goroutine 完成。

package main

import (
    "fmt"
    "sync"
    "time"
)

var counter int
var mu sync.Mutex

func increment(wg *sync.WaitGroup) {
    defer wg.Done()
    mu.Lock()
    counter++
    mu.Unlock()
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < 1000; i++ {
        wg.Add(1)
        go increment(&wg)
    }
    wg.Wait()
    fmt.Println("最终计数器值:", counter) // 应该输出1000
}

第三章：高级特性与设计模式

接口与多态

Go 的接口是隐式实现的：类型只需实现接口所有方法，就自动满足该接口。这促进了松耦合设计。接口常用于定义行为，如 io.Reader 和 io.Writer。

package main

import "fmt"

// 定义接口
type Speaker interface {
    Speak() string
}

// 结构体实现接口
type Dog struct{}

func (d Dog) Speak() string {
    return "Woof!"
}

type Cat struct{}

func (c Cat) Speak() string {
    return "Meow!"
}

func makeSound(s Speaker) {
    fmt.Println(s.Speak())
}

func main() {
    dog := Dog{}
    cat := Cat{}
    makeSound(dog) // 输出: Woof!
    makeSound(cat) // 输出: Meow!
}

空接口 interface{} 可以表示任何类型，但使用时应谨慎，通常与类型断言结合。

错误处理

Go 的错误处理通过返回值实现，而非异常。标准库提供了 error 接口。建议使用 errors.New 或 fmt.Errorf 创建错误，并通过 if err != nil 检查。defer、panic 和 recover 用于处理异常情况，但 panic 应仅用于不可恢复错误。

package main

import (
    "errors"
    "fmt"
)

func process(value int) (int, error) {
    if value < 0 {
        return 0, errors.New("值不能为负")
    }
    return value * 2, nil
}

func safeProcess() {
    defer func() {
        if r := recover(); r != nil {
            fmt.Println("恢复panic:", r)
        }
    }()
    panic("测试panic")
}

func main() {
    result, err := process(5)
    if err != nil {
        fmt.Println("错误:", err)
    } else {
        fmt.Println("结果:", result) // 输出: 结果: 10
    }
    safeProcess() // 输出: 恢复panic: 测试panic
}

反射与元编程

反射通过 reflect 包实现，允许程序在运行时检查类型和值。尽管强大，但反射性能开销大，应仅在必要时使用，如序列化或通用函数中。

package main

import (
    "fmt"
    "reflect"
)

func inspectType(v interface{}) {
    t := reflect.TypeOf(v)
    fmt.Printf("类型: %v, 种类: %v\n", t, t.Kind())
}

func main() {
    var x int = 42
    inspectType(x) // 输出: 类型: int, 种类: int
    inspectType("hello") // 输出: 类型: string, 种类: string
}

第四章：内存管理与性能优化

指针与值语义

Go 有指针，但不像 C 那样复杂。指针允许直接操作内存地址，常用于避免大结构体复制的开销。值语义和引用语义的选择依赖于场景：值语义更安全，引用语义更高效。

package main

import "fmt"

type Person struct {
    Name string
    Age  int
}

// 值接收者
func (p Person) String() string {
    return fmt.Sprintf("%s (%d岁)", p.Name, p.Age)
}

// 指针接收者，可修改结构体
func (p *Person) Birthday() {
    p.Age++
}

func main() {
    p1 := Person{"Alice", 30}
    p1.Birthday() // 即使p1是值，Go会自动取地址
    fmt.Println(p1.String()) // 输出: Alice (31岁)
}

垃圾回收

Go 使用并发标记清除垃圾回收器，自动管理内存。开发者无需手动释放内存，但应注意避免内存泄漏，如未关闭的资源或全局变量引用。通过 runtime 包可以监控 GC 行为。

性能调优

性能优化包括减少分配、使用 sync.Pool 重用对象、避免不必要的反射等。工具如 pprof 用于分析 CPU 和内存使用。

package main

import (
    "fmt"
    "sync"
)

var pool = sync.Pool{
    New: func() interface{} {
        return make([]byte, 1024)
    },
}

func main() {
    buf := pool.Get().([]byte)
    // 使用buf...
    fmt.Println("缓冲区长度:", len(buf))
    pool.Put(buf) // 放回池中以重用
}

第五章：标准库与实战问题

常用标准库

Go 标准库丰富，面试常问 net/http、encoding/json、testing 等。例如，HTTP 服务器实现简单：

package main

import (
    "fmt"
    "net/http"
)

func handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

JSON 序列化和反序列化：

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    user := User{"Bob", 25}
    data, err := json.Marshal(user)
    if err != nil {
        fmt.Println("错误:", err)
        return
    }
    fmt.Println(string(data)) // 输出: {"name":"Bob","age":25}
    var newUser User
    json.Unmarshal(data, &newUser)
    fmt.Println(newUser) // 输出: {Bob 25}
}

常见面试题解析

面试中常出现的问题包括：goroutine 泄漏如何避免、channel 死锁场景、接口设计原则等。例如，goroutine 泄漏通常因未正确关闭 channel 或忽略错误导致，解决方案是使用 context 包进行取消。

package main

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

func worker(ctx context.Context, ch chan int) {
    for {
        select {
        case <-ctx.Done():
            fmt.Println("worker停止")
            return
        case val := <-ch:
            fmt.Println("处理值:", val)
        }
    }
}

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    ch := make(chan int)
    go worker(ctx, ch)
    ch <- 1
    time.Sleep(1 * time.Second)
    cancel() // 取消worker，避免泄漏
    time.Sleep(100 * time.Millisecond)
}

第六章：最佳实践与总结

在 Go 开发中，遵循最佳实践能提升代码质量：使用 go fmt 统一格式、编写单元测试、依赖管理使用 go mod、避免全局状态等。测试是 Go 文化的一部分，内置 testing 包支持表格驱动测试。

package main

import (
    "testing"
)

func Add(a, b int) int {
    return a + b
}

func TestAdd(t *testing.T) {
    tests := []struct {
        a, b, expected int
    }{
        {1, 2, 3},
        {0, 0, 0},
        {-1, 1, 0},
    }
    for _, tt := range tests {
        result := Add(tt.a, tt.b)
        if result != tt.expected {
            t.Errorf("Add(%d, %d) = %d; 期望 %d", tt.a, tt.b, result, tt.expected)
        }
    }
}

总结来说，Go 需要对语言特性的深刻理解。通过本文的梳理，我们希望读者能掌握从基础语法到并发模型、从接口设计到性能优化的核心点。实际编码中，多实践、多阅读优秀源码是提升的关键。持续学习才能应对不断变化的技术挑战。

The post Go深度指南：从基础到高级的全面解析 appeared first on 原立方.

]]> https://www.atomic-cube.cn/go%e6%b7%b1%e5%ba%a6%e6%8c%87%e5%8d%97%ef%bc%9a%e4%bb%8e%e5%9f%ba%e7%a1%80%e5%88%b0%e9%ab%98%e7%ba%a7%e7%9a%84%e5%85%a8%e9%9d%a2%e8%a7%a3%e6%9e%90/feed/ 0 Python+deepseek+微信，秒变聊天机器人 https://www.atomic-cube.cn/python%e9%85%8d%e7%bd%aedeep-seek%e5%8a%a0%e4%b8%8a%e5%be%ae%e4%bf%a1%ef%bc%8c%e7%a7%92%e5%8f%98%e8%81%8a%e5%a4%a9%e6%9c%ba%e5%99%a8%e4%ba%ba/ https://www.atomic-cube.cn/python%e9%85%8d%e7%bd%aedeep-seek%e5%8a%a0%e4%b8%8a%e5%be%ae%e4%bf%a1%ef%bc%8c%e7%a7%92%e5%8f%98%e8%81%8a%e5%a4%a9%e6%9c%ba%e5%99%a8%e4%ba%ba/#respond Tue, 12 May 2026 07:14:41 +0000 https://www.atomic-cube.cn/?p=2073 deep seek接入微信实现自动回复消息

The post Python+deepseek+微信，秒变聊天机器人 appeared first on 原立方.

]]> deepseek接入微信实现自动回复消息，可以任意更改人设，几乎没有封号风险，让你秒变情场高手，附完整代码教程

安装第三方库

先安装调用deep seek的open AI的第三方库pip install openai

接着安装调用微信的wxauto第三方库pip install wxauto

编写代码

导入openAI库和微信库，整个代码不到50行，调用了deep seek API处理用户消息，获取AI自动回复，成为智能客服回复消息

import time
from openai import OpenAI
from wxauto import Wechat
class WeChatBot:
    def __init__(self):
        self.client = OpenAI(api_key="", base_url="")
        self.wx = WeChat()
        self.listen_list = [""]   #需要自行设置监听的好友列表
        for whoItem in self.listen_list:
            self.wx.AddListenChat(who=whoItem)
    def __ask(self, msg):
        response = self.client.chat.completions.create(
            model="deepseek-chat",
            messages=[
                {"role": "system", "content": "你好，我是DeepSeek。"},
                {"role": "user", "content": msg},
            ],
            stream=False
        )
        return response.choices[0].message.content
    def run(self):
        wait = 2  # 设置2秒查看一次是否有新消息
        while True:
            msg = self.wx.GetListenMessage()
            for chat in msgs:
                msg=msgs.get(chat)
                for item in msg:
                    if item.type == 'friend':
                        reply = self.__ask(item.content)
                        print(f"接收【{item.sender}】的消息:{item.content}")
                        print(f"回复【{item.sender}】的消息:{reply}")
                        chat.wx.SendMsg(reply, item.sender)  
if __name__ == "__main__":
    bot = WeChatBot()
    bot.run()

关键的位置在这里，deep seek的key和API地址

获取key和API地址

到deep seek官网获取API开放平台

左边获取API keys

在下面的接口文档获取API地址

添加人设

给deep seek角色信息和人设信息，每段话不超20字。

还要设定要检测的好友名称或者微信群名称，这里只监听一个好友。

最终展示

当然也可以，如本地 部署了模型的话，可以尝试连接本地的模型，如连接本地OLLMA或者是OMLX，这两个本地部署模型都是可以提供openapi地址和key 的，本地值得一试哦

The post Python+deepseek+微信，秒变聊天机器人 appeared first on 原立方.

]]> https://www.atomic-cube.cn/python%e9%85%8d%e7%bd%aedeep-seek%e5%8a%a0%e4%b8%8a%e5%be%ae%e4%bf%a1%ef%bc%8c%e7%a7%92%e5%8f%98%e8%81%8a%e5%a4%a9%e6%9c%ba%e5%99%a8%e4%ba%ba/feed/ 0 Laravel 13 AI 辅助开发 https://www.atomic-cube.cn/laravel-13-ai-%e8%be%85%e5%8a%a9%e5%bc%80%e5%8f%91/ https://www.atomic-cube.cn/laravel-13-ai-%e8%be%85%e5%8a%a9%e5%bc%80%e5%8f%91/#respond Thu, 07 May 2026 00:00:00 +0000 https://www.atomic-cube.cn/?p=2058 Laravel 官方推出两款 AI 工具：Laravel Boost 为 AI 助手提供应用上下文，实现精准代码生成与调试；Laravel MCP 则作为安全桥梁，允许 AI 代理通过受控端点安全执行应用内操作。两者结合旨在将 AI 深度集成至 Laravel 开发工作流，提升效率与自动化能力，同时确保安全性。

The post Laravel 13 AI 辅助开发 appeared first on 原立方.

]]> 简介

Laravel 具有独特的定位，是进行 AI 辅助开发和智能体开发的首选框架。Claude Code、OpenCode、Cursor 和 GitHub Copilot 等 AI 编码智能体的兴起，改变了开发人员编写代码的方式。这些工具能够以空前的速度生成完整功能、调试复杂问题并重构代码——但它们的有效性在很大程度上取决于它们对你代码库的理解程度。

为何选择 Laravel 进行 AI 开发？

Laravel 固有的约定和定义明确的结构使其成为 AI 辅助开发的理想框架。当你要求 AI 智能体添加一个控制器时，它确切地知道该将其放在哪里。当你需要新的迁移文件时，命名约定和文件位置都是可预测的。这种一致性消除了在更灵活的框架中经常困扰 AI 工具的猜测过程。

除了文件组织，Laravel 富有表达力的语法和全面的文档，为 AI 智能体提供了生成准确、地道代码所需的上下文。Eloquent 关系、表单请求和中间件等功能遵循智能体可以可靠理解和复刻的模式。结果就是 AI 生成的代码看起来就像出自资深 Laravel 开发者之手，而不是从通用的 PHP 代码片段中拼凑出来的。

Laravel Boost

Laravel Boost 架起了 AI 编码智能体与 Laravel 应用程序之间的桥梁。Boost 是一个 MCP (模型上下文协议) 服务器，配备了 15 种以上的专用工具，为 AI 智能体提供关于应用程序结构、数据库、路由等的深度见解。当你安装 Boost 后，你的 AI 智能体将从通用的代码助手转变为能够理解你特定应用的 Laravel 专家。

Boost 提供了三大核心能力：一套用于检查和交互应用程序的 MCP 工具、专为 Laravel 生态系统精心设计的可组合 AI 指南，以及一个包含超过 17,000 条 Laravel 特定知识的强大文档 API。

安装

Boost 可安装在运行 PHP 8.1 或更高版本的 Laravel 10、11、12 和 13 应用程序中。若要开始，请将 Boost 安装为开发依赖：

composer require laravel/boost --dev

安装完成后，运行交互式安装程序：

php artisan boost:install

安装程序将自动检测你的 IDE 和 AI 智能体，允许你选择适合项目的集成。Boost 将生成必要的配置文件，例如用于 MCP 兼容编辑器的 .mcp.json 文件以及用于 AI 上下文的指南文件。


生成的配置文件（如 .mcp.json、CLAUDE.md 和 boost.json）可以安全地添加到你的 .gitignore 中，如果你希望每位开发者配置自己的环境的话。

可用工具

Boost 通过模型上下文协议（Model Context Protocol）向 AI 智能体公开了一套全面的工具。这些工具允许智能体深入理解并与你的 Laravel 应用程序进行交互。

  • 应用程序自省 – 查询你的 PHP 和 Laravel 版本，列出已安装的包，并检查应用程序的配置和环境变量。
  • 数据库工具 – 在无需退出对话的情况下，检查数据库模式、执行只读查询并了解数据结构。
  • 路由检查 – 列出所有已注册的路由及其对应的中间件、控制器和参数。
  • Artisan 命令 – 发现可用的 Artisan 命令及其参数，使智能体能够针对你的任务建议并执行正确的命令。
  • 日志分析 – 读取并分析应用程序的日志文件，以协助调试问题。
  • 浏览器日志 – 在使用 Laravel 前端工具进行开发时，访问浏览器控制台日志和错误信息。
  • Tinker 集成 – 通过 Laravel Tinker 在应用程序上下文中执行 PHP 代码，允许智能体验证假设并确认行为。
  • 文档搜索 – 搜索 Laravel 生态系统文档，并获得根据你所安装的包版本量身定制的结果。

AI 指南（AI Guidelines）

Boost 包含一套专门为 Laravel 生态系统精心制作的全面 AI 指南。这些指南教导 AI 智能体如何编写符合习惯的 Laravel 代码、遵循框架约定并避免常见陷阱。指南是可组合且具备版本感知能力的，这意味着智能体接收到的指令将完全适配你所使用的确切包版本。

指南涵盖了 Laravel 本身以及 Laravel 生态系统中的 16 个以上的包，包括：

  • Livewire (2.x, 3.x, 和 4.x)
  • Inertia.js (React, Svelte, 和 Vue 变体)
  • Tailwind CSS (3.x 和 4.x)
  • Filament (3.x 和 4.x)
  • PHPUnit
  • Pest PHP
  • Laravel Pint
  • 以及更多

当你运行 boost:install 时，Boost 会自动检测你的应用程序使用了哪些包，并将相关的指南整合到项目的 AI 上下文文件中。

智能体技能（Agent Skills）

智能体技能 (Agent Skills) 是轻量级、针对性的知识模块，智能体可以在处理特定领域时按需激活。与预先加载的指南不同，技能允许仅在相关时加载详细的模式和最佳实践，从而减少上下文冗余并提高 AI 生成代码的相关性。

这些技能适用于 Livewire、Inertia、Tailwind CSS、Pest 等主流 Laravel 包。当你运行 boost:install 并选择技能作为功能时，系统会根据在 composer.json 中检测到的包自动安装相应的技能。

Boost 包含一个强大的文档 API，使 AI 智能体能够访问超过 17,000 条 Laravel 生态系统文档。与通用的网络搜索不同，这些文档经过索引、向量化并根据你使用的特定包版本进行了筛选。

当智能体需要理解某个功能的工作原理时，它可以搜索 Boost 的文档 API 并获得准确的、特定于版本的相关信息。这消除了 AI 智能体建议已弃用的方法或旧版本框架语法的常见问题。

智能体集成

Boost 与支持模型上下文协议的流行 IDE 和 AI 工具集成。有关 Cursor、Claude Code、Codex、Gemini CLI、GitHub Copilot 和 Junie 的详细设置说明，请参阅 Boost 文档的 设置你的智能体 (Set Up Your Agents) 部分。

The post Laravel 13 AI 辅助开发 appeared first on 原立方.

]]> https://www.atomic-cube.cn/laravel-13-ai-%e8%be%85%e5%8a%a9%e5%bc%80%e5%8f%91/feed/ 0 WordPress主题theme开发入门教程 https://www.atomic-cube.cn/wordpress%e4%b8%bb%e9%a2%98theme%e5%bc%80%e5%8f%91%e5%85%a5%e9%97%a8%e6%95%99%e7%a8%8b/ https://www.atomic-cube.cn/wordpress%e4%b8%bb%e9%a2%98theme%e5%bc%80%e5%8f%91%e5%85%a5%e9%97%a8%e6%95%99%e7%a8%8b/#respond Mon, 04 May 2026 00:00:46 +0000 https://www.atomic-cube.cn/?p=1977 WordPress主题开发入门教程

The post WordPress主题theme开发入门教程 appeared first on 原立方.

]]> 引言

在互联网技术领域，不断涌现的新技术和新理念为开发者提供了无限的可能。本文将深入探讨一系列技术主题，旨在帮助读者更好地理解和应用这些技术，从而提升开发效率和产品质量。

1.1 技术背景

随着云计算、大数据、人工智能等领域的快速发展，互联网技术正面临着前所未有的挑战和机遇。了解这些技术的基础知识和应用场景，对于开发者来说至关重要。

1.2 博客目的

本博客旨在通过详细的段落解释和代码示例，帮助读者掌握以下技术要点：

  • 技术原理和概念
  • 实际应用案例
  • 代码实现和优化策略

通过阅读本博客，读者将能够更好地将这些技术应用到实际项目中，提升个人技术能力。

2. WordPress主题结构解析

WordPress作为世界上最流行的内容管理系统之一，其主题系统提供了强大的定制能力。理解WordPress主题的结构对于开发者来说，是进行主题定制和开发的基础。

2.1 主题文件组成

WordPress主题通常由一系列的文件组成，每个文件都有其特定的作用。以下是一些主要的主题文件及其功能：

- `style.css`：主题的主要样式表，定义了网站的外观和样式。
- `index.php`：主题的主要模板文件，用于显示博客的首页内容。
- `single.php`：用于显示单篇文章的模板。
- `page.php`：用于显示独立页面的模板。
- `header.php`：包含网站头部信息的模板，如导航菜单、Logo等。
- `footer.php`：包含网站底部信息的模板。
- `functions.php`：主题的功能文件，用于添加或修改主题的功能。

2.2 主题模板层次

WordPress的主题模板遵循一定的层次结构，这使得开发者可以更灵活地控制内容的显示。以下是一些常见的模板文件及其用途：

- `archive.php`：用于显示归档页面。
- `category.php`：用于显示特定分类下的文章列表。
- `tag.php`：用于显示特定标签下的文章列表。
- `search.php`：用于显示搜索结果。
- `404.php`：用于显示404错误页面。

2.3 主题自定义

开发者可以通过修改上述文件来自定义主题。例如，要修改网站头部，可以编辑header.php文件。以下是一个简单的示例，展示了如何在header.php中添加一个自定义的Logo：

<!DOCTYPE html>
<html <?php language_attributes(); ?>>
<head>
    <meta charset="<?php bloginfo( 'charset' ); ?>">
    <title><?php wp_title(); ?></title>
    <!-- 其他头部信息 -->
</head>
<body>

<header>
    <a href="<?php echo esc_url( home_url() ); ?>">
        <img src="<?php echo get_template_directory_uri(); ?>/images/logo.png" alt="Logo">
    </a>
</header>

<!-- 页面内容 -->

<?php get_footer(); ?>
</body>
</html>

在这个例子中，get_template_directory_uri()函数用于获取主题的目录URL，以便正确引用Logo图片。通过这种方式，开发者可以轻松地添加自定义元素到WordPress主题中。

3. 创建基本主题文件

在WordPress中创建一个基本主题涉及几个关键步骤，包括设置主题文件夹、创建必要的模板文件以及定义主题信息。

3.1 设置主题文件夹

首先，你需要在WordPress安装目录的wp-content/themes文件夹中创建一个新的文件夹，这个文件夹将用于存放你的主题文件。文件夹的名称通常是主题的名称，例如my-theme。

mkdir wp-content/themes/my-theme

3.2 创建主题文件

接下来，你需要在主题文件夹中创建以下基本文件：

  • style.css：主题样式表。
  • index.php：主题主要模板文件。
  • functions.php：主题功能文件。

以下是一个简单的示例，展示了如何创建这些文件：

/* style.css */
/*
Theme Name: My Theme
Theme URI: http://example.com/my-theme
Author: Your Name
Author URI: http://example.com
Description: A simple WordPress theme.
Version: 1.0
*/

body {
    font-family: Arial, sans-serif;
}

/* 其他样式 */

<?php
/* index.php */
?>
<!DOCTYPE html>
<html <?php language_attributes(); ?>>
<head>
    <meta charset="<?php bloginfo( 'charset' ); ?>">
    <title><?php wp_title(); ?></title>
    <link rel="stylesheet" href="<?php echo get_template_directory_uri(); ?>/style.css">
</head>
<body>

<?php get_header(); ?>

<div class="content">
    <?php if ( have_posts() ) : while ( have_posts() ) : the_post(); ?>
        <article>
            <h2><?php the_title(); ?></h2>
            <?php the_content(); ?>
        </article>
    <?php endwhile; endif; ?>
</div>

<?php get_footer(); ?>

</body>
</html>

<?php
/* functions.php */
?>
<?php
// 注册导航菜单
register_nav_menus(array(
    'primary' => __('Primary Menu'),
));

// 其他功能
?>

3.3 定义主题信息

在style.css文件的顶部，你需要添加一些关键的主题信息，如主题名称、作者、描述等。这些信息将被WordPress用来识别和显示你的主题。

/*
Theme Name: My Theme
Theme URI: http://example.com/my-theme
Author: Your Name
Author URI: http://example.com
Description: A simple WordPress theme.
Version: 1.0
*/

完成这些步骤后，你就可以在WordPress后台的主题列表中看到你的新主题，并可以激活它来使用。

4. 主题模板和模板标签的使用

WordPress主题模板是定义网站布局和内容的文件，而模板标签则是WordPress提供的用于在模板文件中插入动态内容的函数。

4.1 主题模板

WordPress的主题模板由一系列文件组成，每个文件对应网站的某个部分。以下是一些常用的模板文件：

  • index.php：如果没有更具体的模板匹配，WordPress将使用此文件显示首页。
  • single.php：用于显示单篇文章。
  • page.php：用于显示独立页面。
  • archive.php：用于显示文章归档页面。
  • search.php：用于显示搜索结果。

以下是一个index.php的简单示例，展示了如何使用模板标签：

<?php get_header(); ?>

<div class="content">
    <?php if ( have_posts() ) : while ( have_posts() ) : the_post(); ?>
        <article <?php post_class(); ?>>
            <h2><?php the_title(); ?></h2>
            <?php the_content(); ?>
        </article>
    <?php endwhile; endif; ?>
</div>

<?php get_footer(); ?>

4.2 模板标签
模板标签是WordPress提供的函数，用于在模板文件中插入动态内容。以下是一些常用的模板标签：

get_header()：插入网站头部。
get_footer()：插入网站底部。
have_posts()：检查是否有文章可以显示。
the_post()：循环遍历文章。
post_class()：为文章添加CSS类。
the_title()：显示文章标题。
the_content()：显示文章内容。
以下是一个使用get_template_part()模板标签的示例，它允许你在多个模板文件中重用代码：
<?php get_template_part('content', get_post_format()); ?>

这个标签会根据文章格式（如get_post_format()返回的值）加载content-<format>.php文件，如果没有指定格式，则默认加载content.php。

4.3 示例：使用模板标签创建文章列表

以下是一个使用模板标签创建文章列表的示例：

<?php get_header(); ?>

<div class="content">
    <?php if ( have_posts() ) : ?>
        <ul>
            <?php while ( have_posts() ) : the_post(); ?>
                <li <?php post_class(); ?>>
                    <h2><a href="<?php the_permalink(); ?>"><?php the_title(); ?></a></h2>
                    <p><?php echo get_the_excerpt(); ?></p>
                </li>
            <?php endwhile; ?>
        </ul>
    <?php endif; ?>
</div>

<?php get_footer(); ?>

在这个例子中，我们使用了have_posts()和the_post()来遍历文章，并使用the_permalink()、the_title()和get_the_excerpt()来显示每个文章的链接、标题和摘要。通过这种方式，你可以创建一个动态的文章列表，它会随着内容的更新而自动更新。

5. 主题样式和脚本加载

在WordPress主题中加载样式表和脚本是一个重要的步骤，它确保了网站的前端功能和视觉效果。

5.1 加载样式表

样式表通常在主题的header.php文件中通过<link>标签加载。为了确保样式表的正确加载，建议使用WordPress提供的wp_enqueue_style()函数。

以下是一个示例，展示了如何在functions.php文件中使用wp_enqueue_style()函数加载主题样式表：

function my_theme_enqueue_styles() {
    wp_enqueue_style('my-theme-style', get_template_directory_uri() . '/style.css', array(), '1.0', 'all');
}

add_action('wp_enqueue_scripts', 'my_theme_enqueue_styles');

在这个函数中，my-theme-style是样式的句柄，get_template_directory_uri() . '/style.css'是样式表的路径，array()是依赖项数组（这里是空的，表示没有依赖），'1.0'是样式表的版本号，'all'表示样式表适用于所有设备。

5.2 加载脚本

脚本的加载与样式表类似，可以使用wp_enqueue_script()函数。以下是一个示例，展示了如何在functions.php文件中加载自定义脚本：

function my_theme_enqueue_scripts() {
    wp_enqueue_script('my-theme-script', get_template_directory_uri() . '/js/script.js', array('jquery'), '1.0', true);
}

add_action('wp_enqueue_scripts', 'my_theme_enqueue_scripts');

在这个例子中，my-theme-script是脚本的句柄，get_template_directory_uri() . '/js/script.js'是脚本的路径，array('jquery')表示脚本依赖于jQuery库，'1.0'是脚本的版本号，true表示脚本将在页面的底部加载，这通常是推荐的做法，因为它可以避免阻塞页面渲染。

5.3 使用wp_head和wp_footer

在header.php和footer.php文件中，你应该保留wp_head和wp_footer函数调用。这些函数调用是WordPress用来插入所有队列中的样式和脚本的地方。

<?php get_header(); ?>

<head>
    <!-- 其他头部信息 -->
    <?php wp_head(); ?>
</head>

<!-- 页面内容 -->

<?php get_footer(); ?>

<footer>
    <!-- 其他底部信息 -->
    <?php wp_footer(); ?>
</footer>

通过使用wp_head和wp_footer，你确保了所有通过wp_enqueue_style和wp_enqueue_script添加的样式和脚本都会在正确的位置加载。

5.4 示例：在主题中加载Google字体

以下是一个示例，展示了如何在主题中加载Google字体：

function my_theme_enqueue_google_fonts() {
    wp_enqueue_style('my-theme-google-fonts', 'https://fonts.googleapis.com/css?family=Open+Sans&display=swap', false);
}

add_action('wp_enqueue_scripts', 'my_theme_enqueue_google_fonts');

在这个函数中，我们添加了一个新的样式表，它从Google Fonts API加载了一个字体族。通过这种方式，你可以轻松地将外部字体集成到你的WordPress主题中。

6. 主题功能定制

WordPress主题的功能定制是通过修改functions.php文件来实现的。这个文件是主题的核心，用于添加或修改主题的功能。

6.1 添加自定义导航菜单

在WordPress中，你可以通过register_nav_menus()函数来注册自定义导航菜单。

以下是一个示例，展示了如何在functions.php中添加一个自定义导航菜单：

function my_theme_register_nav_menus() {
    register_nav_menus(array(
        'primary-menu' => __('Primary Menu'),
        'footer-menu' => __('Footer Menu'),
    ));
}

add_action('after_setup_theme', 'my_theme_register_nav_menus');

在这个例子中，我们注册了两个菜单：primary-menu和footer-menu。你可以在WordPress后台的“外观” > “菜单”部分创建和分配这些菜单。

6.2 添加自定义小工具区域

WordPress允许你通过register_sidebar()函数添加自定义小工具区域。

以下是一个示例，展示了如何在functions.php中添加一个自定义小工具区域：

function my_theme_register_sidebars() {
    register_sidebar(array(
        'name' => __('Primary Sidebar'),
        'id' => 'primary-sidebar',
        'description' => 'The primary sidebar.',
        'before_widget' => '<div id="%1$s" class="widget %2$s">',
        'after_widget' => '</div>',
        'before_title' => '<h3 class="widget-title">',
        'after_title' => '</h3>',
    ));
}

add_action('widgets_init', 'my_theme_register_sidebars');

在这个例子中，我们添加了一个名为“Primary Sidebar”的小工具区域。你可以在WordPress后台的“外观” > “小工具”部分管理这个区域的小工具。

6.3 添加自定义设置

WordPress提供了add_customizer_section()和add_customizer_setting()函数，允许你在主题定制器中添加自定义设置。

以下是一个示例，展示了如何在functions.php中添加一个自定义设置：

function my_theme_customizer($wp_customize) {
    // 添加一个面板
    $wp_customize->add_panel('my_theme_options', array(
        'title' => 'My Theme Options',
        'description' => 'Customize My Theme',
        'priority' => 10,
    ));

    // 添加一个部分
    $wp_customize->add_section('my_theme_general', array(
        'title' => 'General Settings',
        'priority' => 10,
        'panel' => 'my_theme_options',
    ));

    // 添加一个设置
    $wp_customize->add_setting('my_theme_logo', array(
        'default' => '',
        'transport' => 'refresh',
    ));

    // 添加一个控制
    $wp_customize->add_control(new WP_Customize_Image_Control($wp_customize, 'my_theme_logo', array(
        'label' => 'Logo',
        'section' => 'my_theme_general',
        'settings' => 'my_theme_logo',
    )));
}

add_action('customize_register', 'my_theme_customizer');

在这个例子中，我们添加了一个名为“My Theme Options”的面板，一个名为“General Settings”的部分，以及一个名为“Logo”的图像设置。用户可以在主题定制器中上传一个自定义的Logo。

通过这些定制，你可以扩展WordPress主题的功能，使其更加灵活和适应不同的需求。

7. 响应式设计实现

响应式设计是现代网页设计的关键组成部分，它确保网站能够在不同尺寸的设备上提供良好的用户体验。在WordPress主题中实现响应式设计通常涉及媒体查询和灵活的布局。

7.1 媒体查询

媒体查询是CSS3的一个特性，它允许你根据不同的屏幕尺寸应用不同的样式规则。以下是一个简单的示例，展示了如何在style.css文件中使用媒体查询：

/* 基础样式 */
body {
    font-family: Arial, sans-serif;
}

/* 响应式样式 */
@media (max-width: 768px) {
    .content {
        padding: 10px;
    }

    .sidebar {
        display: none;
    }
}

@media (min-width: 769px) and (max-width: 1024px) {
    .content {
        width: 75%;
    }

    .sidebar {
        width: 25%;
    }
}

在这个例子中，我们定义了两个媒体查询。第一个媒体查询针对最大宽度为768px的设备，它将内容区域的填充设置为10px，并隐藏侧边栏。第二个媒体查询针对宽度在769px到1024px之间的设备，它设置了内容区域和侧边栏的宽度。

7.2 灵活的布局

为了实现灵活的布局，可以使用百分比、flexbox或grid布局。以下是一个使用flexbox的示例：

.container {
    display: flex;
    flex-wrap: wrap;
}

.content {
    flex: 1;
}

.sidebar {
    flex: 1;
}

在这个例子中，.container类使用了flexbox布局，.content和.sidebar类都占据了等宽的空间。

7.3 响应式图片

为了确保图片在不同设备上正确显示，可以使用srcset和sizes属性。以下是一个示例：

<img src="example.jpg" srcset="example-small.jpg 500w, example.jpg 1000w" sizes="(max-width: 500px) 100vw, 50vw" alt="Example">

在这个例子中，srcset属性定义了不同分辨率的图片，而sizes属性定义了在不同屏幕尺寸下图片的显示尺寸。

7.4 测试响应式设计

实现响应式设计后，应该在不同设备上进行测试，以确保布局和功能在不同尺寸的屏幕上都能正常工作。可以使用浏览器的开发者工具来模拟不同设备的屏幕尺寸。

通过以上步骤，你可以为WordPress主题实现响应式设计，从而提升用户体验。

8. 主题测试与发布

在完成WordPress主题的开发后，进行彻底的测试和准备发布是确保主题质量和用户满意度的关键步骤。

8.1 主题测试

主题测试应该包括以下几个方面：

  • 功能测试：确保所有功能如导航菜单、小工具、自定义设置等都能正常工作。
  • 响应式测试：在不同的设备上测试主题的布局和功能，确保响应式设计有效。
  • 兼容性测试：在不同的浏览器和操作系统上测试主题，确保兼容性。
  • 性能测试：使用工具如Google PageSpeed Insights测试主题的性能，优化加载速度。
  • 安全性测试：检查主题代码，确保没有安全漏洞。

8.2 代码审查

在发布之前，应该对主题代码进行审查，确保代码质量高、遵循最佳实践，并且没有错误或警告。

8.3 准备发布

在发布主题之前，需要确保以下几点：

  • 主题信息完整：style.css文件中的主题信息（如名称、描述、版本等）应该完整且准确。
  • 文档准备：准备详细的文档，包括安装指南、使用说明和常见问题解答。
  • 许可证：确保主题遵循适当的许可证，并在主题中包含许可证文件。

8.4 发布主题

发布主题可以通过以下几种方式：

  • WordPress主题目录：如果你希望你的主题被更多人使用，可以将其提交到WordPress主题目录。这需要遵循WordPress.org的指南和审查流程。
  • 个人或公司网站：你可以在自己的网站或公司的网站上发布主题，并提供下载链接。
  • 市场平台：你也可以选择在第三方市场平台如ThemeForest上发布主题，这通常需要支付一定的费用。

8.5 维护和更新

发布主题后，定期维护和更新是必要的。这包括修复bug、添加新功能、更新文档以及响应用户反馈。

通过以上步骤，你可以确保WordPress主题的质量，并为用户提供一个稳定和可靠的产品。

The post WordPress主题theme开发入门教程 appeared first on 原立方.

]]> https://www.atomic-cube.cn/wordpress%e4%b8%bb%e9%a2%98theme%e5%bc%80%e5%8f%91%e5%85%a5%e9%97%a8%e6%95%99%e7%a8%8b/feed/ 0 Kubectl 命令参考手册 https://www.atomic-cube.cn/kubectl-%e5%91%bd%e4%bb%a4%e5%8f%82%e8%80%83%e6%89%8b%e5%86%8c/ https://www.atomic-cube.cn/kubectl-%e5%91%bd%e4%bb%a4%e5%8f%82%e8%80%83%e6%89%8b%e5%86%8c/#respond Sun, 03 May 2026 00:00:22 +0000 https://www.atomic-cube.cn/?p=2016 Kubectl 命令参考手册

The post Kubectl 命令参考手册 appeared first on 原立方.

]]> K8S 命令老是忘记，索性整理了常用的 kubectl 命令，方便日常 Kubernetes 集群管理使用。

一：基础命令

1.1 查看集群信息

# 查看集群信息
kubectl cluster-info

# 查看 Kubernetes 版本
kubectl version

# 查看 API 资源列表
kubectl api-resources

# 查看 API 版本
kubectl api-versions

1.2 查看节点信息

# 查看所有节点
kubectl get nodes

# 查看节点详细信息
kubectl get nodes -o wide

# 查看节点详细信息（JSON/YAML）
kubectl get nodes -o json
kubectl get nodes -o yaml

# 查看特定节点
kubectl get node <node-name>

# 描述节点
kubectl describe node <node-name>

二：资源查看

2.1 Pod 相关：

# 查看所有命名空间的 Podkubectl get pods --all-namespaces
kubectl get pods -A

# 查看指定命名空间的 Podkubectl get pods -n <namespace>

# 查看 Pod 详细信息
kubectl get pods -o wide

# 查看 Pod 详细信息（JSON/YAML）
kubectl get pods -o json
kubectl get pods -o yaml

# 查看特定 Podkubectl get pod <pod-name> -n <namespace>

# 查看 Pod 标签
kubectl get pods --show-labels

2.2 Deployment 相关：

# 查看所有 Deploymentkubectl get deployments
kubectl get deploy

# 查看 Deployment 详细信息
kubectl get deployments -o wide

# 查看特定 Deploymentkubectl get deployment <deployment-name> -n <namespace>

2.3 Service 相关：

# 查看所有 Servicekubectl get services
kubectl get svc

# 查看 Service 详细信息
kubectl get services -o wide

# 查看特定 Servicekubectl get service <service-name> -n <namespace>

2.4 其他资源：

# 查看所有资源类型
kubectl get all

# 查看 ConfigMapkubectl get configmaps
kubectl get cm

# 查看 Secretkubectl get secrets

# 查看 PersistentVolumekubectl get pv

# 查看 PersistentVolumeClaimkubectl get pvc

# 查看 Ingresskubectl get ingress
kubectl get ing

# 查看 Jobkubectl get jobs

# 查看 CronJobkubectl get cronjobs

# 查看 DaemonSetkubectl get daemonsets
kubectl get ds

# 查看 StatefulSetkubectl get statefulsets
kubectl get sts

三：资源操作

3.1 创建资源

# 从文件创建资源
kubectl create -f <file.yaml>

# 从 URL 创建资源
kubectl create -f <url>

# 从目录创建所有资源
kubectl create -f <directory>/

# 创建命名空间
kubectl create namespace <namespace-name>

3.2 应用资源

# 应用配置文件（推荐）
kubectl apply -f <file.yaml>

# 应用目录下所有文件
kubectl apply -f <directory>/

# 应用并记录配置
kubectl apply -f <file.yaml> --record

# 强制替换资源
kubectl apply -f <file.yaml> --force

3.3 删除资源

# 删除资源
kubectl delete -f <file.yaml>

# 删除特定资源
kubectl delete pod <pod-name> -n <namespace>
kubectl delete deployment <deployment-name> -n <namespace>
kubectl delete service <service-name> -n <namespace>

# 删除所有资源
kubectl delete all --all -n <namespace>

# 删除命名空间（会删除命名空间下所有资源）
kubectl delete namespace <namespace-name>

# 强制删除 Podkubectl delete pod <pod-name> --force --grace-period=0

3.4 编辑资源

# 编辑资源（使用默认编辑器）
kubectl edit pod <pod-name> -n <namespace>
kubectl edit deployment <deployment-name> -n <namespace>

# 编辑并应用
kubectl edit -f <file.yaml>

3.5 替换资源

# 替换资源
kubectl replace -f <file.yaml>

# 强制替换
kubectl replace -f <file.yaml> --force

四：调试和日志

4.1查看日志

# 查看 Pod 日志
kubectl logs <pod-name> -n <namespace>

# 查看前 N 行日志
kubectl logs <pod-name> -n <namespace> --tail=100

# 实时跟踪日志
kubectl logs <pod-name> -n <namespace> -f

# 查看之前容器的日志
kubectl logs <pod-name> -n <namespace> --previous

# 查看多容器 Pod 中特定容器的日志
kubectl logs <pod-name> -c <container-name> -n <namespace>

# 查看指定时间范围的日志
kubectl logs <pod-name> -n <namespace> --since=1h
kubectl logs <pod-name> -n <namespace> --since-time="2024-01-01T00:00:00Z"

4.2 进入容器

# 进入 Pod 容器（交互式）
kubectl exec -it <pod-name> -n <namespace> -- /bin/bash
kubectl exec -it <pod-name> -n <namespace> -- /bin/sh

# 在容器中执行命令
kubectl exec <pod-name> -n <namespace> -- <command>

# 在特定容器中执行命令
kubectl exec <pod-name> -c <container-name> -n <namespace> -- <command>

4.3 调试工具

# 查看 Pod 详细信息
kubectl describe pod <pod-name> -n <namespace>

# 查看事件
kubectl get events -n <namespace> --sort-by='.lastTimestamp'

# 查看资源使用情况
kubectl top nodes
kubectl top pods -n <namespace>

# 查看资源使用情况（所有命名空间）
kubectl top pods --all-namespaces

五: 配置管理

5.1 ConfigMap 操作

# 查看 ConfigMapkubectl get configmap <configmap-name> -n <namespace>

# 查看 ConfigMap 内容
kubectl get configmap <configmap-name> -n <namespace> -o yaml

# 从文件创建 ConfigMapkubectl create configmap <configmap-name> --from-file=<file-path>

# 从目录创建 ConfigMapkubectl create configmap <configmap-name> --from-file=<directory>/

# 从字面量创建 ConfigMapkubectl create configmap <configmap-name> --from-literal=key1=value1 --from-literal=key2=value2

# 编辑 ConfigMapkubectl edit configmap <configmap-name> -n <namespace>

# 删除 ConfigMapkubectl delete configmap <configmap-name> -n <namespace>

5.2 Secret 操作

# 查看 Secretkubectl get secret <secret-name> -n <namespace>

# 查看 Secret 内容（Base64 编码）
kubectl get secret <secret-name> -n <namespace> -o yaml

# 解码 Secretkubectl get secret <secret-name> -n <namespace> -o jsonpath='{.data.<key>}' | base64 -d

# 从文件创建 Secretkubectl create secret generic <secret-name> --from-file=<file-path>

# 从字面量创建 Secretkubectl create secret generic <secret-name> --from-literal=username=admin --from-literal=password=secret

# 从 Docker 注册表创建 Secretkubectl create secret docker-registry <secret-name> --docker-server=<server> --docker-username=<username> --docker-password=<password>

# 编辑 Secretkubectl edit secret <secret-name> -n <namespace>

# 删除 Secretkubectl delete secret <secret-name> -n <namespace>

5.3 端口转发

# 转发 Pod 端口到本地
kubectl port-forward <pod-name> <local-port>:<pod-port> -n <namespace>

# 转发 Service 端口到本地
kubectl port-forward service/<service-name> <local-port>:<service-port> -n <namespace>

# 转发 Deployment 端口到本地
kubectl port-forward deployment/<deployment-name> <local-port>:<container-port> -n <namespace>

# 示例：转发 MySQL 服务
kubectl port-forward service/mysql 3306:3306 -n default

5.4 执行命令

# 在 Pod 中执行命令
kubectl exec <pod-name> -n <namespace> -- <command>

# 在 Pod 中执行交互式命令
kubectl exec -it <pod-name> -n <namespace> -- <command>

# 在特定容器中执行命令
kubectl exec <pod-name> -c <container-name> -n <namespace> -- <command>

# 示例
kubectl exec my-pod -- ls /tmp
kubectl exec -it my-pod -- /bin/bash

5.5 标签和选择器

# 查看资源标签
kubectl get pods --show-labels

# 给资源添加标签
kubectl label pod <pod-name> app=myapp -n <namespace>

# 更新标签
kubectl label pod <pod-name> app=newapp --overwrite -n <namespace>

# 删除标签
kubectl label pod <pod-name> app- -n <namespace>

# 使用标签选择器查询
kubectl get pods -l app=myapp -n <namespace>
kubectl get pods -l 'app in (myapp,yourapp)' -n <namespace>
kubectl get pods -l 'app=myapp,version=v1' -n <namespace>

5.6 滚动更新

# 查看滚动更新状态
kubectl rollout status deployment/<deployment-name> -n <namespace>

# 查看滚动更新历史
kubectl rollout history deployment/<deployment-name> -n <namespace>

# 回滚到上一个版本
kubectl rollout undo deployment/<deployment-name> -n <namespace>

# 回滚到指定版本
kubectl rollout undo deployment/<deployment-name> --to-revision=<revision-number> -n <namespace>

# 暂停滚动更新
kubectl rollout pause deployment/<deployment-name> -n <namespace>

# 恢复滚动更新
kubectl rollout resume deployment/<deployment-name> -n <namespace>

# 扩展 Deploymentkubectl scale deployment/<deployment-name> --replicas=<number> -n <namespace>

5.7 资源描述

# 描述 Podkubectl describe pod <pod-name> -n <namespace>

# 描述 Deploymentkubectl describe deployment <deployment-name> -n <namespace>

# 描述 Servicekubectl describe service <service-name> -n <namespace>

# 描述 Nodekubectl describe node <node-name>

# 描述命名空间
kubectl describe namespace <namespace-name>

5.8 事件查看

# 查看所有事件
kubectl get events -n <namespace>

# 查看所有命名空间的事件
kubectl get events --all-namespaces

# 按时间排序查看事件
kubectl get events -n <namespace> --sort-by='.lastTimestamp'

# 查看特定资源的事件
kubectl get events --field-selector involvedObject.name=<pod-name> -n <namespace>

# 实时监控事件
kubectl get events -n <namespace> --watch

5.9 命名空间管理

# 查看所有命名空间
kubectl get namespaces
kubectl get ns

# 查看命名空间详细信息
kubectl get namespace <namespace-name> -o yaml

# 创建命名空间
kubectl create namespace <namespace-name>

# 删除命名空间
kubectl delete namespace <namespace-name>

# 切换到命名空间（使用 kubectx/kubens 工具）
# 或者使用上下文
kubectl config set-context --current --namespace=<namespace-name>

5.10 上下文和配置

# 查看当前上下文
kubectl config current-context

# 查看所有上下文
kubectl config get-contexts

# 切换上下文
kubectl config use-context <context-name>

# 查看配置
kubectl config view

# 查看特定上下文的配置
kubectl config view --context=<context-name>

# 设置默认命名空间
kubectl config set-context --current --namespace=<namespace-name>

# 查看集群信息
kubectl config view --minify

# 重命名上下文
kubectl config rename-context <old-name> <new-name>

六: 实用技巧

6.1 输出格式

# JSON 格式
kubectl get pods -o json

# YAML 格式
kubectl get pods -o yaml

# 自定义列
kubectl get pods -o custom-columns=NAME:.metadata.name,STATUS:.status.phase

# JSONPath
kubectl get pods -o jsonpath='{.items[*].metadata.name}'

# 表格格式（默认）
kubectl get pods

6.2 过滤和搜索

# 按标签过滤
kubectl get pods -l app=myapp

# 按字段选择器过滤
kubectl get pods --field-selector status.phase=Running

# 搜索资源
kubectl get all | grep <keyword>

6.3 批量操作

# 删除所有命名空间下的所有 Podkubectl delete pods --all --all-namespaces

# 删除所有命名空间下的所有 Deploymentkubectl delete deployments --all --all-namespaces

# 删除命名空间下的所有资源
kubectl delete all --all -n <namespace>

6.4 导出资源

<em># 导出资源为 YAMLkubectl get pod <pod-name> -n <namespace> -o yaml > pod.yaml</em>

<em># 导出资源为 JSONkubectl get pod <pod-name> -n <namespace> -o json > pod.json</em>

<em># 导出并移除集群特定信息</em>
kubectl get pod <pod-name> -n <namespace> -o yaml --export > pod.yaml

6.5 补丁操作

<em># 使用 JSON 补丁</em>
kubectl patch pod <pod-name> -p '{"spec":{"containers":[{"name":"mycontainer","image":"newimage"}]}}'

<em># 使用策略性合并补丁</em>
kubectl patch deployment <deployment-name> -p '{"spec":{"replicas":3}}'

<em># 使用 JSON 补丁文件</em>
kubectl patch pod <pod-name> --patch-file=patch.json

七: 常用组合命令

<em># 查看 Pod 并显示标签</em>
kubectl get pods --show-labels -n <namespace>

<em># 查看所有命名空间的资源</em>
kubectl get all --all-namespaces

<em># 查看资源并持续监控</em>
kubectl get pods -w -n <namespace>

<em># 查看资源并排序</em>
kubectl get pods --sort-by=.metadata.creationTimestamp -n <namespace>

<em># 查看资源使用情况</em>
kubectl top pods --sort-by=memory -n <namespace>

<em># 查看资源并过滤</em>
kubectl get pods -n <namespace> | grep <keyword>

<em># 查看资源并导出</em>
kubectl get deployment <deployment-name> -n <namespace> -o yaml > deployment.yaml

八: 故障排查命令

<em># 查看 Pod 状态和事件</em>
kubectl describe pod <pod-name> -n <namespace>

<em># 查看 Pod 日志</em>
kubectl logs <pod-name> -n <namespace> --previous

<em># 查看所有命名空间的错误 Podkubectl get pods --all-namespaces --field-selector status.phase!=Running</em>

<em># 查看节点资源使用</em>
kubectl top nodes

<em># 查看集群事件</em>
kubectl get events --all-namespaces --sort-by='.lastTimestamp'

<em># 检查 API 服务器连接</em>
kubectl cluster-info dump

<em># 查看资源配额</em>
kubectl describe quota -n <namespace>

注意事项

1. 命名空间：大多数命令需要指定 -n <namespace> 或 --namespace=<namespace>，如果不指定则使用默认命名空间（通常是 default）

2. 资源名称：可以使用完整名称或简写形式，例如：

  • pods 或 po
  • services 或 svc
  • deployments 或 deploy
  • namespaces 或 ns

3. 输出格式：使用 -o 参数指定输出格式，常用格式包括：

  • yaml
  • json
  • wide
  • custom-columns

4. 强制删除：删除资源时，如果 Pod 处于 Terminating 状态，可以使用：

kubectl delete pod <pod-name> --force --grace-period=0 -n <namespace>

5. 权限：某些命令可能需要相应的 RBAC 权限，确保当前用户有足够的权限执行操作

参考资源

The post Kubectl 命令参考手册 appeared first on 原立方.

]]> https://www.atomic-cube.cn/kubectl-%e5%91%bd%e4%bb%a4%e5%8f%82%e8%80%83%e6%89%8b%e5%86%8c/feed/ 0 本地安装Minikube部署Kubernetes环境 https://www.atomic-cube.cn/apple-chip%e5%ae%89%e8%a3%85minikube/ https://www.atomic-cube.cn/apple-chip%e5%ae%89%e8%a3%85minikube/#respond Wed, 29 Apr 2026 23:20:00 +0000 https://www.atomic-cube.cn/?p=1685 Minikube 是一个工具，它为本地环境提供了一种轻量化的 Kubernetes&nbs […]

The post 本地安装Minikube部署Kubernetes环境 appeared first on 原立方.

]]> Minikube 是一个工具，它为本地环境提供了一种轻量化的 Kubernetes 集群实现。通过 Minikube，用户可以在本地机器上快速启动并运行一个 Kubernetes 环境，用来学习、测试和开发。Minikube支持Kubernetes的所有主要功能，包括Dashboard、DNS、容器运行时（如Docker、containerd、CRI-O）等。这种本地化的 Kubernetes 环境主要为开发者提供了便捷，不再需要花费额外的精力去搭建和维护一个庞大的远程集群。

1.安装 Docker Desktop

作为官方推荐的容器化平台，安装Docker Desktop能让你顺利使用Docker驱动。

  • 下载与安装：访问 Docker 官网，我使用的是Mac M2，需要下载适用于 Apple Chip 的安装包并进行安装。
  • 启动与验证：安装完成后，启动 Docker Desktop，并确保它在后台正常运行，状态显示为 Running。

2. 安装 Minikube 和 kubectl

使用 Homebrew 可以一键安装这两个核心工具。

使用 Homebrew 安装：在终端中执行以下命令：

brew install kubectl
brew install minikube


验证安装：运行以下命令，确认版本信息能正常输出：

kubectl version --client
minikube version

3. 启动你的 Kubernetes 集群

启动命令是最关键的一步。对于国内的网络环境，强烈建议配置阿里云的镜像加速，这能显著提升启动速度和成功率。

推荐方案：使用 Docker 驱动 + 阿里云镜像/dl.k8s.io加速：使用以下命令启动 Minikube：

docker配置使用国内镜像源后，可直接运行：
minikube start --driver=docker

可以手动指定其他源，可尝试多次下载：
minikube start --driver=docker --kubernetes-version='v1.35.1' --binary-mirror='https://dl.k8s.io'

如出现下载失败或者下载超时，可采用以下方式彻底清除现有集群和缓存，然后重新执行上面的命令进行下载：
minikube delete --all --purge
rm -rf ~/.minikube   # 可选，彻底清理残留配置

4.验证并开始使用

minikube status
kubectl get nodes

如果看到节点状态为 Ready，就说明你的单节点 Kubernetes 集群已经成功运行了。

5. (可选) 启用 Minikube 插件

Minikube 提供了许多插件来扩展功能，最常用的是仪表盘（Dashboard）。

启用仪表盘 (Dashboard)：执行以下命令，浏览器将自动打开 Kubernetes 的 Web UI 界面，方便你直观地管理集群。

minikube addons enable dashboard
启用可能会失败：
# 拉取 dashboard 镜像
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/dashboard:v2.7.0

# 拉取 metrics-scraper 镜像
docker pull registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-scraper:v1.0.8

将拉取下来的国内镜像，标记为 Kubernetes 期望的官方镜像名：
docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/dashboard:v2.7.0 kubernetes/dashboard:v2.7.0

docker tag registry.cn-hangzhou.aliyuncs.com/google_containers/metrics-scraper:v1.0.8 kubernetes/metrics-scraper:v1.0.8

删除失败的 Pod，让它们重新创建
kubectl delete pod -n kubernetes-dashboard --all

kubectl get pods -n kubernetes-dashboard

minikube dashboard


更多插件：执行 minikube addons list 可以查看所有可用插件，例如 ingress 用于管理入站网络流量。

🧪 测试集群：部署一个 Nginx 应用

为了验证集群功能，可以尝试部署一个简单的 Nginx 应用。

  1. 创建 Nginx Deployment：
kubectl create deployment nginx --image=nginx:alpine

2.创建一个 Service 来暴露应用：

kubectl expose deployment nginx --type=NodePort --port=80

3.获取访问地址：运行以下命令获取服务的访问 URL，然后在浏览器中打开它，就能看到 Nginx 的欢迎页面了。

minikube service nginx --url

4.清理测试资源：测试完成后，可以删除 Deployment 和 Service 来释放资源。

kubectl delete service nginx
kubectl delete deployment nginx

常用 Minikube 命令
停止集群: minikube stop (保留数据，释放 CPU/内存)
暂停集群: minikube pause (快速暂停)
删除集群: minikube delete (彻底删除数据)
查看 Dashboard: minikube dashboard (打开 Web 界面)
查看插件列表: minikube addons list

The post 本地安装Minikube部署Kubernetes环境 appeared first on 原立方.

]]> https://www.atomic-cube.cn/apple-chip%e5%ae%89%e8%a3%85minikube/feed/ 0 Go 语言文件处理 https://www.atomic-cube.cn/go-%e8%af%ad%e8%a8%80%e6%96%87%e4%bb%b6%e5%a4%84%e7%90%86/ https://www.atomic-cube.cn/go-%e8%af%ad%e8%a8%80%e6%96%87%e4%bb%b6%e5%a4%84%e7%90%86/#respond Tue, 28 Apr 2026 23:37:11 +0000 https://www.atomic-cube.cn/?p=1952 文件处理是 Go 语言中最常见的操作之一——读取配置、写入日志、数据持久化都离不开它。Go 的标准库提供了一套简洁而强大的文件 I/O 接口，覆盖从单次读写到流式处理的各种场景

The post Go 语言文件处理 appeared first on 原立方.

]]> 文件处理是 Go 语言中最常见的操作之一——读取配置、写入日志、数据持久化都离不开它。Go 的标准库提供了一套简洁而强大的文件 I/O 接口，覆盖从单次读写到流式处理的各种场景。

与文件处理相关的核心包有 5 个，各有分工：

版本提示：ioutil 包在 Go 1.16 已弃用，其功能已迁移到 os（如 os.ReadFile、os.WriteFile）和 io（如 io.ReadAll）。新代码应直接使用 os 和 io 包。

1. 文件创建

os.Create 创建一个新文件。如果文件已存在，会被截断（清空内容）。返回的文件对象必须关闭以释放系统资源：

package main

import (
        "log"
        "os"
)

func main() {
        // os.Create 创建文件（已存在则清空）
        file, err := os.Create("test.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close() // defer 确保函数结束时关闭文件

        // 写入内容验证创建成功
        file.WriteString("文件创建成功\n")
        log.Println("文件创建成功")
}

defer file.Close() 是 Go 文件操作的最佳实践。defer 会确保即使后续代码出现 panic，文件也会被正确关闭，避免文件描述符泄漏。

2. 文件打开与关闭

os 包提供三种打开文件的方式，适用于不同场景：

函数模式说明
os.Open(name)只读最简单的方式，只读打开
os.Create(name)读写 + 创建/截断创建新文件或清空已有文件
os.OpenFile(name, flag, perm)自定义可指定读写、追加、创建等标志
package main

import (
        "fmt"
        "os"
)

func main() {
        // 方式1：只读打开
        file, err := os.Open("example.txt")
        if err != nil {
                fmt.Println("打开失败:", err)
                return
        }
        defer file.Close()
        fmt.Println("文件打开成功")

        // 方式2：OpenFile 自定义模式
        // os.O_WRONLY  只写
        // os.O_CREATE  不存在则创建
        // os.O_APPEND  追加模式
        // os.O_TRUNC   存在则截断
        f, err := os.OpenFile("log.txt",
                os.O_WRONLY|os.O_CREATE|os.O_APPEND, 0644)
        if err != nil {
                fmt.Println("打开失败:", err)
                return
        }
        defer f.Close()
        f.WriteString("追加一行日志\n")
}

OpenFile 标志位说明

标志说明
os.O_RDONLY只读（默认）
os.O_WRONLY只写
os.O_RDWR读写
os.O_APPEND追加模式，写入内容追加到文件末尾
os.O_CREATE文件不存在时创建
os.O_TRUNC打开时清空文件内容
os.O_EXCL与 CREATE 配合，文件已存在时报错

3. 文件读取

Go 提供了三种主要的文件读取方式，根据文件大小和处理需求选择：

3.1 一次性读取（小文件推荐）

os.ReadFile 是最简洁的方式——自动打开、读取、关闭文件，一步到位：

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        // 一次性读取整个文件（Go 1.16+）
        data, err := os.ReadFile("config.json")
        if err != nil {
                log.Fatal(err)
        }

        fmt.Println(string(data))
}

3.2 逐行读取（大文件推荐）

对于大文件，使用 bufio.Scanner 逐行处理，避免一次性加载到内存：

package main

import (
        "bufio"
        "fmt"
        "log"
        "os"
)

func main() {
        file, err := os.Open("large-file.log")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // 逐行扫描
        scanner := bufio.NewScanner(file)
        lineNum := 0
        for scanner.Scan() {
                lineNum++
                line := scanner.Text() // 获取当前行内容
                fmt.Printf("第 %d 行: %s\n", lineNum, line)
        }

        // 检查扫描过程中是否出错
        if err := scanner.Err(); err != nil {
                log.Fatal("读取错误:", err)
        }
}

注意：bufio.Scanner 默认最大行长度为 64KB。如果文件中有超长行，需要在调用 Scan() 前设置 scanner.Buffer(make([]byte, 0), maxSize) 来增大缓冲区。

3.3 使用 io.ReadAll 读取

当你已经有一个打开的 io.Reader（如网络响应、已打开的文件），可以使用 io.ReadAll：

package main

import (
        "fmt"
        "io"
        "log"
        "os"
)

func main() {
        file, err := os.Open("example.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // 从 Reader 读取所有数据
        data, err := io.ReadAll(file)
        if err != nil {
                log.Fatal(err)
        }

        fmt.Println(string(data))
}

4. 文件写入

Go 提供了多种写入方式，从简单的一次性写入到高性能的缓冲写入：

4.1 一次性写入

os.WriteFile 将数据一次性写入文件（覆盖原有内容）：

package main

import (
        "log"
        "os"
)

func main() {
        content := []byte("Hello, Go!\n这是第二行\n")

        // 0644: 所有者读写，其他用户只读
        err := os.WriteFile("output.txt", content, 0644)
        if err != nil {
                log.Fatal(err)
        }
        log.Println("写入成功")
}

4.2 使用 File 对象写入

通过文件对象写入，可以分多次写入内容：

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        file, err := os.Create("output.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // 方式1：写入字符串
        file.WriteString("直接写入字符串\n")

        // 方式2：写入字节切片
        data := []byte("写入字节切片\n")
        file.Write(data)

        // 方式3：格式化写入
        fmt.Fprintf(file, "格式化写入: %d + %d = %d\n", 3, 4, 7)
}

4.3 缓冲写入（大量数据推荐）

bufio.Writer 会先将数据写入内存缓冲区，攒够后再批量写入磁盘，显著减少 I/O 次数。务必在结束前调用 Flush()：

package main

import (
        "bufio"
        "log"
        "os"
)

func main() {
        file, err := os.Create("buffered-output.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // 创建带缓冲的写入器
        writer := bufio.NewWriter(file)

        // 写入多行（先进入缓冲区，不会立即写磁盘）
        for i := 0; i < 1000; i++ {
                writer.WriteString("这是第 " + itoa(i) + " 行\n")
        }

        // Flush 将缓冲区剩余数据写入文件
        if err := writer.Flush(); err != nil {
                log.Fatal("刷新缓冲区失败:", err)
        }
        log.Println("缓冲写入完成")
}

// 简单的 int 转 string 辅助函数
func itoa(n int) string {
        return fmt.Sprintf("%d", n)
}

5. 文件追加写入

使用 os.O_APPEND 标志在文件末尾追加内容，而不覆盖已有数据：

package main

import (
        "log"
        "os"
        "time"
)

func main() {
        // O_APPEND: 追加模式
        // O_CREATE: 不存在则创建
        // O_WRONLY: 只写
        file, err := os.OpenFile("app.log",
                os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
        if err != nil {
                log.Fatal(err)
        }
        defer file.Close()

        // 每次运行都会追加，不会覆盖
        timestamp := time.Now().Format("2006-01-02 15:04:05")
        file.WriteString("[" + timestamp + "] 应用启动\n")
}

对比：os.Create 会清空已有内容；os.OpenFile 配合 O_APPEND 会追加内容。日志场景务必使用追加模式。

6. 文件删除与重命名

package main

import (
        "log"
        "os"
)

func main() {
        // 重命名 / 移动文件
        err := os.Rename("old.txt", "new.txt")
        if err != nil {
                log.Fatal("重命名失败:", err)
        }
        log.Println("重命名成功")

        // 删除文件
        err = os.Remove("temp.txt")
        if err != nil {
                log.Fatal("删除失败:", err)
        }
        log.Println("删除成功")
}

7. 文件信息与检查

7.1 获取文件信息

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        info, err := os.Stat("test.txt")
        if err != nil {
                log.Fatal(err)
        }

        fmt.Println("文件名:    ", info.Name())
        fmt.Println("大小:      ", info.Size(), "字节")
        fmt.Println("权限:      ", info.Mode())
        fmt.Println("修改时间:  ", info.ModTime())
        fmt.Println("是目录吗:  ", info.IsDir())
}

7.2 检查文件是否存在

Go 没有专门的”文件存在”函数，通过 os.Stat + os.IsNotExist 判断：

package main

import (
        "fmt"
        "os"
)

// fileExists 检查文件是否存在
func fileExists(path string) bool {
        _, err := os.Stat(path)
        return !os.IsNotExist(err)
}

func main() {
        if fileExists("test.txt") {
                fmt.Println("文件存在")
        } else {
                fmt.Println("文件不存在")
        }
}

8. 目录操作

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        // 创建单个目录
        err := os.Mkdir("newdir", 0755)
        if err != nil {
                log.Fatal(err)
        }

        // 递归创建多级目录（父目录不存在也会自动创建）
        err = os.MkdirAll("path/to/deep/dir", 0755)
        if err != nil {
                log.Fatal(err)
        }

        // 读取目录内容
        entries, err := os.ReadDir(".")
        if err != nil {
                log.Fatal(err)
        }
        for _, entry := range entries {
                mark := "📄"
                if entry.IsDir() {
                        mark = "📁"
                }
                fmt.Printf("%s %s\n", mark, entry.Name())
        }

        // 删除空目录
        os.Remove("newdir")

        // 递归删除目录及其所有内容（⚠ 谨慎使用）
        os.RemoveAll("path")
}

9. 高级操作

9.1 文件复制

使用 io.Copy 在两个文件之间高效复制数据：

package main

import (
        "io"
        "log"
        "os"
)

// copyFile 复制文件的通用函数
func copyFile(src, dst string) (int64, error) {
        srcFile, err := os.Open(src)
        if err != nil {
                return 0, err
        }
        defer srcFile.Close()

        dstFile, err := os.Create(dst)
        if err != nil {
                return 0, err
        }
        defer dstFile.Close()

        // io.Copy 自动管理缓冲区，高效复制
        return io.Copy(dstFile, srcFile)
}

func main() {
        n, err := copyFile("source.txt", "destination.txt")
        if err != nil {
                log.Fatal(err)
        }
        log.Printf("复制完成，共 %d 字节", n)
}

9.2 临时文件与目录

package main

import (
        "fmt"
        "log"
        "os"
)

func main() {
        // 创建临时文件（自动命名，前缀为 "app-"）
        tmpFile, err := os.CreateTemp("", "app-*.txt")
        if err != nil {
                log.Fatal(err)
        }
        defer os.Remove(tmpFile.Name()) // 用完后清理
        fmt.Println("临时文件:", tmpFile.Name())

        // 创建临时目录
        tmpDir, err := os.MkdirTemp("", "app-*")
        if err != nil {
                log.Fatal(err)
        }
        defer os.RemoveAll(tmpDir) // 用完后清理
        fmt.Println("临时目录:", tmpDir)
}

9.3 递归遍历目录

filepath.Walk 可以递归遍历目录树中的所有文件和子目录：

package main

import (
        "fmt"
        "log"
        "os"
        "path/filepath"
)

func main() {
        root := "." // 从当前目录开始遍历

        err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
                if err != nil {
                        return err // 遇到错误时可以选择跳过或返回
                }

                // 打印路径和大小
                size := ""
                if !info.IsDir() {
                        size = fmt.Sprintf(" (%d bytes)", info.Size())
                }
                fmt.Println(path + size)
                return nil
        })

        if err != nil {
                log.Fatal(err)
        }
}

9.4 跨平台路径拼接

永远不要用字符串拼接路径（如 dir + "/" + file），使用 filepath.Join 确保跨平台兼容：

// 错误：Windows 上路径分隔符是 \<br>path := "dir" + "/" + "file.txt"<br><br>// 正确：自动适配当前操作系统<br>path := filepath.Join("dir", "file.txt")<br><br>

场景速查表

场景推荐方式关键代码
读取小文件os.ReadFiledata, err := os.ReadFile("file.txt")
逐行读取大文件bufio.Scannerscanner := bufio.NewScanner(file)
写入小文件os.WriteFileos.WriteFile("f.txt", data, 0644)
大量数据写入bufio.Writerwriter := bufio.NewWriter(file)
追加日志os.OpenFile + O_APPENDos.OpenFile("log", os.O_APPEND|os.O_WRONLY, 0644)
文件复制io.Copyio.Copy(dst, src)
遍历目录filepath.Walkfilepath.Walk(".", callback)
路径拼接filepath.Joinfilepath.Join("dir", "file.txt")
检查文件存在os.Stat + os.IsNotExist_, err := os.Stat(path)
创建临时文件os.CreateTempos.CreateTemp("", "prefix-*.txt")

文件权限说明：0644 表示所有者可读写（6=4+2），组和其他用户只读（4）。目录通常使用 0755（多了执行权限，否则无法进入目录）。

The post Go 语言文件处理 appeared first on 原立方.

]]> https://www.atomic-cube.cn/go-%e8%af%ad%e8%a8%80%e6%96%87%e4%bb%b6%e5%a4%84%e7%90%86/feed/ 0 VSCode ,codex,claude code使用 ‌oMLX‌ 本地模型 https://www.atomic-cube.cn/vs-code-%e4%b8%ad%e4%bd%bf%e7%94%a8-omlx-%e6%9c%ac%e5%9c%b0%e6%a8%a1%e5%9e%8b/ https://www.atomic-cube.cn/vs-code-%e4%b8%ad%e4%bd%bf%e7%94%a8-omlx-%e6%9c%ac%e5%9c%b0%e6%a8%a1%e5%9e%8b/#respond Mon, 27 Apr 2026 22:00:00 +0000 https://www.atomic-cube.cn/?p=1858 在 VS Code 中使用 ‌oMLX‌ 本地模型，主要依赖于 oMLX 提供的 ‌OpenAI / Anth […]

The post VSCode ,codex,claude code使用 ‌oMLX‌ 本地模型 appeared first on 原立方.

]]> 在 VS Code 中使用 ‌oMLX‌ 本地模型，主要依赖于 oMLX 提供的 ‌OpenAI / Anthropic 兼容 API 接口‌，通过配置 VS Code 的 AI 插件（如 Continue、Copilot Chat 等）连接到 oMLX 本地服务。

✅ 核心步骤

  • ‌oMLX 仅支持 macOS + Apple Silicon（M1/M2/M3/M4/M5）‌，不支持 Windows 或 NVIDIA 显卡 ‌。
  • oMLX 启动后默认提供以下 API 接口：
    • OpenAI 兼容：http://localhost:8000/v1
    • Anthropic 兼容：http://localhost:8000

🛠️ 在 VS Code 中配置 oMLX 的方法

一：使用 ‌Continue 插件‌（推荐）

  1. ‌安装 Continue 插件‌
    • 打开 VS Code → 扩展市场 → 搜索 Continue → 安装 ‌。
  2. ‌配置本地模型‌
    • 打开 VS Code 设置（Cmd+,）→ 搜索 Continue。
    • 在 Continue: Models 中添加如下配置：
    • 重启 VS Code 或重新加载 Continue。
models:
  - name: MLX-Qwen3.5-9B-Claude-4.6-Opus-Reasoning-Distilled-v2-4bit
    provider: openai #一定要设置成openai
    model: MLX-Qwen3.5-9B-Claude-4.6-Opus-Reasoning-Distilled-v2-4bit #这里改成本地使用的模型
    apiKey: omlx #这里改成本地omlx设置的apikey
    apiBase: http://localhost:8000/v1 #这里改成OMLX中API 端点OpenAI API的地址即可
    roles:
      - chat
      - edit
      - apply

  1. 启动 oMLX 服务‌
    • 确保 oMLX 已在终端或菜单栏中运行，并已加载目标模型 ‌。
  2. ‌使用‌
    • 在 VS Code 编辑器中右键 → 选择 Continue: Chat、Agent 或按快捷键（默认 Cmd+I）即可调用本地模型。

✅ 优势：完全离线、代码不上传云端、支持工具调用与结构化输出 ‌。

本地使用截图，能用，够用(M2 16G+512G的macbook pro，请忽略token生成的速度)：

集成 Claude Code / Codex/OpenCode/OpenClaw

oMLX 提供一键配置生成器，简化了与主流开发工具的集成：

  1. 打开 Web 管理面板 (http://localhost:8000/admin)
  2. 选择要使用的模型
  3. 点击 “Integrations” 选项卡
  4. 一键复制配置命令
  5. 打开命令行，cd进入需要处理的项目文件夹，对应的命令 回车就可以啦，如codex和claude code的启动命令
'/Applications/oMLX.app/Contents/MacOS/omlx-cli' launch codex --model 'MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' --api-key 'omlx'
ANTHROPIC_BASE_URL='http://127.0.0.1:8000' ANTHROPIC_AUTH_TOKEN='omlx' ANTHROPIC_DEFAULT_OPUS_MODEL='MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' ANTHROPIC_DEFAULT_SONNET_MODEL='MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' ANTHROPIC_DEFAULT_HAIKU_MODEL='MLX-Qwen3.5-4B-Claude-4.6-Opus-Reasoning-Distilled-v2-8bit' API_TIMEOUT_MS=3000000 CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1 claude

The post VSCode ,codex,claude code使用 ‌oMLX‌ 本地模型 appeared first on 原立方.

]]> https://www.atomic-cube.cn/vs-code-%e4%b8%ad%e4%bd%bf%e7%94%a8-omlx-%e6%9c%ac%e5%9c%b0%e6%a8%a1%e5%9e%8b/feed/ 0 2026AI 编码工具全面对比：Codex CLI、Claude Code、Cursor、Gemini CLI、Copilot CLI https://www.atomic-cube.cn/2026-ai-%e7%bc%96%e7%a0%81-cli-%e5%b7%a5%e5%85%b7%e5%85%a8%e9%9d%a2%e5%af%b9%e6%af%94%ef%bc%9acodex-cli%e3%80%81claude-code%e3%80%81cursor%e3%80%81gemini-cli%e3%80%81copilot-cli/ https://www.atomic-cube.cn/2026-ai-%e7%bc%96%e7%a0%81-cli-%e5%b7%a5%e5%85%b7%e5%85%a8%e9%9d%a2%e5%af%b9%e6%af%94%ef%bc%9acodex-cli%e3%80%81claude-code%e3%80%81cursor%e3%80%81gemini-cli%e3%80%81copilot-cli/#respond Sun, 26 Apr 2026 21:30:23 +0000 https://www.atomic-cube.cn/?p=1927 一、概述与产品定位 2025 至 2026 年间，AI 编程工具从 IDE 插件（以 Cursor 为代表）大 […]

The post 2026AI 编码工具全面对比：Codex CLI、Claude Code、Cursor、Gemini CLI、Copilot CLI appeared first on 原立方.

]]> 一、概述与产品定位

2025 至 2026 年间，AI 编程工具从 IDE 插件（以 Cursor 为代表）大举走向终端（即 “Vibe Coding”）。Anthropic 的 Claude Code、OpenAI 的 Codex CLI、Google 的 Gemini CLI 三款主流命令行工具相继成熟，它们以交互式终端为基本界面，支持读取本地文件、编辑代码、执行 Shell 命令，让开发者在终端内完成从原型到部署的完整编码流程。与此同时，Cursor 于 2026 年 1 月推出 CLI 功能，GitHub Copilot CLI 于 2026 年 2 月正式 GA，终端 AI 编码的战场已经全面铺开。

工具出品方核心定位起步价格
Claude CodeAnthropic高自主度终端 Agent$20/月（Pro）
Cursor CLIAnysphereAI 原生 IDE + CLI 混合体$20/月（Pro）
Gemini CLIGoogle开源终端 Agent免费（1,000 次请求/天）
Codex CLIOpenAI轻量开源终端 Agent$20/月（ChatGPT Plus）
Copilot CLIGitHub / MicrosoftGitHub 原生 CLI免费 / $10/月起（Pro）

以上信息综合整理自各工具官方文档与公开资料。

二、综合对比总表

下表从核心维度对五款工具进行全景对比：

对比维度Claude CodeCursor CLIGemini CLICodex CLICopilot CLI
主界面终端 + VS Code + Web + 桌面VS Code 分支 + CLI终端终端 + macOS 桌面 App终端 + IDE + Web
SWE-bench Verified80.9%（Opus 4.5）~73%（取决于所选模型）~65%77.3%（Terminal-Bench 2.0）未公布官方成绩
最大上下文窗口200K（1M Beta）200K1M（免费）1M（Pro）~128K
多模型支持仅 Claude 系列✅ 多模型仅 Google 系列仅 OpenAI 系列✅ Claude、GPT、Gemini、xAI
Tab 实时补全❌✅（<100ms）❌❌✅
IDE 集成VS Code / JetBrainsVS Code 原生❌VS Code / CursorVS Code / JetBrains
MCP 支持✅✅✅✅✅
后台 Agent✅（子 Agent + 云会话）✅（云 VM 后台）❌✅（云沙箱）✅（后台委托）
开源❌ 闭源❌ 闭源✅ 开源✅ 开源（Apache 2.0）❌ 闭源
CI/CD 支持✅（GitHub Actions）❌✅✅（headless 模式）✅（GitHub Actions）
操作系统支持macOS / Linux / Win(WSL)macOS / Windows / LinuxmacOS / Linux / WindowsmacOS / Linux（Win 预览）macOS / Linux / Windows
Skill.md 标准✅✅✅✅✅
安装方式npm / Homebrew / 原生二进制IDE 内安装npm（@google/gemini-cli）npm / 原生二进制GitHub CLI 插件

主要数据来源：Morphllm 2026 年综合评测、各工具官方文档、JEECG 低代码 2026 年 4 月横评

三、核心能力：谁的编程能力最强？

3.1 SWE-bench Verified 基准跑分

SWE-bench Verified 是目前最权威的编码 Agent 评测标准，任务是自动修复真实的 GitHub Issue。各工具排名如下：

排名工具得分备注
🥇Claude Code80.9%首次通过率约 95%，绝大多数任务一次通过
🥈Codex CLI77.3%Terminal-Bench 2.0 数据，用 Rust 重写后速度和 Token 效率大幅提升
🥉Cursor~73%取决于底层模型选择，选用 Claude 时表现最佳
4Gemini CLI~65%Google 模型在创意和搜索上有优势，但纯编码任务还有提升空间
5Copilot CLI未公布社区反馈显示复杂任务表现偏弱

3.2 真实项目实测

Particula Tech 团队用一个完整的 Express.js 项目重构作为测试任务，结果如下：

  • Claude Code：完成时间 1 小时 17 分钟，一次通过 ✓
  • Codex CLI：完成时间 1 小时 41 分钟，一次通过 ✓
  • Gemini CLI：完成时间 2 小时 04 分钟，一次通过 ✓

3.3 各维度能力细项对比

以下表格展示了五款工具在不同开发维度上的能力分布：

能力维度Claude CodeCursor CLIGemini CLICodex CLICopilot CLI
多文件复杂重构✅ 最强✅ 强⚠️ 中等⚠️ 中等❌ 弱
超大代码库理解（1M 上下文）✅（Beta）⚠️ 200K✅ 免费 1M✅ 1M（Pro）❌ ~128K
实时 Tab 补全❌✅ <100ms❌❌✅
截图转代码❌✅❌✅❌
实时网络搜索❌❌✅ Google 搜索❌❌

从中可以解读出：Claude Code 在自主规划、复杂多文件操作上遥遥领先，Cursor 在交互式实时编码体验上无人能敌，Gemini CLI 免费提供最大的上下文窗口和搜索能力，Codex CLI 在性能和安全性之间取得了出色平衡，Copilot CLI 则在 GitHub 生态深度和低价方面独树一帜。

四、生态与扩展功能对比

4.1 MCP 服务器支持

五款工具全部支持 MCP（Model Context Protocol），这是 2026 年 AI 编码工具的重要基础设施。MCP 允许 Agent 连接到数据库、API、浏览器等外部工具和服务。

各工具 MCP 扩展亮点：

  • Claude Code：支持 STDIO 和流式 HTTP 服务器，通过 claude mcp add 命令管理
  • Gemini CLI：支持通过 hooks 机制在 Agent 生命周期的特定节点调用 MCP 服务
  • Copilot CLI：可自定义 Agent 使用 MCP 服务器，实现 Work IQ 等高级功能

4.2 Skill.md 标准

SKILL.md 标准是 2026 年出现的重要标准化成果，实现了跨工具技能互通，让开发者能灵活组合使用不同工具以优化工作流。五款工具均已支持此标准，这意味着你可以在 Claude Code 中编写的技能文件，同样可以在 Codex CLI 或 Gemini CLI 中使用，大大降低了工具切换成本。

4.3 价格体系与总拥有成本

五款工具的价格体系反映了各自面向的目标用户群体不同。

（1）按价定价之外，还要关注上限

工具基础套餐进阶套餐企业级免费层模型锁定？
Claude Code$20/月（Claude Pro）$100-200/月（Max）Teams / Enterprise无是（仅 Claude 模型）
Cursor CLI$20/月（Pro）$60-200/月（Pro+/Ultra）企业定制有限免费否（多模型）
Gemini CLI免费（1,000 请求/天）N/AN/A是是（仅 Google 模型）
Codex CLI$20/月（ChatGPT Plus）ProEnterprise有限免费是（仅 OpenAI 模型）
Copilot CLI$10/月（Copilot Pro）$39/月（Pro+）Business $19 / Enterprise $392,000 次补全 + 50 次高级请求/月否（多模型）

Copilot 超额使用费为每次高级请求 $0.04，包括 Chat、CLI、Agent 模式、代码审核和 Spark 功能。Claude Code 是唯一完全没有免费层的工具，Gemini CLI 则是性价比最高的选择。

（2）隐藏的成本考量

  • Token 膨胀：虽然 Claude Code 定价最高，但独立测试显示它在完成相同任务时的 Token 消耗远低于 Cursor（约 33K vs 188K），这让高阶用户的实际成本可能更低
  • Codex 沙箱：OpenAI 的 Codex CLI 提供免费的本地执行和云端沙箱分离，Token 优化据称可以减少 40-60% 的实际消耗
  • Gemini 免费的代价：1M 上下文免费，但搜索和复杂任务可能请求消耗较快，而且只支持 Google 自家模型

4.4 工具间配合：不是“替换”而是“组合”

2026 年的调查显示，有经验的开发者平均使用 2.3 个工具同时工作。这些工具并非相互排斥——每个都有自己擅长的工作场景。具体推荐组合见下文选择建议。

五、优势与局限总结

工具核心优势主要短板
Claude Code自主重构能力最强，SWE-bench 得分最高（80.9%），Agent Teams 支持并行子任务，CLAUDE.md 项目记忆驱动仅支持 Claude 模型，无免费层，价格最高（$20-200/月），无 Tab 实时补全
Cursor CLI实时 <200ms Tab 补全行业领先，8 个并行 Agent，多模型自由切换，VS Code 原生体验非开源，SWE-bench 依赖所选模型，自主重构能力不及 Claude Code
Gemini CLI完全免费 + 1,000 次请求/天，1M 上下文免费，Google 搜索集成，开源可审计纯编码任务不如 Claude Code / Codex CLI，无 Tab 补全，仅 Google 模型
Codex CLIRust 重写后性能出色，云端沙箱安全隔离，开源（Apache 2.0），Token 效率高（据称减少 40-60%）$20/月起步，仅 OpenAI 模型，Windows 尚在预览阶段
Copilot CLI价格最低（$10/月起 + 免费层），5 种模型自由选择，GitHub 生态深度集成，内置代码审查 Agent复杂重构能力弱，上下文窗口小（~128K），开源透明度不足

六、选型决策指南

按开发者画像推荐

用户画像首选工具备选工具理由
专注复杂重构的架构师Claude CodeCodex CLI80.9% SWE-bench 得分、Agent Teams、多文件自主操作
日常编码为主的开发者Cursor CLI + Copilot CLI—Cursor 的 Tab 补全 + Copilot 的多模型和低价，双工具覆盖 80% 场景
预算有限的个人 / 学生Gemini CLICopilot CLI 免费层免费、1M 上下文、Google 搜索接地气
开源贡献者Codex CLIGemini CLIApache 2.0 开源、可审计、可自定义
GitHub 深度用户Copilot CLIClaude CodePR / Issue 原生集成、多模型选择、CI/CD 管道
全栈 / Web 开发者Cursor CLI + Codex CLI—VS Code 生态 + 截图转代码 + 远程服务器 Dev
数据隐私优先的企业自部署 CodexGemini CLI开源、企业级部署

按任务场景推荐

任务场景推荐工具说明
大规模代码重构Claude CodeAgent Teams 并行处理，先计划后执行，支持 Git Worktree 安全操作
日常快速编码Cursor CLI 或 Copilot CLI（Tab 补全）Cursor 的 <200ms Tab 补全覆盖日常 80% 编码需求
复杂多步骤任务（CI/CD）Codex CLI云端沙箱隔离执行，支持 headless 远程操作，适合 DevOps 自动化
代码审查Copilot CLI（内置 Code Review Agent）自动委托给专业审查 Agent，修复建议可直接采纳
学习新技术栈Gemini CLI（Ask + 搜索）或 Cursor CLI（Ask 模式）免费上下文窗口 + Google 搜索接地气
API 文档编写Claude Code强大的自主生成和结构化内容能力
多模型对比实验Cursor CLI 或 Copilot CLI支持在多个模型间自由切换，方便比较

实际工作流建议

2026 年 AI 编码调查显示，有经验的开发者平均使用 2.3 个工具。这些工具并非互斥——每个都有其擅长的工作场景。

组合方案核心配置月成本适合人群
日常极简主义Copilot CLI（Tab 补全 + 多模型）$10普通开发者的全能选择
高效全能型Cursor + Codex CLI（IDE + 后台 Agent）$40（Cursor $20 + Codex $20）全栈 / 高级开发者的日常主力和后台自动化
性能狂热型Claude Code + Copilot CLI（重构 + 补全）$30（CC $20 + Copilot $10）架构师 + 高要求项目的全覆盖方案
零成本学习型Gemini CLI + Cursor 免费层（搜索 + 补全）$0学生 / 学习者 / 试水者

七、2026 年关键趋势

1. 终端成为新的战场。 2026 年，所有主流 AI 编码工具都已经或即将发布 CLI 版本，终端已成为 AI Agent 的第一界面。

2. 多工具组合使用成为常态。 单靠一个工具解决所有问题的时代已经过去，开发者倾向于根据不同任务选择最佳工具，再利用 Skill.md 标准实现跨工具复用。

3. 上下文窗口竞赛白热化。 Gemini CLI 免费提供 1M 上下文，Claude Code 有 1M Beta，Codex CLI 的 Pro 版也达到 1M。更大的上下文窗口意味着更好的代码库理解能力。

4. 开源与闭源的博弈。 Gemini CLI 和 Codex CLI 选择了开源路线，Claude Code 和 Cursor 则保持闭源。开源意味着可审计、可定制，闭源则意味着更集中的资源投入。

5. 后台 Agent 执行成为标配。 从 Cursor 的 Cloud Agent 到 Copilot CLI 的 & 前缀后台委托，再到 Codex CLI 的云端沙箱执行，AI 编码正在从“人盯 AI”走向“AI 自主执行、人异步审查”的新范式。

6. 国内生态加速接入。 Claude Code 支持阿里云 Coding Plan，可调用 Qwen 系列模型。低代码平台 JEECG 等已深度集成 AI CLI 工具，形成面向国内开发者的完整工具链。

本报告综合整理自 Morphllm 2026 年评测数据、各工具官方文档与 GitHub 仓库、以及多个独立开发者社区的实际使用反馈。AI 编码工具迭代极快，建议在决策前查阅各工具最新文档。

The post 2026AI 编码工具全面对比：Codex CLI、Claude Code、Cursor、Gemini CLI、Copilot CLI appeared first on 原立方.

]]> https://www.atomic-cube.cn/2026-ai-%e7%bc%96%e7%a0%81-cli-%e5%b7%a5%e5%85%b7%e5%85%a8%e9%9d%a2%e5%af%b9%e6%af%94%ef%bc%9acodex-cli%e3%80%81claude-code%e3%80%81cursor%e3%80%81gemini-cli%e3%80%81copilot-cli/feed/ 0