Question

我有以下数组，其中包含用户搜索的产品；一旦被搜索到，产品的标签也将存储在searchTags数组中，如下所示：

searchedTags = [ [product : [tagA, tagB, tagC, tagD, tagH ]] ]

现在，我有了所有产品的数组列表，其中每个产品都包含不同的标签：

productTagsArray = [ [product1 : [tagA, tagB, tagC, tagD]],
                [product2 : [tagC, tagD, tagE, tagF, tag H]], 
                [product3 : [tagH, tagI, tagJ]],
                [product4 : [tagK, tagL, tagM]],
                ...
              ]

现在，我想检查并比较searchedTags中搜索到的产品中的标签与productTagsArray中的每个产品中的标签。比较之后，我想制作一个新的产品数组，并按与搜索到的产品匹配（从高到低）的COUNTS个标签进行排序。如果没有匹配的标签，我不想将它们包括在新变量中。我想填充这种排序的匹配结果，如下所示：

sortedProductsByCount = [[productId : product1, numberOfTagsMatched : 4],
                        [productId : product2, numberOfTagsMatched : 2],
                        [productId : product1, numberOfTagsMatched : 1]
                        ]

编辑： 这是我在用户单击表视图中的搜索结果时写的内容：

var productsTagCount: [[String:Any]] = [[:]]

    for tags in searchedProductTags {
        for tag in tags {
            for productArray in productTagsArray {
                for product in productArray {

                    var tagCount: Int = 0

                    for productTag in product.value {
                        if productTag == tag {
                            tagCount = tagCount + 1
                        }
                    }

                    let data: [String : Any] = [
                        "productId": product.key,
                        "tagCount": tagCount
                    ]

                    productsTagCount.append(data)

                }
            }
        }
    }

有更好的方法吗？如何完成sortedProductByCount数组？

Answer 1

这是我修复它的方法。不得不改变我的代码很多。

var productTagsArray : [[String : [String]]] = [[:]]
var productTagCount : [String : Int] = [:]
var sortedProductTagCount: [Int : [String : Int]] = [:]


let searchedProductTags = searchResults[indexPath.row].values

    for productArray in productTagsArray {
        for product in productArray {

            let productId: String = product.key
            var tagCount: Int = 0

            for productTag in product.value {

                for searchedTags in searchedProductTags {
                    for searchedTag in searchedTags {

                        if productTag == searchedTag {
                            tagCount = tagCount + 1
                        }
                    }
                }
            }

            if tagCount != 0 {                    
                productTagCount[productId] = tagCount                    
            }
        }
    }

    //Make an array with sorted tagscount
    let sortedProductTagCountVar = productTagCount.sorted{ $0.value > $1.value }
    var productSortIndex: Int = 0

    for (k,v) in sortedProductTagCountVar {
        productSortIndex = productSortIndex + 1
        sortedProductTagCount[productSortIndex, default: [:]][k] = v
    }

比较两个包含字典和数组的数组

1 个答案: