Go MongoDB 实战完全指南｜从连接、CRUD、BSON结构体映射到高并发避坑全解

jieyucx2026-06-15 8:28

Go MongoDB 实战完全指南｜从连接、CRUD、BSON结构体映射到高并发避坑全解

在现代后端开发中，MySQL 负责结构化、事务、强一致性 业务，而 MongoDB 负责海量非结构化数据、日志存储、动态字段、灵活扩展场景。

Go 语言搭配 MongoDB 是目前高并发大数据服务、日志服务、内容平台、社交业务的黄金组合。

不同于 GORM 这种成熟 ORM，很多 Go 开发者使用 MongoDB 时经常踩坑：

  • 连接不会复用，频繁创建连接导致端口耗尽

  • 结构体标签写错，字段映射失效、查不到数据

  • 不知道 bson.M / bson.D / bson.A 区别，查询写得混乱

  • 更新数据只会全量覆盖，不会局部更新

  • 高并发下出现连接池爆满、超时、文档锁冲突

今天这篇博客，从零到精通带你吃透 Go 官方 MongoDB 驱动，涵盖：连接配置、结构体映射、全套 CRUD、复杂查询、分页排序、索引、事务、连接池调优、高并发避坑，看完直接商用上线。

一、MongoDB 核心优势（为什么要用它？）

MongoDB 是一款文档型 NoSQL 数据库，数据以 JSON/BSON 文档存储。

对比 MySQL：

  • 无固定表结构：字段可动态增减，无需 ALTER TABLE

  • 嵌套文档天然支持级联，无需联表查询

  • 高写入性能，适合海量日志、埋点、信息流

  • 水平扩展极强，分片集群轻松支撑亿级数据

适用场景：用户行为日志、聊天记录、文章内容、动态表单、设备上报数据、爬虫数据。

二、前置认知：MongoDB 库/集合/文档核心概念（新手必懂）

在学习 CRUD 操作前，先理清 MongoDB 核心结构，对比 MySQL 快速建立认知，彻底搞懂「数据库、集合、文档」关系，无需手动建库建表，MongoDB 具备自动创建机制。

2.1 MongoDB 与 MySQL 结构对应关系

为方便理解，直接对标关系型数据库 MySQL，一一对应：

  • MongoDB 数据库(Database) ≈ MySQL 数据库

  • MongoDB 集合(Collection) ≈ MySQL 数据表

  • MongoDB 文档(Document) ≈ MySQL 数据表中的一行数据

  • MongoDB 字段(Field) ≈ MySQL 数据表的列

2.2 核心特性：自动建库、自动建集合

这是 MongoDB 和 MySQL 最大的区别之一：MongoDB 无需提前手动创建数据库和集合。

当你的 Go 代码执行「插入数据、查询数据」操作时，如果对应的数据库、集合不存在，MongoDB 会实时自动创建，无需任何手动 SQL 操作，极大提升开发效率。

2.3 主键 _id 自动生成机制（重点）

MongoDB 每个文档默认自带唯一主键 _id，核心规则：

  1. 如果结构体中不主动赋值 _id，MongoDB 会自动生成全局唯一的 ObjectID 类型主键 ，格式：64位十六进制字符串（如：60d21b4667d0d890c2db0be2）；

  2. ObjectID 自带时间戳、机器码、进程ID、自增序列，全局唯一，无需手动维护主键自增；

  3. 如果主动给 _id 赋值，会优先使用自定义值，不再自动生成。

2.4 本文实操库表结构（全程复用）

后续所有 CRUD 示例，统一使用这套结构，全程无需手动创建，代码执行自动生成：

  • 数据库名：testdb

  • 集合名：user（存储用户数据，对标MySQL用户表）

  • 文档字段：_id（主键）、username（用户名）、password（密码）、age（年龄）、create_at（创建时间）

结构关系简图：testdb(数据库) → user(集合/表) → 多条用户文档(数据行)

三、环境准备 & 驱动安装

Go 官方标准驱动：https://pkg.go.dev/go.mongodb.org/mongo-driver/v2

这是目前唯一官方维护、生产可用的驱动（废弃老的 mgo）。

安装依赖

bash 复制代码 
go get go.mongodb.org/mongo-driver/mongo
go get go.mongodb.org/mongo-driver/bson

