分类 golang 下的文章

2024-08-24

Go语言中常见的IO模型包括：

阻塞IO（Blocking I/O）
非阻塞IO（Non-blocking I/O）
IO多路复用（I/O Multiplexing）
信号驱动IO（Signal-driven I/O）
异步IO（Asynchronous I/O）

其中，IO多路复用是使用最广泛的模型之一，常用的实现有select、poll和epoll。Go语言标准库中的网络编程通常使用net包，它在不同的操作系统上会使用不同的IO多路复用机制。

Go 1.14之后，Go的网络库开始使用netpoll作为IO多路复用的底层实现，它是一个可插拔的多路复用器，可以支持不同的IO多路复用系统调用。

netpoll的使用方法和原生的Go网络库net相似，但在某些边缘场景下，可能会有性能上的提升或者行为上的不同。

以下是使用netpoll和原生net库进行TCP连接的简单示例：




package main
 
import (
    "context"
    "fmt"
    "net"
    "os"
    "golang.org/x/net/netpoll"
)
 
func main() {
    // 使用net标准库
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        fmt.Println("net.Dial error:", err)
        os.Exit(1)
    }
    defer conn.Close()
    fmt.Println("Connected with net stdlib")
 
    // 使用netpoll库
    c, err := netpoll.Dial("tcp", "example.com:80")
    if err != nil {
        fmt.Println("netpoll.Dial error:", err)
        os.Exit(1)
    }
    defer c.Close()
    fmt.Println("Connected with netpoll")
}

在实际应用中，你需要根据具体的需求和环境来选择合适的IO模型和库。对于大多数应用来说，使用标准库的net包就足够了，它会自动根据操作系统来选择最优的IO多路复用机制。只有在特定的测试或者性能要求下，才可能需要直接使用netpoll。

2024-08-24

在Visual Studio Code (VSCode) 中写 Go 语言时，以下是一些常见的问题和解决方案：

Go 单元测试：
- 问题：VSCode 默认不运行单元测试。
- 解决方案：安装并使用 go.test 命令或通过 test 函数运行测试。
goimports 没有自动格式化依赖：
- 问题：VSCode Go 插件默认不使用 goimports 来自动格式化代码。
- 解决方案：安装 goimports：go get -u golang.org/x/tools/cmd/goimports，并在 VSCode 设置中启用 go.useCodeSnippetsOnFunctionSuggest 和 go.formatTool。
接口实现：
- 问题：VSCode 不提供自动生成接口实现的功能。
- 解决方案：使用 gopls 提供的特性，如安装 fillstruct 代码段或使用 godoc -http=:6060 然后在浏览器中查看类型文档。
错误的工作区路径：
- 问题：如果工作区路径设置错误，VSCode 可能无法正确解析依赖。
- 解决方案：确保 GOPATH 和 GOROOT 环境变量正确设置，并在 VSCode 设置中正确配置 go.gopath 和 go.goroot。
代码提示和自动完成问题：
- 问题：VSCode Go 插件可能无法提供代码提示或自动完成。
- 解决方案：确保安装了最新版本的 Go 插件，并检查是否启用了 go.autocompleteUnimportedPackages。
代码导航和符号查找问题：
- 问题：VSCode 可能无法正确导航至定义或查找符号。
- 解决方案：确保安装了 gopls 并在 VSCode 设置中启用它。
代码格式化问题：
- 问题：VSCode 默认格式化可能不满足需求。
- 解决方案：使用 gofmt 或 goimports 进行格式化，并确保在 VSCode 设置中正确配置。
错误的依赖管理：
- 问题：如果依赖管理不当，可能会遇到依赖未正确下载或版本冲突的问题。
- 解决方案：使用 go mod tidy 来清理不需要的依赖，并使用 go get 添加缺失的依赖。

这些是一些常见的使用 VSCode 编写 Go 代码时可能遇到的问题和相应的解决方案。如果你遇到了特定的问题，请提供详细信息，以便获得更具体的帮助。

