分类 golang 下的文章

2024-08-27

crypto.internal/subtle 包是Go语言标准库中的一个内部包，它提供了一些低级的、非导出的加密原语，这些原语不保证向后兼容，并且不应该直接被外部代码所使用。

这个包中的函数主要用于比较两个字节切片是否相等，或者用于计算字节切片的哈希值，它们对性能要求很高，因此不做边界检查，不进行长度的比较，也不分配额外的内存。

以下是一些主要函数的简单介绍：

ConstantTimeByteEq：比较两个字节是否相等，如果相等返回1，否则返回0。这个函数在两个字节之间没有数据依赖性，可以被优化去除分支。
ConstantTimeCompare：比较两个字节切片是否相等，如果相等返回1，否则返回0。
ConstantTimeCopy：从src到dst中复制数据，如果len(src) >= length，那么复制length个字节。
ConstantTimeEq：比较两个整数值是否相等，如果相等返回1，否则返回0。
ConstantTimeLessOrEq：比较两个整数是否小于等于，如果是返回1，否则返回0。
XorConstantTime：用于计算两个字节切片的XOR值。

由于这些函数是非导出的，所以你不能直接调用它们。这个包的目的主要是为了Go语言内部的加密库提供基础支持，一般情况下不推荐直接使用。

以下是一个使用subtle包中函数的简单示例：




package main
 
import (
    "crypto/rand"
    "crypto/subtle"
    "fmt"
)
 
func main() {
    // 假设我们有两个字节切片需要比较
    slice1 := []byte{0x01, 0x02, 0x03}
    slice2 := []byte{0x01, 0x02, 0x03}
 
    // 使用ConstantTimeCompare来比较它们
    result := subtle.ConstantTimeCompare(slice1, slice2)
    fmt.Printf("Comparison result: %d\n", result)
 
    // 使用XorConstantTime来计算两个字节切片的XOR值
    xorResult := subtle.XorConstantTime(slice1, slice2)
    fmt.Printf("XOR result: %x\n", xorResult)
 
    // 生成一个随机的字节切片
    randomBytes := make([]byte, 10)
    rand.Read(randomBytes)
 
    // 使用ConstantTimeCopy来复制一部分随机字节到目标切片
    dest := make([]byte, 5)
    subtle.ConstantTimeCopy(1, randomBytes, dest)
    fmt.Printf("Copied bytes: %x\n", dest)
}

这个示例展示了如何使用subtle包中的函数，但是请注意，这些函数主要用于加密库内部，一般情况下不推荐直接使用。

Golang 结构体

2024-08-27

在Golang中，结构体是用户定义的数据类型，它可以包含不同类型的变量。结构体的定义以关键字"struct"开始，并且可以包含零个或多个字段。每个字段都有一个名称和一个类型。

以下是一些创建和使用Golang结构体的方法：

定义并初始化结构体：




type Employee struct {
    name string
    age  int
}
 
func main() {
    emp1 := Employee{"John", 30}
    fmt.Println(emp1)
}

使用new关键字创建结构体实例：




type Employee struct {
    name string
    age  int
}
 
func main() {
    emp1 := new(Employee)
    emp1.name = "John"
    emp1.age = 30
    fmt.Println(*emp1)
}

使用结构体指针接收函数返回的结构体：




type Employee struct {
    name string
    age  int
}
 
func getEmployee() *Employee {
    return &Employee{"John", 30}
}
 
func main() {
    emp1 := getEmployee()
    fmt.Println(*emp1)
}

使用结构体作为字段创建新的结构体：




type Employee struct {
    name string
    age  int
}
 
type Department struct {
    name     string
    employee Employee
}
 
func main() {
    dept := Department{"HR", Employee{"John", 30}}
    fmt.Println(dept)
}

使用标签选项控制结构体的JSON编码和解码：




type Employee struct {
    name string `json:"name"`
    age  int    `json:"age"`
}
 
func main() {
    emp1 := Employee{"John", 30}
    empBytes, _ := json.Marshal(emp1)
    fmt.Println(string(empBytes))
}

使用匿名字段创建嵌入结构体：




type Employee struct {
    name string
    age  int
}
 
type Manager struct {
    Employee
    department string
}
 
func main() {
    manager := Manager{Employee{"John", 30}, "IT"}
    fmt.Println(manager)
}

使用for-range遍历结构体的字段：




type Employee struct {
    name string
    age  int
}
 
