Tech Blog

2024-08-16




package main
 
import (
    "fmt"
    "github.com/sjwhitworth/golearn/deep"
    "github.com/sjwhitworth/golearn/linear_models"
)
 
func main() {
    // 创建一个线性支持向量机实例
    svm := deep.NewLinearSupportVectorMachine()
 
    // 加载数据集
    data, err := deep.ReadCSVToInstances("房价数据.csv", true)
    if err != nil {
        fmt.Println("无法加载CSV文件:", err)
        return
    }
 
    // 划分数据集为训练集和测试集
    trainingData, testingData := deep.InstancesTrainTestSplit(data, 0.70)
 
    // 训练模型
    err = svm.Train(trainingData)
    if err != nil {
        fmt.Println("无法训练模型:", err)
        return
    }
 
    // 评估模型
    predictions, err := svm.Predict(testingData)
    if err != nil {
        fmt.Println("无法进行预测:", err)
        return
    }
 
    // 打印模型评估结果
    fmt.Println(linear_models.MetricsToString(predictions, testingData))
}

这段代码示例展示了如何在Go中加载CSV数据集，将其划分为训练集和测试集，训练一个线性支持向量机模型，并评估模型性能。代码使用了golearn库中的相关函数，并处理了可能出现的错误。

- 阅读更多 -

【HTML5】逐步分析如何实现拖放功能

System

2024-08-16

所有,html5




<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>拖放功能演示</title>
    <style>
        #dropZone {
            width: 300px;
            height: 200px;
            border: 2px dashed #aaa;
            margin: 20px;
            padding: 20px;
            text-align: center;
            line-height: 150px;
            font-size: 20px;
        }
        #draggableItem {
            width: 100px;
            height: 100px;
            background-color: #333;
            color: #fff;
            text-align: center;
            line-height: 100px;
            border: 2px solid #000;
            margin: 20px;
            padding: 20px;
        }
    </style>
</head>
<body>
 
<div id="dropZone">将物品拖放到这里</div>
<div id="draggableItem" draggable="true">拖动我</div>
 
<script>
    // 获取拖拽区域和可拖动的元素
    var dropZone = document.getElementById('dropZone');
    var dragItem = document.getElementById('draggableItem');
 
    // 添加拖拽事件监听
    dragItem.addEventListener('dragstart', function(event) {
        // 开始拖动
        event.dataTransfer.setData("text/plain", event.target.id);
    });
    dropZone.addEventListener('dragover', function(event) {
        // 在拖动时改变放置目标的样式
        event.preventDefault(); // 阻止默认行为
        event.dataTransfer.dropEffect = 'move'; // 设置拖放操作的视觉效果
    });
    dropZone.addEventListener('drop', function(event) {
        // 放置
        event.preventDefault();
        var data = event.dataTransfer.getData("text");
        dropZone.appendChild(document.getElementById(data));
    });
</script>
 
</body>
</html>

这段代码演示了如何在HTML5中实现一个基本的拖放功能。首先，我们定义了一个可拖动的元素和一个可以放置的区域。通过为可拖动元素添加draggable="true"属性，我们使其可以被拖动。然后，我们使用JavaScript添加dragstart和dragover事件监听器来处理拖动行为。dragstart事件用于设置要传输的数据（这里是元素的ID），而dragover事件用于改变放置目标的外观，并阻止其默认行为。最后，在drop事件中，我们将被拖动的元素添加到放置区域。

- 阅读更多 -

go 进阶三方库之 go-resty

System

2024-08-16

所有,golang

go-resty 是一个 Go 语言的 HTTP 客户端库，它提供了一种简单的方式来发送各种 HTTP 请求并处理响应。以下是一个使用 go-resty 发送 GET 请求的示例代码：




package main
 
import (
    "fmt"
    "github.com/go-resty/resty/v2"
)
 
func main() {
    client := resty.New()
 
    resp, err := client.R().
        SetHeader("Content-Type", "application/json").
        SetHeader("Accept", "application/json").
        Get("http://example.com/api/resource")
 
    if err != nil {
        fmt.Println("Error:", err)
    } else {
        fmt.Println("Response Status Code:", resp.StatusCode())
        fmt.Println("Response Body:", resp.String())
    }
}

