【10】Golang实用且神奇的开发操作总结

news2025/1/16 7:03:31

文章目录

    • 一、文件操作 📂
      • （一）文件读取与写入 🌟
      • （二）文件路径操作 🌐
      • （三）文件信息获取 📋
      • （四）目录操作 🗂️
    • 二、并发与并行处理 ⚙️
      • （一）Goroutines 并发 🌠
      • （二）Channels 通信 📡
      • （三）Select 语句 ⏱️
      • （四）Concurrency Patterns 并发模式 🔀
    • 三、网络编程 🌐
      • （一）HTTP 服务 🌍
      • （二）TCP 服务与客户端 📡
      • （三）WebSocket 服务 🌐
    • 四、数据库操作 🗃️
      • （一）SQL 数据库 💾
      • （二）NoSQL 数据库 🔍
    • 五、日志记录与调试 📝
      • （一）标准日志记录 📜
      • （二）日志级别和自定义日志 🌟
      • （三）调试工具 🐞
    • 六、配置管理 ⚙️
      • （一）环境变量读取 🌳
      • （二）YAML/JSON 配置文件读取 📄
    • 七、错误处理与恢复 🛡️
      • （一）错误处理 ❌
      • （二）Panic 与 Recover 🔧
    • 八、测试与性能优化 🧪
      • （一）单元测试 🧐
      • （二）性能测试 🚀
      • （三）代码优化 🔍
    • 九、数据结构与算法 🔢
      • （一）切片操作 🍕
      • （二）映射操作 🔑
      • （三）排序算法 🔀
    • 十、模板引擎 🎨
      • （一）HTML 模板 🌐
      • （二）文本模板 📃
    • 十一、命令行工具开发 🛠️
      • （一）`flag` 包 🏁
      • （二）`cobra` 包 🔨
    • 十二、加密与安全 🔒
      • （一）加密算法 🔐
      • （二）哈希算法 🔑

一、文件操作 📂

（一）文件读取与写入 🌟

在 Go 语言中，文件操作是常见的开发任务，以下是一些实用的操作技巧：

  • 使用 os.Open 和 os.Create 打开和创建文件：

    file, err := os.Open("example.txt")
if err!= nil {
    log.Fatal(err)
}
defer file.Close()

    这里使用 os.Open 打开文件，同时使用 defer 关键字确保文件在操作完成后关闭，避免资源泄漏。

  • 利用 ioutil.ReadAll 快速读取文件的全部内容：

    content, err := ioutil.ReadAll(file)
if err!= nil {
    log.Fatal(err)
}

    此方法能方便地将文件内容读取到一个字节切片中。

  • 对于大文件，可以使用 bufio.Scanner 逐行读取：

    scanner := bufio.NewScanner(file)
for scanner.Scan() {
    fmt.Println(scanner.Text())
}

    这种方式避免了一次性加载整个文件到内存，适用于大文件处理。

  • 用 os.WriteFile 简单地将数据写入文件：

    data := []byte("Hello, World!")
err := os.WriteFile("output.txt", data, 0644)
if err!= nil {
    log.Fatal(err)
}

（二）文件路径操作 🌐

文件路径的处理在文件操作中至关重要，path/filepath 包提供了强大的功能：

  • filepath.Join 可以正确拼接路径：

    path := filepath.Join("dir", "subdir", "file.txt")

    它会根据操作系统自动选择正确的路径分隔符，确保跨平台的兼容性。

  • 使用 filepath.Abs 获取文件的绝对路径：

    absPath, err := filepath.Abs("relative/path")
if err!= nil {
    log.Fatal(err)
}

（三）文件信息获取 📋

我们经常需要获取文件的各种信息，os.Stat 是一个得力工具：

  • os.Stat 可以获取文件的信息，如文件大小、权限、是否为目录等：
    fileInfo, err := os.Stat("example.txt")
if err!= nil {
    log.Fatal(err)
}
fmt.Println(fileInfo.Size())
fmt.Println(fileInfo.IsDir())

