Qual é a maneira mais concisa e eficiente de descobrir se uma matriz JavaScript contém um valor?

Esta é a única maneira que sei fazer:

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

Existe uma maneira melhor e mais concisa de fazer isso?

Isso está muito relacionado à pergunta Stack Overflow. Melhor maneira de encontrar um item em uma matriz JavaScript? que aborda a localização de objetos em uma matriz usando indexOf.

Navegadores modernos têm Array#includes, o que faz exatamente isso e é amplamente suportado por todos, exceto o IE:

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

Você também pode usar Array#indexOf, que é menos direto, mas não requer polyfills para navegadores desatualizados.

Muitas estruturas também oferecem métodos semelhantes:

• jQuery: $.inArray(value, array, [fromIndex])
• Underscore.js: _.contains(array, value)(também com alias como _.includee _.includes)
• Dojo Toolkit: dojo.indexOf(array, value, [fromIndex, findLast])
• Protótipo: array.indexOf(value)
• MooTools: array.indexOf(value)
• MochiKit: findValue(array, value)
• MS Ajax: array.indexOf(value)
• Ext: Ext.Array.contains(array, value)
• Lodash: _.includes(array, value, [from])(é _.contains4.0.0 anterior)
• Ramda: R.includes(value, array)

Observe que algumas estruturas implementam isso como uma função, enquanto outras adicionam a função ao protótipo da matriz.

Atualização de 2019: esta resposta é de 2008 (11 anos!) E não é relevante para o uso moderno de JS. A melhoria de desempenho prometida foi baseada em uma referência feita nos navegadores da época. Pode não ser relevante para os contextos modernos de execução de JS. Se você precisar de uma solução fácil, procure outras respostas. Se você precisar do melhor desempenho, faça um benchmark para si nos ambientes de execução relevantes.

Como já foi dito, a iteração na matriz é provavelmente a melhor maneira, mas foi provado que um whileloop decrescente é a maneira mais rápida de iterar em JavaScript. Portanto, você pode reescrever seu código da seguinte maneira:

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

Obviamente, você também pode estender o protótipo de matriz:

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

E agora você pode simplesmente usar o seguinte:

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

indexOf talvez, mas é uma "extensão JavaScript para o padrão ECMA-262; portanto, pode não estar presente em outras implementações do padrão".

Exemplo:

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

AFAICS A Microsoft não oferece algum tipo de alternativa a isso, mas você pode adicionar funcionalidades semelhantes às matrizes no Internet Explorer (e outros navegadores que não suportam indexOf) se desejar, como revela uma pesquisa rápida no Google (por exemplo, esta )

O ECMAScript 7 apresenta Array.prototype.includes .

Pode ser usado assim:

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

Também aceita um segundo argumento opcional fromIndex:

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

Ao contrário indexOf, que usa Comparação de igualdade estrita , includescompara usando o algoritmo de igualdade SameValueZero . Isso significa que você pode detectar se uma matriz inclui um NaN:

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

Ao contrário indexOf, includestambém não ignora os índices ausentes:

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

Atualmente, ainda é um rascunho, mas pode ser preenchido com polyfill para fazê-lo funcionar em todos os navegadores.

As respostas principais assumem tipos primitivos, mas se você deseja descobrir se uma matriz contém um objeto com alguma característica, Array.prototype.some () é uma solução muito 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

O bom disso é que a iteração é abortada quando o elemento é encontrado, para que ciclos de iteração desnecessários sejam poupados.

Além disso, ele se encaixa perfeitamente em uma ifdeclaração, pois retorna um booleano:

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

* Como jamess apontou no comentário, no momento desta resposta, setembro de 2018, Array.prototype.some()é totalmente suportada: tabela de suporte do caniuse.com

Digamos que você definiu uma matriz assim:

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

Abaixo estão três maneiras de verificar se há um 3lá. Todos eles retornam trueou false.

Método de matriz nativa (desde ES2016) ( tabela de compatibilidade )

array.includes(3) // true

Como método Array personalizado (pré 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

Função simples

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

Aqui está uma implementação compatível com JavaScript 1.6 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;
        };
}

Usar:

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

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

Estender o Arrayobjeto JavaScript é uma péssima idéia, porque você introduz novas propriedades (seus métodos personalizados) em for-inloops que podem quebrar os scripts existentes. Alguns anos atrás, os autores da biblioteca Prototype tiveram que reprojetar a implementação da biblioteca para remover esse tipo de coisa.

Se você não precisa se preocupar com a compatibilidade com outro JavaScript em execução na sua página, vá em frente, caso contrário, recomendo a solução de função independente mais estranha, mas mais segura.

Uma linha:

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

