我通过一个小例子展示了普通更新（使用FindOneAndUpdate方法完成）和使用Aggregate方法进行聚合操作之间的区别。作为一个前提，我通过从结构体中删除字段并硬编码一些值来简化代码。如果我错过了什么，只是让我知道，我会更新我的答案！
首先，让我们分享代码：

package main

import (
    "context"
    "fmt"
    "time"

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

type Passenger struct {
    NumberOfSeats    int    `json:"numberOfSeats" bson:"numberOfSeats"`
    DoorToDoorOption bool   `bson:"doorToDoorOption" json:"doorToDoorOption"`
    LuggageSize      string `bson:"luggageSize" json:"luggageSize"`
}

type Carpool struct {
    ID             string       `json:"id,omitempty" bson:"_id,omitempty"`
    SeatsAvailable int          `json:"seatsAvailable" bson:"seatsAvailable"`
    Passengers     []*Passenger `bson:"passengers" json:"passengers"`
    CreatedAt      time.Time    `json:"createdAt" bson:"createdAt"`
    UpdatedAt      time.Time    `json:"updatedAt" bson:"updatedAt"`
}

func main() {
    clientOptions := options.Client().ApplyURI("mongodb://root:root@localhost:27017")
    mongoClient, err := mongo.Connect(context.Background(), clientOptions)
    if err != nil {
        panic(err)
    }
    defer mongoClient.Disconnect(context.Background())

    appDB := mongoClient.Database("appDB")
    demoCollection := appDB.Collection("demoCollection")

    // clean up data - troubleshooting purposes
    defer func() {
        demoCollection.DeleteMany(context.Background(), bson.M{})
    }()

    // seed data
    carPool := &Carpool{
        ID:             "1",
        SeatsAvailable: 4,
        Passengers: []*Passenger{
            {NumberOfSeats: 1, DoorToDoorOption: false, LuggageSize: "small"},
        },
        CreatedAt: time.Now(),
        UpdatedAt: time.Now(),
    }
    insertRes, err := demoCollection.InsertOne(context.Background(), carPool)
    if err != nil {
        panic(err)
    }

    // fetch data
    fmt.Println("before update")
    cursor, err := demoCollection.Find(context.Background(), bson.M{"_id": insertRes.InsertedID})
    if err != nil {
        panic(err)
    }
    var carPools []bson.M
    if err = cursor.All(context.Background(), &carPools); err != nil {
        panic(err)
    }
    for _, v := range carPools {
        fmt.Println(v)
    }

    // set data
    filter := bson.M{"_id": insertRes.InsertedID}
    update := bson.D{
        bson.E{
            Key: "$push",
            Value: bson.D{
                bson.E{
                    Key:   "passengers",
                    Value: &Passenger{NumberOfSeats: 2, DoorToDoorOption: true, LuggageSize: "medium"},
                },
            },
        },
    }
    updateOptions := options.FindOneAndUpdate().SetReturnDocument(1)
    demoCollection.FindOneAndUpdate(context.Background(), filter, update, updateOptions)

    // aggregate update
    pipe := []bson.M{
        {
            "$addFields": bson.M{ // if the field already exists, it overwrites the value
                "seatsAvailable": bson.M{
                    "$subtract": []string{"$seatsAvailable", "$seatsAvailable"},
                },
            },
        },
    }
    cursor, err = demoCollection.Aggregate(context.Background(), pipe)
    if err != nil {
        panic(err)
    }
    if err = cursor.All(context.Background(), &carPools); err != nil {
        panic(err)
    }
    fmt.Println("after update")
    for _, v := range carPools {
        fmt.Println(v)
    }
}

我将只对update和聚合函数进行更详细的介绍。

更新

更新功能分为以下几个部分：
1.设置用于获取要更新的文档的筛选器
1.设置$push运算符以向集合中添加项
1.设置要添加的值
这里没有什么要补充的。让我们切换到Aggregate函数。

聚合

对于此操作，您必须设置要使用的管道。此管道用于$addFiels阶段。
请注意，如果您要添加一个已经存在的字段，这将被覆盖。我选择用这个是因为我很好。
最后，必须设置要使用的运算符（在本例中为$subtract运算符），并提供一个字符串数组，表示要减去的数字。多亏了$subtract运算符，您可以从第一个中减去第二个。
我添加了一些日志用于演示目的。您可以很容易地看到记录被代码更新。
让我知道这是否有助于澄清您的问题，谢谢！