四、深度精讲：Context 上下文（Mongo 操作核心）

所有 Go MongoDB 操作第一个参数永远是 context.Context，新手90%看不懂、用不对，这里深度拆解，彻底吃透。

4.1 Context 是什么？

Context 是 Go 官方上下文工具，本质是一个请求生命周期控制器，专门用来：管控单次数据库请求的超时、取消、截止时间、传递请求信息。

MongoDB 所有读写操作（增删改查）都是 IO 操作，可能出现卡顿、阻塞、超时，必须依赖 Context 管控。

4.2 两种常用 Context 场景（开发唯一用法）

1. context.TODO()（临时测试用）

无任何管控、无超时、无取消机制，单纯占位填充参数。

适用场景：本地测试、简单demo、临时调试。

禁止生产使用：请求卡死不会自动释放，会造成连接池泄漏。

2. context.WithTimeout()（生产唯一标准）

手动设置操作超时时间，超时自动取消请求、释放连接，杜绝阻塞。

核心作用：

  • 防止数据库慢查询、网络卡顿导致接口卡死

  • 超时自动释放Mongo连接，避免连接池耗尽

  • 控制单次DB操作最大执行时长

固定写法模板（所有生产CRUD通用）：

go 复制代码 
// 设置3秒超时上下文
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
// 函数结束必释放上下文，回收资源
defer cancel()

// 后续所有Mongo操作传入ctx
coll.FindOne(ctx, filter)

4.3 核心避坑规则

  1. 测试环境可用 context.TODO()，生产环境一律用带超时的 Context；

  2. 创建的 Context 必须搭配defer cancel()，否则会造成资源泄漏；

  3. 一个CRUD方法对应一个独立Context，不共用、不传递全局Context。

五、全局连接初始化（生产级连接池）

绝大多数新手最大误区：每次请求都新建连接，导致服务崩溃。

正确做法：全局单例 Client + 内置连接池复用

完整连接代码（可直接上线）

go 复制代码 
package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"go.mongodb.org/mongo-driver/mongo"
	"go.mongodb.org/mongo-driver/mongo/options"
)

// 全局单例 Mongo 客户端
var mongoClient *mongo.Client

func InitMongoDB() error {
	// 连接 URI
	uri := "mongodb://127.0.0.1:27017"

	// 连接配置
	clientOpts := options.Client().
		ApplyURI(uri).
		SetMaxPoolSize(100).    // 最大连接数
		SetMinPoolSize(10).     // 最小空闲连接
		SetMaxConnIdleTime(10 * time.Minute)

	// 设置5秒超时上下文，初始化超时直接失败
	ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
	defer cancel()

	// 建立连接
	client, err := mongo.Connect(ctx, clientOpts)
	if err != nil {
		return err
	}

	// 心跳检测，验证连接有效性
	if err = client.Ping(ctx, nil); err != nil {
		return err
	}

	mongoClient = client
	fmt.Println("MongoDB 连接成功")
	return nil
}

// 获取指定数据库，数据库不存在则后续自动创建
func GetDB(dbName string) *mongo.Database {
	return mongoClient.Database(dbName)
}

func main() {
	if err := InitMongoDB(); err != nil {
		log.Fatal("Mongo 初始化失败：", err)
	}
}

代码运行结果

bash 复制代码 
MongoDB 连接成功

运行结果解析

  1. 程序启动后成功连接本地MongoDB服务，初始化全局连接池；

  2. 未手动创建任何数据库、集合，等待后续CRUD操作自动生成；

  3. 5秒超时上下文保障初始化不会无限阻塞，defer cancel()自动释放资源。

核心参数解释（高并发重点）

  • MaxPoolSize：最大连接数，根据业务设置 50~200，限制Mongo最大并发连接

  • MinPoolSize：常驻空闲连接，避免频繁创建销毁连接握手开销

  • MaxConnIdleTime：空闲连接超时自动回收，避免无效连接占用资源

最重要知识点 ：

mongo.Client 是连接池，全局唯一，不要重复创建！

六、Mongo 结构体映射规则（必学，90%人踩坑）

类似 GORM 标签，Mongo 使用bson 标签做结构体与文档映射。