（四）目录操作 🗂️

目录的创建、删除和管理是文件系统操作的重要部分：

  • 使用 os.Mkdir 和 os.MkdirAll 创建目录，os.MkdirAll 可递归创建目录：

    err := os.Mkdir("newdir", 0755)
if err!= nil {
    log.Fatal(err)
}
err = os.MkdirAll("parent/child/grandchild", 0755)
if err!= nil {
    log.Fatal(err)
}

  • os.Remove 和 os.RemoveAll 用于删除文件和目录，os.RemoveAll 可以递归删除目录：

    err := os.Remove("file.txt")
if err!= nil {
    log.Fatal(err)
}
err = os.RemoveAll("parent")
if err!= nil {
    log.Fatal(err)
}

二、并发与并行处理 ⚙️

（一）Goroutines 并发 🌠

Goroutines 是 Go 语言并发的核心，以下是其使用示例：

  • 启动 Goroutines 进行并发操作：

    func printMessage(msg string) {
    fmt.Println(msg)
}
go printMessage("Hello from goroutine 1")
go printMessage("Hello from goroutine 2")

    简单的 go 关键字就能启动一个 Goroutine。

  • 使用 sync.WaitGroup 来等待多个 Goroutines 完成任务：

    var wg sync.WaitGroup
wg.Add(2)
go func() {
    defer wg.Done()
    printMessage("Task 1")
}()
go func() {
    defer wg.Done()
    printMessage("Task 2")
}()
wg.Wait()

    它能帮助我们更好地控制 Goroutines 的同步。

（二）Channels 通信 📡

Channels 是 Goroutines 之间通信的重要方式：

  • 通过 Channels 进行 Goroutines 间的数据通信，可用于数据传递和同步：

    ch := make(chan int)
go func() {
    ch <- 42
}()
value := <-ch
fmt.Println(value)

  • 使用 buffered channels 减少阻塞，提高性能：

    bufferedCh := make(chan int, 10)
bufferedCh <- 1
bufferedCh <- 2
value := <-bufferedCh
fmt.Println(value)

（三）Select 语句 ⏱️

select 语句为并发编程带来了更多的灵活性：

  • select 语句可以同时等待多个 Channel 的操作，实现非阻塞通信和超时机制：
    ch1 := make(chan int)
ch2 := make(chan int)
go func() {
    ch1 <- 1
}()
select {
case val := <-ch1:
    fmt.Println(val)
case val := <-ch2:
    fmt.Println(val)
case <-time.After(1 * time.Second):
    fmt.Println("Timeout")
}

（四）Concurrency Patterns 并发模式 🔀

一些常见的并发模式能帮助我们解决复杂的并发问题：

  • Fan-In 模式，将多个 Channels 数据汇聚到一个 Channel：

    func fanIn(input1, input2 <-chan int) <-chan int {
    output := make(chan int)
    go func() {
        for {
            select {
            case val := <-input1:
                output <- val
            case val := <-input2:
                output <- val
            }
        }
    }()
    return output
}

  • Worker Pool 模式，多个工作 Goroutines 处理任务队列：

    func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("worker %d started job %d\n", id, j)
        time.Sleep(time.Second)
        results <- j * 2
        fmt.Printf("worker %d finished job %d\n", id, j)
    }
}
jobs := make(chan int, 100)
results := make(chan int, 100)
for w := 1; w <= 3; w++ {
    go worker(w, jobs, results)
}
for j := 1; j <= 5; j++ {
    jobs <- j
}
close(jobs)
for a := 1; a <= 5; a++ {
    fmt.Println(<-results)
}

三、网络编程 🌐

（一）HTTP 服务 🌍

Go 语言在网络编程方面提供了简洁而强大的支持，以下是 HTTP 服务的创建方法：

  • 使用 net/http 包创建简单的 HTTP 服务器：

    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintln(w, "Hello, World!")
})
http.ListenAndServe(":8080", nil)

  • 自定义 HTTP 客户端，设置请求头、超时等：

    client := &http.Client{
    Timeout: 10 * time.Second,
}
req, err := http.NewRequest("GET", "http://example.com", nil)
req.Header.Set("User-Agent", "my-client")
resp, err := client.Do(req)
if err!= nil {
    log.Fatal(err)
}
defer resp.Body.Close()

