Arrays 无法转换类型为'；[数据模型]'；到预期的参数类型'；（数据模型）抛出->；布尔'；

由于某些原因，我无法比较两个不同的阵列，例如：

if (self.data.contains(where: self.compareData)){
}

抛出：

无法将“[dataModel]”类型的值转换为预期的参数类型 “（数据模型）抛出->布尔”

使用

==

尝试比较它们也会抛出一个错误，因为

二进制运算符“==”不能应用于“（（数据模型）throws->Bool）throws->Bool”和“[dataModel]”类型的操作数。

数组的格式为：

var data : [dataModel] = [dataModel] ()
var compareData : [dataModel] = [dataModel]()

我正在检查该数组是否设置为在替换数据和更新表之前发送的相同数组

编辑：以下是数据模型代码：

class dataModel {
   var teamName : String = ""

   var aboutTeams : String = ""

   // var rate : String = "5" // team Rating

   var messageID : String = ""
}

---

这是因为您尝试使用的函数需要NSPredicate

检查一个数组是否包含另一个数组的子集的一种方法是执行以下操作：

var dataSet = Set(data)
var compareDataSet = Set(compareData)

if compareDataSet.isSubsetOf(dataSet) {
   // Do something
}

编辑：您的类需要符合equalable

class dataModel: Equatable {

    var teamName : String = ""

    var aboutTeams : String = ""

   // var rate : String = "5" // team Rating

    var messageID : String = ""

    override func isEqual(_ object: Any?) -> Bool {
        if let object = object as? dateModel {
            return self.teamName == object.teamName && self.aboutTeams == object.aboutTeams && self.messageID == object.messageID
        } else {
            return false
        }
    } 
}

---

这是因为您尝试使用的函数需要NSPredicate

检查一个数组是否包含另一个数组的子集的一种方法是执行以下操作：

var dataSet = Set(data)
var compareDataSet = Set(compareData)

if compareDataSet.isSubsetOf(dataSet) {
   // Do something
}

编辑：您的类需要符合equalable

class dataModel: Equatable {

    var teamName : String = ""

    var aboutTeams : String = ""

   // var rate : String = "5" // team Rating

    var messageID : String = ""

    override func isEqual(_ object: Any?) -> Bool {
        if let object = object as? dateModel {
            return self.teamName == object.teamName && self.aboutTeams == object.aboutTeams && self.messageID == object.messageID
        } else {
            return false
        }
    } 
}

---

如果数据模型中的元素本质上具有可比性/可等式，如字符串或Int，则可以比较这些元素的属性。如果希望能够测试数据模型数组本身中特定元素的相等性，则必须使数据模型符合可等式

我相信您面临的问题与使您的数据模型类或结构符合Equatable有关，或者与如何填充数据和比较数据有关

这个基本的例子应该给你一个如何做的想法。它测试数据不同部分（更小和更大的实体）的相等性：

我看到您刚刚展示了数据模型的代码（类通常应该大写），因此下面是一个使用实际类实现的更定制的示例：

class DataModel: Equatable {
    static func == (lhs: DataModel, rhs: DataModel) -> Bool {
        guard lhs.aboutTeams == rhs.aboutTeams else {return false}
        guard lhs.messageID == rhs.messageID else {return false}
        guard lhs.teamName == rhs.teamName else {return false}
        return true
    }

    var teamName : String = ""
    var aboutTeams : String = ""
    var messageID : String = ""
}

var data : [DataModel] = [DataModel]()

var compareData : [DataModel] = [DataModel]()

data = [
    DataModel(),
    DataModel()
]
data[0].teamName = "raptors"
data[0].messageID = "5"

compareData = [
    DataModel(),
    DataModel()
]
compareData[0].teamName = "raptors"
compareData[0].messageID = "4"

if data[0].teamName == compareData[0].teamName {
    print("Element 0 team names are equal")
} else {
    print("Element 0 team names are not equal")
}

if data[0].messageID == compareData[0].messageID {
    print("Elemeant 0 message IDs are equal")
} else {
    print("Elemeant 0 message IDs are not equal")
}

if data[1] == compareData[1] {
    print("Element 1 of data and compareData are equal")
}

if data == compareData {
    print("Arrays are equal")
} else {
    print("Arrays are not equal")
}

控制台输出为：

Element 0 team names are equal
Elemeant 0 message IDs are not equal
Element 1 of data and compareData are equal
Arrays are not equal

---

希望这有帮助

如果数据模型中的元素本质上具有可比性/可均衡性，如字符串或Int，则可以比较这些元素的属性。如果希望能够测试数据模型数组本身中特定元素的相等性，则必须使数据模型符合可均衡性

我相信您面临的问题与使您的数据模型类或结构符合Equatable有关，或者与如何填充数据和比较数据有关

这个基本的例子应该给你一个如何做的想法。它测试数据不同部分（更小和更大的实体）的相等性：

我看到您刚刚展示了数据模型的代码（类通常应该大写），因此下面是一个使用实际类实现的更定制的示例：

class DataModel: Equatable {
    static func == (lhs: DataModel, rhs: DataModel) -> Bool {
        guard lhs.aboutTeams == rhs.aboutTeams else {return false}
        guard lhs.messageID == rhs.messageID else {return false}
        guard lhs.teamName == rhs.teamName else {return false}
        return true
    }

    var teamName : String = ""
    var aboutTeams : String = ""
    var messageID : String = ""
}

var data : [DataModel] = [DataModel]()

