blocks|key|1200009|text|下面是用于相同目的的标准util：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200010|(defn+in?+
++"true+if+coll+contains+elm"
++[coll+elm]++
++(some+#(=+elm+%25)+coll))|code-block|syntax|javascript|1200011|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's my standard util for the same purpose:

<pre><code>(defn in? 
 "true if coll contains elm"
 [coll elm] 
 (some #(= elm %) coll))
</code></pre>

blocks|key|1200415|text|您可以始终使用.methodName语法调用java方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200416|(.contains+[100+101+102]+101)+=>+true|code-block|syntax|javascript|1200417|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can always call java methods with .methodName syntax.

<pre><code>(.contains [100 101 102] 101) =&gt; true
</code></pre>

blocks|key|1200123|text|我知道我来晚了点，但是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200124|(contains?+(set+'(101+102+103))+102)|code-block|syntax|javascript|1200125|最后，在clojure+1.4中输出true+:)|1200126|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I know that I'm a little bit late, but what about:

<pre><code>(contains? (set '(101 102 103)) 102)
</code></pre>

At last in clojure 1.4 outputs true :)

blocks|key|1200149|text|(not=+-1+(.indexOf+'(101+102+103)+102))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1200150|工作，但下面是更好的：|unstyled|1200151|(some+#(=+102+%25)+'(101+102+103))+|1200152|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>(not= -1 (.indexOf '(101 102 103) 102))
</code></pre>

Works, but below is better:

<pre><code>(some #(= 102 %) '(101 102 103)) 
</code></pre>

blocks|key|985517|text|值得注意的是，这是我对列表的一个包含函数的简单实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|985518|(defn+list-contains?+[coll+value]
++(let+[s+(seq+coll)]
++++(if+s
++++++(if+(=+(first+s)+value)+true+(recur+(rest+s)+value))
++++++false)))|code-block|syntax|javascript|985519|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For what it is worth, this is my simple implementation of a contains function for lists:

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

blocks|key|985485|text|下面是我使用的用于此目的的标准实用程序中的一个快速函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|985486|(defn+seq-contains?
++"Determine+whether+a+sequence+contains+a+given+item"
++[sequence+item]
++(if+(empty?+sequence)
++++false
++++(reduce+#(or+%251+%252)+(map+#(=+%251+item)+sequence))))|code-block|syntax|javascript|985487|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a quick function out of my standard utilities that I use for this purpose:

<pre><code>(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))))
</code></pre>

blocks|key|1200268|text|下面是经典的Lisp解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200269|(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)))|code-block|syntax|javascript|1200270|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's the classic Lisp solution:

<pre><code>(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)))
</code></pre>

blocks|key|1200066|text|我建立在"list-contains?“的j-g-faustus+version之上。它现在可以接受任意数量的参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1200067|(defn+list-contains?
([collection+value]
++++(let+[sequence+(seq+collection)]
++++++++(if+sequence+(some+#(=+value+%25)+sequence))))
([collection+value+&+next]
++++(if+(list-contains?+collection+value)+(apply+list-contains?+collection+next))))|code-block|syntax|javascript|1200068|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/3249334/test-whether-a-list-contains-a-specific-value-in-clojure/3249777#3249777^0|X|7|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I've built upon j-g-faustus <a href="https://stackoverflow.com/questions/3249334/test-whether-a-list-contains-a-specific-value-in-clojure/3249777#3249777">version</a> of "list-contains?". It now takes any number of arguments.

<pre><code>(defn list-contains?
([collection value]
 (let [sequence (seq collection)]
 (if sequence (some #(= value %) sequence))))
([collection value &amp; next]
 (if (list-contains? collection value) (apply list-contains? collection next))))
</code></pre>

blocks|key|1200375|text|它就像使用set一样简单--类似于map，您只需将其放在函数位置即可。它的计算结果是集合中的值(这是真的)或nil+(这是假的)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1200376|(#{100+101+102}+101)+;+101
(#{100+101+102}+99)+;+nil|code-block|syntax|javascript|1200377|如果您正在检查一个大小合理的向量/列表，那么您也可以使用set函数：|1200378|;+(def+nums+'(100+101+102))
((set+nums)+101)+;+101|1200379|entityMap^0|1I|3|0|0|S|3|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|P|$]]

It is as simple as using a set - similar to maps, you can just drop it in the function position. It evaluates to the value if in the set (which is truthy) or <code>nil</code> (which is falsey):

<pre><code>(#{100 101 102} 101) ; 101
(#{100 101 102} 99) ; nil
</code></pre>

If you're checking against a reasonably sized vector/list you won't have until runtime, you can also use the <code>set</code> function:

<pre><code>; (def nums '(100 101 102))
((set nums) 101) ; 101
</code></pre>

blocks|key|1200216|text|推荐的方法是将some与set一起使用-请参阅clojure.core/some的文档。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1200217|然后，您可以在真实的真/假谓词中使用some，例如|1200218|(defn+in?+[coll+x]+(if+(some+#{x}+coll)+true+false))|code-block|syntax|javascript|1200219|entityMap^0|7|4|N|H|0|I|4|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|W|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|N|$]]

The recommended way is to use <code>some</code> with a set - see documentation for <code>clojure.core/some</code>.

You could then use <code>some</code> within a real true/false predicate, e.g. 

<pre><code>(defn in? [coll x] (if (some #{x} coll) true false))
</code></pre>

blocks|key|985755|text|(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))))))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|985756|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>(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))))))
</code></pre>

blocks|key|985992|text|因为Clojure是基于Java构建的，所以您可以很容易地调用.indexOf+Java函数。此函数返回集合中任何元素的索引，如果找不到该元素，则返回-1。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|985993|利用这个，我们可以简单地说：|985994|(not=+(.indexOf+[1+2+3+4]+3)+-1)
=>+true|code-block|syntax|javascript|985995|entityMap^0|V|8|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

Since Clojure is built on Java, you can just as easily call the <code>.indexOf</code> Java function. This function returns the index of any element in a collection, and if it can't find this element, returns -1.

Making use of this we could simply say:

<pre><code>(not= (.indexOf [1 2 3 4] 3) -1)
=&gt; true
</code></pre>

blocks|key|1200552|text|(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+%251++(first+(filter+(fn[a]+(=+a+%252))
+++++++++++++++++++++++++++ncoll)))+nil+rest+)))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1200553|示例用法(哪个?1+2+3+3)或(哪个？#{+1+2+3}+4+5+3)|unstyled|1200554|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>(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 &amp; rest ]
 (let [ncoll (if (map? coll) (keys coll) coll)]
 (reduce
 #(or %1 (first (filter (fn[a] (= a %2))
 ncoll))) nil rest )))
</code></pre>

example usage (which? [ 1 2 3 ] 3) or (which? #{ 1 2 3} 4 5 3)

blocks|key|986022|text|“推荐”解决方案的问题是，当您正在寻找的值为“nil”时，它会中断。我更喜欢这个解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|986023|(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+%25)+series)+true))|code-block|syntax|javascript|986024|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

The problem with the 'recommended' solution is it is breaks when the value you are seeking is 'nil'. I prefer this solution:

<pre><code>(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))
</code></pre>

blocks|key|1200624|text|in+the+Tupelo+library提供了一些方便的函数来实现此目的。特别是，函数contains-elem?、contains-key?和contains-val?非常有用。in+the+API+docs提供了完整的文档。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1200625|contains-elem?是最通用的，它适用于向量或任何其他clojure+seq|1200626|++(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))))|code-block|syntax|javascript|1200627|在这里，我们可以看到，对于整数范围或混合向量，contains-elem?对于集合中现有和不存在的元素都按预期工作。对于map，我们还可以搜索任何键-值对(表示为len-2向量)：|1200628|+(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]+))))|1200629|搜索一个集合也很简单：|1200630|++(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)))))|1200631|对于映射和集合，使用contains-key?查找映射条目或集合元素会更简单(也更有效)：|1200632|(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)))|1200633|此外，对于地图，还可以使用contains-val?搜索值|1200634|(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)))|1200635|正如在测试中看到的，在搜索nil值时，这些函数中的每一个都可以正常工作。|1200636|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/cloojure/tupelo|1|http://cloojure.github.io/doc/tupelo/tupelo.core.html#var-contains-elem.3F^0|18|E|1N|D|21|D|0|L|0|2J|F|1|0|0|E|13|3|0|0|N|E|0|0|0|0|A|D|0|0|D|D|0|0|D|3|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]]|D|@$9|1L|A|1M|1|1N]|$9|1O|A|1P|1|1Q]]|E|$]]|$1|F|3|G|5|6|7|1R|8|@$9|1S|A|1T|B|C]|$9|1U|A|1V|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|1W|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1X|8|@$9|1Y|A|1Z|B|C]]|D|@]|E|$]]|$1|O|3|P|5|J|7|20|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|21|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|22|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|23|8|@$9|24|A|25|B|C]]|D|@]|E|$]]|$1|W|3|X|5|J|7|26|8|@]|D|@]|E|$K|L]]|$1|Y|3|Z|5|6|7|27|8|@$9|28|A|29|B|C]]|D|@]|E|$]]|$1|10|3|11|5|J|7|2A|8|@]|D|@]|E|$K|L]]|$1|12|3|13|5|6|7|2B|8|@$9|2C|A|2D|B|C]]|D|@]|E|$]]|$1|14|3|-4|5|6|7|2E|8|@]|D|@]|E|$]]]|15|$16|$5|17|18|19|E|$1A|1B]]|1C|$5|17|18|19|E|$1A|1D]]]]