func (e Employee) getDetails() {
    fmt.Printf("Name: %s, Age: %d\n", e.name, e.age)
}
 
func main() {
    emp1 := Employee{"John", 30}
    emp1.getDetails()
}

使用switch对结构体的字段进行比较：




type Employee struct {
    name string
    age  int
}
 
func (e Employee) getCategory() string {
    switch {
    case e.age < 30:
        return "Young"
    case e.age < 60:
        return "Midlife"
    default:
        return "Senior"
    }
}
 
func main() {
    emp1 := Employee{"John", 30}
    fmt.Println(emp1.getCategory())
}

以上是创建和使用Golang结构体的一些常见方法。每种方法都有其特定的用途，可以根据实际需求选择合适的方法来使用结构体。

Golang os.exec 包详解

2024-08-27

os/exec 包提供了一种简单的方式来运行外部命令。这个包可以用来执行外部命令，并与之交互（例如，通过管道连接输入和输出）。

以下是使用 os/exec 包的一些常见方法：

使用 exec.Command 方法运行一个外部命令：




cmd := exec.Command("echo", "Hello, World!")
output, err := cmd.CombinedOutput()
if err != nil {
    log.Fatalf("cmd.Run() failed with %s\n", err)
}
 
fmt.Printf("Combined output: %s\n", output)

使用 cmd.Run() 方法运行命令，并获取输出：




cmd := exec.Command("echo", "Hello, World!")
err := cmd.Run()
if err != nil {
    log.Fatalf("cmd.Run() failed with %s\n", err)
}
 
fmt.Printf("Output: %s\n", cmd.Stdout)

使用 cmd.Start() 和 cmd.Wait() 方法运行命令，并获取输出：




cmd := exec.Command("echo", "Hello, World!")
err := cmd.Start()
if err != nil {
    log.Fatalf("cmd.Start() failed with '%s'\n", err)
}
 
err = cmd.Wait()
if err != nil {
    log.Fatalf("cmd.Wait() failed with '%s'\n", err)
}
 
fmt.Printf("Output: %s\n", cmd.Stdout)

使用 cmd.Output() 方法运行命令，并获取输出：




output, err := exec.Command("echo", "Hello, World!").Output()
if err != nil {
    log.Fatalf("cmd.Output() failed with %s\n", err)
}
 
fmt.Printf("Output: %s\n", output)

使用 cmd.Stdin, cmd.Stdout, 和 cmd.Stderr 方法来重定向输入输出：




cmd := exec.Command("grep", "hello")
cmd.Stdin = strings.NewReader("hello world\ngo hello")
var out bytes.Buffer
cmd.Stdout = &out
cmd.Run()
 
fmt.Printf("Output: %s\n", out.String())

使用 cmd.Dir 方法来改变命令运行的目录：




cmd := exec.Command("pwd")
cmd.Dir = "/home"
output, err := cmd.CombinedOutput()
if err != nil {
    log.Fatalf("cmd.Run() failed with %s\n", err)
}
 
fmt.Printf("Output: %s\n", output)

使用 cmd.Env 方法来改变命令运行的环境变量：




cmd := exec.Command("echo", "$GOPATH")
cmd.Env = append(os.Environ(), "GOPATH=/home/go")
output, err := cmd.CombinedOutput()
if err != nil {
    log.Fatalf("cmd.Run() failed with %s\n", err)
}
 
fmt.Printf("Output: %s\n", output)

以上代码片段展示了如何使用 os/exec 包的不同方法来运行外部命令，并获取输出。每个方法都有其适用的场景，开发者可以根据需要选择合适的方法。

Golang defer 和追踪

2024-08-27

在Golang中，defer 关键字用于延迟函数的执行。这个特性常常被用于资源清理、错误处理或者追踪某些操作的执行情况。

如果你想要使用 defer 和追踪来追踪某个操作的执行情况，你可以创建一个变量用于追踪操作的执行次数，并在每次操作执行时递增这个变量。

以下是一个简单的例子，展示了如何使用 defer 和追踪操作执行情况：




package main
 
import "fmt"
 
func main() {
    // 追踪变量
    var operationCount int
 
    // 注册一个函数在当前函数退出时执行
    defer func() {
        fmt.Printf("操作执行了 %d 次\n", operationCount)
    }()
 
    // 模拟操作
    for i := 0; i < 5; i++ {
        // 执行操作
        operation(i)
    }
}
 
