Los navegadores modernos tienen Array#includes, que hace exactamente eso y es ampliamente apoyado por todos excepto IE:

console.log(['joe', 'jane', 'mary'].includes('jane')); //true

También puedes usar Array#indexOf, que es menos directo, pero no requiere polyfills para navegadores obsoletos.

console.log(['joe', 'jane', 'mary'].indexOf('jane') >= 0); //true

Muchos marcos también ofrecen métodos similares:

• jQuery: $.inArray(value, array, [fromIndex])
• Subrayado.js: _.contains(array, value) (también alias como _.include y _.includes)
• Kit de herramientas de Dojo: dojo.indexOf(array, value, [fromIndex, findLast])
• Prototipo: array.indexOf(value)
• MooHerramientas: array.indexOf(value)
• MochiKit: findValue(array, value)
• MS Ajax: array.indexOf(value)
• Ext: Ext.Array.contains(array, value)
• Lodash: _.includes(array, value, [from]) (es _.contains anterior a 4.0.0)
• ramda: R.includes(value, array)

Tenga en cuenta que algunos marcos implementan esto como una función, mientras que otros agregan la función al prototipo de matriz.

Actualización de 2019: esta respuesta es de 2008 (¡11 años!) Y no es relevante para el uso moderno de JS. La mejora de rendimiento prometida se basó en un punto de referencia realizado en navegadores de esa época. Puede que no sea relevante para los contextos de ejecución de JS modernos. Si necesita una solución sencilla, busque otras respuestas. Si necesita el mejor rendimiento, realice una evaluación comparativa en los entornos de ejecución relevantes.

Como han dicho otros, la iteración a través de la matriz es probablemente la mejor manera, pero se ha demostrado que una decreciente while loop es la forma más rápida de iterar en JavaScript. Entonces, es posible que desee reescribir su código de la siguiente manera:

function contains(a, obj) {
    var i = a.length;
    while (i--) {
       if (a[i] === obj) {
           return true;
       }
    }
    return false;
}

Por supuesto, también puede extender el prototipo Array:

Array.prototype.contains = function(obj) {
    var i = this.length;
    while (i--) {
        if (this[i] === obj) {
            return true;
        }
    }
    return false;
}

Y ahora simplemente puede usar lo siguiente:

alert([1, 2, 3].contains(2)); // => true
alert([1, 2, 3].contains('2')); // => false

indexOf tal vez, pero es una "extensión JavaScript del estándar ECMA-262; como tal, puede que no esté presente en otras implementaciones del estándar".

Ejemplo:

[1, 2, 3].indexOf(1) => 0
["foo", "bar", "baz"].indexOf("bar") => 1
[1, 2, 3].indexOf(4) => -1

AFAICS Microsoft lo hace no ofrecer algún tipo de alternativa a esto, pero puede agregar una funcionalidad similar a las matrices en Internet Explorer (y otros navegadores que no admiten indexOf) si quieres, como La búsqueda rápida de Google revela (por ejemplo, esta).

ECMAScript 7 presenta Array.prototype.includes.

Se puede usar así:

[1, 2, 3].includes(2); // true
[1, 2, 3].includes(4); // false

También acepta un segundo argumento opcional fromIndex:

[1, 2, 3].includes(3, 3); // false
[1, 2, 3].includes(3, -1); // true

Diferente a la indexOf, Que utiliza Comparación estricta de igualdad, includes compara el uso MismoValorCero algoritmo de igualdad. Eso significa que puede detectar si una matriz incluye un NaN:

[1, 2, NaN].includes(NaN); // true

También a diferencia de indexOf, includes no omite los índices que faltan:

new Array(5).includes(undefined); // true

Actualmente todavía es un borrador, pero puede ser polietileno para que funcione en todos los navegadores.

Las respuestas principales asumen tipos primitivos, pero si desea averiguar si una matriz contiene un objeto con algún rasgo, Array.prototype.some () es una solución elegante:

const items = [ {a: '1'}, {a: '2'}, {a: '3'} ]

items.some(item => item.a === '3')  // returns true
items.some(item => item.a === '4')  // returns false

Lo bueno de esto es que la iteración se aborta una vez que se encuentra el elemento, por lo que se evitan los ciclos de iteración innecesarios.

Además, encaja muy bien en un if declaración ya que devuelve un booleano:

if (items.some(item => item.a === '3')) {
  // do something
}