Pensando fora da caixa por um segundo, se você estiver fazendo essa ligação muitas vezes, é muito mais eficiente usar uma matriz associativa de um mapa para fazer pesquisas usando uma função hash.

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

Eu uso o seguinte:

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 () foi adicionado ao padrão ECMA-262 na 5ª edição

Uma alternativa bidirecional indexOf/ esperançosamente mais rápidalastIndexOf

2015

Embora o novo método inclua é muito bom, o suporte é basicamente zero por enquanto.

Há muito tempo que eu estava pensando em uma maneira de substituir as funções indexOf / lastIndexOf lentas.

Uma maneira de desempenho já foi encontrada, observando as principais respostas. Daqueles eu escolhi ocontains função postada por @Damir Zekic, que deve ser a mais rápida. Mas também afirma que os benchmarks são de 2008 e estão desatualizados.

Eu também prefiro whilemais for, mas por não um motivo específico Acabei escrevendo a função com um loop for. Também poderia ser feito com umwhile -- .

Fiquei curioso se a iteração era muito mais lenta se eu verificasse os dois lados da matriz enquanto fazia isso. Aparentemente não, e, portanto, essa função é cerca de duas vezes mais rápida do que as votadas com maior número de votos. Obviamente, também é mais rápido que o nativo. Isso em um ambiente do mundo real, onde você nunca sabe se o valor que está pesquisando está no início ou no final da matriz.

Quando você sabe que acabou de empurrar uma matriz com um valor, usar lastIndexOf provavelmente é a melhor solução, mas se você precisar percorrer grandes matrizes e o resultado puder estar em qualquer lugar, essa poderá ser uma solução sólida para tornar as coisas mais rápidas.

Índice bidirecionalOf / 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');

Teste de performance

http://jsperf.com/bidirectionalindexof

Como teste, criei uma matriz com 100 mil entradas.

Três consultas: no início, no meio e no final da matriz.

Espero que você também ache isso interessante e teste o desempenho.

Nota: Como você pode ver, modifiquei levemente a containsfunção para refletir a saída indexOf & lastIndexOf (basicamente truecom os botões com indexe falsecom -1). Isso não deve prejudicá-lo.

A variante do protótipo 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');

A função também pode ser facilmente modificada para retornar verdadeiro ou falso, ou mesmo o objeto, a string ou o que for.

E aqui está a whilevariante:

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');

Como isso é possível?

Eu acho que o cálculo simples para obter o índice refletido em uma matriz é tão simples que é duas vezes mais rápido que fazer uma iteração de loop real.

Aqui está um exemplo complexo que faz três verificações por iteração, mas isso só é possível com um cálculo mais longo que causa a lentidão do código.

http://jsperf.com/bidirectionalindexof/2

atuação

Hoje 2020.01.07 realizo testes no MacOs HighSierra 10.13.6 no Chrome v78.0.0, Safari v13.0.4 e Firefox v71.0.0 para 15 soluções escolhidas. Conclusões

• As soluções com base em JSON, Sete surpreendentemente find(K, N, S) são mais lento em todos os navegadores
• o es6 includes(F) é rápido apenas no chrome
• as soluções baseadas em for(C, D) eindexOf (G, H) são bastante rápidas em todos os navegadores em matrizes pequenas e grandes; portanto, provavelmente são a melhor escolha para uma solução eficiente
• as soluções em que o índice diminui durante o loop, (B) é mais lento, provavelmente porque o modo de cache da CPU funciona .
• Também executo teste para grande matriz quando o elemento pesquisado estava na posição 66% do comprimento da matriz, e as soluções baseadas em for(C, D, E) dão resultados semelhantes (~ 630 ops / s - mas o E no safari e no firefox era 10- 20% mais lento que C e D)

Resultados

Detalhes

Realizo 2 casos de teste: para matriz com 10 elementos e matriz com 1 milhão de elementos. Nos dois casos, colocamos o elemento pesquisado no meio da 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 pequena - 10 elementos

Você pode realizar testes em sua máquina AQUI

Matriz grande - 1.000.000 elementos

Você pode realizar testes em sua máquina AQUI

Se você estiver usando JavaScript 1.6 ou posterior (Firefox 1.5 ou posterior), poderá usar Array.indexOf . Caso contrário, acho que você terminará com algo semelhante ao seu 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;
} 

Retorna o índice da matriz, se encontrado, ou -1, se não encontrado

Usamos esse trecho (trabalha com objetos, matrizes, strings):