// 一个模拟的操作函数
func operation(i int) {
    // 追踪操作执行次数
    operationCount++
    fmt.Println("执行操作:", i)
}

在这个例子中，operationCount 变量用于追踪 operation 函数被调用的次数。defer 关键字确保了在 main 函数退出前打印出操作执行次数。每次调用 operation 函数时，operationCount 都会递增，这样就可以追踪操作的执行情况。

Golang 糟糕的错误处理

2024-08-27

在Go语言中，错误处理是一个重要的部分，因为Go语言的设计哲学中强调简单和可靠的错误处理。然而，在实践中，很多Go开发者在错误处理上可能没有做到位，这可能导致一些不佳的实践。

以下是一些常见的不佳错误处理实践：

忽略错误：




file, err := os.Open("filename.ext")
if err != nil {
    // 错误被忽略了
}

在上述代码中，如果发生了错误，我们没有任何处理措施，错误被忽略了。

简单的错误打印：




file, err := os.Open("filename.ext")
if err != nil {
    fmt.Println(err)
}

虽然我们做了错误处理，但只是简单地打印错误信息，这对调试问题没有太大帮助。

使用panic：




file, err := os.Open("filename.ext")
if err != nil {
    panic(err)
}

虽然panic可以在错误严重的情况下中断程序，但它不适合错误处理，因为它会导致程序崩溃并且不会进行清理操作。

错误处理不一致：




file, err := os.Open("filename.ext")
if err != nil {
    // 错误处理
}
 
if err := file.Close(); err != nil {
    // 不一致的错误处理
}

在上述代码中，我们对os.Open函数返回的错误进行了处理，但对file.Close()的错误处理却不一致。

为了避免上述的不佳实践，我们应该：

对所有的错误进行检查，并做出适当的响应。
记录错误信息，以便进行调试和监控。
使用多值返回来处理错误，这样可以保证错误处理的一致性。
使用defer语句确保文件和其他资源在错误发生时能够正确关闭。

示例代码：




func openFile(filename string) (*os.File, error) {
    file, err := os.Open(filename)
    if err != nil {
        return nil, fmt.Errorf("error opening file: %w", err)
    }
    return file, nil
}
 
func processFile(filename string) {
    file, err := openFile(filename)
    if err != nil {
        log.Printf("error: %v\n", err)
        return
    }
    defer file.Close()
 
    // 文件处理逻辑
}

在上述代码中，我们首先定义了一个openFile函数，它尝试打开文件，并在遇到错误时返回错误。在processFile函数中，我们调用openFile，并且对可能发生的错误进行处理。我们使用log.Printf记录错误信息，并且使用defer确保文件在函数结束时关闭。这样的错误处理方式遵循了Go语言的最佳实践。

Golang 发生错误时使用defer关闭一个文件

2024-08-27

在Golang中，如果你在打开文件后使用defer关键字来关闭文件，这是一种常见的做法，可以确保文件在程序执行完毕后正确关闭。但是，如果在打开文件的过程中发生错误，你不应该尝试关闭一个未打开的文件。因此，你应该先检查文件是否成功打开，然后才使用defer来关闭文件。

以下是一个简单的示例代码：




package main
 
import (
    "os"
    "fmt"
)
 
func main() {
    file, err := os.Open("example.txt")
    if err != nil {
        // 如果打开文件失败，直接返回错误
        fmt.Println("Error opening file:", err)
        return
    }
    // 如果文件成功打开，使用defer来关闭文件
    defer file.Close()
 
    // 在这里进行文件读写操作
}

在这个例子中，我们首先尝试打开文件，如果失败，则打印错误并返回，不再执行任何操作。如果成功打开文件，则通过defer关键字注册文件在函数退出时自动关闭，这样可以保证不会遗留打开的文件句柄，也避免了在发生错误时尝试关闭一个未打开的文件。

Golang encoding.xml 包详解

2024-08-27

encoding/xml 包在 Go 语言中用于处理 XML 数据。这个包提供了编码和解码 XML 的功能。

解码 XML

解码 XML 是将 XML 数据转换为 Go 中的数据结构（如：map，struct）的过程。这可以通过 Unmarshal 函数实现。




package main
 
import (
    "encoding/xml"
    "fmt"
    "log"
)
 
type Person struct {
    XMLName xml.Name `xml:"person"`
    Id      string   `xml:"id,attr"`
    Name    string   `xml:"name"`
    Age     string   `xml:"age"`
}
 