在这个示例中，我们首先创建了一个新的 resty.Client 实例。然后，我们使用这个客户端发送了一个 GET 请求到 "http://example.com/api/resource"。我们还设置了请求头 Content-Type 和 Accept，这通常用于指定我们期望从服务器接收的数据类型。

如果请求成功，我们打印出响应的状态码和文本内容。如果有错误发生，我们打印出错误信息。这个示例展示了如何使用 go-resty 发送一个简单的 GET 请求，并处理响应。

- 阅读更多 -

Go最全Go日志库——logrus，Golang开发指南

System

2024-08-16

所有,golang




package main
 
import (
    "github.com/sirupsen/logrus"
)
 
// 初始化日志配置
func initLog() {
    // 设置日志级别
    logrus.SetLevel(logrus.DebugLevel)
 
    // 设置日志格式
    logrus.SetFormatter(&logrus.JSONFormatter{})
 
    // 也可以设置为文本格式
    // logrus.SetFormatter(&logrus.TextFormatter{})
 
    // 也可以自定义格式
    // logrus.SetFormatter(&logrus.Formatter{
    //    TimestampFormat: "2006-01-02 15:04:05",
    //    DisableSorting:  true,
    // })
 
    // 可以设置输出到文件
    file, err := os.OpenFile("logrus.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
    if err == nil {
        logrus.SetOutput(file)
    } else {
        logrus.Info("Failed to log to file, using default stderr")
    }
 
    // 也可以同时输出到文件和标准输出
    // multiWriter := io.MultiWriter(file, os.Stdout)
    // logrus.SetOutput(multiWriter)
}
 
func main() {
    initLog()
    logrus.WithFields(logrus.Fields{
        "animal": "dog",
    }).Info("A group of walkers")
}

这段代码演示了如何在Go中使用logrus库来初始化和配置日志记录。它设置了日志级别、格式以及输出位置，并在main函数中记录了一条信息级别的日志。这是学习如何在Go中使用logrus库的一个很好的起点。

System

2024-08-16

所有,golang




package uuid
 
import (
    "crypto/rand"
    "encoding/binary"
    "io"
)
 
// NewRandom 返回一个新的、随机版本4的UUID。
func NewRandom() UUID {
    var u UUID
    randomBytes(u[:]) // 使用全局随机源填充u
    u[6] = (u[6] & 0x0f) | 0x40 // 设置版本4并清除所有变体
    u[8] = (u[8] & 0x3f) | 0x80 // 设置Variant是80xx以便是RFC4122编码的UUID
    return u
}
 
// randomBytes 使用全局随机源从rand.Reader读取n个字节到u。
func randomBytes(u []byte) error {
    _, err := io.ReadFull(rand.Reader, u) // 读取随机源数据填充u
    return err
}

这段代码定义了一个NewRandom函数，用于创建一个版本4的UUID。它首先创建了一个UUID的实例，然后使用随机源填充其字节数组。接着，它通过设置适当的字节来确保UUID的版本和变体符合RFC4122规范。最后，返回一个新的、随机生成的UUID。

- 阅读更多 -

推荐开源项目：Pion WebRTC —— 纯Go实现的WebRTC库

System

2024-08-16

所有,golang

Pion WebRTC 是一个纯 Go 语言实现的 WebRTC 库。以下是一个使用 Pion WebRTC 创建简单视频通话的示例代码：




package main
 
import (
    "fmt"
    "os"
    "os/signal"
    "sync"
    "syscall"
 
    "github.com/pion/webrtc/v2"
    "github.com/pion/webrtc/v2/examples/internal/signal"
)
 
func main() {
    // 创建一个新的WebRTC引擎实例
    config := webrtc.Configuration{
        ICEServers: []webrtc.ICEServer{
            {
                URLs: []string{"stun:stun.l.google.com:19302"},
            },
        },
    }
 
    // 信令服务器的URL
    offerSignal, answerSignal := example.NewSignal()
 
    // 创建一个新的PeerConnection
    peerConnection, err := webrtc.NewPeerConnection(config)
    if err != nil {
        panic(err)
    }
 
    // 在PeerConnection上添加一个视频跟踪
    _, err = peerConnection.AddTransceiverFromKind(webrtc.RTPCodecTypeVideo)
    if err != nil {
        panic(err)
    }
 
    // 创建一个等待Offer的goroutine
    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        offer := <-offerSignal
        if err := peerConnection.SetRemoteDescription(offer); err != nil {
            panic(err)
        }
 
        answer, err := peerConnection.CreateAnswer(nil)
        if err != nil {
            panic(err)
        }
 
        if err := peerConnection.SetLocalDescription(answer); err != nil {
            panic(err)
        }
 
        fmt.Println("Send answer to remote")
        answerSignal <- answer
    }()
 
    // 等待SIGINT或SIGTERM信号
    interrupt := make(chan os.Signal, 1)
    signal.Notify(interrupt, syscall.SIGINT, syscall.SIGTERM)
    fmt.Println("Waiting for interrupt")
 
    // 等待中断信号
    select {
    case <-interrupt:
        fmt.Println("Received interrupt, stopping PeerConnection")
 
        // 关闭PeerConnection
        if err := peerConnection.Close(); err != nil {
            panic(err)
        }
 
        // 等待goroutine完成
        wg.Wait()
        return
    }
}