There are convenient functions for this purpose <a href="https://github.com/cloojure/tupelo" rel="nofollow noreferrer">in the Tupelo library</a>. In particular, the functions <code>contains-elem?</code>, <code>contains-key?</code>, and <code>contains-val?</code> are very useful. Full documentation is present <a href="http://cloojure.github.io/doc/tupelo/tupelo.core.html#var-contains-elem.3F" rel="nofollow noreferrer">in the API docs</a>.

<code>contains-elem?</code> is the most generic and is intended for vectors or any other clojure <code>seq</code>:

<pre><code> (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))))
</code></pre>

Here we see that for an integer range or a mixed vector, <code>contains-elem?</code> works as expected for both existing and non-existant elements in the collection. For maps, we can also search for any key-value pair (expressed as a len-2 vector):

<pre><code> (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] ))))
</code></pre>

It is also straightforward to search a set:

<pre><code> (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)))))
</code></pre>

For maps &amp; sets, it is simpler (&amp; more efficient) to use <code>contains-key?</code> to find a map entry or a set element:

<pre><code>(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)))
</code></pre>

And, for maps, you can also search for values with <code>contains-val?</code>:

<pre><code>(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)))
</code></pre>

As seen in the test, each of these functions works correctly when for searching for <code>nil</code> values.

