标签 golang 下的文章

2024-08-09

C语言中的字符串通常是以空字符'\0'结尾的字符数组。

C++中的std::string是一个动态大小的字符串，它在内部处理字符串的存储和管理，包括内存分配和扩展。

Go语言中的字符串是不可变的，它们在底层是通过字节切片实现的，并且总是 nil 结尾。

以下是各种语言中创建和使用字符串的简单示例：

C语言:




char str[] = "Hello, World!";

C++:




#include <string>
 
std::string str = "Hello, World!";

Go语言:




str := "Hello, World!"

2024-08-09

Cloudflare 的 golibs 项目是一个用于 Go 语言的库集合，它提供了一系列的模块化解决方案，旨在帮助开发者更高效地构建和维护其基于 Cloudflare 服务的应用程序。

以下是一个简单的例子，展示如何使用 golibs 中的 cfssl 库来生成一个自签名的 SSL 证书：




package main
 
import (
    "crypto/rand"
    "crypto/x509"
    "encoding/pem"
    "fmt"
    "log"
    "time"
 
    "github.com/cloudflare/cfssl/csr"
    "github.com/cloudflare/cfssl/initca"
)
 
func main() {
    // 创建一个自签名的 CA
    ca, err := initca.InitCA(initca.InitCAOptions{
        // 指定 CA 的有效期
        Duration:    time.Hour * 24 * 365 * 10, // 10年
        CommonName:  "example.com",
        Serial:      1,
    })
    if err != nil {
        log.Fatal(err)
    }
 
    // 创建一个 CSR
    req := &csr.CertificateRequest{
        CN: "example.com",
    }
 
    // 使用 CA 签名 CSR 生成证书
    cert, err := initca.Sign(req, ca, ca.PrivateKey, x509.RSA, 2048, time.Hour*24*365*10, cfssl.LogRequest)
    if err != nil {
        log.Fatal(err)
    }
 
    // 将证书和密钥写入文件
    certOut, err := pem.Open("cert.pem")
    if err != nil {
        log.Fatal(err)
    }
    pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: cert.Cert})
    certOut.Close()
 
    keyOut, err := os.OpenFile("key.pem", os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
    if err != nil {
        log.Fatal(err)
    }
    pem.Encode(keyOut, &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(ca.PrivateKey)})
    keyOut.Close()
 
    fmt.Println("Certificate and key generated.")
}

在这个例子中，我们首先初始化了一个自签名的 CA，然后创建了一个 CSR 并用该 CA 对其进行了签名，生成了一个自签名的 SSL 证书。最后，我们将证书和密钥写入了文件。这个过程展示了如何使用 Cloudflare 提供的 cfssl 库来进行 SSL 证书管理。

使用 Go 和 Gin 开发 RESTful API

2024-08-09




package main
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
)
 
type User struct {
    Username string `json:"username"`
    Email    string `json:"email"`
}
 
func main() {
    router := gin.Default()
 
    // 获取所有用户
    router.GET("/users", func(c *gin.Context) {
        users := []User{
            {Username: "张三", Email: "zhangsan@example.com"},
            {Username: "李四", Email: "lisi@example.com"},
        }
        c.JSON(200, users)
    })
 
    // 获取单个用户
    router.GET("/users/:username", func(c *gin.Context) {
        username := c.Param("username")
        user := User{Username: username, Email: "bob@example.com"}
        c.JSON(200, user)
    })
 
    // 创建新用户
    router.POST("/users", func(c *gin.Context) {
        var user User
        if c.BindJSON(&user) == nil {
            fmt.Printf("创建用户: %#v\n", user)
            c.JSON(200, gin.H{"status": "ok", "message": "用户创建成功!"})
        } else {
            c.JSON(400, gin.H{"status": "error", "message": "无效的请求体!"})
        }
    })
 
    // 启动服务器
    router.Run(":8080")
}

这段代码定义了一个简单的RESTful API，包括获取所有用户、获取单个用户、创建新用户的接口。它使用Gin框架，并展示了如何使用该框架来路由HTTP请求、解析JSON请求体、以及返回JSON响应。

深入理解Go语言中的可比较数据类型

2024-08-09




package main
 
import (
    "fmt"
    "reflect"
)
 
// 定义一个函数，用于比较两个interface{}类型的值是否相等
func compareValues(a, b interface{}) bool {
    if a == nil || b == nil {
        return a == b
    }
    aValue := reflect.ValueOf(a)
    bValue := reflect.ValueOf(b)
    if aValue.Type() != bValue.Type() {
        return false
    }
    // 使用reflect.DeepEqual来进行深度比较
    return reflect.DeepEqual(a, b)
}
 
func main() {
    // 测试compareValues函数
    // 基本类型
    fmt.Println(compareValues(10, 10))        // true
    fmt.Println(compareValues(10, "10"))       // false
    // 切片
    fmt.Println(compareValues([]int{1, 2}, []int{1, 2})) // true
    fmt.Println(compareValues([]int{1, 2}, []int{2, 1})) // false
    // 结构体
    type testStruct struct {
        Field1 int
        Field2 string
    }
    fmt.Println(compareValues(testStruct{1, "a"}, testStruct{1, "a"})) // true
    fmt.Println(compareValues(testStruct{1, "a"}, testStruct{2, "a"})) // false
    // 字典
    fmt.Println(compareValues(map[string]int{"key": 1}, map[string]int{"key": 1})) // true
    fmt.Println(compareValues(map[string]int{"key": 1}, map[string]int{"key": 2})) // false
}