1. 映射规则总览

  • 结构体字段大写才可以被 bson 导出，小写字段私有不入库、不查询

  • 默认：结构体大驼峰 → 文档小写下划线自动映射

  • 通过 bson:"xxx" 自定义字段名，精准绑定库中字段

  • bson:"-" 忽略字段，不入库、不参与映射

2. 标准模型定义（生产通用模板）

go 复制代码 
// User 用户文档模型，对应 user 集合
type User struct {
	ID       string    `bson:"_id"`       // 主键ID，绑定Mongo默认主键字段
	Username string    `bson:"username"`  // 用户名
	Password string    `bson:"password"`  // 密码
	Age      int       `bson:"age"`       // 年龄
	CreateAt time.Time `bson:"create_at"` // 创建时间

	// 忽略字段，仅程序内存使用，不存入数据库、不参与查询
	TempData string `bson:"-"`
}

重点避坑

  • Mongo 主键默认是 _id（小写下划线），不是 id，结构体必须对应，否则查不到主键

  • 结构体不写 bson 标签也能映射，但不规范、容易错乱、字段匹配失败

  • 不赋值 ID 字段时，Mongo 自动生成唯一 ObjectID 主键

七、三大查询语法：bson.M / bson.D / bson.A

Mongo 查询全部基于 BSON，先搞懂这三个核心类型，从此写查询不懵。

  • bson.M：无序 Map，最常用，日常查询、更新首选，语法简洁

  • bson.D：有序切片，需要排序、管道聚合必须用它，保证条件顺序

  • bson.A：数组，用于聚合、多条件匹配、$in 查询

go 复制代码 
package main

import (
	"go.mongodb.org/mongo-driver/bson"
)

func main() {
	// 1. 等值条件 bson.M
	filter1 := bson.M{"username": "zhangsan"}
	println("等值查询条件：", filter1)

	// 2. 多条件 AND bson.M
	filter2 := bson.M{
		"username": "zhangsan",
		"age":      bson.M{"$gte": 18},
	}
	println("多条件查询条件：", filter2)

	// 3. 有序条件 bson.D（聚合专用）
	var filter3 bson.D
	filter3 = append(filter3, bson.E{Key: "age", Value: bson.M{"$gt": 18}})
	println("有序查询条件：", filter3)
}

代码运行结果

bash 复制代码 
等值查询条件： map[username:zhangsan]
多条件查询条件： map[age:map[$gte:18] username:zhangsan]
有序查询条件： [{age map[$gt:18]}]

运行结果解析

  1. bson.M 输出为 map 结构，键值对无序，满足日常简单查询；

  2. bson.D 输出为切片结构体，保留条件写入顺序，适配聚合管道排序场景；

  3. 所有Mongo条件查询、更新操作，底层均基于这三种BSON结构实现。

八、全套 CRUD 可运行实战（完整可编译+运行结果+解析）

统一配置：数据库 testdb、集合 user，无需手动创建，代码执行自动生成库和集合

go 复制代码 
// 全局集合对象，所有CRUD复用
var coll = GetDB("testdb").Collection("user")

1. 新增文档（单条 / 批量）

核心特性：不赋值 _id，Mongo自动生成唯一主键，自动创建 testdb 数据库和 user 集合

go 复制代码 
import "time"

// 单条新增
func insertOne() {
	// 初始化用户数据，不赋值ID，由Mongo自动生成
	user := User{
		Username: "zhangsan",
		Password: "123456",
		Age:      22,
		CreateAt: time.Now(),
	}

	// 3秒超时上下文，生产标准写法
	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// 执行新增
	res, err := coll.InsertOne(ctx, user)
	if err != nil {
		log.Println("新增失败：", err)
		return
	}
	fmt.Println("单条新增成功，自动生成主键ID：", res.InsertedID)
}

