Arrays 检查一个数组是否包含另一个数组的所有值（是否所有用户都分配了作业？）

总的来说是个noob问题，但我已经尽了最大努力，不知道如何迭代我的数组并确定它是否包含另一个数组的所有值

这是我的数组类（dailyJobs）：

下面是我要检查的类（用户）：

这是我的JSON树，如果有帮助的话：

{
"-Kw2SkmAqo3G_cVFP26Y" : {
"assigned" : "Aiden",
"multiplier" : 1,
"name" : "table",
"order" : 2
},
"-Kw2SkmAqo3G_cVFP26Z" : {
"assigned" : "Mom",
"multiplier" : 1,
"name" : "dishes",
"order" : 3
},
"-Kw2SyhJNkjKNQ-sKBeT" : {
"assigned" : "Sophie",
"multiplier" : 1,
"name" : "floors",
"order" : 0
},
"-Kw2SyhJNkjKNQ-sKBeU" : {
"assigned" : "Savannah",
"multiplier" : 1,
"name" : "laundry",
"order" : 1
},
"-Kw7H3pY2L5PzLLdd6qD" : {
"assigned" : "Dad",
"multiplier" : 1,
"name" : "another daily test",
"order" : 4
},
"-Kw7HAWwAvv5ZjYuNOrg" : {
"assigned" : "Sophie",
"multiplier" : 1,
"name" : "daily job testsaroo!",
"order" : 5 }

以下是我尝试过的：

尝试#1:

var tempArray = [String]()
    for user in self.users {
        for job in self.dailyJobs {
            if job.assigned == user.firstName {
                print(user.firstName,"has a job",job.name)
                tempArray.append(user.firstName)
            }
        }
    }
    for user in self.users {
        if tempArray.contains(user.firstName) {
            print("true")
        } else {
            print("false")
        }
    }

尝试#2:（这甚至没有编译）

尝试#3:重复打印“失败”

for job in self.dailyJobs {
        for user in self.users {
            if job.assigned != user.firstName {
                print("FAILED")
            }
        }
    }

如何检查用户阵列中的每个用户是否至少分配了一个作业？换句话说，如何确保在

dailyJobs

数组中，每个

user.firstName

至少表示一次

我想我必须做一些循环，但我不知道如何继续。有人能给我指出正确的方向吗？现在我只是在兜圈子（请原谅我的双关语）。

尝试1就快到了。在检查所有用户后，您只能说它是

true

：

func areAllAssigned(users: [UserClass], tempArray: [String]) -> Bool {
  for user in users {
    if !tempArray.contains(user.firstName) {
        return false
    }
  }
  return true
}

实际上，对于循环，您不需要外部的

：

for job in self.dailyJobs {
    print(job.assigned, "has a job", job.name)
    tempArray.append(job.assigned)
}

areAllAssigned(users: self.users, tempArray: tempArray)

尝试1接近成功。在检查所有用户后，您只能说它是
true
：

func areAllAssigned(users: [UserClass], tempArray: [String]) -> Bool {
  for user in users {
    if !tempArray.contains(user.firstName) {
        return false
    }
  }
  return true
}

实际上，对于

循环，您不需要外部的

：

for job in self.dailyJobs {
    print(job.assigned, "has a job", job.name)
    tempArray.append(job.assigned)
}

areAllAssigned(users: self.users, tempArray: tempArray)

找到后，我让它开始工作

我的代码：

func checkIfAllUsersHaveDailyJobs() -> Bool {
    var tempArray = [String]()
    for job in self.dailyJobs {
        for user in self.users {
            if job.assigned == user.firstName {
                print(user.firstName,"has the job:",job.assigned)
                tempArray.append(user.firstName)
            }
        }
    }
    print(tempArray.count)

    for user in self.users {
        if !tempArray.contains(user.firstName) {
            return false
        }
    }
    return true
}

找到后，我让它开始工作

我的代码：

func checkIfAllUsersHaveDailyJobs() -> Bool {
    var tempArray = [String]()
    for job in self.dailyJobs {
        for user in self.users {
            if job.assigned == user.firstName {
                print(user.firstName,"has the job:",job.assigned)
                tempArray.append(user.firstName)
            }
        }
    }
    print(tempArray.count)

    for user in self.users {
        if !tempArray.contains(user.firstName) {
            return false
        }
    }
    return true
}

使类符合可散列的
并使用
Set
。你不需要那么多代码

已更新

您不需要在此处使用Hashable。我误解了你的问题。我简化了代码，但基本上它有你需要的

struct JobsAndHabits {
    let assigned: String
}

struct UserClass {
    let firstName: String
}

let users = [UserClass(firstName: "person_a"),
             UserClass(firstName: "person_b"),
             UserClass(firstName: "person_c"),
             UserClass(firstName: "person_d")]

let jobs = [JobsAndHabits(assigned: "person_a"),
            JobsAndHabits(assigned: "person_c")]

let names = Set(users.map({ return $0.firstName }))
let assigned = Set(jobs.map({ return $0.assigned }))

print(names.subtracting(assigned)) // users who doesn't have jobs

使类符合可散列的
并使用
Set
。你不需要那么多代码

已更新

您不需要在此处使用Hashable。我误解了你的问题。我简化了代码，但基本上它有你需要的

struct JobsAndHabits {
    let assigned: String
}

struct UserClass {
    let firstName: String
}

let users = [UserClass(firstName: "person_a"),
             UserClass(firstName: "person_b"),
             UserClass(firstName: "person_c"),
             UserClass(firstName: "person_d")]

let jobs = [JobsAndHabits(assigned: "person_a"),
            JobsAndHabits(assigned: "person_c")]

let names = Set(users.map({ return $0.firstName }))
let assigned = Set(jobs.map({ return $0.assigned }))

print(names.subtracting(assigned)) // users who doesn't have jobs

下面介绍如何使用集合（而不使类可散列）

下面介绍如何使用集合（而不使类可散列）

你回答的时候，我自己就知道了。谢谢你的帮助。我会把你的答案标记为正确，因为这正是我最终要做的。太好了！谢谢标记：）注意，正如我在回答中提到的，创建
tempArray
时，不需要嵌套的
for
循环。当你回答时，我自己解决了这个问题。谢谢你的帮助。我会把你的答案标记为正确，因为这正是我最终要做的。太好了！感谢您的标记：）请注意，正如我在回答中提到的，您不需要嵌套的
for
循环来创建
tempArray
。请注意，您应该只使用
类
，对于极少数情况，使用引用而不是值是有意义的。对于大多数数据对象，应该使用
struct
。然后您可以完全摆脱那些
init
方法，因为
structs
合成了一个设置所有属性的
init
。此外，在Swift 4中，如果您遵守
Codable
协议，您将自动从JSON（以及可能的其他数据结构）获得编码和解码。非常好的信息。我是否能够以1:1的比例将类替换为结构，还是需要完全重写代码？我的意思是，我可以进去把我的类改成struct然后一切都会好起来吗，还是因为类和结构不是可比较的对象，所以需要做更多的工作？除非您使用一些高度特定于类的语言功能，否则在交换这两个功能时应该不会有什么问题。关于为什么要使用一个而不是另一个的进一步阅读：我刚开始时阅读了apple文档，这让它看起来像是一个
类
是更好的选择。所以现在我很困惑，因为你发给我的链接让我觉得
structs
才是正确的选择。看来我还需要做更多的研究。请注意，您应该只使用
类
，对于那些罕见的情况，使用引用而不是值是有意义的。对于大多数数据对象，应该使用
struct
。然后您可以完全摆脱那些
init
方法，因为
structs
合成了一个设置所有属性的
init
。此外，在Swift 4中，如果您遵守
Codable
协议，您将自动从JSON（以及可能的其他数据结构）获得编码和解码。非常好的信息。我是否能够以1:1的比例将类替换为结构，还是需要完全重写代码？我的意思是，我可以进去把我的类改成struct然后一切都会好起来吗，还是因为类和结构不是可比较的对象，所以需要做更多的工作？除非您使用一些高度特定于类的语言功能，否则在交换这两个功能时应该不会有什么问题。关于为什么要使用一个而不是另一个的进一步阅读：我刚开始时阅读了apple文档，这让它看起来像是一个
类
是更好的选择。所以现在我很困惑，因为你发给我的链接让我觉得
structs
才是正确的选择。看来，我还需要做更多的研究。我读了一些关于遵守
散列值以及使用
集的内容，但既然我是个傻瓜，你能详细说明一下你将如何使用它们吗？我完全准备好清理和简化我的代码。我读了一些关于遵守
哈希值的书，也读了一些关于使用
set
，但是既然我是个傻瓜，你能详细说明一下你将如何使用它们吗？我完全准备好清理和简化我的代码。如果使用“过滤器”，则无需使用Set。取决于作业和用户的数量，一个简单的过滤器将给出O（n/2），而Set将给出pro