2024-08-15



package main
 
import (
    "fmt"
)
 
func main() {
    // 声明变量
    var a int = 10
    var b bool = true
    var c string = "Hello, World!"
    var d float64 = 3.14159
 
    // 打印变量
    fmt.Printf("a: %v\n", a)
    fmt.Printf("b: %v\n", b)
    fmt.Printf("c: %v\n", c)
    fmt.Printf("d: %v\n", d)
 
    // 使用 := 快速声明并初始化变量
    e := 20
    f := true
    g := "Hello, Go!"
    h := 2.71828
 
    // 打印变量
    fmt.Printf("e: %v\n", e)
    fmt.Printf("f: %v\n", f)
    fmt.Printf("g: %v\n", g)
    fmt.Printf("h: %v\n", h)
}

这段代码首先使用传统的方式声明并初始化了四个不同类型的变量,然后使用Go语言的简短声明方式进行了相同的操作。代码展示了如何声明变量并打印它们的值,这是学习Go语言中基础语法的一个很好的起点。

2024-08-15

GoRequests 是一个第三方的 Go 语言 HTTP 库,它提供了一种简洁的方式来发送 HTTP 请求。

安装 GoRequests:




go get -u github.com/imroc/req

基本使用示例:




package main
 
import (
    "fmt"
    "github.com/imroc/req"
)
 
func main() {
    // 发送 GET 请求
    resp, err := req.Get("http://httpbin.org/get")
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.String())
 
    // 发送 POST 请求
    resp, err = req.Post("http://httpbin.org/post", req.BodyJSON(&map[string]string{"key": "value"}))
    if err != nil {
        panic(err)
    }
    fmt.Println(resp.String())
}

这段代码首先导入了 req 包,然后在 main 函数中发送了一个 GET 和一个 POST 请求。它演示了如何使用 GoRequests 发送请求并处理可能出现的错误。通过 resp.String() 方法,我们可以获取响应的字符串形式。

2024-08-15



package main
 
import (
    "context"
    "fmt"
    "log"
    "math/big"
 
    "github.com/ethereum/go-ethereum/accounts/abi/bind"
    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/ethclient"
)
 
func main() {
    client, err := ethclient.Dial("https://mainnet.infura.io/v3/YOUR_INFURA_PROJECT_ID")
    if err != nil {
        log.Fatal(err)
    }
 
    privateKey, err := crypto.HexToECDSA("YOUR_PRIVATE_KEY")
    if err != nil {
        log.Fatal(err)
    }
 
    auth := bind.NewKeyedTransactor(privateKey)
    auth.GasLimit = uint64(300000) // in units of gas
 
    tokenAddress := common.HexToAddress("0xTokenContractAddress")
    tokenInstance, err := NewToken(tokenAddress, client)
    if err != nil {
        log.Fatal(err)
    }
 
    // 获取代币余额
    balance, err := tokenInstance.BalanceOf(&bind.CallOpts{}, common.HexToAddress("0xYourAddress"))
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Your token balance is", balance)
 
    // 转账
    toAddress := common.HexToAddress("0xRecipientAddress")
    amount := big.NewInt(100) // 以单位代币转账,例如以太币为wei,代币为单位
    tx := tokenInstance.Transfer(auth, toAddress, amount)
    fmt.Println("Tx sent:", tx.Hash().Hex())
 
    // 等待交易被确认
    receipt, err := client.TransactionReceipt(context.Background(), tx.Hash())
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println("Receipt:", receipt)
}

在这个代码实例中,我们首先通过Infura连接以太坊网络,然后使用提供的私钥创建一个Transactor用于签署交易。接着,我们实例化代币合约,并通过BalanceOf方法获取代币余额。之后,我们调用Transfer方法来转账,并等待交易被确认。这个过程展示了如何与以太坊区块链上的智能合约交互,是开发Web3钱包的基础。

2024-08-15



package main
 
import (
    "fmt"
    "sync"
)
 
// 假设的任务接口
type Task interface {
    Run() error
}
 
// 任务执行器
func ExecuteTasks(tasks []Task) {
    var wg sync.WaitGroup
    wg.Add(len(tasks))
 
    for _, task := range tasks {
        go func(t Task) {
            defer wg.Done()
            if err := t.Run(); err != nil {
                fmt.Printf("Task failed with error: %v\n", err)
            }
        }(task)
    }
 
    wg.Wait()
}
 
// 示例任务
type SampleTask struct {
    id   int
    name string
}
 
func (t *SampleTask) Run() error {
    fmt.Printf("Task %d: %s is running.\n", t.id, t.name)
    // 模拟任务执行
    // time.Sleep(time.Second)
    return nil
}
 