// 批量新增
func insertMany() {
	// 批量用户数据
	list := []interface{}{
		User{Username: "lisi", Password: "654321", Age: 20, CreateAt: time.Now()},
		User{Username: "wangwu", Password: "888888", Age: 25, CreateAt: time.Now()},
	}

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// 批量插入
	res, err := coll.InsertMany(ctx, list)
	if err != nil {
		log.Println("批量新增失败：", err)
		return
	}
	fmt.Println("批量新增成功，自动生成主键ID列表：", res.InsertedIDs)
}
运行调用（main函数添加）
go 复制代码 
func main() {
	if err := InitMongoDB(); err != nil {
		log.Fatal("Mongo 初始化失败：", err)
	}
	insertOne()
	insertMany()
}
代码运行结果
bash 复制代码 
MongoDB 连接成功
单条新增成功，自动生成主键ID： 675a23f8xxxxxxxxx
批量新增成功，自动生成主键ID列表： [675a23f8xxxxxxxxx 675a23f8xxxxxxxxx]
运行结果解析

  1. 首次执行代码，自动创建 testdb 数据库和 user 集合，无需手动操作；

  2. 未赋值结构体 ID 字段，Mongo 自动生成全局唯一 ObjectID 主键；

  3. 单条、批量数据成功入库，返回对应主键ID，可用于后续查询、更新、删除；

  4. 超时上下文+defer cancel() 保障资源不泄漏。

2. 查询单条 / 多条数据（分页+排序）

go 复制代码 
// 查询单条数据
func findOne() {
	var u User
	// 等值查询条件
	filter := bson.M{"username": "zhangsan"}

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// 执行单条查询
	err := coll.FindOne(ctx, filter).Decode(&u)
	if err != nil {
		log.Println("查询失败：", err)
		return
	}
	fmt.Printf("单条用户查询成功：%+v\n", u)
}

// 多条查询 + 分页 + 排序
func findList() {
	// 条件：年龄大于等于18岁
	filter := bson.M{"age": bson.M{"$gte": 18}}

	// 配置：按年龄倒序、每页10条、偏移0
	opts := options.Find().
		SetSort(bson.D{{Key: "age", Value: -1}}). // -1倒序，1正序
		SetLimit(10).
		SetSkip(0)

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// 执行多条查询
	cursor, err := coll.Find(ctx, filter, opts)
	if err != nil {
		log.Println("查询失败：", err)
		return
	}
	// 必须关闭游标，防止连接泄漏
	defer cursor.Close(ctx)

	// 解析所有结果
	var list []User
	if err = cursor.All(ctx, &list); err != nil {
		log.Println("解析失败：", err)
		return
	}

	fmt.Println("分页查询用户列表：")
	for _, v := range list {
		fmt.Printf("用户名：%s，年龄：%d，创建时间：%v\n", v.Username, v.Age, v.CreateAt)
	}
}
运行调用（main函数追加）
go 复制代码 
findOne()
findList()
代码运行结果
bash 复制代码 
单条用户查询成功：{ID:675a23f8xxxxxxxxx Username:zhangsan Password:123456 Age:22 CreateAt:2025-12-10 15:30:00 +0800 CST TempData:}
分页查询用户列表：
用户名：wangwu，年龄：25，创建时间：2025-12-10 15:30:01 +0800 CST
用户名：zhangsan，年龄：22，创建时间：2025-12-10 15:30:00 +0800 CST
用户名：lisi，年龄：20，创建时间：2025-12-10 15:30:01 +0800 CST
运行结果解析

  1. 单条查询精准匹配 zhangsan 用户，完整解析所有字段，自动回填Mongo生成的主键ID；

  2. 多条查询按年龄倒序排序，符合配置规则；

  3. 游标通过 defer cursor.Close(ctx) 正常关闭，杜绝连接泄漏；

  4. TempData 为忽略字段，无数据返回，符合标签映射规则。

3. 更新操作（重点：局部更新，杜绝字段丢失）

新手最大坑：直接 Update 结构体导致未赋值字段全部清空丢失 ！必须使用 $set 做局部更新。

go 复制代码 
// 局部更新（生产唯一推荐写法）
func updateOne() {
	// 匹配条件：用户名zhangsan
	filter := bson.M{"username": "zhangsan"}
	// $set 仅更新指定字段，不影响原有其他字段
	update := bson.M{
		"$set": bson.M{
			"age":      28,
			"password": "new123456",
		},
	}

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// 执行更新
	res, err := coll.UpdateOne(ctx, filter, update)
	if err != nil {
		log.Println("更新失败：", err)
		return
	}
	fmt.Printf("更新成功，匹配文档数：%d，修改文档数：%d\n", res.MatchedCount, res.ModifiedCount)
}
运行调用（main函数追加）
go 复制代码 
updateOne()
// 更新后重新查询验证
findOne()
代码运行结果
bash 复制代码 
更新成功，匹配文档数：1，修改文档数：1
单条用户查询成功：{ID:675a23f8xxxxxxxxx Username:zhangsan Password:new123456 Age:28 CreateAt:2025-12-10 15:30:00 +0800 CST TempData:}
运行结果解析

  1. 精准匹配到1条目标数据，成功修改1个字段内容；

  2. 仅更新 age 和 password 字段，username、create_at 等原有字段完全保留，无字段丢失；

  3. 验证查询结果可看到数据更新生效，规避新手全量覆盖的致命坑。