Go语言的指针（深度解析）

2024-08-24

Go语言中的指针是一个存储变量内存地址的变量。使用指针，可以直接访问和修改变量的值。

声明指针：




var varName *varType

例如：




var ip *int

使用&运算符获取变量的内存地址：




var ip *int
a := 10
ip = &a

使用*运算符获取指针指向的值：




fmt.Println(*ip) // 输出：10

修改指针指向的值：




*ip = 20
fmt.Println(a) // 输出：20

指针作为函数参数：




func change(val *int) {
    *val = 30
}
 
change(ip)
fmt.Println(a) // 输出：30

空指针和nil值：

空指针是指针变量的默认值，表示不指向任何对象。




var test *int
if test == nil {
    fmt.Println("test is nil") // 输出：test is nil
}

指针与结构体：




type Person struct {
    name string
    age  int
}
 
func main() {
    person := Person{"John", 30}
    p := &person
    fmt.Println(p.name) // 输出：John
    fmt.Println((*p).name) // 输出：John
    p.age = 31
    fmt.Println(person.age) // 输出：31
}

数组指针：




arr := [5]int{1, 2, 3, 4, 5}
arrPtr := &arr
for i := 0; i < 5; i++ {
    fmt.Printf("Address of arr[%d] = %p\n", i, &arr[i])
}

切片指针：




s := []int{1, 2, 3, 4, 5}
sPtr := &s
for i := 0; i < len(s); i++ {
    fmt.Printf("Address of s[%d] = %p\n", i, &s[i])
}

方法接收者为指针：




type Person struct {
    name string
    age  int
}
 
func (p Person) say() {
    fmt.Printf("I am %s\n", p.name)
}
 
func (p *Person) change(name string, age int) {
    p.name = name
    p.age = age
}
 
func main() {
    person := Person{"John", 30}
    person.say() // 输出：I am John
    person.change("Doe", 31)
    person.say() // 输出：I am Doe
}

以上是Go语言指针的基本使用方法和示例。

【Go程序】爬虫获取豆瓣Top250

2024-08-24

以下是一个简单的Go语言爬虫示例，用于获取豆瓣电影Top250的电影名称和评分，并将其输出到控制台：




package main
 
import (
    "fmt"
    "log"
    "net/http"
    "os"
    "regexp"
    "strings"
)
 
func main() {
    url := "https://movie.douban.com/top250"
    resp, err := http.Get(url)
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
 
    if resp.StatusCode != 200 {
        log.Fatalf("status code error: %d %s", resp.StatusCode, resp.Status)
    }
 
    content, err := os.ReadFile("top250.html", os.O_RDWR|os.O_CREATE, 0666)
    if err != nil {
        log.Fatal(err)
    }
 
    _, err = content.Write([]byte(resp.Status))
    if err != nil {
        log.Fatal(err)
    }
 
    reg := regexp.MustCompile(`<a href="https://movie.douban.com/subject/[0-9]+/" title="[^"]+">([^<]+)</a>`)
    matches := reg.FindAllStringSubmatch(string(content), -1)
 
    for _, match := range matches {
        fmt.Printf("电影名称: %s\n", match[1])
    }
}

这段代码首先发送一个HTTP GET请求到豆瓣Top250的页面，然后读取响应内容，并使用正则表达式匹配电影名称。最后，它打印出所有匹配到的电影名称。

注意：实际应用中，可能需要处理更多的页面结构变化和反爬虫策略。此外，为了更好地处理复杂的HTML结构，可以使用像goquery这样的库来解析HTML文档。

2024-08-24




package main
 
import (
    "net/http"
    "github.com/gin-gonic/gin"
    "github.com/sirupsen/logrus"
    "log"
    "os"
    "time"
)
 