（二）TCP 服务与客户端 📡

TCP 是基础的网络协议，以下是 TCP 服务和客户端的实现：

  • 实现 TCP 服务器，监听和处理连接：

    listener, err := net.Listen("tcp", ":12345")
if err!= nil {
    log.Fatal(err)
}
defer listener.Close()
for {
    conn, err := listener.Accept()
    if err!= nil {
        log.Fatal(err)
    }
    go func(c net.Conn) {
        defer c.Close()
        // 处理连接
    }(conn)
}

  • TCP 客户端，建立连接并发送数据：

    conn, err := net.Dial("tcp", "localhost:12345")
if err!= nil {
    log.Fatal(err)
}
defer conn.Close()
conn.Write([]byte("Hello, Server!"))

（三）WebSocket 服务 🌐

对于实时通信，WebSocket 是一个不错的选择：

  • 使用 gorilla/websocket 包实现 WebSocket 服务：
    var upgrader = websocket.Upgrader{}
http.HandleFunc("/ws", func(w http.ResponseWriter, r *http.Request) {
    c, err := upgrader.Upgrade(w, r, nil)
    if err!= nil {
        log.Fatal(err)
    }
    defer c.Close()
    for {
        _, message, err := c.ReadMessage()
        if err!= nil {
            log.Println(err)
            break
        }
        fmt.Printf("Received: %s\n", message)
        err = c.WriteMessage(websocket.TextMessage, []byte("Echo: "+string(message)))
        if err!= nil {
            log.Println(err)
            break
        }
    }
})
http.ListenAndServe(":8080", nil)

四、数据库操作 🗃️

（一）SQL 数据库 💾

操作 SQL 数据库是后端开发的常见需求：

  • 使用 database/sql 包操作 SQL 数据库，如 MySQL、PostgreSQL 等：

    db, err := sql.Open("mysql", "user:password@/dbname")
if err!= nil {
    log.Fatal(err)
}
defer db.Close()
rows, err := db.Query("SELECT * FROM users")
if err!= nil {
    log.Fatal(err)
}
defer rows.Close()
for rows.Next() {
    var id int
    var name string
    if err := rows.Scan(&id, &name); err!= nil {
        log.Fatal(err)
    }
    fmt.Printf("ID: %d, Name: %s\n", id, name)
}

  • 使用 sqlx 包简化 SQL 操作，自动映射结果到结构体：

    type User struct {
    ID   int
    Name string
}
var users []User
err := db.Select(&users, "SELECT * FROM users")
if err!= nil {
    log.Fatal(err)
}

（二）NoSQL 数据库 🔍

NoSQL 数据库也有丰富的 Go 语言支持：

  • 操作 Redis 数据库，使用 redis/go-redis 包：

    client := redis.NewClient(&redis.Options{
    Addr:     "localhost:6379",
    Password: "",
    DB:       0,
})
err := client.Set("key", "value", 0).Err()
if err!= nil {
    log.Fatal(err)
}
val, err := client.Get("key").Result()
if err!= nil {
    log.Fatal(err)
}
fmt.Println(val)

  • 与 MongoDB 交互，使用 mongo-go-driver 包：

    client, err := mongo.Connect(context.TODO(), options.Client().ApplyURI("mongodb://localhost:25017"))
if err!= nil {
    log.Fatal(err)
}
defer client.Disconnect(context.TODO())
collection := client.Database("test").Collection("users")
result, err := collection.InsertOne(context.TODO(), bson.D{
    {"name", "John Doe"},
})
if err!= nil {
    log.Fatal(err)
}
fmt.Println(result.InsertedID)

五、日志记录与调试 📝

（一）标准日志记录 📜

Go 语言内置了基本的日志记录功能：

  • 使用 log 包进行基本日志记录：
    log.Println("This is a log message")