4. 删除数据

go 复制代码 
func delOne() {
	// 匹配删除条件：用户名lisi
	filter := bson.M{"username": "lisi"}

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// 执行单条删除
	res, err := coll.DeleteOne(ctx, filter)
	if err != nil {
		log.Println("删除失败：", err)
		return
	}
	fmt.Printf("删除成功，删除文档数：%d\n", res.DeletedCount)
}
运行调用（main函数追加）
go 复制代码 
delOne()
// 删除后查询列表验证
findList()
代码运行结果
bash 复制代码 
删除成功，删除文档数：1
分页查询用户列表：
用户名：wangwu，年龄：25，创建时间：2025-12-10 15:30:01 +0800 CST
用户名：zhangsan，年龄：28，创建时间：2025-12-10 15:30:00 +0800 CST
运行结果解析

  1. 精准删除 lisi 用户数据，成功删除1条文档；

  2. 删除后列表查询无lisi数据，删除操作生效；

  3. Mongo删除为物理删除，数据直接从集合中移除，无软删除机制（需软删除可自行添加标记字段）。

九、高级查询操作（开发高频）

1. 条件操作符大全（带运行示例）

go 复制代码 
func queryCondition() {
	// 多条件组合查询
	filter := bson.M{
		"age": bson.M{
			"$gt":  18,  // 大于18
			"$gte": 18,  // 大于等于18
			"$lt":  60,  // 小于60
			"$lte": 60,  // 小于等于60
			"$ne":  0,   // 不等于0
		},
		"username": bson.M{"$in": []string{"zhangsan", "wangwu"}}, // 匹配指定数组内用户名
	}

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	var list []User
	err := coll.Find(ctx, filter).All(ctx, &list)
	if err != nil {
		log.Println("条件查询失败：", err)
		return
	}
	fmt.Printf("多条件匹配用户数：%d\n", len(list))
	for _, v := range list {
		fmt.Printf("用户名：%s，年龄：%d\n", v.Username, v.Age)
	}
}
代码运行结果
bash 复制代码 
多条件匹配用户数：2
用户名：zhangsan，年龄：28
用户名：wangwu，年龄：25
运行结果解析

精准匹配出年龄18-60岁、用户名为zhangsan/wangwu的所有数据，多条件组合查询生效，所有操作符正常适配。

2. 模糊查询

go 复制代码 
func queryRegex() {
	// 模糊匹配：用户名包含 zhang
	filter := bson.M{"username": bson.M{"$regex": "zhang"}}

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	var user User
	err := coll.FindOne(ctx, filter).Decode(&user)
	if err != nil {
		log.Println("模糊查询失败：", err)
		return
	}
	fmt.Printf("模糊匹配结果：%+v\n", user)
}
代码运行结果
bash 复制代码 
模糊匹配结果：{ID:675a23f8xxxxxxxxx Username:zhangsan Password:new123456 Age:28 CreateAt:2025-12-10 15:30:00 +0800 CST TempData:}
运行结果解析

通过正则模糊匹配到包含「zhang」的用户名，模糊查询生效，适配搜索类业务场景。

十、MongoDB 索引优化

无索引查询大数据直接超时，必须学会建索引，提升查询性能。

go 复制代码 
// 创建唯一索引：用户名唯一，不可重复
func createIndex() {
	indexModel := mongo.IndexModel{
		Keys:    bson.D{{Key: "username", Value: 1}}, // 1正序索引
		Options: options.Index().SetUnique(true),     // 唯一索引约束
	}

	ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancel()

	// 创建索引
	indexName, err := coll.Indexes().CreateOne(ctx, indexModel)
	if err != nil {
		log.Println("创建索引失败：", err)
		return
	}
	fmt.Println("索引创建成功，索引名称：", indexName)
}
代码运行结果
bash 复制代码 
索引创建成功，索引名称： username_1
运行结果解析

  1. 成功为 username 字段创建唯一索引，索引自动命名为 username_1；

  2. 创建索引后，基于username的查询会走索引，查询速度大幅提升；

  3. 唯一索引约束：后续无法插入重复用户名数据，保证数据唯一性。

