配列に要素が含まれるか調べるには

fruits = ["apple", "banana", "cherry"]
print("banana" in fruits)      # True
print("grape" not in fruits)   # True
 
# 位置も欲しいなら index。見つからないと ValueError になる
print(fruits.index("banana"))  # 1
 
# 比較は == で行われるので、中身が同じリストも見つかる
print([1, 2] in [[1, 2], [3, 4]])  # True
 
# NaN は自分自身と等しくないが、in は先に同一性（is）を見る
nan = float("nan")
print(nan in [nan])            # True（同じオブジェクト）
print(float("nan") in [nan])   # False（別のオブジェクト）

const fruits = ["apple", "banana", "cherry"];
console.log(fruits.includes("banana")); // true
console.log(fruits.indexOf("grape"));   // -1（見つからないときは -1）
 
// NaN は includes なら見つかるが、indexOf では見つからない
console.log([NaN].includes(NaN)); // true
console.log([NaN].indexOf(NaN));  // -1
 
// オブジェクトは参照で比較されるので、中身が同じでも見つからない
console.log([{ id: 1 }].includes({ id: 1 }));     // false
console.log([{ id: 1 }].some((u) => u.id === 1)); // true
 
// in 演算子が調べるのは要素ではなくインデックス
console.log("banana" in fruits); // false
console.log(1 in fruits);        // true

const fruits: string[] = ["apple", "banana", "cherry"];
const input: string = "banana";
console.log(fruits.includes(input)); // true
 
// as const の配列は要素がリテラル型になるため、string を渡す includes は型エラーになる
const ROLES = ["admin", "editor"] as const;
const role: string = "admin";
// console.log(ROLES.includes(role)); // error TS2345
console.log((ROLES as readonly string[]).includes(role)); // true
 
// 型ガードにしておけば、通過後の値は "admin" | "editor" に絞られる
function isRole(value: string): value is (typeof ROLES)[number] {
  return (ROLES as readonly string[]).includes(value);
}
console.log(isRole("editor"), isRole("guest")); // true false

package main
 
import (
	"fmt"
	"slices"
)
 
type User struct{ ID int }
 
func main() {
	fruits := []string{"apple", "banana", "cherry"}
	fmt.Println(slices.Contains(fruits, "banana")) // true
	fmt.Println(slices.Index(fruits, "grape"))     // -1
 
	// 条件で探すなら ContainsFunc（Go 1.21 以降）
	users := []User{{ID: 1}, {ID: 2}}
	fmt.Println(slices.ContainsFunc(users, func(u User) bool { return u.ID == 2 })) // true
}

fn main() {
    let fruits = vec!["apple", "banana", "cherry"];
    println!("{}", fruits.contains(&"banana")); // true（引数は参照で渡す）
    println!("{:?}", fruits.iter().position(|&f| f == "grape")); // None
 
    // Vec<String> に &"bob" を渡すと型が合わずコンパイルエラーになる
    let names = vec![String::from("alice"), String::from("bob")];
    println!("{}", names.iter().any(|n| n == "bob")); // true
    println!("{}", names.contains(&"bob".to_string())); // true
}

import java.util.Arrays;
import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        List<String> fruits = List.of("apple", "banana", "cherry");
        System.out.println(fruits.contains("banana")); // true
        System.out.println(fruits.indexOf("grape"));   // -1
 
        String[] arr = {"apple", "banana", "cherry"};
        System.out.println(Arrays.asList(arr).contains("banana")); // true
 
        // int[] を asList に渡すと、要素は int ではなく int[] が 1 個になってしまう
        int[] nums = {1, 2, 3};
        System.out.println(Arrays.asList(nums).contains(2));            // false
        System.out.println(Arrays.stream(nums).anyMatch(n -> n == 2)); // true
 
        // List.of が作るリストは null を許さず、contains(null) は例外になる
        try {
            fruits.contains(null);
        } catch (NullPointerException e) {
            System.out.println("NullPointerException");
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
 
class Program {
    static void Main() {
        string[] fruits = { "apple", "banana", "cherry" };
        Console.WriteLine(fruits.Contains("banana"));      // True（LINQ の拡張メソッド）
        Console.WriteLine(Array.IndexOf(fruits, "grape")); // -1
 
        // 大文字小文字を無視するなら比較子を渡す
        Console.WriteLine(fruits.Contains("BANANA", StringComparer.OrdinalIgnoreCase)); // True
 
        var list = new List<string>(fruits);
        Console.WriteLine(list.Contains("banana"));              // True
        Console.WriteLine(list.Exists(f => f.StartsWith("ch"))); // True
    }
}