log.Printf("Value: %d", 42)

（二）日志级别和自定义日志 🌟

为了更好地管理日志，可以使用第三方日志库：

  • 使用 logrus 等第三方包实现日志分级：
    import (
    log "github.com/sirupsen/logrus"
)
log.SetLevel(log.InfoLevel)
log.Info("This is an info message")
log.Warn("This is a warning message")

（三）调试工具 🐞

在性能分析和调试时，以下工具会很有用：

  • 使用 pprof 进行性能分析和调试：
    import (
    _ "net/http/pprof"
)
go func() {
    http.ListenAndServe(":6060", nil)
}()

六、配置管理 ⚙️

（一）环境变量读取 🌳

环境变量在不同部署环境中起着重要作用：

  • 读取环境变量，使用 os.Getenv：
    port := os.Getenv("PORT")
if port == "" {
    port = "8080"
}

（二）YAML/JSON 配置文件读取 📄

配置文件常用于存储程序的配置信息：

  • 读取 YAML 配置文件，使用 gopkg.in/yaml.v3 包：

    type Config struct {
    Server struct {
        Port int `yaml:"port"`
    } `yaml:"server"`
}
var config Config
data, err := ioutil.ReadAll(file)
if err!= nil {
    log.Fatal(err)
}
err = yaml.Unmarshal(data, &config)
if err!= nil {
    log.Fatal(err)
}
fmt.Println(config.Server.Port)

  • 读取 JSON 配置文件，使用 encoding/json 包：

    var config Config
data, err := ioutil.ReadAll(file)
if err!= nil {
    log.Fatal(err)
}
err = json.Unmarshal(data, &config)
if err!= nil {
    log.Fatal(err)
}
fmt.Println(config.Server.Port)

七、错误处理与恢复 🛡️

（一）错误处理 ❌

良好的错误处理是编写健壮程序的关键：

  • 函数返回错误，调用者检查错误：
    func divide(a, b int) (int, error) {
    if b == 0 {
        return 0, fmt.Errorf("division by zero")
    }
    return a / b, nil
}
result, err := divide(10, 2)
if err!= nil {
    log.Fatal(err)
}
fmt.Println(result)

（二）Panic 与 Recover 🔧

处理异常情况时，panic 和 recover 是重要的工具：

  • 使用 panic 和 recover 处理异常：
    func main() {
    defer func() {
        if r := recover(); r!= nil {
            fmt.Println("Recovered from panic:", r)
        }
    }()
    panic("Something went wrong")
}

八、测试与性能优化 🧪

（一）单元测试 🧐

测试是保证代码质量的重要手段：

  • 编写单元测试，使用 testing 包：
    func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result!= 5 {
        t.Errorf("Expected 5, got %d", result)
    }
}

（二）性能测试 🚀

性能测试可以帮助我们优化代码性能：

  • 进行性能测试，使用 testing 包：
    func BenchmarkAdd(b *testing.B) {
    for i := 0; i < b.N; i++ {
        Add(2, 3)
    }
}

（三）代码优化 🔍

为了提高代码性能，我们可以进行各种优化：

  • 避免不必要的内存分配，使用 strings.Builder 替代 + 拼接字符串：
    var builder strings.Builder
builder.WriteString("Hello")
builder.WriteString(", World!")
result := builder.String()

九、数据结构与算法 🔢

（一）切片操作 🍕

切片是 Go 语言中常用的数据结构：

  • 使用切片存储和操作数据：
    slice := []int{1, 2, 3}
slice = append(slice, 4)
fmt.Println(slice[0])

（二）映射操作 🔑

映射可以存储键值对，方便数据查找：

  • 使用映射存储键值对：
    m := make(map[string]int)
m["key"] = 42
value, exists := m["key"]
if exists {
    fmt.Println(value)
}

（三）排序算法 🔀

排序是常见的数据操作，sort 包提供了方便的排序功能：

  • 使用 sort 包对切片排序：
    ints := []int{3, 1, 4, 1, 5, 9}