这段代码创建了一个WebRTC连接的基本框架，包括创建了一个新的PeerConnection对象，并添加了一个视频发送者。它还展示了如何使用信令服务器来交换SDP（Session Description Protocol）提议，并建立通信。这个简单的例子可以作为开发者学习和实践WebRTC技术的起点。

- 阅读更多 -

xrpc: 一个基于消息队列的的Go语言RPC框架

System

2024-08-16

所有,golang

xrpc是一个基于消息队列的Go语言RPC框架，它提供了一种简单的方式来进行跨服务的远程过程调用。以下是一个使用xrpc的示例：

首先，你需要安装xrpc：




go get -u github.com/dubbogo/xrpc

然后，你可以使用xrpc来创建一个服务端和客户端：

服务端：




package main
 
import (
    "context"
    "fmt"
    "github.com/dubbogo/xrpc"
)
 
type Greeter struct{}
 
func (g *Greeter) Hello(ctx context.Context, req string) (string, error) {
    return "Hello " + req, nil
}
 
func main() {
    s := xrpc.NewServer()
    s.RegisterName("Greeter", new(Greeter))
    s.Serve("tcp", ":8972")
}

客户端：




package main
 
import (
    "context"
    "fmt"
    "github.com/dubbogo/xrpc"
)
 
func main() {
    c := xrpc.NewClient()
    var greeter Greeter
    c.UseService(&greeter)
    resp, err := greeter.Hello(context.Background(), "world")
    if err != nil {
        panic(err)
    }
    fmt.Println(resp)
}

在这个例子中，我们定义了一个名为Greeter的服务，它有一个Hello方法。服务端启动后，客户端连接到服务端，并调用Hello方法。

注意：以上代码仅为示例，实际使用时需要根据具体的消息队列实现和配置进行相应的调整。

- 阅读更多 -

go语言实现验证码登录（完整代码）

System

2024-08-16

所有,golang




package main
 
import (
    "bytes"
    "fmt"
    "image/png"
    "io/ioutil"
    "net/http"
    "net/http/httptest"
    "net/url"
    "strings"
 
    "github.com/dchest/captcha"
    "github.com/gorilla/mux"
    "github.com/gorilla/sessions"
)
 
var (
    // 使用内存存储会话
    store = sessions.NewMemStore(nil)
)
 
func main() {
    r := mux.NewRouter()
    r.HandleFunc("/captcha", serveCaptcha).Methods("GET")
    r.HandleFunc("/login", loginHandler).Methods("POST")
 
    http.ListenAndServe(":8080", r)
}
 
