Clojure按id筛选向量中的嵌套映射

在矢量和地图数据示例中：

        [{:id 2, 
        :codigo "2", 
        :subcats 
            [{:id 3, 
              :codigo "3", 
              :subcats [], 
              :slug "pens-ss", 
              :foto nil, 
              :parent 2}
             {:id 4, 
              :codigo "44", 
              :subcats [], 
              :slug "rotula", 
              :foto nil, 
              :parent 2}
             {:id 5, 
              :codigo "hand", 
              :subcats 
                  [{:id 6, 
                      :codigo "caba", 
                      :subcats [], 
                      :slug "caballetes",
                      :foto nil, 
                      :parent 5}
                   {:id 7, 
                      :codigo "Carton", 
                      :subcats 
                           [{:id 9, 
                             :codigo "ooo", 
                             :subcats [], 
                             :slug "carton-piedra-el-nuevo", 
                             :parent 7}], 
                      :slug "cartoncillos", 
                      :foto nil, 
                      :parent 5}],
               :slug "hands", 
               :foto nil, 
               :padre 2}], 
        :slug "paper",
        :foto nil, 
        :padre nil}]

我可以过滤第一级id，但不能按id过滤嵌套的“子类别”。如何过滤向量中没有“for”的嵌套映射？。我需要获取嵌套贴图，例如，id=5返回所有子类别：

(filter #(= (:id %) 5 ) @cats)

通过id 5查找，我要返回以下内容：

             {:id 5, 
              :codigo "hand", 
              :subcats 
                  [{:id 6, 
                      :codigo "caba", 
                      :subcats [], 
                      :slug "caballetes",
                      :foto nil, 
                      :parent 5}
                   {:id 7, 
                      :codigo "Carton", 
                      :subcats 
                           [{:id 9, 
                             :codigo "ooo", 
                             :subcats [], 
                             :slug "carton-piedra-el-nuevo", 
                             :parent 7}], 
                      :slug "cartoncillos", 
                      :foto nil, 
                      :parent 5}],
               :slug "hands", 
               :foto nil, 
               :padre 2}

给定

(def root {:id 2, 
        :codigo "2", 
        :subcats 
            [{:id 3, 
              :codigo "3", 
              :subcats [], 
              :slug "pens-ss", 
              :foto nil, 
              :parent 2}
             {:id 4, 
              :codigo "44", 
              :subcats [], 
              :slug "rotula", 
              :foto nil, 
              :parent 2}
             {:id 5, 
              :codigo "hand", 
              :subcats 
                  [{:id 6, 
                      :codigo "caba", 
                      :subcats [], 
                      :slug "caballetes",
                      :foto nil, 
                      :parent 5}
                   {:id 7, 
                      :codigo "Carton", 
                      :subcats 
                           [{:id 9, 
                             :codigo "ooo", 
                             :subcats [], 
                             :slug "carton-piedra-el-nuevo", 
                             :parent 7}], 
                      :slug "cartoncillos", 
                      :foto nil, 
                      :parent 5}],
               :slug "hands", 
               :foto nil, 
               :padre 2}], 
        :slug "paper",
        :foto nil, 
        :padre nil})

您可以使用

tree seq

获取所有节点的序列：

(tree-seq map? :subcats root)

然后，您可以通过

：id

找到所需的节点：

(first (filter #(= 5 (:id %)) (tree-seq map? :subcats root)))

如果返回的数据是顶级序列，则可以使用

mapcat

检索林中的所有节点：

(def root [{:id 2, ...}])

(mapcat #(tree-seq map? :subcats %) root)

---

大致

（filter（fn[{:keys[subcats]}]（some#（=（：id%）5）subcats））@cats）

您能给出一个您想要实现的查询和结果的示例吗？是否要按id的路径筛选嵌套子类别？@cfrick现在，第一级找不到它，数据示例：id=2@chivam例如，从id 5，我需要您的所有子类别。这给出了第一个级别：ID2（filter#（=（：id%）5）@cats）我把这个问题理解为“给我所有根猫”，它们包含一个id为N的子类别”；我想第二点，您应该给出一个输入和输出的（simplifye）示例。当数据是一个向量时，我可以更改为映射为：（转换为{}数据），但只转换最后一行数据。有什么建议吗？你应该用一个所需输出的例子来更新你的问题。@AlanThompson用[{…}]表示API响应，树seq以一个映射开始，而不是以vector@dpmontero-我已经更新了答案，对你有用吗？