Logo

Programming-Idioms

# 12 Check if list contains a value
Check if the list contains the value x.
list is an iterable finite container.
New implementation

Be concise.

Be useful.

All contributions dictatorially edited by webmasters to match personal tastes.

Please do not paste any copyright violating material.

Please try to avoid dependencies to third-party libraries and frameworks.

Other implementations 
with Ada.Containers.Vectors;
Result := List.Contains (X);
#include <stdbool.h>
bool contains(int x, int* list, size_t list_len) {
    for (int i=0 ; i<list_len ; i++)
        if (list[i] == x)
            return true;
    return false;
}
List.mem x list
(some #{x} list)
(some (partial = x) list)
#include <vector>
#include <algorithm>
bool Contains(const std::vector<int> &list, int x)
{
	return std::find(list.begin(), list.end(), x) != list.end();
}
#include <ranges>
auto contains(auto list, auto x) -> bool {
  return std::ranges::find(list, x) != std::ranges::end(list);
}
System.Collections.Generic
list.Contains(item);
import std.algorithm.searching;
bool here = canFind(items, x);
list.contains(x);
x in list
Enum.member?(list, x)
member(_, []) -> false;
member(Value, [H|_]) where Value =:= H -> true;
member(Value, [_|T]) -> member(Value, T).
member(_, []) -> false;
member(Value, [H|T]) -> 
  case H of
    Value -> true;
    _ -> member(T)
  end.
lists:member(X, List).
if (any(x == list)) ...
if (findloc (list, x, 1) != 0) then
func Contains(list []T, x T) bool {
	for _, item := range list {
		if item == x {
			return true
		}
	}
	return false
}
import "slices"
slices.Contains(list, x)
list.contains(x)
find _ [] = False
find n (x:xs)
  | x == n = True
  | otherwise = find n xs
x `elem` list
return list.indexOf(x) !== -1;
return list.includes(x);
import java.util.List;
list.contains(x)
boolean <T> contains(T[] list, T x){
  if( x==null){
    for(T y:list)
      if( y==null )
        return true;
  }else{
    for(T y:list)
      if( x.equals(y) )
        return true;
  }
  return false;
}
boolean contains(int[] list, int x){
  for(int y:list)
    if( y==x )
      return true;
  return false;
}
import static java.util.Arrays.asList;
asList(list).contains(x);
list.contains(x)
x in list
(find x list :test #'equal)
(member x list)
function contains(list, x)
	for _, v in ipairs(list) do
		if v == x then return true end
	end
	return false
end
[list containsObject:x];
in_array($x, $list, true);
result := false;
for e in list do 
	if e=x then
		begin
			result := true;
			break;
		end

uses classes;
result := list.IndexOf(x) <> -1;
p := list;
while (p <> nil) and (p^.key = x) do p := p^.next;
found := p.key = x
use List::Util 'first';
print "ok\n" if first {$_ eq $x} @list;
print "Found 'foo'\n" if grep {$_ eq $x} @list;
member(X, [One]).
x in list
list.include? x
(&list).into_iter().any(|v| v == &x)
list.contains(&x);
list.iter().any(|v| v == &x)
list.binary_search(&x).is_ok()
list.contains(x)

(member x list)
(define (contains list x)
	(cond [(null? list) #f]
		[(equal? (car list) x) #t]
		[else (contains (cdr list) x)]))
list includes: x.
List.Contains(x)

Preview