1

动机是检查深层嵌套地图中发生了什么变化，有点像update-in.

这是一个简单的例子：

(def p1 {:a {:a1 :1 :a2 :2}
         :b {:b1 :1 :b2 :2}})

(def p2 (update-in p1 [:a :a1] (constantly :updated))
;; => {:a {:a1 :updated :a2 :2}
;;     :b {:b1 :1 :b2 :2}}

(what-changed? p1 p2) 
;; => {:keys [:a :a1] :value :updated)

(what-changed? p2 p1) 
;; => {:keys [:a :a1] :value :2)

我希望因为 clojure 映射是持久的数据结构，可能有一种智能算法可以通过查看底层结构而不是遍历嵌套映射并比较差异来解决这个问题。

4

2 回答 2

2

我会想象一个直接的递归算法，比如(if (= map1 map2) :no-change (recursively-check-children ...))已经很好地利用了结构共享，除非你正在处理非常宽的树（每个节点有很多分支）。在任何情况下，您可能都想查看clojure.data/diff，它解决了您的问题的一般、非递归版本，并且还从直接开始(= a b)

于 2012-12-04T07:56:23.480 回答
1

持久性数据结构仅与实现有关，而与“查看底层结构”无关。正如 Joost 所说（+1），您可以使用“差异”。它只需要使用您的 "{:keys ... :value ...}" 模式转换答案：

(def p1 {:a {:a1 :1 :a2 :2}
         :b {:b1 :1 :b2 {:b11 :11 :b22 :22}}})

(def p2 {:a {:a1 :updated1 :a2 :2}
         :b {:b1 :1 :b2 {:b11 :updated2 :b22 :updated3}}})

(defn what-changed?* [m]
  (if (not (map? m))
    [(list m)]
    (apply concat (map (fn [k]
                         (map (fn [nest-k]
                                (conj nest-k k))
                              (nested-keys (m k))))
                       (keys m)))))

(defn what-changed? [m1 m2]
  (map (fn [l] {:keys (drop-last l) :value (last l)})
       (nested-keys (second (data/diff m1 m2)))))

测试：

(what-changed? p1 p2)
-> ({:keys (:a :a1), :value :updated1}
    {:keys (:b :b2 :b11), :value :updated2}
    {:keys (:b :b2 :b22), :value :updated3})

(what-changed? p2 p1)
-> ({:keys (:a :a1), :value :1}
    {:keys (:b :b2 :b11), :value :11}
    {:keys (:b :b2 :b22), :value :22})

顺便说一句，在您的情况下，您可以通过“assoc-in”而不是“update-in”来修改 hashmap：

(assoc-in {:a {:a1 :1 :a2 :2}
           :b {:b1 :1 :b2 :2}}
          [:a :a1] :updated)
-> {:a {:a2 :2, :a1 :updated}
    :b {:b2 :2, :b1 :1}}
于 2012-12-04T11:02:46.417 回答