/*
 * @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

Se você está verificando repetidamente a existência de um objeto em uma matriz, talvez deva procurar

1. Mantendo a matriz sempre classificada, classificando a inserção em sua matriz (coloque novos objetos no lugar certo)
2. Faça a atualização de objetos como remover + operação de inserção classificada e
3. Use uma pesquisa de pesquisa binária no seu contains(a, obj).

Solução que funciona em todos os 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

Solução 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.indexOfe Array.includes(assim como a maioria das respostas aqui) são comparadas apenas por referência e não por valor.

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

Bônus

Linha única ES6 não otimizada:

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

Nota: A comparação de objetos por valor funcionará melhor se as chaves estiverem na mesma ordem. Portanto, para garantir a segurança, você deve classificar as chaves primeiro com um pacote como este: https://www.npmjs.com/package/sort-keys

Atualizada a containsfunção com uma otimização de desempenho. Obrigado itinance por apontá-lo.

Use alguma função do lodash .

É conciso, preciso e possui excelente suporte entre plataformas.

A resposta aceita nem atende aos requisitos.

Requisitos: recomende a maneira mais concisa e eficiente de descobrir se uma matriz JavaScript contém um objeto.

Resposta Aceita:

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

Minha recomendação:

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

Notas:

$ .inArray funciona bem para determinar se existe um valor escalar em uma matriz de escalares ...

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

... mas a pergunta claramente pede uma maneira eficiente de determinar se um objeto está contido em uma matriz.

Para lidar com escalares e objetos, você pode fazer o seguinte:

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

O ECMAScript 6 tem uma proposta elegante em busca.

O método find executa a função de retorno de chamada uma vez para cada elemento presente na matriz até encontrar um em que o retorno de chamada retorne um valor verdadeiro. Se esse elemento for encontrado, find retornará imediatamente o valor desse elemento. Caso contrário, encontre retornos indefinidos. o retorno de chamada é invocado apenas para índices da matriz que atribuíram valores; não é chamado para índices que foram excluídos ou aos quais nunca foram atribuídos valores.

Aqui está a documentação MDN sobre isso.

A funcionalidade de localização funciona assim.

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

Você pode usar isso no ECMAScript 5 e abaixo, definindo a função .

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;
    }
  });
}

Embora array.indexOf(x)!=-1seja a maneira mais concisa de fazer isso (e seja suportada por navegadores que não sejam o Internet Explorer há mais de uma década ...), não é O (1), mas O (N), o que é terrível. Se sua matriz não for alterada, você poderá convertê-la em uma hashtable e, em seguida, faça table[x]!==undefinedou ===undefined:

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

Demo:

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

(Infelizmente, embora você possa criar um Array.prototype.contains para "congelar" uma matriz e armazenar uma hashtable nesta._cache em duas linhas, isso geraria resultados incorretos se você optar por editar sua matriz mais tarde. O JavaScript possui ganchos insuficientes para mantenha esse estado, diferente do Python, por exemplo.)

Pode-se usar Set que possui o 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'));

Usar:

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

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

Demo

Para saber exatamente o que tilde ~fazer neste momento, consulte esta pergunta O que um til faz quando precede uma expressão? .

OK, você pode otimizar seu código para obter o resultado!

Existem muitas maneiras de fazer isso que são mais limpas e melhores, mas eu só queria que seu padrão se aplicasse a isso JSON.stringify, basta fazer algo assim no seu 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;
}

De maneira alguma o melhor, mas eu estava apenas sendo criativo e aumentando o repertório.

Não use isso

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'));

Surpreso que esta pergunta ainda não tenha a sintaxe mais recente adicionada, adicionando meus 2 centavos.

Digamos que temos uma matriz de objetos arrObj e queremos pesquisar obj nele.

Array.prototype. indexOf -> (retorna índice ou -1 ) geralmente é usado para encontrar o índice do elemento na matriz. Isso também pode ser usado para pesquisar objetos, mas só funciona se você estiver passando referência ao mesmo 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

Array.prototype. inclui -> (retorna verdadeiro ou falso )

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

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

Array.prototype. find -> (recebe retorno de chamada, retorna o primeiro valor / objeto que retorna true no 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

Array.prototype. findIndex -> (recebe retorno de chamada, retorna o índice do primeiro valor / objeto que retorna verdadeiro no 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

Como find e findIndex recebem um retorno de chamada, podemos buscar qualquer objeto (mesmo que não tenhamos a referência) da matriz, configurando de forma criativa a verdadeira condição.

A solução simples para esse requisito é usar find()

Se você estiver tendo uma variedade de objetos como abaixo,

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

Então você pode verificar se o objeto com seu valor já está presente ou não

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

se os dados forem nulos, não haverá administrador; caso contrário, ele retornará o objeto existente, como abaixo.

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

Em seguida, você pode encontrar o índice desse objeto na matriz e substituí-lo usando o código abaixo.

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

você terá valor como abaixo

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

espero que isso ajude alguém.