func main() {
    tasks := []Task{
        &SampleTask{id: 1, name: "Task 1"},
        &SampleTask{id: 2, name: "Task 2"},
        &SampleTask{id: 3, name: "Task 3"},
    }
 
    ExecuteTasks(tasks)
}

这个代码示例展示了如何在Go语言中使用sync.WaitGroup来实现并发地执行一组任务。每个任务实现了Task接口的Run方法,并在ExecuteTasks函数中并发执行。这样可以充分利用多核处理器的优势,提高任务执行的并发度和系统的吞吐量。

2024-08-15



#!/bin/bash
 
# 更新系统包索引
sudo apt update
 
# 安装Go语言编译器
sudo apt install -y golang-go
 
# 检查Go版本
go version
 
# 设置GOPATH环境变量(根据实际情况修改)
export GOPATH="$HOME/go"
 
# 将Go的bin目录添加到PATH环境变量中
export PATH="$PATH:$GOPATH/bin"
 
# 下载Gin框架
go get -u github.com/gin-gonic/gin
 
# 检查Gin是否安装成功
gin --version

这段代码提供了在Ubuntu或Debian系统上快速搭建Go语言开发环境以及安装Gin Web框架的步骤。代码中使用了apt包管理器来安装Go,并通过go get命令获取Gin框架。在脚本的最后,它还检查了Go和Gin的版本,以确保安装无误。这是一个简洁且有效的脚本,适合作为零基础学习者的教学示例。

2024-08-15

在Go语言中,可以使用crypto/rsa标准库来生成RSA公钥和私钥。以下是生成RSA密钥对的示例代码:




package main
 
import (
    "crypto/rand"
    "crypto/rsa"
    "crypto/x509"
    "encoding/pem"
    "log"
    "os"
)
 
func main() {
    // 生成RSA私钥
    privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
    if err != nil {
        log.Fatalf("生成RSA私钥失败: %v", err)
    }
 
    // 编码为PEM格式
    privateKeyPEM := &pem.Block{
        Type:  "RSA PRIVATE KEY",
        Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
    }
 
    // 写入私钥文件
    privateFile, err := os.Create("private.pem")
    if err != nil {
        log.Fatalf("创建私钥文件失败: %v", err)
    }
    defer privateFile.Close()
    err = pem.Encode(privateFile, privateKeyPEM)
    if err != nil {
        log.Fatalf("写入私钥失败: %v", err)
    }
 
    // 生成公钥
    publicKey := &privateKey.PublicKey
    publicKeyPEM := &pem.Block{
        Type:  "PUBLIC KEY",
        Bytes: x509.MarshalPKCS1PublicKey(publicKey),
    }
 
    // 写入公钥文件
    publicFile, err := os.Create("public.pem")
    if err != nil {
        log.Fatalf("创建公钥文件失败: %v", err)
    }
    defer publicFile.Close()
    err = pem.Encode(publicFile, publicKeyPEM)
    if err != nil {
        log.Fatalf("写入公钥失败: %v", err)
    }
}

这段代码首先使用rsa.GenerateKey函数生成一个2048位的RSA私钥。然后,它将私钥编码为PEM格式并保存到文件中。接着,它从私钥中提取公钥,将公钥编码为PEM格式,并保存到另一个文件中。

2024-08-15



package main
 
import (
    "fmt"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/facebody"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests"
)
 
func main() {
    // 创建一个阿里云人脸识别客户端实例
    client, err := facebody.NewClientWithAccessKey("regionId", "yourAccessKeyId", "yourAccessKeySecret")
    if err != nil {
        panic(err)
    }
 
    // 创建一个请求并设置参数
    request := requests.NewCommonRequest()
    request.Method = "POST"
    request.Domain = "facebody.aliyuncs.com"
    request.Version = "2019-12-30"
    request.ApiName = "DetectFace"
    request.QueryParams["RegionId"] = "regionId"
 
    // 设置请求的表单数据
    request.PostForm = map[string]interface{}{
        "ImageURL": "imageUrl",
    }
 
    // 发送请求并获取响应
    response, err := client.ProcessCommonRequest(request)
    if err != nil {
        panic(err)
    }
 
    // 打印响应的主体内容
    fmt.Println(response.GetHttpContentString())
}

这个代码示例展示了如何在Go语言中使用阿里云SDK来调用人脸识别服务的接口。首先,我们创建了一个facebody.NewClientWithAccessKey的客户端实例,然后构建了一个请求并设置了必要的参数,包括API名称、版本、方法和要访问的域。我们还设置了请求的表单数据,其中包含了要处理的图片的URL。最后,我们调用ProcessCommonRequest方法发送请求并打印出响应的主体内容。这个例子简单地展示了如何使用阿里云人脸识别服务的基本用法。

2024-08-15