* Como señaló Jamess en el comentario, en el momento de esta respuesta, septiembre de 2018, Array.prototype.some() es totalmente compatible: tabla de soporte de caniuse.com

Digamos que ha definido una matriz así:

const array = [1, 2, 3, 4]

A continuación se muestran tres formas de comprobar si hay un 3 ahí. Todos regresan bien true or false.

Método de matriz nativa (desde ES2016) (tabla de compatibilidad)

array.includes(3) // true

Como método de matriz personalizado (anterior a ES2016)

// Prefixing the method with '_' to avoid name clashes
Object.defineProperty(Array.prototype, '_includes', { value: function (v) { return this.indexOf(v) !== -1 }})
array._includes(3) // true

Función simple

const includes = (a, v) => a.indexOf(v) !== -1
includes(array, 3) // true

Aquí hay una Compatible con JavaScript 1.6 aplicación de Array.indexOf:

if (!Array.indexOf) {
    Array.indexOf = [].indexOf ?
        function(arr, obj, from) {
            return arr.indexOf(obj, from);
        } :
        function(arr, obj, from) { // (for IE6)
            var l = arr.length,
                i = from ? parseInt((1 * from) + (from < 0 ? l : 0), 10) : 0;
            i = i < 0 ? 0 : i;
            for (; i < l; i++) {
                if (i in arr && arr[i] === obj) {
                    return i;
                }
            }
            return -1;
        };
}

Uso:

function isInArray(array, search)
{
    return array.indexOf(search) >= 0;
}

// Usage
if(isInArray(my_array, "my_value"))
{
    //...
}

Extendiendo el JavaScript Array object es una muy mala idea porque introduces nuevas propiedades (tus métodos personalizados) en for-in bucles que pueden romper los scripts existentes. Hace unos años los autores de la Prototipo library tuvo que rediseñar la implementación de su biblioteca para eliminar este tipo de cosas.

Si no necesita preocuparse por la compatibilidad con otros JavaScript que se ejecutan en su página, hágalo, de lo contrario, le recomendaría la solución de función independiente más incómoda pero más segura.

Un trazador de líneas:

function contains(arr, x) {
    return arr.filter(function(elem) { return elem == x }).length > 0;
}

Pensando fuera de la caja por un segundo, si está haciendo esta llamada muchas veces, es mucho más eficiente usar una matriz asociativa un mapa para realizar búsquedas utilizando una función hash.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map

Rendimiento

Hoy 2020.01.07 realizo pruebas en MacOs HighSierra 10.13.6 en Chrome v78.0.0, Safari v13.0.4 y Firefox v71.0.0 para 15 soluciones elegidas. Conclusiones

• soluciones basadas en JSON, Set y sorprendentemente find (K, N, O) son los más lentos en todos los navegadores
• el es6 includes (F) es rápido solo en Chrome
• las soluciones basadas en for (C, D) y indexOf (G, H) son bastante rápidos en todos los navegadores en arreglos pequeños y grandes, por lo que probablemente sean la mejor opción para una solución eficiente
• las soluciones donde el índice disminuye durante el ciclo, (B) es más lento probablemente porque la forma de La caché de la CPU funciona.
• También ejecuto una prueba para una matriz grande cuando el elemento buscado estaba en la posición 66% de la longitud de la matriz y las soluciones se basan en for (C, D, E) da resultados similares (~ 630 operaciones / seg, pero la E en safari y firefox fue un 10-20% más lenta que C y D)

Resultados

Detalles

Realizo 2 casos de prueba: para matriz con 10 elementos y matriz con 1 millón de elementos. En ambos casos, colocamos el elemento buscado en el medio de la matriz.

let log = (name,f) => console.log(`${name}: 3-${f(arr,'s10')}  's7'-${f(arr,'s7')}  6-${f(arr,6)} 's3'-${f(arr,'s3')}`)

let arr = [1,2,3,4,5,'s6','s7','s8','s9','s10'];
//arr = new Array(1000000).fill(123); arr[500000]=7;