sort.Ints(ints)
fmt.Println(ints)

十、模板引擎 🎨

（一）HTML 模板 🌐

模板引擎可以帮助我们生成动态内容：

  • 使用 html/template 包生成 HTML 内容：
    tmpl := template.Must(template.New("index").Parse(`<html><body>{{.}}</body></html>`))
tmpl.Execute(w, "Hello, World!")

（二）文本模板 📃

文本模板适用于生成文本内容：

  • 使用 text/template 包生成文本内容：
    tmpl := template.Must(template.New("greet").Parse("Hello, {{.}}!"))
tmpl.Execute(w, "World")

十一、命令行工具开发 🛠️

（一）flag 包 🏁

flag 包方便我们解析命令行参数：

  • 使用 flag 包解析命令行参数：
    var name string
flag.StringVar(&name, "name", "World", "a name to greet")
flag.Parse()
fmt.Printf("Hello, %s!\n", name)

（二）cobra 包 🔨

cobra 是一个强大的命令行工具开发包：

  • 使用 cobra 包创建强大的命令行工具：
    var rootCmd = &cobra.Command{
    Use:   "myapp",
    Short: "My amazing application",
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Println("Hello, World!")
    },
}
rootCmd.Execute()

十二、加密与安全 🔒

（一）加密算法 🔐

加密对于数据安全至关重要：

  • 使用 crypto 包进行加密操作，如 AES 加密：
    block, err := aes.NewCipher(key)
if err!= nil {
    log.Fatal(err)
}
ciphertext := make([]byte, aes.BlockSize+len(plaintext))
iv := ciphertext[:aes.BlockSize]
stream := cipher.NewCFBEncrypter(block, iv)
stream.XORKeyStream(ciphertext[aes.BlockSize:], plaintext)

（二）哈希算法 🔑

哈希算法常用于数据完整性和密码存储：

  • 使用 crypto/sha256 计算哈希值：
    h := sha25

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2277425.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

qml AngleDirection详解

qml AngleDirection详解

1、概述 AngleDirection 是 QML&#xff08;Qt Meta Language&#xff09;中用于定义粒子发射方向的一个类&#xff0c;它属于 Qt Quick Particles 模块。AngleDirection 通过设置角度范围来控制粒子从发射器射出时的初始方向。这个类在创建具有特定发射模式的粒子效果时非常有…
阅读更多...
VSCode使用纪要

VSCode使用纪要

1、常用快捷键 1&#xff09;注释 ctrl? 单行注释&#xff0c; altshifta 块注释&#xff0c; 个人测试&#xff0c;ctrl? 好像也能块注释 2&#xff09;开多个项目 可以先开一个新窗口&#xff0c;再新窗口打开另一个项目&#xff0c;这时就是同时打开多个项目了。 打开…
阅读更多...
单独编译QT子模块

单独编译QT子模块

单独编译QT子模块 系统 win qt-everywhere-src-5.12.12 下载源码&#xff1a; https://download.qt.io/archive/qt/5.12/5.12.12/single/ 参考&#xff1a; https://doc.qt.io/qt-5/windows-building.html 安装依赖 https://doc.qt.io/qt-5/windows-requirements.html Per…
阅读更多...
浙江安吉成新照明电器：Acrel-1000DP 分布式光伏监控系统应用探索

浙江安吉成新照明电器：Acrel-1000DP 分布式光伏监控系统应用探索

安科瑞吕梦怡 18706162527 摘 要&#xff1a;分布式光伏发电站是指将光伏发电组件安装在用户的建筑物屋顶、空地或其他适合的场地上&#xff0c;利用太阳能进行发电的一种可再生能源利用方式&#xff0c;与传统的大型集中式光伏电站相比&#xff0c;分布式光伏发电具有更灵活…
阅读更多...
DAMA GDPA 备考笔记（二）

DAMA GDPA 备考笔记（二）

