测试列表是否包含 Clojure 中的特定值答案

【问题标题】：Test whether a list contains a specific value in Clojure测试列表是否包含 Clojure 中的特定值
【发布时间】：2011-03-16 00:40:11
【问题描述】：

在 Clojure 中测试列表是否包含给定值的最佳方法是什么？

尤其是contains? 的行为目前让我很困惑：

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

我显然可以编写一个简单的函数来遍历列表并测试是否相等，但肯定有一个标准的方法来做到这一点？

【问题讨论】：

确实很奇怪，包含？必须是 Clojure 中最容易被误导的函数 :) 希望 Clojure 1.3 能看到它重命名为 contains-key？或类似的。
我想这已经被说死了好几次了。包含？不会改变。见这里：groups.google.com/group/clojure/msg/f2585c149cd0465d 和 groups.google.com/group/clojure/msg/985478420223ecdf
@kotarak 感谢您的链接！在使用包含的方面，我实际上同意 Rich 的观点？名称虽然我认为应该更改它以在应用于列表或序列时引发错误

标签： data-structures clojure

【解决方案1】：

啊，contains?...据说是前五个常见问题解答之一：Clojure。

它不检查一个集合是否包含一个值；它会检查是否可以使用get 检索项目，或者换句话说，检查集合是否包含键。这对于集合（可以认为是不区分键和值）、映射（所以 (contains? {:foo 1} :foo) 是 true）和向量（但请注意 (contains? [:foo :bar] 0) 是 true，因为这里的键是索引，并且有问题的向量确实“包含”索引0！）。

~~为了增加混乱，在调用contains? 没有意义的情况下，它只是返回false；这就是(contains? :foo 1) 和 (contains? '(100 101 102) 101) 中发生的情况。~~ 更新： 在 Clojure ≥ 1.5 contains? 中，当传递一个类型的对象时抛出不支持预期的“关键成员”测试。

做你想做的事情的正确方法如下：

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

当搜索一堆项目中的一个时，你可以使用更大的集合；搜索false/nil时，可以使用false?/nil?——因为(#{x} x)返回x，因此(#{nil} nil)是nil；当搜索其中一些可能是false 或nil 的多个项目之一时，您可以使用

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

（请注意，项目可以在任何类型的集合中传递给zipmap。）

【讨论】：

正如 Michal 所说 - 核心中已经有一个功能可以满足您的需求：一些。
在上面，Michal 评论了 (some #{101} '(100 101 102)) 说“大部分时间都有效”。说它总是有效是不是很公平？我正在使用 Clojure 1.4，文档使用了这种示例。它适用于我并且很有意义。是否有某种特殊情况不起作用？
@DavidJames：如果您要检查false 或nil 的存在，则它不起作用——请参阅以下段落。另外，在 Clojure 1.5-RC1 中，contains? 在给定非键控集合作为参数时会引发异常。我想我会在最终版本发布时编辑这个答案。
这太愚蠢了！集合的主要区别是成员关系。它应该是收藏品最重要的功能。 en.wikipedia.org/wiki/Set_(mathematics)#Membership
@jgomo3 你可以使用包含吗？在一组测试成员资格。你不能做的是在地图或列表上使用它，因为这样做不再是 O(1)，而是变成了 O(n)。包含？意味着 O(1)，这就是为什么你需要在这些情况下进行自己的线性搜索。

【解决方案2】：

这是我用于此目的的标准实用程序中的一个快速功能：

(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))))

【讨论】：

是的，你的优点是一旦找到匹配项就会停止，而不是继续映射整个序列。

【解决方案3】：

不管怎样，这是我对列表的 contains 函数的简单实现：

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

【讨论】：

我们可以要求谓词部分作为参数吗？得到类似的东西：(defn list-contains? [pred coll value] (let [s (seq coll)] (if s (if (pred (first s) value) true (recur (rest s) value)) false)))

【解决方案4】：

这是我用于相同目的的标准工具：

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

【讨论】：

这是最简单和最安全的解决方案，因为它还可以处理 nil 和 false 等虚假值。现在为什么这不是 clojure/core 的一部分？
seq 可以重命名为coll，以避免与函数seq 混淆？
@nha 你可以这样做，是的。这里没关系：由于我们没有在body内部使用函数seq，所以与同名参数没有冲突。但是，如果您认为重命名会更容易理解，请随时编辑答案。
值得注意的是，如果您不必担心 nil 或 false，这可能比 (boolean (some #{elm} coll)) 慢 3-4 倍。
@AviFlax 我在想clojure.org/guides/threading_macros，它说“按照惯例，对序列进行操作的核心函数期望序列作为它们的最后一个参数。因此，包含 map、filter、remove、reduce 的管道, into 等通常需要 ->> 宏。”但我猜这个约定更多是关于对序列进行操作并返回序列的函数。

【解决方案5】：

我建立在 j-g-faustus version 的 "list-contains?" 之上。它现在可以接受任意数量的参数。

(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))))

