How to know if an object is contained in an array?

You can use the indexOfclass function Array, which returns the position where the searched object is located.

arreglo.indexOf("3") >= 0

Returns -1if it does not exist, and otherwise the position that will be greater than or equal to 0.

You can use a simple script like:

<script>    
var arreglo = ["1", "2", "4", "5"]            
for(var i = 0; i < arreglo.length; i++) {
    alert("se encuentra " + arreglo[i]);
    if (arreglo[i] == "4") {
        alert("se encuentra objeto!.");
        break;
    }
}
</script>

Although based on your question ¿Cómo saber si un objeto está contenido en un array?, for me an object would be for example:

arreglo = [
    {
      indice: 'a',
      valor: '1'
     },
    {
      indice: 'b',
      valor: '2'
     },
    {
      indice: 'b',
      valor: '4'
     },
    {
      indice: 'd',
      valor: '5'
     },
];

Now, to determine if the object exists, it "b"would be by:

for(var i = 0; i < arreglo.length; i++) {
    if (arreglo[i].valor== 'b') {
          alert("se encuentra objeto!.");
        break;
    }
}

But as you comment, for me it would also be enough to use only the indexOf() method :arreglo.indexOf('3') > -1

Doing some research on MDN, there is a method Array.prototype.includes()proposed for EcmaScript 2016 (ES7) and it returns a boolean value if the array contains the indicated element:

[1, 2, 3].includes(3); // true
["a", "b", "c"].includes("d"); // false

This method accepts an optional second parameter, which indicates from which index the search will be performed (0 by default).

["foo", "bar", "baz"].includes("baz", 1); // true

It is not yet official that the method will be present in the next version of JavaScript, but if it is, this answer will be more relevant and I think it is a good addition to Arrays because it allows us to express our intention clearly, which produces more readable code. Currently it is possible to test it in the latest versions of the most common browsers except IE and Edge (surprisingly).

In the official documentation we find the following polyfill :

if (!Array.prototype.includes) {
  Array.prototype.includes = function(searchElement /*, fromIndex*/ ) {
    'use strict';
    var O = Object(this);
    var len = parseInt(O.length) || 0;
    if (len === 0) {
      return false;
    }
    var n = parseInt(arguments[1]) || 0;
    var k;
    if (n >= 0) {
      k = n;
    } else {
      k = len + n;
      if (k < 0) {k = 0;}
    }
    var currentElement;
    while (k < len) {
      currentElement = O[k];
      if (searchElement === currentElement ||
         (searchElement !== searchElement && currentElement !== currentElement))     { // NaN !== NaN
        return true;
      }
      k++;
    }
    return false;
  };
}

If you don't care about being compatible with IE6, 7 or 8 browsers, you can just use use indexOfas stated in the first answer.

function inArray(arreglo, elemento) {
  return arreglo.indexOf(elemento) !== -1;
}

Now if you need to be compatible with "historic" browsers, you could implement indexOfit yourself. The following code can be safely added to your code since if indexOfit is defined it has no effect:

if (!Array.prototype.indexOf) {
  Array.prototype.indexOf = function (obj, fromIndex) {
    if (fromIndex == null) {
        fromIndex = 0;
    } else if (fromIndex < 0) {
        fromIndex = Math.max(0, this.length + fromIndex);
    }
    for (var i = fromIndex, j = this.length; i < j; i++) {
        if (this[i] === obj)
            return i;
    }
    return -1;
  };
}

Note: this implementation of indexOfwas originally published by Daniel James .

Taking into account that we have:

var arreglo = ["1", "2", "4", "5"];

Solution 1 - Native

We have the following Array.prototype.indexOf() function and documentation :

array.indexOf(searchElement[, fromIndex])

Practical use:

arreglo.indexOf('1'); // Devuelve 0
arreglo.indexOf('3'); // Devuelve -1

Solution 2 - Using Libraries

We can use 3rd party tools to achieve this result, such as:

- Using jQuery

jQuery.inArray () documentation :

jQuery.inArray( value, array [, fromIndex ] )

Practical use:

$.inArray('3', arreglo); // Devuelve -1

- Using Underscore.js

Documentation for _.indexOf() :

_.indexOf(array, value, [isSorted])

Practical use:

_.indexOf(arreglo, '3'); // Devuelve -1