这段代码定义了一个compareValues函数，用于比较两个interface{}类型的值是否相等。它首先检查nil情况，然后获取两个值的reflect.Value，检查它们的类型是否相同，最后使用reflect.DeepEqual来进行深度比较。代码中包含了基本类型、切片、结构体和字典的比较示例，展示了如何使用反射包来进行复杂数据结构的比较。

2024-08-09




package main
 
import (
    "fmt"
    "net/http"
    "os"
    "time"
)
 
func main() {
    // 设置HTTP客户端超时
    client := http.Client{Timeout: 10 * time.Second}
 
    // 创建一个请求
    req, err := http.NewRequest(http.MethodGet, "https://www.example.com", nil)
    if err != nil {
        fmt.Println("请求创建失败:", err)
        os.Exit(1)
    }
 
    // 发送请求并获取响应
    resp, err := client.Do(req)
    if err != nil {
        fmt.Println("请求发送失败:", err)
        os.Exit(1)
    }
    defer resp.Body.Close() // 确保关闭响应体
 
    // 输出响应状态
    fmt.Printf("状态码: %s\n", resp.Status)
}

这段代码演示了如何使用Go语言的标准库net/http来发送一个HTTP GET请求到指定的URL，并处理响应。代码中包含了错误处理，以确保在发生错误时程序能够优雅地退出。这是学习Go语言和网络爬虫的一个很好的起点。

2024-08-09

go-zero 是一个集成了各种工程实践的 Web 和微服务开发框架。以下是一个标准的 go-zero 项目结构示例，以及如何使用 docker-compose 部署到 Linux 服务器的步骤。

项目结构示例：




go-zero-example/
│
├── cmd
│   ├── api
│   │   └── main.go
│   └── rpc
│       └── main.go
│
├── etc
│   ├── api.yaml
│   └── rpc.yaml
│
├── internal
│   ├── config
│   │   └── config.go
│   ├── handler
│   │   ├── api
│   │   │   └── index.go
│   │   └── rpc
│   │       └── index.go
│   ├── logic
│   │   ├── api
│   │   │   └── index.go
│   │   └── rpc
│   │       └── index.go
│   ├── model
│   │   └── default.go
│   ├── svc
│   │   └── servicecontext.go
│   └── types
│       └── types.go
│
└── docker-compose.yml

docker-compose.yml 文件示例：




version: '3'
services:
  api:
    build:
      context: .
      dockerfile: Dockerfile
      target: api
    ports:
      - "8080:8080"
    volumes:
      - ./cmd/api:/go/src/go-zero-example/cmd/api
      - ./etc:/go/src/go-zero-example/etc
      - ./internal:/go/src/go-zero-example/internal
      - ./buffer:/go/src/go-zero-example/buffer
    depends_on:
      - rpc
  rpc:
    build:
      context: .
      dockerfile: Dockerfile
      target: rpc
    ports:
      - "8081:8081"
    volumes:
      - ./cmd/rpc:/go/src/go-zero-example/cmd/rpc
      - ./etc:/go/src/go-zero-example/etc
      - ./internal:/go/src/go-zero-example/internal
      - ./buffer:/go/src/go-zero-example/buffer

在 Linux 服务器上部署：

确保已安装 Docker 和 docker-compose。
将上述结构的代码和 docker-compose.yml 文件上传到服务器。
在包含 docker-compose.yml 文件的目录中运行 docker-compose up -d 命令。

注意：

需要在每个服务的 Dockerfile 中指定构建目标（如 api 或 rpc）。
确保卷（volumes）中的路径正确映射到服务器上的代码路径。
确保服务器的防火墙和安全组设置允许访问相应的端口。

了解Go interface以及其所带来的开销

2024-08-09

在Go语言中，interface是一种类型，它定义了一个对象的行为，即它提供了一些方法。任何类型的对象，只要它实现了interface中的所有方法，那么这个对象就可以被认为是实现了这个interface。

在Go中，使用interface会带来一些性能上的开销，这是由于interface的动态性和隐式接口的实现方式导致的。每次你通过interface调用方法时，Go都会在运行时检查该对象是否实现了该方法。这种检查会使得程序的执行速度变慢。

解决方案：

尽可能减少使用interface。如果你知道变量的具体类型，就应该使用该类型。
如果你需要使用interface，尽可能使用值类型，而不是引用类型。因为引用类型会带来额外的间接性，使得变量在访问时需要额外的指针取值操作。
使用工厂模式或构造函数来创建对象，这样可以在创建时就确定其类型，减少后续的运行时检查。
对于经常需要调用的方法，可以使用接口变量的具体类型来调用，以避免每次调用时的运行时检查。