【讨论】：

【解决方案6】：

我知道我有点晚了，但是呢：

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

最后在 clojure 1.4 中输出 true :)

【讨论】：

(set '(101 102 103)) 与 %{101 102 103} 相同。所以你的答案可以写成(contains? #{101 102 103} 102)。
这样做的缺点是需要将原始列表'(101 102 103) 转换为集合。

【解决方案7】：

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

有效，但以下更好：

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

【讨论】：

如果没有匹配项，有些返回 nil，而不是 false

【解决方案8】：

推荐的方法是使用 some 和一组 - 请参阅 clojure.core/some 的文档。

然后您可以在真正的真/假谓词中使用some，例如

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

【讨论】：

为什么是 if true 和 false？ some 已经返回真值和假值。
那（一些#{nil} [nil]）呢？它会返回 nil 并将其转换为 false。

【解决方案9】：

(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))))))

【讨论】：

【解决方案10】：

如果你有一个向量或列表，想检查其中是否包含一个值，你会发现contains?不起作用。 Michał 已经explained why。

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

在这种情况下，您可以尝试四件事：

考虑您是否真的需要向量或列表。如果您改用集合，contains? 将起作用。
```
(contains? #{:a :b :c} :b) ; = true
```
使用some，将目标包裹在一个集合中，如下：
```
(some #{:b} [:a :b :c]) ; = :b, which is truthy
```
如果您正在搜索虚假值（false 或 nil），则 set-as-function 快捷方式将不起作用。
```
; will not work
(some #{false} [true false true]) ; = nil
```
在这些情况下，您应该为该值使用内置谓词函数，false? 或 nil?：
```
(some false? [true false true]) ; = true
```

如果您需要经常进行此类搜索，请为其编写一个函数：

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

另外，请参阅Michał’s answer，了解检查序列中是否包含任何多个目标的方法。

【讨论】：

【解决方案11】：

这是经典的 Lisp 解决方案：

(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)))

【讨论】：

好的，Clojure 中一个糟糕的解决方案的原因是它在一个处理器上递归堆栈。更好的 Clojure 解决方案是
```
 (defn member? [elt col] (some #(= elt %) col)) 
```
这是因为 some 可能跨可用内核并行。

【解决方案12】：

就像使用一个集合一样简单 - 类似于地图，您只需将其放在函数位置即可。如果在集合中（这是真的）或nil（这是假的），它会评估值：

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

如果您要检查一个合理大小的向量/列表，直到运行时才拥有，您还可以使用 set 函数：

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

【讨论】：

【解决方案13】：

您始终可以使用 .methodName 语法调用 java 方法。

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

【讨论】：

恕我直言，这是最好的答案。太糟糕的clojure包含？名字太混乱了。
尊贵的 Qc Na 大师与他的学生 Anton 同行。当 Anton 告诉他 contains? 有一些初学者的问题时，Qc Na 用 Bô 打他说：“愚蠢的学生！你必须意识到没有勺子。下面都是 Java！使用点符号。”。那一刻，安东顿悟了。

【解决方案14】：

由于 Clojure 是基于 Java 构建的，因此您可以很容易地调用 .indexOf Java 函数。该函数返回集合中任意元素的索引，如果找不到该元素，则返回-1。

利用这一点，我们可以简单地说：

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

【讨论】：

【解决方案15】：

“推荐”解决方案的问题是，当您寻求的值为“nil”时，它会中断。我更喜欢这个解决方案：

(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))

【讨论】：

【解决方案16】：

(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 )))

示例用法 (which? [ 1 2 3 ] 3) 或 (which? #{ 1 2 3} 4 5 3)

【讨论】：

仍然没有为它提供语言核心功能？

【解决方案17】：

为此目的提供了方便的功能in the Tupelo library。特别是contains-elem?、contains-key? 和contains-val? 函数非常有用。完整的文档存在 in the API docs。

contains-elem? 是最通用的，适用于向量或任何其他 clojure 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))))

在这里我们看到，对于整数范围或混合向量，contains-elem? 对于集合中现有和不存在的元素都按预期工作。对于地图，我们还可以搜索任意键值对（表示为 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] ))))

搜索集合也很简单：

  (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)))))

对于地图和集合，使用contains-key? 查找地图条目或集合元素更简单（也更高效）：

(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)))

而且，对于地图，您还可以使用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)))

从测试中可以看出，这些函数在搜索nil 值时都能正常工作。

【讨论】：

【解决方案18】：

另一种选择：

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

使用 java.util.Collection#contains()：

(.contains '(100 101 102) 101)

【讨论】：