筛选包含嵌套数组的数据

在 Go 中，可以通过定义一个函数来筛选包含嵌套数组的数据。该函数接收一个包含结构体的数组作为输入，并根据指定的条件过滤出满足条件的结构体。通过将过滤条件定义为一个可变参数函数，可以灵活地定制筛选规则。该函数返回一个新的包含满足条件的结构体的数组。

我有一个返回 result 数组的函数，我想创建另一个函数，该函数将 []results 作为输入，并应返回 []results 作为输出。这个函数应该根据平均数过滤学生，假设只有平均分高于 80 的学生应该被附加到过滤列表中，我怎样才能在 go 中实现这一点？

type Result struct {
    StudentName    string
    StudentNum         int
    Info     []StudentData
}

type StudentData struct {
    Name     string
    Age      int
    Report  *ReportCard
}

type ReportCard struct {
    Subject     string
    Average     float64
}

正确答案

我对结构做了轻微的改变。

对我来说，这个问题应该是 根据指定的条件过滤所需的学生。

我不提倡对过滤器函数进行硬编码。我觉得过滤条件很灵活，所以我觉得下面的方法比较合适。

func newfilter(sdata []*student, criteriafunc func(subjects []*subject) bool) func() []*student {
    return func() []*student {
        result := make([]*student, 0)
        for _, curstudent := range sdata {
            if criteriafunc(curstudent.report) {
                result = append(result, curstudent)
            }
        }
        return result
    }
}

完整示例

package main

import (
    "encoding/json"
    "fmt"
)

type Student struct {
    Name   string
    Age    int
    Report []*Subject
}

func (s Student) String() string {
    return fmt.Sprintf("%s(%d):%+v", s.Name, s.Age, s.Report)
}

type Subject struct {
    Name    string `json:"Subject"`
    Average float64
}

func (s *Subject) String() string {
    return fmt.Sprintf("%s:%f", s.Name, s.Average)
}

const DBData string = `
{
  "Students": [
    {
      "Name": "Carson",
      "Age": 30,
      "Report": [
        {
          "Subject": "Math",
          "Average": 100
        },
        {
          "Subject": "English",
          "Average": 60
        }
      ]
    },
    {
      "Name": "Foo",
      "Age": 18,
      "Report": [
        {
          "Subject": "Math",
          "Average": 60
        },
        {
          "Subject": "English",
          "Average": 88
        }
      ]
    },
    {
      "Name": "Bar",
      "Age": 13,
      "Report": [
        {
          "Subject": "Math",
          "Average": 91.3
        },
        {
          "Subject": "English",
          "Average": 80.5
        }
      ]
    },
    {
      "Name": "Mary",
      "Age": 10,
      "Report": [
        {
          "Subject": "Math",
          "Average": 95.3
        },
        {
          "Subject": "English",
          "Average": 80.5
        }
      ]
    }
  ]
}
`

func NewFilter(sData []*Student, criteriaFunc func(subjects []*Subject) bool) func() []*Student {
    return func() []*Student {
        result := make([]*Student, 0)
        for _, curStudent := range sData {
            if criteriaFunc(curStudent.Report) {
                result = append(result, curStudent)
            }
        }
        return result
    }
}

func main() {
    var jsonObj struct {
        Students []*Student
    }
    if err := json.Unmarshal([]byte(DBData), &jsonObj); err != nil {
        panic(err)
    }

    students := jsonObj.Students

    filterMathExcellent := NewFilter(students, func(subjects []*Subject) bool {
        for _, s := range subjects {
            if s.Name == "Math" && s.Average > 90 {
                return true
            }
        }
        return false
    })

    // each subject score must >= 80
    filterEveryGood := NewFilter(students, func(subjects []*Subject) bool {
        for _, s := range subjects {
            if s.Average < 80 {
                return false
            }
        }
        return true
    })

    groupMathExcellentStudents := filterMathExcellent()
    groupEveryGoodStudents := filterEveryGood()
    fmt.Printf("%+v\n", groupMathExcellentStudents)
    fmt.Printf("%+v\n", groupEveryGoodStudents)
}

go playground

以上就是《筛选包含嵌套数组的数据》的详细内容，更多关于的资料请关注golang学习网公众号！