blocks|key|1200657|text|另一种选择：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1200658|((set+'(100+101+102))+101)|code-block|syntax|javascript|1200659|使用java.util.Collection#contains()：|1200660|(.contains+'(100+101+102)+101)|1200661|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Another option:

<pre><code>((set '(100 101 102)) 101)
</code></pre>

Use java.util.Collection#contains():

<pre><code>(.contains '(100 101 102) 101)
</code></pre>

blocks|key|986207|text|这么晚才发现的。但这就是我所做的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|986208|(some+(partial+=+102)+'(101+102+103))+|code-block|syntax|javascript|986209|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Found this late. But this is what im doing
<pre><code>(some (partial = 102) '(101 102 103)) 
</code></pre>

What is the best way to test whether a list contains a given value in Clojure?

In particular, the behaviour of <code>contains?</code> is currently confusing me:

<pre><code>(contains? '(100 101 102) 101) =&gt; false
</code></pre>

I could obviously write a simple function to traverse the list and test for equality, but there must surely be a standard way to do this?

Test whether a list contains a specific value in Clojure

在Clojure中测试列表是否包含给定值的最佳方法是什么？特别是，contains?的行为目前让我感到困惑：(contains? '(100 101 102) 101) => false我显然可以编写一个简单的函数来遍历列表并测试相等性，但肯定有一种标准的方法来做到这一点？

问测试列表是否包含Clojure中的特定值
EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问测试列表是否包含Clojure中的特定值EN

回答 17

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问测试列表是否包含Clojure中的特定值
EN