---
type: reference
language: javascript
slug: array/includes
title: "Array.prototype.includes() と some() / every()"
title_tag: "JavaScript includes の使い方 — 含まれるかを調べる3つ"
summary: >
  値が入っているかを調べる includes、条件で調べる some と every の違いをまとめます。
  NaN が見つかる理由、型が違うと一致しない話、空配列で every が true になる理由まで確かめます。
description: >
  includes は値そのもの、some は条件で探します。NaN が includes では見つかる理由、オブジェクトの配列で使えない理由、every が空配列で true になる理由まで示します。
status: published
difficulty: 2
minutes: 7

versions:
  verified: "Node 22.22.3"
  since: "ES2016"
  deprecated: null
  removed: null

sources:
  - title: "Array.prototype.includes — ECMAScript® 2026 Language Specification"
    url: "https://tc39.es/ecma262/#sec-array.prototype.includes"
  - title: "Array.prototype.some — ECMAScript® 2026 Language Specification"
    url: "https://tc39.es/ecma262/#sec-array.prototype.some"
  - title: "Array.prototype.every — ECMAScript® 2026 Language Specification"
    url: "https://tc39.es/ecma262/#sec-array.prototype.every"

terms: [SameValueZero, 短絡評価, 空虚な真]

links:
  related:
    - javascript/reference/array/find
    - javascript/why/nan-equality

content_updated_at: 2026-09-07
published_at: 2026-09-07
---

「入っているか」を調べる方法は[num:3]つあります。**何で調べたいかで選びます。**

```js run
const nums = [1, 2, 3];

console.log(nums.includes(2));
console.log(nums.some(n => n > 2));
console.log(nums.every(n => n > 0));
```
```output
true
true
true
```

| | 何で調べるか | 返るもの |
|---|---|---|
| `includes()` | [key:値そのもの] | 入っていれば `true` |
| `some()` | [key:条件]（1つでも） | 1つでも合えば `true` |
| `every()` | [key:条件]（全部） | 全部合えば `true` |

上のコードは書き換えて実行できます。`n > 2` を `n > 5` にしてみてください。

## includes と indexOf の違い

**`NaN` を見つけられるかどうか**が違います。

```js run
const nums = [1, NaN, 3];

console.log(nums.includes(NaN));
console.log(nums.indexOf(NaN));
console.log(nums.includes(3), nums.indexOf(3));
```
```output
true
-1
true 2
```

`indexOf()` は `===` で比べます。[code:NaN === NaN] は `false` なので[bad:見つかりません]。
`includes()` は [type:SameValueZero] という比べ方を使うので[key:見つかります]。

詳しくは
[なぜ NaN === NaN は false なのか](/ja/javascript/why/nan-equality/) にあります。

**「あるか」を知りたいだけなら `includes()`** を使ってください。
`indexOf(x) !== -1` は読みにくく、`NaN` で間違えます。

## 型が違うと一致しない

`includes()` は[key:型変換をしません]。

```js run
const nums = [1, 2, 3];

console.log(nums.includes('2'));
console.log(nums.includes(2));
console.log(['1', '2'].includes(1));
```
```output
false
true
false
```

フォームから来た値は文字列です。**そのまま渡すと必ず `false` になります。**

```js run
const allowed = [1, 2, 3];
const input = '2';

console.log(allowed.includes(input));
console.log(allowed.includes(Number(input)));
```
```output
false
true
```

変換の注意は
[文字列を数値に変換する](/ja/javascript/how-to/string/to-number/) にあります。

## オブジェクトは参照で比べる

中身が同じでも、[bad:別々に作ったものは別物]です。

```js bad
const users = [{ id: 1 }];

console.log(users.includes({ id: 1 }));
```
```output
false
```

**中身で調べたいなら `some()` を使ってください。**

```js run
const users = [{ id: 1 }, { id: 2 }];

console.log(users.some(u => u.id === 1));
console.log(users.every(u => u.id > 0));
```
```output
true
true
```

## 見つかったところで止まる

`some()` は真になった時点、`every()` は偽になった時点で[key:止まります]。

```js run
const nums = [1, 2, 3, 4, 5];
let calls = 0;

nums.some((n) => { calls++; return n === 2; });
console.log('some  :', calls);

calls = 0;
nums.every((n) => { calls++; return n < 2; });
console.log('every :', calls);
```
```output
some  : 2
every : 2
```

どちらも[num:5]件のうち[num:2]件しか見ていません。

`includes()` も途中で止まりますが、**回数は数えられません**（関数を渡さないため）。

## 空配列では every が true になる

**ここが引っかかりどころです。**

```js run
console.log([].some(n => n > 0));
console.log([].every(n => n > 0));
```
```output
false
true
```

`every()` は「[key:条件に合わないものが1つも無い]」を返します。
要素が[num:0]件なら、合わないものも[num:0]件です。だから `true` です。

数学ではこれを[type:空虚な真]と呼びます。**仕様どおりの正しい動き**です。

実務では困ることがあります。「全員が同意したか」を `every()` で調べると、
**誰もいないときに「全員同意」になります。**

```js run
const members = [];

console.log(members.every(m => m.agreed));
console.log(members.length > 0 && members.every(m => m.agreed));
```
```output
true
false
```

**件数を先に確かめてください。**

## 穴のある配列での違い

`includes()` は[type:疎な配列]の穴を `undefined` として[key:見ます]。
`indexOf()` は[bad:飛ばします]。

```js run
const sparse = [1, , 3];

console.log(sparse.includes(undefined));
console.log(sparse.indexOf(undefined));
```
```output
true
-1
```

`find()` と同じで、`includes()` は穴を見に行きます。
[filter()](/ja/javascript/reference/array/filter/) や `map()` は飛ばします。**揃っていません。**

## 途中から探す

第2引数で開始位置を指定できます。

```js run
const nums = [1, 2, 3, 2];

console.log(nums.includes(2));
console.log(nums.includes(2, 2));
console.log(nums.includes(1, 1));
console.log(nums.includes(2, -1));
```
```output
true
true
false
true
```

負の数は[key:後ろから]数えます。`-1` は最後の要素からです。

## 文字列にも includes がある

同じ名前で、**部分文字列**を調べます。

```js run
const text = 'abcdef';

console.log(text.includes('cd'));
console.log(text.indexOf('cd'));
console.log(text.startsWith('ab'), text.endsWith('ef'));
```
```output
true
2
true true
```

配列の `includes()` は[key:要素そのもの]、文字列の `includes()` は[key:部分文字列]です。
**名前は同じでも、調べているものが違います。**

```js run
console.log(['abc'].includes('b'));
console.log('abc'.includes('b'));
```
```output
false
true
```

## 選び方

| やりたいこと | 使うもの |
|---|---|
| その値が入っているか | `includes()` |
| 条件に合うものが**1つでも**あるか | `some()` |
| **全部**が条件に合うか | `every()`（**空配列に注意**） |
| 合うものを**取り出したい** | [find()](/ja/javascript/reference/array/find/) |
| 合うものを**全部**取り出したい | [filter()](/ja/javascript/reference/array/filter/) |
| **何番目か**を知りたい | `indexOf()` / `findIndex()` |

**`filter(...).length > 0` と書かないでください。** 最後まで数えてしまいます。
`some()` なら見つかった時点で止まります。

```js run
const nums = [1, 2, 3, 4, 5];

console.log(nums.filter(n => n > 3).length > 0);
console.log(nums.some(n => n > 3));
```
```output
true
true
```