func main() {
    xmlData := `
        <person Id="123">
            <name>John</name>
            <age>25</age>
        </person>
    `
    var result Person
    err := xml.Unmarshal([]byte(xmlData), &result)
    if err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%+v\n", result)
}

编码 XML

编码 XML 是将 Go 中的数据结构（如：map，struct）转换为 XML 数据的过程。这可以通过 Marshal 函数实现。




package main
 
import (
    "encoding/xml"
    "fmt"
    "log"
)
 
type Person struct {
    XMLName xml.Name `xml:"person"`
    Id      string   `xml:"id,attr"`
    Name    string   `xml:"name"`
    Age     string   `xml:"age"`
}
 
func main() {
    person := Person{
        XMLName: xml.Name{
            Space: "",
            Local: "person",
        },
        Id:   "123",
        Name: "John",
        Age:  "25",
    }
    output, err := xml.MarshalIndent(person, "  ", "    ")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(string(output))
}

创建新的 XML 标签

NewName 函数可以用于创建一个新的 XML 名称。




package main
 
import (
    "encoding/xml"
    "fmt"
)
 
func main() {
    name := xml.Name{Space: "someSpace", Local: "someLocalName"}
    fmt.Printf("%v\n", name)
}

创建新的 XML 属性

NewAttr 函数可以用于创建一个新的 XML 属性。




package main
 
import (
    "encoding/xml"
    "fmt"
)
 
func main() {
    attr := xml.Attr{Name: xml.Name{Local: "someAttr"}, Value: "someValue"}
    fmt.Printf("%v\n", attr)
}

以上就是 encoding/xml 包的基本使用方法。这个包提供了对 XML 的强大支持，使得在 Go 语言中处理 XML 数据变得非常简单和直观。

Golang expvar 包详解

2024-08-27

expvar 包在 Go 语言中用于导出变量，允许通过 HTTP 服务这些变量的值。这对于监控和调试应用程序非常有用。

expvar 包提供了一个机制，通过这个机制，可以将 Go 程序中的变量发布到 HTTP 服务上，以便用户可以通过 Web 浏览器或其他工具查看这些变量的值。

以下是使用 expvar 包的一些示例：

导出一个简单的变量：




package main
 
import (
    "expvar"
    "fmt"
    "log"
    "net/http"
)
 
func main() {
    counter := expvar.NewInt("counter")
 
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        counter.Add(1)
        fmt.Fprintf(w, "Hello, you've requested this %d times\n", counter.Value())
    })
 
    go http.ListenAndServe(":8080", nil)
 
    log.Fatal(http.ListenAndServe(":8081", nil))
}

在上面的代码中，我们创建了一个名为 counter 的 expvar.Int 类型的变量，并将其初始值设置为 0。然后，我们通过 / 路径将其绑定到 HTTP 服务上。每当有请求发送到根路径时，counter 的值就会增加 1。

导出一个更复杂的变量：




package main
 
import (
    "expvar"
    "log"
    "net/http"
    "sync"
)
 
func main() {
    http.Handle("/vars", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json; charset=utf-8")
        var mu sync.RWMutex
        mu.RLock()
        firstRequest := expvar.Do(func(kv expvar.KeyValue) {
            _, _ = w.Write([]byte(`"` + kv.Key + `":`))
            _ = kv.Value.Write(w)
            _, _ = w.Write([]byte(","))
        })
        mu.RUnlock()
        w.Write([]byte(`{"time":"` + time.Now().Format(time.RFC3339) + `"}`))
        if firstRequest {
            w.Write([]byte(" -- first request"))
        }
    }))
 
    log.Fatal(http.ListenAndServe(":8080", nil))
}

在上面的代码中，我们使用 expvar.Do 函数遍历所有已发布的变量，并将它们以 JSON 格式输出到 HTTP 响应中。此外，我们还添加了一个自定义变量 time，它包含当前的请求时间。

注意：在实际的生产环境中，你应该使用更安全的方式来处理 HTTP 响应写入，并且应该考虑到并发访问导致的竞态条件等问题。

Golang text.scanner 包详解

2024-08-27

text.Scanner 包是 Go 语言标准库中的一部分，它提供了一个简单的文本扫描器，可以用来扫描任何文本输入。以下是如何使用 text.Scanner 的一些基本示例。

