Question

这似乎是一个基本问题..但我对如何使用新的swift语法实现这一点感到困惑。点击集合视图上的按钮，我就有了这样的东西....

    let productObject = productData1[(indexPath?.row)!]
    self.myArray.append(productObject)

现在，当我再次点击该按钮时，我想检查myArray是否已经productObject，以便它不会再次添加到阵列中...希望有人可以提供帮助......

编辑：productData1是一种结构产品，如此......

struct Product {
    let name : String
    let id : String
    var images = [ProductImage]()
    var theRate : String
    var quantity: String
    var sku: String
    var prdCateg: String
    var prodDescr: String
    var mrp: String
    var prodcutImage: ProductImage?

    init(name : String, id: String, theRate: String, quantity: String, sku: String, prdCateg:String, prodDescr: String, prodcutImage: ProductImage?, mrp: String) {
        self.name = name
        self.id = id
        self.theRate = theRate
        self.quantity = quantity
        self.sku = sku
        self.prdCateg = prdCateg
        self.prodDescr = prodDescr
        self.prodcutImage = prodcutImage
        self.mrp = mrp

    }

    mutating func add(image: ProductImage) {
        images.append(image)
    }
}

Answer 1

希望这会对你有帮助..

  let productObject = productData1[(indexPath?.row)!]

     let filteredArray = self.myArray.filter(){
             return $0.id == productObject.id
          }
   if filteredArray.count == 0 {
      self.myArray.append(productObject)
             }

Answer 2

这是2个解决方案。第一个是更高效的IMO。

解决方案I - 维护其他地图数据源

var myArray: [Product] = []
var myDictionary: [String : Product] = [:]

func add(newProduct product: Product) {

    // Add only if product isn't contained in datasource (Test in O(1))
    guard myDictionary[product.id] == nil else {
        return
    }

    myArray.append(product)
    myDictionary[product.id] = product
}

内存动机/考虑：由于Swift语言复制结构的惰性方式，附加数据源的内存成本相对较低。数组和字典都包含相同的Products实例，直到其内部内容发生更改。

解决方案II （效率较低） - 使用包含集合视图的方法（每次迭代数组

var myArray: [Product] = []

func add(newProduct product: Product) {

    // Test while `contains`
    guard !myArray.contains { $0.id == product.id } else {
        return
    }

    myArray.append(product)
}

Answer 3

如果您不关心myArray内对象的顺序，那么一个解决方案就是使用Set。首先，您需要使struct Product符合Hashable。通过查看结构，我们可以假设两个产品等于它们的ID是等于。

extension Product: Hashable {

    var hashValue: Int { return id.hashValue}

    static func ==(lhs: Product, rhs: Product) -> Bool {
        return lhs.id == rhs.id
    }
}

您重新定义myArray，如下所示：

var myArray: Set<Product> = [] // Creating the Set of `Products`

// inserting product with id "123"
myArray.insert(Product(name: "name",
                       id: "123",
                       images: [],
                       theRate: "",
                       quantity: "",
                       sku: "",
                       prdCateg: "",
                       prodDescr: "",
                       mrp: "", prodcutImage: nil))

// Trying to insert product with id "123" but it already exists,
// It won't be added to myArray
myArray.insert(Product(name: "name",
                       id: "123",
                       images: [],
                       theRate: "",
                       quantity: "",
                       sku: "",
                       prdCateg: "",
                       prodDescr: "",
                       mrp: "", prodcutImage: nil))

print(myArray.count) // 1

Answer 4

ProductImage应符合协议Equatable。然后你可以 check是ProductImage的对象是相同的，因此在添加新的之前是images.contains（image）。

要符合协议，您需要为ProductImage实现func ==。

像

这样的东西

$which pip
/usr/local/Cellar/python/2.7.14/libexec/bin/pip

检查数组是否包含对象的问题

4 个答案: