Uji apakah daftar berisi nilai tertentu di Clojure

Apa cara terbaik untuk menguji apakah daftar berisi nilai yang diberikan di Clojure?

Secara khusus, perilaku contains?saat ini membingungkan saya:

(contains? '(100 101 102) 101) => false

Saya jelas bisa menulis fungsi sederhana untuk menelusuri daftar dan menguji kesetaraan, tetapi pasti ada cara standar untuk melakukan ini?

Ah, contains?... seharusnya salah satu dari lima FAQ teratas: Clojure.

Itu tidak memeriksa apakah koleksi berisi nilai; itu memeriksa apakah suatu item dapat diambil dengan getatau, dengan kata lain, apakah koleksi berisi kunci. Ini masuk akal untuk set (yang dapat dianggap sebagai membuat tidak ada perbedaan antara kunci dan nilai-nilai), peta (jadi (contains? {:foo 1} :foo)adalah true) dan vektor (tapi catatan itu (contains? [:foo :bar] 0)adalah true, karena kunci di sini adalah indeks dan vektor yang bersangkutan tidak "mengandung" yang indeks 0!).

Untuk menambah kebingungan, dalam kasus di mana tidak masuk akal untuk menelepon contains?, itu hanya kembali false; inilah yang terjadi di (contains? :foo 1) dan juga (contains? '(100 101 102) 101) . Pembaruan: Di Clojure ≥ 1,5 contains?lemparan ketika menyerahkan objek jenis yang tidak mendukung tes "keanggotaan kunci" yang dimaksud.

Cara yang benar untuk melakukan apa yang Anda coba lakukan adalah sebagai berikut:

; most of the time this works
(some #{101} '(100 101 102))

Saat mencari salah satu dari banyak item, Anda dapat menggunakan set yang lebih besar; ketika mencari false/ nil, Anda dapat menggunakan false?/ nil?- karena (#{x} x)mengembalikan x, dengan demikian (#{nil} nil)adalah nil; saat mencari salah satu dari beberapa item yang beberapa di antaranya mungkin falseatau nil, Anda dapat menggunakan

(some (zipmap [...the items...] (repeat true)) the-collection)

(Perhatikan bahwa barang dapat dikirimkan ke zipmapdalam jenis koleksi apa pun.)

Inilah utilisasi standar saya untuk tujuan yang sama:

(defn in? 
  "true if coll contains elm"
  [coll elm]  
  (some #(= elm %) coll))

Anda selalu dapat memanggil metode java dengan sintaks .methodName.

(.contains [100 101 102] 101) => true

Saya tahu bahwa saya sedikit terlambat, tetapi bagaimana dengan:

(contains? (set '(101 102 103)) 102)

Akhirnya di clojure 1.4 output benar :)

(not= -1 (.indexOf '(101 102 103) 102))

Bekerja, tetapi di bawah ini lebih baik:

(some #(= 102 %) '(101 102 103)) 

Untuk apa nilainya, ini adalah implementasi sederhana saya dari fungsi berisi daftar:

(defn list-contains? [coll value]
  (let [s (seq coll)]
    (if s
      (if (= (first s) value) true (recur (rest s) value))
      false)))

Jika Anda memiliki vektor atau daftar dan ingin memeriksa apakah suatu nilai terkandung di dalamnya, Anda akan menemukan bahwa contains?itu tidak berfungsi. Michał telah menjelaskan alasannya .

; does not work as you might expect
(contains? [:a :b :c] :b) ; = false

Ada empat hal yang dapat Anda coba dalam hal ini:

1. Pertimbangkan apakah Anda benar-benar membutuhkan vektor atau daftar. Jika Anda menggunakan set sebagai gantinya , contains?akan berfungsi.

   (contains? #{:a :b :c} :b) ; = true

2. Gunakansome , balutkan target dalam satu set, sebagai berikut:

   (some #{:b} [:a :b :c]) ; = :b, which is truthy

3. Pintasan set-as-function tidak akan berfungsi jika Anda mencari nilai palsu ( falseatau nil).

   ; will not work
   (some #{false} [true false true]) ; = nil

   Dalam kasus ini, Anda harus menggunakan fungsi predikat bawaan untuk nilai itu, false?atau nil?:

   (some false? [true false true]) ; = true

4. Jika Anda harus sering melakukan pencarian seperti ini, tuliskan fungsinya :

   (defn seq-contains? [coll target] (some #(= target %) coll))
   (seq-contains? [true false true] false) ; = true

Juga, lihat jawaban Michał untuk cara memeriksa apakah ada dari beberapa target yang terkandung dalam suatu urutan.

Berikut adalah fungsi cepat dari utilitas standar saya yang saya gunakan untuk tujuan ini:

(defn seq-contains?
  "Determine whether a sequence contains a given item"
  [sequence item]
  (if (empty? sequence)
    false
    (reduce #(or %1 %2) (map #(= %1 item) sequence))))

Inilah solusi Lisp klasik:

(defn member? [list elt]
    "True if list contains at least one instance of elt"
    (cond 
        (empty? list) false
        (= (first list) elt) true
        true (recur (rest list) elt)))

Saya telah membangun versi jg-faustus dari "daftar-berisi?". Sekarang dibutuhkan sejumlah argumen.

(defn list-contains?
([collection value]
    (let [sequence (seq collection)]
        (if sequence (some #(= value %) sequence))))
([collection value & next]
    (if (list-contains? collection value) (apply list-contains? collection next))))

Ini sesederhana menggunakan set - mirip dengan peta, Anda bisa menjatuhkannya di posisi fungsi. Ini mengevaluasi nilai jika di set (yang benar) atau nil(yang palsu):

(#{100 101 102} 101) ; 101
(#{100 101 102} 99) ; nil

Jika Anda mengecek vektor / daftar berukuran cukup yang tidak akan Anda miliki sampai runtime, Anda juga dapat menggunakan set fungsi:

; (def nums '(100 101 102))
((set nums) 101) ; 101

Cara yang disarankan adalah menggunakan somedokumentasi set - see untukclojure.core/some .

Anda kemudian dapat menggunakan somedalam predikat benar / salah nyata, mis

(defn in? [coll x] (if (some #{x} coll) true false))

(defn in?
  [needle coll]
  (when (seq coll)
    (or (= needle (first coll))
        (recur needle (next coll)))))

(defn first-index
  [needle coll]
  (loop [index 0
         needle needle
         coll coll]
    (when (seq coll)
      (if (= needle (first coll))
        index
        (recur (inc index) needle (next coll))))))

(defn which?
 "Checks if any of elements is included in coll and says which one
  was found as first. Coll can be map, list, vector and set"
 [ coll & rest ]
 (let [ncoll (if (map? coll) (keys coll) coll)]
    (reduce
     #(or %1  (first (filter (fn[a] (= a %2))
                           ncoll))) nil rest )))

contoh penggunaan (yang? [1 2 3] 3) atau (yang? # {1 2 3} 4 5 3)

Karena Clojure dibangun di Jawa, Anda dapat dengan mudah memanggilnya .indexOf fungsi Java. Fungsi ini mengembalikan indeks elemen apa pun dalam koleksi, dan jika tidak dapat menemukan elemen ini, mengembalikan -1.

Memanfaatkan ini kita bisa mengatakan:

(not= (.indexOf [1 2 3 4] 3) -1)
=> true

Masalah dengan solusi 'disarankan' adalah rusak ketika nilai yang Anda cari adalah 'nihil'. Saya lebih suka solusi ini:

(defn member?
  "I'm still amazed that Clojure does not provide a simple member function.
   Returns true if `item` is a member of `series`, else nil."
  [item series]
  (and (some #(= item %) series) true))

Ada fungsi yang nyaman untuk tujuan ini di perpustakaan Tupelo . Secara khusus, fungsi contains-elem?, contains-key?dan contains-val?sangat berguna. Dokumentasi lengkap ada di dokumen API .

contains-elem?adalah yang paling umum dan ditujukan untuk vektor atau clojure lainnya seq:

  (testing "vecs"
    (let [coll (range 3)]
      (isnt (contains-elem? coll -1))
      (is   (contains-elem? coll  0))
      (is   (contains-elem? coll  1))
      (is   (contains-elem? coll  2))
      (isnt (contains-elem? coll  3))
      (isnt (contains-elem? coll  nil)))

    (let [coll [ 1 :two "three" \4]]
      (isnt (contains-elem? coll  :no-way))
      (isnt (contains-elem? coll  nil))
      (is   (contains-elem? coll  1))
      (is   (contains-elem? coll  :two))
      (is   (contains-elem? coll  "three"))
      (is   (contains-elem? coll  \4)))

    (let [coll [:yes nil 3]]
      (isnt (contains-elem? coll  :no-way))
      (is   (contains-elem? coll  :yes))
      (is   (contains-elem? coll  nil))))

Di sini kita melihat bahwa untuk rentang bilangan bulat atau vektor campuran, contains-elem?berfungsi seperti yang diharapkan untuk elemen yang ada dan tidak ada dalam koleksi. Untuk peta, kami juga dapat mencari pasangan nilai kunci apa saja (dinyatakan sebagai vektor len-2):

 (testing "maps"
    (let [coll {1 :two "three" \4}]
      (isnt (contains-elem? coll nil ))
      (isnt (contains-elem? coll [1 :no-way] ))
      (is   (contains-elem? coll [1 :two]))
      (is   (contains-elem? coll ["three" \4])))
    (let [coll {1 nil "three" \4}]
      (isnt (contains-elem? coll [nil 1] ))
      (is   (contains-elem? coll [1 nil] )))
    (let [coll {nil 2 "three" \4}]
      (isnt (contains-elem? coll [1 nil] ))
      (is   (contains-elem? coll [nil 2] ))))

Juga mudah untuk mencari satu set:

  (testing "sets"
    (let [coll #{1 :two "three" \4}]
      (isnt (contains-elem? coll  :no-way))
      (is   (contains-elem? coll  1))
      (is   (contains-elem? coll  :two))
      (is   (contains-elem? coll  "three"))
      (is   (contains-elem? coll  \4)))

    (let [coll #{:yes nil}]
      (isnt (contains-elem? coll  :no-way))
      (is   (contains-elem? coll  :yes))
      (is   (contains-elem? coll  nil)))))

Untuk peta & set, lebih mudah (& lebih efisien) untuk digunakan contains-key?untuk menemukan entri peta atau elemen set:

(deftest t-contains-key?
  (is   (contains-key?  {:a 1 :b 2} :a))
  (is   (contains-key?  {:a 1 :b 2} :b))
  (isnt (contains-key?  {:a 1 :b 2} :x))
  (isnt (contains-key?  {:a 1 :b 2} :c))
  (isnt (contains-key?  {:a 1 :b 2}  1))
  (isnt (contains-key?  {:a 1 :b 2}  2))

  (is   (contains-key?  {:a 1 nil   2} nil))
  (isnt (contains-key?  {:a 1 :b  nil} nil))
  (isnt (contains-key?  {:a 1 :b    2} nil))

  (is   (contains-key? #{:a 1 :b 2} :a))
  (is   (contains-key? #{:a 1 :b 2} :b))
  (is   (contains-key? #{:a 1 :b 2}  1))
  (is   (contains-key? #{:a 1 :b 2}  2))
  (isnt (contains-key? #{:a 1 :b 2} :x))
  (isnt (contains-key? #{:a 1 :b 2} :c))

  (is   (contains-key? #{:a 5 nil   "hello"} nil))
  (isnt (contains-key? #{:a 5 :doh! "hello"} nil))

  (throws? (contains-key? [:a 1 :b 2] :a))
  (throws? (contains-key? [:a 1 :b 2]  1)))

Dan, untuk peta, Anda juga dapat mencari nilai dengan contains-val?:

(deftest t-contains-val?
  (is   (contains-val? {:a 1 :b 2} 1))
  (is   (contains-val? {:a 1 :b 2} 2))
  (isnt (contains-val? {:a 1 :b 2} 0))
  (isnt (contains-val? {:a 1 :b 2} 3))
  (isnt (contains-val? {:a 1 :b 2} :a))
  (isnt (contains-val? {:a 1 :b 2} :b))

  (is   (contains-val? {:a 1 :b nil} nil))
  (isnt (contains-val? {:a 1 nil  2} nil))
  (isnt (contains-val? {:a 1 :b   2} nil))

  (throws? (contains-val?  [:a 1 :b 2] 1))
  (throws? (contains-val? #{:a 1 :b 2} 1)))

Seperti yang terlihat dalam tes, masing-masing fungsi ini bekerja dengan benar ketika mencari nilnilai.

Pilihan lain:

((set '(100 101 102)) 101)

Gunakan java.util.Collection # berisi ():

(.contains '(100 101 102) 101)