2012-02-18 12 views

risposta

35

userei:

(into {} (filter (comp some? val) {:a :x, :b nil, :c :z})) 

=> {:a :x, :c :z} 

Facendo il controllo some? esplicitamente è importante perché se lo farete (into {} (filter val {...})) allora verrà rimosso erroneamente valori che sono booleano falso.

+9

o forse ' (in {} (remove (comp nil? val) {: a: x: b nil: c: z})) ' – Jonas

+3

Sì, t lui rimuovere la versione è equivalente. In effetti, la rimozione è effettivamente implementata nel sorgente Clojure usando il filtro, come: '(filter (complement pred) coll)'. La versione con filtro è leggermente più veloce, la versione con remove è leggermente più breve per digitare :-) – mikera

+0

E i valori nid annidati? –

0
(into {} (keep (fn [e] (if (val e) e)) {:a :x :b nil :c :z})) 
;;=> {:a :x, :c :z} 

o un po 'più corto:

(into {} (keep #(if (val %) %) {:a :x :b nil :c :z})) 

In realtà, il suo suggerimento filtro è molto meglio e più breve, quindi mi sarebbe solo usare quella:

(into {} (filter val {:a :x :b nil :c :z})) 
+0

la funzione restituisce (: x: z) al posto di {: a: x: c: z} – mishadoff

+0

mishadoff: tnx, risolto ora –

5

io uso codice seguente:

(into {} (filter val {:a 1, :b 2, :c nil})) 
;;=> {:a 1, :b 2} 

NOTA: questo sarà rimuovere i valori falsi così come Nils

+5

questo filtro falsa anche :( –

+0

di u puoi usare il metodo decifrato da mikera.Ma nella maggior parte dei casi abbiamo una logica che nil significa falso e vv – mishadoff

3

Probabilmente non è la soluzione migliore, ma qui è uno che utilizza la lista di comprensione:

(into {} 
    (for [[k v] {:a 1 :b nil :c :z} :when (not (nil? v))] 
    [k v])) 
-3

Il miglior modo per farlo è in realtà (into {} (keep second {:a :x :b nil}))

+0

(mantieni il secondo {: a: x: b nil}) ==> (: x), 'in' genera un'eccezione. –

Problemi correlati