Updated July 5, 2023
Introduction to JavaScript Array includes()
The JavaScript array includes() function helps us determine whether the array contains any specified element. This is an inbuilt function that helps in finding a particular element in the array. It returns a Boolean value which can be true or false depending on the result. The result is true if the element we are looking for is present in the array, or else the result is false if the element we are looking for is not present in the array. It is a method that finds elements and provides results accordingly.
Syntax and Parameters
Let us have a look at the syntax of this function. It is represented below in the syntactical format
array.includes(element, start)Parameters
The parameters in this syntax include the following:
- element: This is the value that needs to be searched in the array.
- start: This is an optional parameter. It represents the index from where the search should start by the includes() method. The default value is 0 in this scenario.
- Return Value: This function returns either true when the element is present or false when the element is not found in the searched array.
How does JavaScript Array include() Method works?
To see how the array.includes() function works, let us take an array A.
var A = [ 1, 2, 3, 4, 5 ];The Array has five elements as defined above. We can search to check if any element is present in this array.
checkInclude= A.includes(2);Here in this statement, a checkInclude variable is used. This variable stores the result of the include() method. It will check if the array contains the integer 2. Here there is no starting point mentioned. That means it will directly start looking for 2 in the array A. It traverses through the array and looks for the integer 2 in it. It finds 2 at index position 1. It will return the value true and store it in the user-defined variable checkInclude.
If the optional parameter with start position was mentioned instead of traversing the entire array, the method includes() would have started from that position. It will look for the number or element from the index position mentioned and traverse the array until the end. If the element is found, it must return true, or the function will return false.
Examples of JavaScript Array includes()
Given below are the examples:
Example #1 – Numeric array
Code:
<script>
var A = [ 1, 2, 3, 4, 5 ];
a = A.includes(2)
document.write(a);
</script>Output:
Explanation: The above script first creates an array. Once this array is created, it uses the includes() method to check if 2 is in the mentioned array. The second statement here serves this purpose. Post find the result; we can print it and get it if it is true or false. True will signify that the mentioned element is present in the array, and false will signify that it is not present in the array. The third statement work for this purpose.
If you check the above screenshot, the result of the above code snippet is true as the includes() method finds 2 in the array. The result which is displayed is hence true.
Example #2 – String Array
Code:
<script>
var animals = [ 'dog', 'rat', 'elephant', 'camel' ];
checkArray = name.includes('cat')
document.write(checkArray);
</script>Output:
Explanation: The above code snippet makes use of a string array. Here we have an array created with the name ‘animals’. Using the includes() method, we check if the array has ‘cat’ in the array. The second statement stores the result of includes() in the checkArray variable. Using the document, you can display the result stored in the mentioned variable.write() method. The third statement helps us in displaying the result. Here the array does not consist of a cat. The result that is stored in the variable will be hence false.
The result in the above screenshot is false, which is as expected.
Example #3 – Optional parameter
Code:
<script>
var arr=["We","will","learn","JavaScript"]
var result=arr.includes("JavaScript",2);
document.writeln(result);
</script>Output:
Explanation: The above snippet declares as an array that has string values. Here in the result variable, we will, as usual, store the result if it is present. We have added the optional parameter in the includes() method. This is the start index from which we want to start the search. In the above example, we have chosen the start position as 2. When we start at 2, we have ‘learn’ present at the beginning. The next word being searched is “JavaScript”. Hence the result for this query should be true. The third statement displays the result.
The above screenshot displays the result to be true, which is as expected.
Example #4 – Variation
Let us make a variation in this example. We will now change the word to be searched to ‘will’. The position remains the same as 2. Let us run and see the results of the below code.
Code:
<script>
var arr=["We","will","learn","JavaScript"]
var result=arr.includes("will",2);
document.writeln(result);
</script>Output:
Explanation: The above script starts looking for the word ‘will’ in the array from position 2. Indexes start from 0, and hence the start position for search will be from the word ‘learn’. After the index 2 positions, there is no ‘will’ present. That means it will never find the word will when it starts from index position 2, though it is present in the array. This will make the include function return a false in the result.
The above screenshot gives the result as false, though ‘will’ is present in the array. As explained above, this is the expected result due to the start point.
Conclusion
In JavaScript, developers use the array.includes () method to find any element in an array. You may want to search an array for a particular element, and that array has many elements. This function hence comes to the rescue and lets us know whether it is present in the array. You can make use of this anywhere in the JavaScript code.
Recommended Articles
We hope that this EDUCBA information on “JavaScript Array includes()” was beneficial to you. You can view EDUCBA’s recommended articles for more information.