// 生成并服务验证码
func serveCaptcha(w http.ResponseWriter, r *http.Request) {
    captchaID := captcha.NewLen(4)
    captcha.WriteImage(w, captchaID, 240, 80)
}
 
// 登录处理函数
func loginHandler(w http.ResponseWriter, r *http.Request) {
    // 解析请求体
    err := r.ParseForm()
    if err != nil {
        http.Error(w, "无法解析请求体", http.StatusBadRequest)
        return
    }
 
    // 获取表单数据
    captchaId := r.FormValue("captcha_id")
    captchaSolution := r.FormValue("captcha_solution")
 
    // 验证验证码
    if !captcha.VerifyString(captchaId, captchaSolution) {
        http.Error(w, "错误的验证码", http.StatusForbidden)
        return
    }
 
    // 验证通过后的逻辑处理...
    fmt.Fprintln(w, "登录成功")
}

这段代码实现了一个简单的验证码登录功能。它使用了github.com/dchest/captcha库来生成和验证验证码，以及github.com/gorilla/mux来简化HTTP路由的处理。在登录处理函数中，它首先验证请求中的验证码是否正确，如果正确则允许用户登录，否则拒绝访问。这个例子展示了如何在Web应用中实现验证码登录的基本流程。

- 阅读更多 -

使用GoAccess进行Web日志可视化

System

2024-08-16

所有,golang




# 安装GoAccess（如果尚未安装）
# 在Debian/Ubuntu系统上：
sudo apt-package install goaccess
 
# 生成日志文件的交互式HTML报告
goaccess /path/to/your/webserver.log -o /path/to/report.html --log-format=COMBINED
 
# 说明：
# /path/to/your/webserver.log - 替换为你的日志文件路径
# /path/to/report.html - 生成报告的目标路径
# --log-format=COMBINED - 日志格式选项，根据你的服务器日志格式更改

这个例子演示了如何使用GoAccess命令行工具来分析一个Web服务器的日志文件并生成一个交互式的HTML报告。你需要将/path/to/your/webserver.log替换为你的日志文件的实际路径，同时指定输出报告的路径/path/to/report.html。--log-format=COMBINED选项指定了日志的格式，根据你的服务器的配置，这个值可能是COMBINED、APACHE、AWWW等，具体取决于服务器的日志格式。

- 阅读更多 -

【Go】在 JSON 中解析 time.Duration

System

2024-08-16

所有,golang

在Go中，time.Duration是一种用于记录持续时间的类型，通常以纳秒为单位。当你需要在JSON中解析或生成time.Duration时，你可以将其视为一个数字，并使用相应的JSON编码/解码机制。

以下是一个简单的例子，展示了如何在JSON中解析time.Duration：




package main
 
import (
    "encoding/json"
    "fmt"
    "time"
)
 
type DurationJSON struct {
    Duration time.Duration `json:"duration"`
}
 
func main() {
    // 示例JSON数据
    jsonData := `{"duration": 5000000000}` // 5秒（以纳秒为单位）
 
    // 解码JSON数据到结构体
    var durationJSON DurationJSON
    if err := json.Unmarshal([]byte(jsonData), &durationJSON); err != nil {
        panic(err)
    }
 
    // 输出解析后的时长
    fmt.Println(durationJSON.Duration) // 输出：5s
}

在这个例子中，我们定义了一个DurationJSON结构体，它有一个time.Duration字段。我们使用json.Unmarshal函数将含有时长的JSON数据解码到这个结构体。

如果你需要将time.Duration编码为JSON，可以使用相同的方法：




package main
 
import (
    "encoding/json"
    "fmt"
    "time"
)
 
func main() {
    duration := 5 * time.Second // 5秒的时长
 
    // 编码时长到JSON
    jsonData, err := json.Marshal(duration)
    if err != nil {
        panic(err)
    }
 
    // 输出JSON字符串
    fmt.Println(string(jsonData)) // 输出："5000000000"
}

在这个例子中，我们直接将time.Duration值编码为JSON。

- 阅读更多 -