1. 考点分布 2. 第二章 数据处理伦理知识点总结 伦理是建立在是非观念上的行为准则。伦理准则通常侧重于公平、尊重、责任、诚信、质量、可靠性、透明度和信任等方面。数据伦理是一项社会责任问题不是法律问题。 度量指标&#xff1a;培训员工人数、合规/不合规事件、企业高管…
阅读更多...
Unity中实现倒计时结束后干一些事情

Unity中实现倒计时结束后干一些事情

问题描述&#xff1a;如果我们想实现在一个倒计时结束后可以执行某个方法&#xff0c;比如挑战成功或者挑战失败&#xff0c;或者其他什么的比如生成boss之类的功能&#xff0c;而且你又不想每次都把代码复制一遍&#xff0c;那么就可以用下面这种方法。 结构 实现步骤 创建一…
阅读更多...
【Elasticsearch】filterQuery过滤查询

【Elasticsearch】filterQuery过滤查询

&#x1f9d1; 博主简介&#xff1a;CSDN博客专家&#xff0c;历代文学网&#xff08;PC端可以访问&#xff1a;https://literature.sinhy.com/#/?__c1000&#xff0c;移动端可微信小程序搜索“历代文学”&#xff09;总架构师&#xff0c;15年工作经验&#xff0c;精通Java编…
阅读更多...
带头双向循环链表（数据结构初阶）

带头双向循环链表（数据结构初阶）

文章目录 双向链表链表的分类概念与结构实现双向链表定义链表结构链表打印判空申请结点初始化头插尾插头删尾删查找指定位置插入和删除销毁链表 顺序表和链表的分析结语 欢迎大家来到我的博客&#xff0c;给生活来点impetus&#xff01;&#xff01; 这一节我们学习双向链表&a…
阅读更多...
在eNSp上telnet一下吧

在eNSp上telnet一下吧

在上篇博客&#xff1a;DNS 我们提到了telnet和设备带外管理、带内管理&#xff0c;它确实是非常有趣的一个知识点哦&#xff0c;接下来我们一起来学习学习吧~ Telnet&#xff08;远程登陆协议&#xff09; Telnet基于TCP 23号端口&#xff0c;典型的C/S架构模式&#xff0c;是…
阅读更多...
Spring MVC复杂数据绑定-绑定集合

Spring MVC复杂数据绑定-绑定集合

【图书介绍】《SpringSpring MVCMyBatis从零开始学&#xff08;视频教学版&#xff09;&#xff08;第3版&#xff09;》_【新华文轩】springspring mvcmybatis从零开始学(视频教学版) 第3版 正版-CSDN博客 《SpringSpring MVCMyBatis从零开始学(视频教学版)&#xff08;第3版…
阅读更多...
基于禁忌搜索算法的TSP问题最优路径搜索matlab仿真

基于禁忌搜索算法的TSP问题最优路径搜索matlab仿真

目录 1.程序功能描述 2.测试软件版本以及运行结果展示 3.核心程序 4.本算法原理 5.完整程序 1.程序功能描述 基于禁忌搜索算法的TSP问题最优路径搜索&#xff0c;旅行商问题&#xff08;TSP&#xff09;是一个经典的组合优化问题。其起源可以追溯到 19 世纪初&#xff0c;…
阅读更多...
静态综合路由实验

静态综合路由实验

实验拓扑 实验要求 1.除R5的环回地址外&#xff0c;整个其他所有网段基于192.168.1.0/24进行合理的IP地址划分 2.R1-R4每个路由器存在两个环回接口&#xff0c;用于模拟pc网段&#xff1b;地址也在192.168.1.0/24这个网络范围内 3.R1-R4上不能直接编写到达5.5.5.0/24的静态路由…
阅读更多...
前端组件开发：组件开发 / 定义配置 / 配置驱动开发 / 爬虫配置 / 组件V2.0 / form表单 / table表单

前端组件开发：组件开发 / 定义配置 / 配置驱动开发 / 爬虫配置 / 组件V2.0 / form表单 / table表单