function A(a, val) {
    var i = -1;
    var n = a.length;
    while (i++<n) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function B(a, val) {
    var i = a.length;
    while (i--) {
       if (a[i] === val) {
           return true;
       }
    }
    return false;
}

function C(a, val) {
    for (var i = 0; i < a.length; i++) {
        if (a[i] === val) return true;
    }
    return false;
}

function D(a,val)
{
    var len = a.length;
    for(var i = 0 ; i < len;i++)
    {
        if(a[i] === val) return true;
    }
    return false;
} 

function E(a, val){  
  var n = a.length-1;
  var t = n/2;
  for (var i = 0; i <= t; i++) {
        if (a[i] === val || a[n-i] === val) return true;
  }
  return false;
}

function F(a,val) {
	return a.includes(val);
}

function G(a,val) {
	return a.indexOf(val)>=0;
}

function H(a,val) {
	return !!~a.indexOf(val);
}

function I(a, val) {
  return a.findIndex(x=> x==val)>=0;
}

function J(a,val) {
	return a.some(x=> x===val);
}

function K(a, val) {
  const s = JSON.stringify(val);
  return a.some(x => JSON.stringify(x) === s);
}

function L(a,val) {
	return !a.every(x=> x!==val);
}

function M(a, val) {
  return !!a.find(x=> x==val);
}

function N(a,val) {
	return a.filter(x=>x===val).length > 0;
}

function O(a, val) {
  return new Set(a).has(val);
}

log('A',A);
log('B',B);
log('C',C);
log('D',D);
log('E',E);
log('F',F);
log('G',G);
log('H',H);
log('I',I);
log('J',J);
log('K',K);
log('L',L);
log('M',M);
log('N',N);
log('O',O);

This shippet only presents functions used in performance tests - it not perform tests itself!

Matriz pequeña - 10 elementos

Puedes realizar pruebas en tu máquina AQUÍ

Matriz grande - 1.000.000 elementos

Puedes realizar pruebas en tu máquina AQUÍ

Yo uso lo siguiente:

Array.prototype.contains = function (v) {
    return this.indexOf(v) > -1;
}

var a = [ 'foo', 'bar' ];

a.contains('foo'); // true
a.contains('fox'); // false

function contains(a, obj) {
    return a.some(function(element){return element == obj;})
}

Array.prototype.some () se agregó al estándar ECMA-262 en la quinta edición

Un bidireccional con suerte más rápido indexOf / lastIndexOf alternativa

2015

Mientras que el nuevo método incluye es muy bueno, el soporte es básicamente cero por ahora.

Hace mucho tiempo que estaba pensando en la forma de reemplazar las funciones lentas indexOf / lastIndexOf.

Ya se ha encontrado una forma de rendimiento, mirando las respuestas principales. De los que elegí el contains función publicada por @Damir Zekic, que debería ser la más rápida. Pero también establece que los puntos de referencia son de 2008 y, por lo tanto, están desactualizados.

Yo tambien prefiero while encima for, pero no por una razón específica, terminé de escribir la función con un bucle for. También se puede hacer con un while --.

Tenía curiosidad por saber si la iteración era mucho más lenta si verifico ambos lados de la matriz mientras lo hacía. Aparentemente no, por lo que esta función es aproximadamente dos veces más rápida que las más votadas. Obviamente también es más rápido que el nativo. Esto en un entorno del mundo real, donde nunca se sabe si el valor que está buscando está al principio o al final de la matriz.

Cuando sabe que acaba de enviar una matriz con un valor, usar lastIndexOf sigue siendo probablemente la mejor solución, pero si tiene que viajar a través de matrices grandes y el resultado podría estar en todas partes, esta podría ser una solución sólida para hacer las cosas más rápido.

Bidireccional indexOf / lastIndexOf

function bidirectionalIndexOf(a, b, c, d, e){
  for(c=a.length,d=c*1; c--; ){
    if(a[c]==b) return c; //or this[c]===b
    if(a[e=d-1-c]==b) return e; //or a[e=d-1-c]===b
  }
  return -1
}

//Usage
bidirectionalIndexOf(array,'value');

Prueba de rendimiento

http://jsperf.com/bidirectionalindexof

Como prueba, creé una matriz con 100k entradas.

Tres consultas: al principio, en el medio y al final de la matriz.

Espero que también encuentres esto interesante y pruebes el rendimiento.

Nota: Como puede ver, modifiqué ligeramente el contains función para reflejar la salida indexOf y lastIndexOf (así que básicamente true con el index y false con -1). Eso no debería dañarlo.

La variante del prototipo de matriz

Object.defineProperty(Array.prototype,'bidirectionalIndexOf',{value:function(b,c,d,e){
  for(c=this.length,d=c*1; c--; ){
    if(this[c]==b) return c; //or this[c]===b
    if(this[e=d-1-c] == b) return e; //or this[e=d-1-c]===b
  }
  return -1
},writable:false, enumerable:false});

// Usage
array.bidirectionalIndexOf('value');

La función también se puede modificar fácilmente para devolver verdadero o falso o incluso el objeto, la cadena o lo que sea.

Y aquí está el while variante:

function bidirectionalIndexOf(a, b, c, d){
  c=a.length; d=c-1;
  while(c--){
    if(b===a[c]) return c;
    if(b===a[d-c]) return d-c;
  }
  return c
}

// Usage
bidirectionalIndexOf(array,'value');

¿Cómo es esto posible?

Creo que el cálculo simple para obtener el índice reflejado en una matriz es tan simple que es dos veces más rápido que hacer una iteración de bucle real.

Aquí hay un ejemplo complejo que hace tres comprobaciones por iteración, pero esto solo es posible con un cálculo más largo que provoca la ralentización del código.

http://jsperf.com/bidirectionalindexof/2

Si está usando JavaScript 1.6 o posterior (Firefox 1.5 o posterior) puede usar Array.indexOf. De lo contrario, creo que terminará con algo similar a su código original.

function inArray(elem,array)
{
    var len = array.length;
    for(var i = 0 ; i < len;i++)
    {
        if(array[i] == elem){return i;}
    }
    return -1;
} 

Devuelve el índice de la matriz si se encuentra, o -1 si no se encuentra

Si está comprobando repetidamente la existencia de un objeto en una matriz, tal vez debería investigar

1. Mantener la matriz ordenada en todo momento haciendo tipo de inserción en su matriz (coloque nuevos objetos en el lugar correcto)
2. Realice la actualización de objetos como operación de inserción eliminar + ordenada y
3. Utilizar búsqueda binaria buscar en tu contains(a, obj).

Usamos este fragmento (funciona con objetos, matrices, cadenas):

/*
 * @function
 * @name Object.prototype.inArray
 * @description Extend Object prototype within inArray function
 *
 * @param {mix}    needle       - Search-able needle
 * @param {bool}   searchInKey  - Search needle in keys?
 *
 */
Object.defineProperty(Object.prototype, 'inArray',{
    value: function(needle, searchInKey){

        var object = this;

        if( Object.prototype.toString.call(needle) === '[object Object]' || 
            Object.prototype.toString.call(needle) === '[object Array]'){
            needle = JSON.stringify(needle);
        }

        return Object.keys(object).some(function(key){

            var value = object[key];

            if( Object.prototype.toString.call(value) === '[object Object]' || 
                Object.prototype.toString.call(value) === '[object Array]'){
                value = JSON.stringify(value);
            }

            if(searchInKey){
                if(value === needle || key === needle){
                return true;
                }
            }else{
                if(value === needle){
                    return true;
                }
            }
        });
    },
    writable: true,
    configurable: true,
    enumerable: false
});

Uso:

var a = {one: "first", two: "second", foo: {three: "third"}};
a.inArray("first");          //true
a.inArray("foo");            //false
a.inArray("foo", true);      //true - search by keys
a.inArray({three: "third"}); //true

var b = ["one", "two", "three", "four", {foo: 'val'}];
b.inArray("one");         //true
b.inArray('foo');         //false
b.inArray({foo: 'val'})   //true
b.inArray("{foo: 'val'}") //false

var c = "String";
c.inArray("S");        //true
c.inArray("s");        //false
c.inArray("2", true);  //true
c.inArray("20", true); //false

Solución que funciona en todos los navegadores modernos:

function contains(arr, obj) {
  const stringifiedObj = JSON.stringify(obj); // Cache our object to not call `JSON.stringify` on every iteration
  return arr.some(item => JSON.stringify(item) === stringifiedObj);
}

Uso:

contains([{a: 1}, {a: 2}], {a: 1}); // true

Solución IE6 +:

function contains(arr, obj) {
  var stringifiedObj = JSON.stringify(obj)
  return arr.some(function (item) {
    return JSON.stringify(item) === stringifiedObj;
  });
}

// .some polyfill, not needed for IE9+
if (!('some' in Array.prototype)) {
  Array.prototype.some = function (tester, that /*opt*/) {
    for (var i = 0, n = this.length; i < n; i++) {
      if (i in this && tester.call(that, this[i], i, this)) return true;
    } return false;
  };
}

Uso:

contains([{a: 1}, {a: 2}], {a: 1}); // true

Por que usar JSON.stringify?

Array.indexOf y Array.includes (así como la mayoría de las respuestas aquí) solo compare por referencia y no por valor.

[{a: 1}, {a: 2}].includes({a: 1});
// false, because {a: 1} is a new object

Bono

Una sola línea ES6 no optimizada:

[{a: 1}, {a: 2}].some(item => JSON.stringify(item) === JSON.stringify({a: 1));
// true

Nota: Comparar objetos por valor funcionará mejor si las claves están en el mismo orden, por lo que para estar seguro, puede ordenar las claves primero con un paquete como este: https://www.npmjs.com/package/sort-keys

Actualizado el contains función con una optimización de rendimiento. Gracias itinancia por señalarlo.

Usa lodash's algo función.

Es conciso, preciso y tiene un excelente soporte multiplataforma.

La respuesta aceptada ni siquiera cumple con los requisitos.

Requisitos: Recomendar la forma más concisa y eficiente de averiguar si una matriz de JavaScript contiene un objeto.

Respuesta aceptada:

$.inArray({'b': 2}, [{'a': 1}, {'b': 2}])
> -1

Mi recomendación:

_.some([{'a': 1}, {'b': 2}], {'b': 2})
> true

Notas

$ .inArray funciona bien para determinar si un escalar el valor existe en una matriz de escalares ...

$.inArray(2, [1,2])
> 1

... pero la pregunta pide claramente una forma eficiente de determinar si un objeto está contenido en una matriz.

Para manejar escalares y objetos, puede hacer esto:

(_.isObject(item)) ? _.some(ary, item) : (_.indexOf(ary, item) > -1)

ECMAScript 6 tiene una elegante propuesta para encontrar.

El método de búsqueda ejecuta la función de devolución de llamada una vez para cada elemento presente en la matriz hasta que encuentra uno donde la devolución de llamada devuelve un valor verdadero. Si se encuentra un elemento de este tipo, find devuelve inmediatamente el valor de ese elemento. De lo contrario, busque devoluciones indefinidas. la devolución de llamada se invoca solo para los índices de la matriz que tienen valores asignados; no se invoca para índices que se han eliminado o a los que nunca se les han asignado valores.

Aquí está la Documentación MDN en eso.

La funcionalidad de búsqueda funciona así.

function isPrime(element, index, array) {
    var start = 2;
    while (start <= Math.sqrt(element)) {
        if (element % start++ < 1) return false;
    }
    return (element > 1);
}

console.log( [4, 6, 8, 12].find(isPrime) ); // Undefined, not found
console.log( [4, 5, 8, 12].find(isPrime) ); // 5

Puede usar esto en ECMAScript 5 y a continuación por definiendo la función.

if (!Array.prototype.find) {
  Object.defineProperty(Array.prototype, 'find', {
    enumerable: false,
    configurable: true,
    writable: true,
    value: function(predicate) {
      if (this == null) {
        throw new TypeError('Array.prototype.find called on null or undefined');
      }
      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }
      var list = Object(this);
      var length = list.length >>> 0;
      var thisArg = arguments[1];
      var value;

      for (var i = 0; i < length; i++) {
        if (i in list) {
          value = list[i];
          if (predicate.call(thisArg, value, i, list)) {
            return value;
          }
        }
      }
      return undefined;
    }
  });
}

Aunque la array.indexOf(x)!=-1 es la forma más concisa de hacer esto (y ha sido compatible con navegadores que no son de Internet Explorer durante más de una década ...), no es O (1), sino O (N), lo cual es terrible. Si su matriz no cambiará, puede convertir su matriz en una tabla hash, luego haga table[x]!==undefined or ===undefined:

Array.prototype.toTable = function() {
    var t = {};
    this.forEach(function(x){t[x]=true});
    return t;
}

Demostración:

var toRemove = [2,4].toTable();
[1,2,3,4,5].filter(function(x){return toRemove[x]===undefined})

(Desafortunadamente, aunque puede crear un Array.prototype.contains para "congelar" una matriz y almacenar una tabla hash en this._cache en dos líneas, esto daría resultados incorrectos si elige editar su matriz más tarde. JavaScript no tiene suficientes ganchos para le permite mantener este estado, a diferencia de Python, por ejemplo).

Uno puede usar Kit que tiene el método "has ()":

function contains(arr, obj) {
      var proxy = new Set(arr);
      if (proxy.has(obj))
        return true;
      else
        return false;
    }

    var arr = ['Happy', 'New', 'Year'];
    console.log(contains(arr, 'Happy'));

Uso:

var myArray = ['yellow', 'orange', 'red'] ;

alert(!!~myArray.indexOf('red')); //true

Demo

Para saber exactamente lo que tilde ~ hacer en este punto, consulte esta pregunta ¿Qué hace una tilde cuando precede a una expresión?.

OK, puedes simplemente optimiza tu código para obtener el resultado!

Hay muchas formas de hacer esto que son más limpias y mejores, pero solo quería obtener tu patrón y aplicarlo usando JSON.stringify, simplemente haz algo como esto en tu caso:

function contains(a, obj) {
    for (var i = 0; i < a.length; i++) {
        if (JSON.stringify(a[i]) === JSON.stringify(obj)) {
            return true;
        }
    }
    return false;
}

Una solución simple para este requisito es utilizar find()

Si tiene una variedad de objetos como a continuación,

var users = [{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "admin"},
{id: "105", name: "user"}];

Luego puede verificar si el objeto con su valor ya está presente o no

let data = users.find(object => object['id'] === '104');

si los datos son nulos, entonces no hay administrador, de lo contrario, devolverá el objeto existente como se muestra a continuación.

{id: "104", name: "admin"}

Luego, puede encontrar el índice de ese objeto en la matriz y reemplazar el objeto usando el siguiente código.

let indexToUpdate = users.indexOf(data);
let newObject = {id: "104", name: "customer"};
users[indexToUpdate] = newObject;//your new object
console.log(users);

obtendrás valor como a continuación

[{id: "101", name: "Choose one..."},
{id: "102", name: "shilpa"},
{id: "103", name: "anita"},
{id: "104", name: "customer"},
{id: "105", name: "user"}];

Espero que esto ayude a cualquiera.

De ninguna manera el mejor, pero me estaba volviendo creativo y agregando al repertorio.

No use esto

Object.defineProperty(Array.prototype, 'exists', {
  value: function(element, index) {

    var index = index || 0

    return index === this.length ? -1 : this[index] === element ? index : this.exists(element, ++index)
  }
})


// Outputs 1
console.log(['one', 'two'].exists('two'));

// Outputs -1
console.log(['one', 'two'].exists('three'));

console.log(['one', 'two', 'three', 'four'].exists('four'));

Me sorprende que esta pregunta todavía no tenga la última sintaxis agregada, agregando mis 2 centavos.

Digamos que tenemos una matriz de Objetos arrObj y queremos buscar obj en ella.

matriz.prototipo.índice de -> (devuelve índice o -1) se usa generalmente para encontrar el índice de un elemento en una matriz. Esto también se puede usar para buscar objetos, pero solo funciona si está pasando una referencia al mismo objeto.

let obj = { name: 'Sumer', age: 36 };
let arrObj = [obj, { name: 'Kishor', age: 46 }, { name: 'Rupen', age: 26 }];


console.log(arrObj.indexOf(obj));// 0
console.log(arrObj.indexOf({ name: 'Sumer', age: 36 })); //-1

console.log([1, 3, 5, 2].indexOf(2)); //3

matriz.prototipo.incluye -> (devuelve verdadero or false)

console.log(arrObj.includes(obj));  //true
console.log(arrObj.includes({ name: 'Sumer', age: 36 })); //false

console.log([1, 3, 5, 2].includes(2)); //true

matriz.prototipo.encontrar -> (recibe devolución de llamada, regresa primero valor / objeto que devuelve verdadero en CB).

console.log(arrObj.find(e => e.age > 40));  //{ name: 'Kishor', age: 46 }
console.log(arrObj.find(e => e.age > 40)); //{ name: 'Kishor', age: 46 }

console.log([1, 3, 5, 2].find(e => e > 2)); //3

matriz.prototipo.buscarÍndice -> (recibe devolución de llamada, devuelve índice del primer valor / objeto que devuelve verdadero en CB).

console.log(arrObj.findIndex(e => e.age > 40));  //1
console.log(arrObj.findIndex(e => e.age > 40)); //1

console.log([1, 3, 5, 2].findIndex(e => e > 2)); //1

Dado que find y findIndex toman una devolución de llamada, podemos recuperar cualquier objeto (incluso si no tenemos la referencia) de la matriz estableciendo creativamente la condición verdadera.