var compareData : [DataModel] = [DataModel]()

data = [
    DataModel(),
    DataModel()
]
data[0].teamName = "raptors"
data[0].messageID = "5"

compareData = [
    DataModel(),
    DataModel()
]
compareData[0].teamName = "raptors"
compareData[0].messageID = "4"

if data[0].teamName == compareData[0].teamName {
    print("Element 0 team names are equal")
} else {
    print("Element 0 team names are not equal")
}

if data[0].messageID == compareData[0].messageID {
    print("Elemeant 0 message IDs are equal")
} else {
    print("Elemeant 0 message IDs are not equal")
}

if data[1] == compareData[1] {
    print("Element 1 of data and compareData are equal")
}

if data == compareData {
    print("Arrays are equal")
} else {
    print("Arrays are not equal")
}

控制台输出为：

Element 0 team names are equal
Elemeant 0 message IDs are not equal
Element 1 of data and compareData are equal
Arrays are not equal

---

希望这有帮助

如果您只需要查看两个数组是否相等，则可以使用一个简单的函数：

func compare<T: Equatable>(_ array1: [T], _ array2: [T] ) -> Bool {
   guard array1.count == array2.count else {return false}
   for i in 0 ..< array1.count {
      if array1[i] != array2[i] { return false}
   }
   return true
}

func比较（array1:[T]，array2:[T]）->Bool{
guard array1.count==array2.count else{return false}
对于0中的i..

您甚至可以将其构建为数组的扩展

extension Array where Element: Equatable{
   func compare(to array: [Element]) -> Bool {
      guard array.count == self.count else {return false}
      for i in 0 ..< array.count {
            if array[i] != self[i] { return false}
      }
      return true
   }
}

扩展数组，其中元素：equalable{
func比较（到数组：[Element]）->Bool{
guard array.count==self.count else{return false}
对于0中的i..

---

编译器不允许您比较两个不同类型的数组

如果您只需要查看两个数组是否相等，则可以使用一个简单的函数：

func compare<T: Equatable>(_ array1: [T], _ array2: [T] ) -> Bool {
   guard array1.count == array2.count else {return false}
   for i in 0 ..< array1.count {
      if array1[i] != array2[i] { return false}
   }
   return true
}

func比较（array1:[T]，array2:[T]）->Bool{
guard array1.count==array2.count else{return false}
对于0中的i..

您甚至可以将其构建为数组的扩展

extension Array where Element: Equatable{
   func compare(to array: [Element]) -> Bool {
      guard array.count == self.count else {return false}
      for i in 0 ..< array.count {
            if array[i] != self[i] { return false}
      }
      return true
   }
}

扩展数组，其中元素：equalable{
func比较（到数组：[Element]）->Bool{
guard array.count==self.count else{return false}
对于0中的i..

---

编译器不允许您比较两个不同类型的数组

你可以试试这个例子

import UIKit


class ViewController: UIViewController, NavDelegate {
    var data : [dataModel] = [dataModel]()
    var compareData : [dataModel] = [dataModel]()

    override func viewDidLoad() {
        super.viewDidLoad()

        data = [
            dataModel(teamName: "cyber1", aboutTeams: "strong", messageID: "1001"),
            dataModel(teamName: "cyber1", aboutTeams: "good", messageID: "1002")
        ]

        compareData = [
            dataModel(teamName: "cyber1", aboutTeams: "strong", messageID: "1001"),
            dataModel(teamName: "cyber1", aboutTeams: "good 2", messageID: "1002")
        ]


        let dataSet = Set(data)
        let compareDataSet = Set(compareData)

        if compareDataSet == dataSet {
           print("compareDataSet and dataSet are equal")
        }else{
            print("compareDataSet and dataSet are not equal")
        }
    }

    struct dataModel: Hashable {
        var teamName : String = ""
        var aboutTeams : String = ""
        var messageID : String = ""
    }
}

---

你可以试试这个例子

import UIKit


class ViewController: UIViewController, NavDelegate {
    var data : [dataModel] = [dataModel]()
    var compareData : [dataModel] = [dataModel]()

    override func viewDidLoad() {
        super.viewDidLoad()

        data = [
            dataModel(teamName: "cyber1", aboutTeams: "strong", messageID: "1001"),
            dataModel(teamName: "cyber1", aboutTeams: "good", messageID: "1002")
        ]

        compareData = [
            dataModel(teamName: "cyber1", aboutTeams: "strong", messageID: "1001"),
            dataModel(teamName: "cyber1", aboutTeams: "good 2", messageID: "1002")
        ]


        let dataSet = Set(data)
        let compareDataSet = Set(compareData)

        if compareDataSet == dataSet {
           print("compareDataSet and dataSet are equal")
        }else{
            print("compareDataSet and dataSet are not equal")
        }
    }

    struct dataModel: Hashable {
        var teamName : String = ""
        var aboutTeams : String = ""
        var messageID : String = ""
    }
}

---

它说：类型“dataModel”不符合协议“Hashable”什么是dataModel？它是一个用于设置/获取字符串的类，我进行了编辑以包含“dataModel”代码。我用类dataModel的代码更新了我的答案。看看这是否有效。请看这里的可哈希错误：它说：类型“dataModel”不符合协议“Hashable”什么是dataModel？它是一个用于设置/获取字符串的类，我进行了编辑以包含“dataModel”代码。我用类dataModel的代码更新了我的答案。查看是否有效。请参阅此处了解哈希错误：