一、最早的灵感 最早的灵感来自sprider / 网络爬虫 / 爬虫配置&#xff0c;在爬虫爬取网站文章时候&#xff0c;会输入给爬虫一个配置文件&#xff0c;里边的内容是一个json对象。里边包含了所有想要抓取的页面的信息。爬虫通过这个配置就可以抓取目标网站的数据。其实本文要引…
阅读更多...
[Deep Learning] Anaconda+CUDA+CuDNN+Pytorch(GPU)环境配置-2025

[Deep Learning] Anaconda+CUDA+CuDNN+Pytorch(GPU)环境配置-2025

文章目录 [Deep Learning] AnacondaCUDACuDNNPytorch(GPU)环境配置-20250. 引子1. 安装Anaconda1.1 安装包下载&#xff1a;1.2 启用安装包安装1.3 配置(系统)环境变量1.4 验证Anaconda是否安装完毕1.5 Anaconda换源 2. 安装CUDACuDNN2.1 判断本机的CUDA版本2.2 下载适合自己CU…
阅读更多...
直播预告丨Arxiv Insight：用 AI 重新定义论文检索

直播预告丨Arxiv Insight：用 AI 重新定义论文检索

1月16日晚上20:00-20:50&#xff0c;Zilliz直播间&#xff0c;深圳大学计算机视觉所硕士牛增豪先生将带来《Arxiv Insight&#xff1a;用 AI 重新定义论文检索》分享&#xff0c;届时他将讲述从零到一构建 Arxiv Insight产品的过程&#xff0c;思考以及未来计划。欢迎大家锁定Z…
阅读更多...
STM32 FreeRTOS 的任务挂起与恢复以及查看任务状态

STM32 FreeRTOS 的任务挂起与恢复以及查看任务状态

目录 任务的挂起与恢复的API函数 任务挂起函数 任务恢复函数 任务恢复函数&#xff08;中断中恢复&#xff09; 函数说明 注意事项 查看任务状态 任务的挂起与恢复的API函数 vTaskSuspend()&#xff1a;挂起任务, 类似暂停&#xff0c;可恢复 vTaskResume()&#xff1a…
阅读更多...
4. 使用springboot做一个音乐播放器软件项目【数据库表的创建】

4. 使用springboot做一个音乐播放器软件项目【数据库表的创建】

上一章文章 我们做了音乐播放器 这个项目一些公共封装的一些工具类。参考网址&#xff1a; https://blog.csdn.net/Drug_/article/details/145093705 那么这篇文章 我们开始创建数据表。来存储我们项目中所需要存储的数据。 对于 我们这个项目 版本一 需要开发的核心功能 在 第…
阅读更多...
leetcode刷题记录（五十四）——560. 和为 K 的子数组

leetcode刷题记录（五十四）——560. 和为 K 的子数组

&#xff08;一&#xff09;问题描述 560. 和为 K 的子数组 - 力扣&#xff08;LeetCode&#xff09;560. 和为 K 的子数组 - 给你一个整数数组 nums 和一个整数 k &#xff0c;请你统计并返回 该数组中和为 k 的子数组的个数 。子数组是数组中元素的连续非空序列。 示例 1&am…
阅读更多...
软考，质量管理。

软考，质量管理。

项目质量管理&#xff0c;PMBOOK 质量是满足需求的能力的特性的总结 需求的满足程度 质量通常是指产品的质量&#xff0c;广义上的质量还包括工作质量。产品质量是指产品的使用价值及其属性&#xff1b;而工作质量则是产品质量的保证&#xff0c;它反映了与产品质量直接有关的…
阅读更多...
Re78 读论文：GPT-4 Technical Report

Re78 读论文：GPT-4 Technical Report

诸神缄默不语-个人CSDN博文目录 诸神缄默不语的论文阅读笔记和分类 论文全名&#xff1a;GPT-4 Technical Report 官方博客&#xff1a;GPT-4 | OpenAI appendix懒得看了。 文章目录 1. 模型训练过程心得2. scaling law3. 实验结果减少风险 1. 模型训练过程心得 模型结构还…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023