func main() {
    // 日志配置
    logFilePath := "./myapp.log"
    logFile, err := os.OpenFile(logFilePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        log.Fatalf("open log file error:%v", err)
    }
    defer logFile.Close()
 
    // 日志写入配置
    logger := logrus.New()
    logger.Out = logFile
    logger.SetLevel(logrus.DebugLevel)
    logger.SetFormatter(&logrus.JSONFormatter{})
 
    // 使用自定义的日志记录器
    gin.DefaultWriter = logger.Out
 
    // 路由配置
    router := gin.Default()
    router.GET("/", func(c *gin.Context) {
        logger.WithFields(logrus.Fields{
            "animal": "dog",
            "size":    "small",
        }).Info("A new log entry")
        c.String(http.StatusOK, "Hello, World!")
    })
 
    router.Run(":8080")
}

这段代码首先配置了日志文件的路径和权限，并创建了日志文件。然后，使用logrus库创建了一个日志记录器，并设置了日志的写入目标、日志级别和格式化方式。接着，将Gin框架的默认日志输出改为我们自定义的日志记录器。最后，配置了一个简单的HTTP GET路由，并在路由处理函数中使用自定义的日志记录器记录一条日志，并响应客户端请求。

Golang硬件控制：将软件力量扩展到物理世界_go 单片机

2024-08-24




package main
 
import (
    "machine"
)
 
func main() {
    // 初始化LED为输出模式
    machine.LED.Configure(machine.PinConfig{Mode: machine.PinOutput})
 
    // 循环开启和关闭LED
    for {
        machine.LED.Low()  // 开启LED（低电平）
        machine.LED.Notify(machine.PinEventFallingEdge, func() {
            machine.LED.High() // 关闭LED（高电平）
        })
    }
}

这段代码使用了Go语言和TinyGo编译器来控制单片机上的LED灯。首先导入了machine包，然后在主函数中配置LED引脚为输出模式。在无限循环中，程序会周期性地开启和关闭LED，通过改变引脚电平来实现。这个例子展示了如何将单片机作为硬件设备进行控制，并且如何使用Go语言进行开发。

[Go]配置国内镜像源

2024-08-24

在Go语言中，配置中国大陆地区的官方镜像源可以通过以下步骤完成：

打开命令行工具。
执行以下命令来设置Go模块代理。




go env -w GOPROXY=https://goproxy.cn,direct

这条命令会设置GOPROXY环境变量，使得Go模块系统使用goproxy.cn作为代理，direct表示直接访问其他模块代理或VCS服务器。

如果你想要将这个设置永久保存，可以将上述命令写入到你的shell配置文件中，例如.bashrc、.zshrc或.profile等，根据你使用的shell而定。

例如，在bash shell中，你可以将以下内容添加到~/.bashrc或~/.bash_profile：




echo "export GOPROXY=https://goproxy.cn,direct" >> ~/.bashrc
source ~/.bashrc

这样设置后，每次你使用Go命令行工具时，都会自动使用配置好的代理。

go Channel原理

2024-08-24

在Go语言中，channel是一种内置的数据结构类型，可以用于安全地进行并发编程。它主要用于goroutine之间的通信。

在Go语言中，创建channel的语法是：




c := make(chan int)

这里创建了一个int类型的channel。

接下来，我们可以使用以下两种方式向channel发送数据：

使用channel <-语法发送数据。例如，我们可以将数据1发送到上面创建的channel中：




c <- 1

使用select语句发送数据。select语句可以用于等待多个channel操作。例如，我们可以等待上面创建的channel可以接收数据：




select {
case c <- 1:
    fmt.Println("successfully sent data")
default:
    fmt.Println("cannot send data")
}

然后，我们可以使用以下两种方式从channel接收数据：

使用<-channel语法接收数据。例如，我们可以从上面创建的channel中接收数据：




data := <-c
fmt.Println(data)

使用select语句接收数据。例如，我们可以等待从上面创建的channel接收数据：