要在Go语言中连接Oracle 11g数据库,你需要使用第三方库如godror。以下是如何使用godror库连接Oracle数据库的步骤和示例代码:

  1. 首先,你需要安装godror库。在命令行中运行以下命令:

    
    
    
    go get github.com/godror/godror
  2. 然后,使用以下Go代码连接到Oracle数据库:



package main
 
import (
    "context"
    "database/sql"
    "fmt"
    "github.com/godror/godror"
    "log"
)
 
func main() {
    // 数据库连接字符串,包括用户名、密码、数据库服务名称
    dsn := "username/password@hostname:port/service_name"
 
    // 创建一个上下文对象
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
 
    // 打开一个连接
    db, err := sql.Open("godror", dsn)
    if err != nil {
        log.Fatalf("failed to open database: %v", err)
    }
    defer db.Close()
 
    // 用Ping()方法检查数据库连接是否成功
    err = db.Ping()
    if err != nil {
        log.Fatalf("failed to ping database: %v", err)
    }
 
    fmt.Println("Connected to Oracle 11g database successfully!")
}

确保替换dsn变量的值为你的Oracle数据库的实际连接信息。

这段代码首先定义了一个数据库连接字符串dsn,然后使用sql.Open函数初始化了一个数据库连接。Ping方法用来检查数据库是否可以成功响应。如果连接成功,它会打印出连接成功的消息。

2024-08-15

在Go语言中,可以使用sort包提供的sort.Slice函数或sort.SliceStable函数来根据特定字段对结构体切片进行排序。以下是一个示例,演示如何根据结构体中的Age字段对切片进行排序。




package main
 
import (
    "fmt"
    "sort"
)
 
type Person struct {
    Name string
    Age  int
}
 
func main() {
    people := []Person{
        {"Alice", 30},
        {"Bob", 25},
        {"Charlie", 35},
    }
 
    // 根据Age字段对people切片进行排序
    sort.Slice(people, func(i, j int) bool {
        return people[i].Age < people[j].Age
    })
 
    fmt.Println("Sorted by Age:", people)
}

这段代码定义了一个Person结构体,并在main函数中创建了一个Person类型的切片。使用sort.Slice函数,我们提供了一个按Age字段升序排序的比较函数。最后,切片会根据Age的值进行排序。

如果你需要稳定的排序(即当元素的排序条件相同时,保持它们原始的顺序),你应该使用sort.SliceStable代替sort.Slice

2024-08-15

以下是五个流行的Go语言REST API框架,并附有简短的描述和示例代码。

  1. Gin

    Gin是一个用Go编写的web框架,它以简单的API为主要设计原则提供功能。




package main
 
import "github.com/gin-gonic/gin"
 
func main() {
    r := gin.Default()
    r.GET("/hello", func(c *gin.Context) {
        c.JSON(200, gin.H{"message": "Hello world!"})
    })
    r.Run() // 默认在0.0.0.0:8080启动服务
}
  1. Echo

    Echo是一个高性能的Go Web框架,它以路由功能为核心。




package main
 
import (
    "net/http"
    "github.com/labstack/echo"
)
 
func main() {
    e := echo.New()
    e.GET("/", func(c echo.Context) error {
        return c.String(http.StatusOK, "Hello, World!")
    })
    e.Start(":8080")
}
  1. Iris

    Iris是另一个Go语言的高性能Web框架,它以性能优越和易用性为设计原则。




package main
 
import "github.com/kataras/iris"
 
func main() {
    app := iris.Default()
    app.Get("/", func(ctx iris.Context) {
        ctx.JSON(iris.Map{"message": "Hello world!"})
    })
    app.Listen(":8080")
}
  1. Beego

    Beego是一个开源的Go语言网络框架,它具有丰富的功能,例如路由、MVC、日志、配置管理、数据库操作、缓存等。




package main
 
import "github.com/astaxie/beego"
 
type MainController struct {
    beego.Controller
}
 
func (c *MainController) Get() {
    c.Data["json"] = map[string]string{"message": "Hello world!"}
    c.ServeJSON()
}
 
func main() {
    beego.Router("/", &MainController{})
    beego.Run()
}
  1. Revel

    Revel是一个高生产力的Go语言Web框架,它以简单性和高生产力为设计原则。




package controllers
 
import "github.com/revel/revel"
 
type AppController struct {
    *revel.Controller
}
 
func (c AppController) Hello() revel.Result {
    return c.RenderJson(map[string]string{"message": "Hello world!"})
}

以上代码片段提供了不同Go REST API框架的简单示例。每个示例都创建了一个基础的API,监听8080端口,并对根URL的GET请求进行处理,返回一个简单的JSON响应。开发者可以根据具体需求进一步扩展这些示例。