示例代码：




// 使用interface
var r Reader
r = os.Stdin
// 改进：知道类型，直接使用
var stdin *os.File
stdin = os.Stdin




// 使用interface
var w io.Writer
w = os.Stdout
// 改进：直接使用具体类型
var stdout *os.File
stdout = os.Stdout




// 使用interface
var b Buffer
b = new(Buffer)
// 改进：使用具体类型
var buffer *bytes.Buffer
buffer = bytes.NewBuffer(make([]byte, 1024))




// 使用interface
var files []io.Reader
for _, f := range filenames {
    files = append(files, os.Open(f))
}
// 改进：直接使用具体类型
var fileReaders []*os.File
for _, filename := range filenames {
    var file *os.File
    file, _ = os.Open(filename)
    fileReaders = append(fileReaders, file)
}

注意：在实际编程中，应当根据具体情况来权衡利弊，选择最合适的方案。

【Golang星辰图】Go语言的机器学习之旅：从基础知识到实际应用的综合指南

2024-08-09

由于原文章已经提供了完整的指南，这里我们只需要提供一个简单的示例代码，展示如何在Go中创建一个简单的线性回归模型。




package main
 
import (
    "fmt"
    "github.com/sjwhitworth/golearn/base"
    "github.com/sjwhitworth/golearn/linear_models"
)
 
func main() {
    // 创建一个简单的数据集
    data := base.DenseInstances{
        Attributes: []base.Attribute{
            {Name: "age", Type: base.Float},
            {Name: "income", Type: base.Float},
        },
    }
 
    // 添加一些示例数据
    data.AddInstance(base.Instance{
        Label:    0.0, // 假设0代表“不购买”
        Features: []float64{30.0, 2.5},
    })
    data.AddInstance(base.Instance{
        Label:    1.0, // 假设1代表“购买”
        Features: []float64{50.0, 4.0},
    })
 
    // 创建一个线性回归模型
    regressor := linear_models.NewLinearRegression()
 
    // 训练模型
    regressor.Train(data)
 
    // 进行预测
    predictions, err := regressor.Predict(data)
    if err != nil {
        panic(err)
    }
 
    // 输出预测结果
    for i, pred := range predictions {
        fmt.Printf("实例 %d: 预测标签 %f\n", i, pred)
    }
}

这段代码展示了如何在Go中使用golearn库来创建一个线性回归模型，训练它并进行预测。这是机器学习中一个基本且重要的概念，对于理解机器学习的基本原理有很大帮助。

Go内存回收

2024-08-09

Go语言的内存回收主要是通过垃圾回收器（GC）实现的。Go的GC能够自动识别不再使用的内存，并在运行时回收这些内存。

要启用GC，你需要导入runtime包，并调用GC()函数。但在实际应用中，通常不需要手动调用GC()，因为GC会在需要的时候自动运行。

以下是一个简单的例子，展示了如何在Go程序中启用GC：




package main
 
import (
    "fmt"
    "runtime"
)
 
func main() {
    // 启用GC
    runtime.GC()
 
    // 打印GC的统计信息
    printGCStats()
}
 
func printGCStats() {
    // 获取最后一次GC的统计信息
    stats := runtime.MemStats{}
    runtime.ReadMemStats(&stats)
 
    // 打印一些有关最后一次GC的统计信息
    fmt.Printf("Last GC: %v\n", stats.NumGC)
    fmt.Printf("Total Alloc: %v\n", stats.TotalAlloc)
    fmt.Printf("Heap Alloc: %v\n", stats.HeapAlloc)
    fmt.Printf("Heap Sys: %v\n", stats.HeapSys)
}

在这个例子中，runtime.GC()用于显式触发GC。runtime.ReadMemStats()用于获取当前内存的统计信息，并通过printGCStats()函数打印出来。

请注意，手动触发GC通常不建议在生产环境中使用，因为GC在需要时会自动运行，手动触发可能会影响程序的性能。

2024-08-09

在Go语言中，time包提供了时间的处理功能。time.Time类型表示时间。格式化时间的函数是Format，它接收一个参数，即时间布局（layout）字符串，用以指定时间的格式。

以下是一些常用的时间布局字符：

2006 年
01 月（01-12）
02 月（01-29，带有前导零）
03 月（01-31）
04 小时（00-23）
05 分（00-59）
06 秒（00-59）
07 纳秒（000-999）
08 微秒（000000-999999）
09 毫秒（000000-999999）
15 分秒（00-59）
18 小时（03-12）
2006-01-02 15:04:05 标准日期和时间
2006-01-02T15:04:05Z0700 标准日期和时间，RFC3339格式

例如，如果你想要以年-月-日时:分:秒的格式输出当前时间，可以这样做：




package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    t := time.Now()
    fmt.Println(t.Format("2006-01-02 15:04:05"))
}

如果你想要以月/日/年的格式输出时间，可以这样：




package main
 
import (
    "fmt"
    "time"
)
 
func main() {
    t := time.Now()
    fmt.Println(t.Format("01/02/2006"))
}

这些例子展示了如何使用Go语言的time包来格式化时间。