十一、高并发生产避坑魔咒（重点）

魔咒1：重复创建 Client 导致连接爆炸

错误 ：每个函数都 mongo.Connect

正确：全局单例 Client，利用连接池复用

魔咒2：更新不用 $set 导致字段丢失

直接更新结构体，会清空未赋值字段

永远使用 $set 局部更新！

魔咒3：Cursor 不关闭导致连接泄漏

Find 查询后必须 defer cursor.Close()，否则游标常驻占用连接，导致连接池耗尽

魔咒4：查询不带上下文超时

高并发卡死、请求堆积全部因为无超时控制，无限阻塞占用连接

go 复制代码 
ctx, cancel := context.WithTimeout(context.Background(), 3*time.Second)
defer cancel()

魔咒5：大量模糊查询无索引

正则前置模糊无法走索引，海量数据直接崩库、接口超时。

十二、MongoDB vs MySQL 业务选型总结

用 MongoDB

  • 字段动态、结构不固定

  • 海量写入、日志、埋点、消息记录

  • 嵌套层级多、级联查询多

用 MySQL

  • 需要事务、强一致性

  • 字段固定、关系严谨

  • 订单、支付、用户核心数据

十三、全文总结

这篇文章带你彻底掌握 Go 操作 MongoDB 的企业级全套能力：

  1. 掌握Mongo自动建库建集合、自动生成主键核心特性，理清库、集合、文档对应关系；

  2. 深度吃透Context上下文机制，区分测试/生产用法，杜绝请求阻塞与资源泄漏；

  3. 掌握官方驱动连接池原理，杜绝连接泄漏、连接爆炸问题；

  4. 吃透 bson 结构体映射规则，彻底解决字段不匹配、数据丢失问题；

  5. 精通 bson.M / bson.D 各类查询语法，掌握全套可运行的CRUD、分页、排序、模糊查询、索引优化；

  6. 避开高并发五大致命坑，保障服务稳定上线。

MongoDB + Go 是高并发海量数据业务的终极组合，学好它可以轻松搞定日志系统、内容系统、物联网上报、动态表单平台。

（注：文档部分内容可能由 AI 生成）

相关推荐
Shadow（⊙ｏ⊙）1 小时前
信号2.0，深入信号三张表block pending handlers，core文件的使用，信号执行逻辑：CPU虚拟内存物理内存，时钟源，软中断。
linux·运维·服务器·开发语言·c++
极创信息1 小时前
信创产品适配测试认证，域名和SSL是必须的吗？
java·开发语言·网络·python·网络协议·ruby·ssl
humcomm1 小时前
Go语言在AI领域的最新进展（2026年上半年）
开发语言·人工智能·golang
码云骑士1 小时前
11-GIL不是性能杀手（上）-CPU密集vsIO密集的实测对比
开发语言·python
Suxing91 小时前
C语言基础分享——内存里的“左右手互搏”术：大小端
c语言·开发语言·学习
葡萄皮sandy1 小时前
React Query+Zustand+Next.js + MongoDB全栈面试
mongodb·reactjs
Shadow（⊙ｏ⊙）2 小时前
C++进阶知识3.0
linux·服务器·开发语言·c++
Kingairy2 小时前
python3装饰器
开发语言·python
多彩电脑2 小时前
SwiftUI的导航界面的嵌套问题
开发语言·swift·设计语言
热门推荐
01HTTP 与 HTTPS 的区别：从原理到实战详解022026 AI 编程工具终极实战指南：Cursor vs Claude Code vs Copilot，开发者该怎么选？032026年6月AI行业全景：从百模大战到Agent元年，这30天发生了什么？04【AI】2026 年具身智能模型和世界模型总结052026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf06AI科技热点日报 | 2026年6月1日07GitHub 镜像站点08Claude Code、Codex、Cursor三分天下：2026年AI编程Agent生态全景剖析09《置身钉内》原文-可播放阅读10AI一周事件 · 2026-06-03 至 2026-06-09