Question: Beyond the improved readability, is there any advantage to `includes` over `indexOf`? They seem identical to me.

What is the difference between this

```
var x = [1,2,3].indexOf(1) > -1; //true

```

And this? 

```
var y = [1,2,3].includes(1); //true

```

Answer: 
**tl;dr:** `NaN` is treated differently:

* `[NaN].indexOf(NaN) > -1` is `false`
* `[NaN].includes(NaN)` is `true`

---

From the [proposal](https://github.com/tc39/Array.prototype.includes/#motivation):

> 
> ### Motivation
> 
> 
> When using ECMAScript arrays, it is commonly desired to determine if the array includes an element. The prevailing pattern for this is
> 
> 
> 
> ```
> if (arr.indexOf(el) !== -1) {
>     ...
> }
> 
> ```
> 
> with various other possibilities, e.g. `arr.indexOf(el) >= 0`, or even `~arr.indexOf(el)`.
> 
> 
> These patterns exhibit two problems:
> 
> 
> * They fail to "say what you mean": instead of asking about whether the array includes an element, you ask what the index of the first occurrence of that element in the array is, and then compare it or bit-twiddle it, to determine the answer to your actual question.
> * They fail for `NaN`, as `indexOf` uses Strict Equality Comparison and thus `[NaN].indexOf(NaN) === -1`.
> 
> 
> ### Proposed Solution
> 
> 
> We propose the addition of an `Array.prototype.includes` method, such that the above patterns can be rewritten as
> 
> 
> 
> ```
> if (arr.includes(el)) {
>     ...
> }
> 
> ```
> 
> This has almost the same semantics as the above, except that it uses the SameValueZero comparison algorithm instead of Strict Equality Comparison, thus making `[NaN].includes(NaN)` true.
> 
> 
> Thus, this proposal solves both problems seen in existing code.
> 
> 
> We additionally add a `fromIndex` parameter, similar to `Array.prototype.indexOf` and `String.prototype.includes`, for consistency.
> 
> 
> 

---

Further information:

* [`SameValueZero` algorithm](http://www.ecma-international.org/ecma-262/6.0/#sec-samevaluezero)
* [`Strict Equality Comparison` algorithm](http://www.ecma-international.org/ecma-262/6.0/#sec-strict-equality-comparison)
`.indexOf()` and `.includes()` methods can be used to search for an element in an array or to search for a character/substring in a given string.

Usage in Array
--------------

([Link](https://www.ecma-international.org/ecma-262/7.0/#sec-array.prototype.includes) to ECMAScript Specification)

1. `indexOf` uses [Strict Equality Comparison](https://www.ecma-international.org/ecma-262/7.0/#sec-strict-equality-comparison) whereas `includes` uses the [SameValueZero](https://www.ecma-international.org/ecma-262/7.0/#sec-samevaluezero) algorithm. Because of this reason, the following two points of differences arise.
2. As pointed out by [Felix Kling](https://stackoverflow.com/users/218196/felix-kling), the behavior is different in case of `NaN`.

```
let arr = [NaN];

arr.indexOf(NaN); // returns -1; meaning NaN is not present
arr.includes(NaN); // returns true

```

3. The behavior is also different in case of `undefined`.

```
let arr = [ , , ];

arr.indexOf(undefined); // returns -1; meaning undefined is not present
arr.includes(undefined); // returns true

```

Usage in String
---------------

([Link](https://www.ecma-international.org/ecma-262/7.0/#sec-string.prototype.includes) to ECMAScript Specification)

1.
If you pass a RegExp to `indexOf`, it will treat the RegExp as a string and will return the index of the string, if found. However, if you pass a RegExp to `includes`, it will throw an exception.

```
let str = "javascript";

str.indexOf(/\w/); // returns -1 even though the elements match the regex because /\w/ is treated as string
str.includes(/\w/); // throws TypeError: First argument to String.prototype.includes must not be a regular expression

```

Performance
-----------

As [GLAND\_PROPRE](https://stackoverflow.com/users/5309984/538romeo) pointed out, `includes` may be a little (very tiny) bit slower (for it needs to check for a regex as the first argument) than `indexOf` but in reality, this doesn't make much difference and is negligible.

History
-------

`String.prototype.includes()` was introduced in ECMAScript 2015 whereas `Array.prototype.includes()` was introduced in ECMAScript 2016. With regards to browser support, use them wisely.

`String.prototype.indexOf()` and `Array.prototype.indexOf()` are present in ES5 edition of ECMAScript and hence supported by all browsers.