select {
case data := <-c:
    fmt.Println(data)
default:
    fmt.Println("cannot receive data")
}

最后，我们可以使用close函数关闭channel。例如，我们可以关闭上面创建的channel：




close(c)

需要注意的是，一旦关闭了channel，就不能再向它发送数据了，但仍然可以从中接收数据，直到channel中所有的数据都被接收。

以上就是Go语言中channel的基本使用方法。

2024-08-24

首先，我们需要了解一下什么是GoPass系列免杀工具。GoPass系列是一款针对Go语言编写的，用于绕过安全软件检测的免杀工具。这个系列包含了多个免杀工具，每个工具都针对不同的检测机制和技术。

关于Go语言免杀，我们可以采取以下几种策略：

改变二进制文件的字节码：对Go编译生成的二进制文件进行字节码修改，使其绕过检测。
使用反调试技术：在程序运行时检测调试器的存在，如果检测到调试器，则退出程序。
加密混淆代码：使用工具对Go代码进行混淆加密，增加逆向分析的难度。
使用加壳技术：为Go程序添加一个外壳，来绕过安全软件的检测。

以下是一个简单的Go语言代码示例，用于演示如何检测调试器的存在并退出程序：




package main
 
import (
    "os"
    "syscall"
)
 
func isDebuggerPresent() bool {
    var isDebuggerPresent bool
    modkernel32 := syscall.NewLazyDLL("kernel32.dll")
    procIsDebuggerPresent := modkernel32.NewProc("IsDebuggerPresent")
    procIsDebuggerPresent.Call(uintptr(unsafe.Pointer(&isDebuggerPresent)))
    return isDebuggerPresent
}
 
func main() {
    if isDebuggerPresent() {
        os.Exit(1)
    }
    // 正常的程序逻辑
}

这段代码首先定义了isDebuggerPresent函数，它通过加载kernel32.dll中的IsDebuggerPresent函数来检测调试器。如果检测到调试器，程序就会调用os.Exit(1)退出。这是一个简单的防止反编译和调试的例子，实际的免杀工具可能会更加复杂。

请注意，上述代码只是一个简单的示例，实际的GoPass系列免杀工具会更加复杂和先进，并且会不断更新以应对最新的安全检测技术。

Go最全Golang中的闭包详解_golang闭包，保洁阿姨看完都会了

2024-08-24

在Golang中，闭包是一个函数和与其相关的引用环境的组合。换句话说，闭包可以访问在其函数外部定义的变量。

闭包的一个常见用途是创建内部函数，即在函数内部定义的函数。这些内部函数可以访问外部函数的变量，即使外部函数已经返回。

以下是一个简单的Golang闭包示例：




package main
 
import "fmt"
 
func main() {
    getSqure := getSqureMaker()
    fmt.Println(getSqure(3)) // 输出：9
}
 
func getSqureMaker() func(int) int {
    var number int
    return func(squareNum int) int {
        number = squareNum
        return number * number
    }
}

在这个例子中，getSqureMaker 是一个外部函数，它返回一个闭包。这个闭包是一个内部函数，它可以访问外部函数的变量 number。

闭包的另一个用途是创建工厂函数，这些函数可以基于其环境创建特定功能的函数。

以下是一个使用Golang闭包创建计算器的例子：




package main
 
import "fmt"
 
func main() {
    add := adderMaker()
    fmt.Println(add(10)) // 输出：10
    fmt.Println(add(20)) // 输出：30
    fmt.Println(add(30)) // 输出：60
}
 
func adderMaker() func(int) int {
    var total int
    return func(value int) int {
        total += value
        return total
    }
}

在这个例子中，adderMaker 是一个返回闭包的工厂函数。每次调用 adderMaker 时，它都会创建一个新的闭包实例，该实例会记住上次调用的 total 值。

以上就是Golang中的闭包，它是Golang的一个强大特性，可以用来创建可重用的函数和封装复杂的状态管理。