Sorting go lang中按动态字段排序

所以我正在努力找出如何按“状态”字段（asc、desc）对以下结构进行排序

完整活动分页的示例：

   "pagination": {
        "page": 1,
        "per_page": 15,
        "page_count": 1,
        "total_count": 4
    },
    "campaigns": [
        {
            "Campaign": {
                "_id": "57597fc6799e0fe41d0eede6",
                "name": "Test campaign",
                "description": "Just test campaign"
                "isEmail": true
            },
            "status": "expired"
        },
        ...
    }

所以我的函数是retuting变量ret:=&campaitspagination{}，它填充了来自mongoDB的数据，但是状态是由其他东西实时确定的。所以reflect package说，我正在尝试对*CampaignsPagination类型进行排序，我使用的所有内容都以错误结尾，比如“类型CampaignsPagination不支持索引”（使用sort package）。任何提示都是受欢迎的

更新：

我如何尝试对其进行排序（但由于（type*activatespagination不支持索引），它无法编译

func (a *CampaignsPagination) Len() int {
    return len(a)
}
func (a *CampaignsPagination) Swap(i, j int) {
    a[i], a[j] = a[j], a[i]
}
func (a *CampaignsPagination) Less(i, j int) bool {
    if a[i].Status < a[j].Status {
        return true
    }
    if a[i].Status > a[j].Status {
        return false
    }
    return a[i].Status < a[j].Status
}

func（a*activatespagination）Len（）int{
返回len（a）
}
func（a*活动计划）掉期（i，j int）{
a[i]，a[j]=a[j]，a[i]
}
func（a*activatespagination）减去（i，j int）bool{
如果a[i]。状态a[j].状态{
返回错误
}
返回a[i]。状态

通常排序是在一个切片上定义的。您可以尝试在

活动分页

结构类型上定义排序

这也可以做到，但有点不寻常（例如，如果您决定基于另一个字段下另一个订单，您会怎么做？）。因为您的接收器

a

不是一个切片，而是一个（指向a的指针）包装结构，在索引和返回长度时，使用切片

a.activities

。而且

string

值具有可比性和顺序（按字节顺序）。因此，您可以简单地比较

activitystatus.Status

值，并在

Less（）

中返回结果

---

activatespagination

和

Status

之间没有一对一的关系

activatespagination

有一个

activatespagination

片段作为字段；这意味着

activatespagination

有许多

Status

es

因此，我假设您希望对字段

活动[]活动状态

进行排序。您的代码几乎正确；对于

活动计划

，要实现接口

排序。接口

：

func (x *CampaignsPagination) Len() int {
    return len(x.Campaigns)
}
func (x *CampaignsPagination) Swap(i, j int) {
    a := x.Campaigns
    a[i], a[j] = a[j], a[i]
}
func (x *CampaignsPagination) Less(i, j int) bool {
    a := x.Campaigns
    if a[i].Status < a[j].Status {
        return true
    }
    if a[i].Status > a[j].Status {
        return false
    }
    return a[i].Status < a[j].Status
}

---

请发布您的代码，说明您如何尝试对它们进行排序。当然，您不能对CampaingPagination进行排序，因为这不是一个片段。请在包装成提供排序的类型后对活动应用排序。比较状态的接口方法。@icza我添加了我如何尝试对它们进行排序。Volker有任何提示，我如何将其包装成正确的类型？y将使用哪个字段你想对你的子文件进行排序，并使其反映JSON 1:1的结构吗？谢谢你的解释，太好了！

func (a *CampaignsPagination) Len() int {
    return len(a.Campaigns)
}
func (a *CampaignsPagination) Swap(i, j int) {
    a.Campaigns[i], a.Campaigns[j] = a.Campaigns[j], a.Campaigns[i]
}
func (a *CampaignsPagination) Less(i, j int) bool {
    return a.Campaigns[i].Status < a.Campaigns[j].Status
}

type CampaignStatusSort []CampaignStatus

func (c CampaignStatusSort) Len() int { return len(c) }

func (c CampaignStatusSort) Swap(i, j int) { c[i], c[j] = c[j], c[i] }

func (c CampaignStatusSort) Less(i, j int) bool { return c[i].Status < c[j].Status }

cp := &CampaignsPagination{} // Init struct

sort.Sort(CampaignStatusSort(cp.Campaigns))

func (x *CampaignsPagination) Len() int {
    return len(x.Campaigns)
}
func (x *CampaignsPagination) Swap(i, j int) {
    a := x.Campaigns
    a[i], a[j] = a[j], a[i]
}
func (x *CampaignsPagination) Less(i, j int) bool {
    a := x.Campaigns
    if a[i].Status < a[j].Status {
        return true
    }
    if a[i].Status > a[j].Status {
        return false
    }
    return a[i].Status < a[j].Status
}

type Statuses []CampaignStatus

func (a Statuses) Len() int {
    return len(a)
}
func (a Statuses) Swap(i, j int) {
    a[i], a[j] = a[j], a[i]
}
func (a Statuses) Less(i, j int) bool {
    if a[i].Status < a[j].Status {
        return true
    }
    if a[i].Status > a[j].Status {
        return false
    }
    return a[i].Status < a[j].Status
}

type CampaignsPagination struct {
    Pagination PageMetadata `json:"pagination"`
    Campaigns  Statuses     `json:"campaigns"`
}