导入 text.Scanner 包

在 Go 程序中，你需要先导入 text.Scanner 包，以便使用它提供的功能。




import (
    "text/scanner"
)

创建一个新的 Scanner

你可以通过传入一个 io.Reader 来创建一个新的 text.Scanner 实例。




var s scanner.Scanner
s.Init(os.Stdin)

基本的扫描操作

Scanner 提供了几个方法来处理文本，如 Scan、Text、Pos 等。

Scan 方法用于扫描下一个标记，返回 true 如果成功，false 如果到达输入的末尾。
Text 方法返回当前标记的文本。
Pos 方法返回当前标记的位置。




for s.Scan() {
    // 处理标记
    fmt.Println(s.Text())
}
 
// 扫描结束后，可能会有错误
if err := s.Err(); err != nil {
    fmt.Fprintln(os.Stderr, "reading input:", err)
}

自定义分隔符

默认情况下，Scanner 使用空格、制表符、换行等作为分隔符，但你可以通过 Whitespace 和 Split 方法来自定义分隔符。




s.Whitespace = 1<<'\t' // 制表符是分隔符
s.Split(bufio.ScanWords) // 按单词分割

完整示例

以下是一个完整的示例，它定义了一个 Scanner，扫描输入中的单词，并将它们转换为大写。




package main
 
import (
    "fmt"
    "os"
    "text/scanner"
)
 
func main() {
    var s scanner.Scanner
    s.Init(os.Stdin)
    s.Whitespace = 1<<' ' | 1<<'\t' | 1<<'\n' // 空格、制表符、换行是分隔符
    s.Split(bufio.ScanWords)                 // 按单词分割
 
    for s.Scan() {
        fmt.Println(s.Text()) // 输出当前单词
    }
 
    if err := s.Err(); err != nil {
        fmt.Fprintln(os.Stderr, "reading input:", err)
    }
}

这个示例程序首先初始化一个 Scanner，然后设置分隔符，接着扫描输入的文本，将每个单词输出到控制台，并在扫描结束后检查并输出可能发生的错误。

Golang regexp 包

2024-08-27

regexp包在Go语言中提供了正则表达式的处理功能。以下是一些使用regexp包的常见示例：

匹配字符串：




package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
    fmt.Println(match)
}

在这个例子中，regexp.MatchString函数用于检查字符串"peach"是否匹配正则表达式"p([a-z]+)ch"。如果匹配，match将为true。

用于查找和替换字符串：




package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    re, _ := regexp.Compile("p([a-z]+)ch")
    fmt.Println(re.ReplaceAllString("peach punch", "[$`$1`$']"))
}

在这个例子中，regexp.Compile函数用于编译正则表达式，ReplaceAllString方法用于在整个字符串中查找匹配正则表达式的部分，并用指定的字符串进行替换。

获取匹配的子字符串：




package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    re, _ := regexp.Compile("p([a-z]+)ch")
    s := "peach punch"
    fmt.Println(re.FindStringSubmatch(s)) // 输出: [peach p]
}

在这个例子中，regexp.Compile函数用于编译正则表达式，FindStringSubmatch方法用于查找第一个匹配的子字符串，并返回一个字符串切片，其中包含完全匹配的文本以及按括号分隔的子匹配项。

获取所有匹配的子字符串：




package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    re, _ := regexp.Compile("p([a-z]+)ch")
    s := "peach punch"
    fmt.Println(re.FindAllStringSubmatch(s, -1)) // 输出: [[peach p] [unch p]]
}

在这个例子中，regexp.Compile函数用于编译正则表达式，FindAllStringSubmatch方法用于查找所有匹配的子字符串，并返回一个字符串切片，其中包含每一个匹配的文本以及按括号分隔的子匹配项。

获取匹配的位置：




package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    re, _ := regexp.Compile("p([a-z]+)ch")
    s := "peach punch"
    fmt.Println(re.FindStringIndex(s)) // 输出: [0 5]
}

在这个例子中，regexp.Compile函数用于编译正则表达式，FindStringIndex方法用于查找第一个匹配的位置，并返回一个两元素的整数切片，其中包含匹配的开始和结束位置。

获取所有匹配的位置：




package main
 
import (
    "fmt"
    "regexp"
)
 
func main() {
    re, _ := regexp.Compile("p([a-z]+)ch")
    s := "peach punch"
    fmt.Println(re.FindAllIndexString(s, -1