¿La mejor manera de encontrar si un elemento está en una matriz de JavaScript? [duplicate]

8 minutos de lectura

¿La mejor manera de encontrar si un elemento esta en
zimbat

¿Cuál es la mejor manera de encontrar si un objeto está en una matriz?

Esta es la mejor manera que conozco:

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

console.log(include([1, 2, 3, 4], 3)); // true
console.log(include([1, 2, 3, 4], 6)); // undefined

  • Ver: stackoverflow.com/a/25765186/1320932

    – dr.dimitru

    10 de septiembre de 2014 a las 12:18

  • 2 cosas: 1.) ‘incluir’ es un nombre realmente malo para una función que no modifica el estado de nada. Es especialmente malo para una función que simplemente devuelve un valor booleano. 2.) Debe agregar “return(false);” antes del final de la función.

    – Aquarelle

    12 de mayo de 2015 a las 0:57


  • a partir de ECMAScript 2016, puede usar la función Array.prototype.includes: myArray.includes(3); // cierto

    – mhd

    15 de junio de 2016 a las 13:25


  • En ES6 puedes hacer algo como arr.find(función lamda), ejemplo: [1, 2, 3,4,5].encontrar(x => x == 3). si se encuentra el elemento, se devuelve; de ​​lo contrario, se devuelve indefinido

    – ALLSYED

    29 de julio de 2016 a las 10:26


  • arr.some(elemento => elemento === obj); some es la mejor manera porque cuando encuentra un elemento y luego rompe el ciclo.

    – Cenk Çetinkaya

    9 de enero de 2018 a las 11:58

¿La mejor manera de encontrar si un elemento esta en
Vinko Vrsalovic

A partir de ECMAScript 2016 puede usar includes()

arr.includes(obj);

Si desea admitir IE u otros navegadores más antiguos:

function include(arr,obj) {
    return (arr.indexOf(obj) != -1);
}

EDITAR: Sin embargo, esto no funcionará en IE6, 7 u 8. La mejor solución es definirlo usted mismo si no está presente:

  1. de Mozilla (ECMA-262) versión:

       if (!Array.prototype.indexOf)
       {
    
            Array.prototype.indexOf = function(searchElement /*, fromIndex */)
    
         {
    
    
         "use strict";
    
         if (this === void 0 || this === null)
           throw new TypeError();
    
         var t = Object(this);
         var len = t.length >>> 0;
         if (len === 0)
           return -1;
    
         var n = 0;
         if (arguments.length > 0)
         {
           n = Number(arguments[1]);
           if (n !== n)
             n = 0;
           else if (n !== 0 && n !== (1 / 0) && n !== -(1 / 0))
             n = (n > 0 || -1) * Math.floor(Math.abs(n));
         }
    
         if (n >= len)
           return -1;
    
         var k = n >= 0
               ? n
               : Math.max(len - Math.abs(n), 0);
    
         for (; k < len; k++)
         {
           if (k in t && t[k] === searchElement)
             return k;
         }
         return -1;
       };
    
     }
    
  2. La versión de Daniel James:

     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;
       };
     }
    
  3. versión de roosteronacid:

     Array.prototype.hasObject = (
       !Array.indexOf ? function (o)
       {
         var l = this.length + 1;
         while (l -= 1)
         {
             if (this[l - 1] === o)
             {
                 return true;
             }
         }
         return false;
       } : function (o)
       {
         return (this.indexOf(o) !== -1);
       }
     );
    

  • Tengo curiosidad por saber por qué su versión de la función de Mozilla es tan diferente del sitio web al que está enlazando. ¿Lo modificaste tú mismo o es solo una versión antigua o algo así?

    – Justin G.

    11 de marzo de 2014 a las 1:16

  • @Shenjoku: “respondido el 27 de septiembre de 2008 a las 15:45”

    -Vinko Vrsalovic

    11 de marzo de 2014 a las 5:49

  • Bueno, ahí está mi respuesta jaja. No puedo decir si hay una versión anterior con solo mirar el sitio web de Mozilla, así que no estaba seguro. No es que importe, es solo una curiosidad. En cualquier caso, esto siguió siendo útil, por lo que obtienes un voto a favor;)

    – Justin G.

    13 de marzo de 2014 a las 2:24

  • @Vinko Vrsalovic Sí, es una buena solución, pero debe ocultar la función indexOf() de implementación integrada que devuelve -1 con el operador ~: function include(arr,obj) { return !!(~arr.indexOf(obj)) ; }

    – KRRySS

    2 de agosto de 2017 a las 11:53

  • pero, desde cuándo indexOf es compatible con IE, porque descubrí que es compatible con IE w3schools.com/jsref/jsref_indexof.asp

    – gelves

    24 de agosto de 2017 a las 13:18

1646757015 474 ¿La mejor manera de encontrar si un elemento esta en
Germán Rodríguez

Si está utilizando jQuery:

$.inArray(5 + 5, [ "8", "9", "10", 10 + "" ]);

Para más información: http://api.jquery.com/jQuery.inArray/

  • Tenga en cuenta que “inArray” es un nombre inapropiado, porque no devuelve un valor booleano; devuelve el índice del primer elemento encontrado. Entonces, si está verificando si existe un elemento, debe usar if (-1 != $.inArray(...)) ....

    – johndodo

    10 de febrero de 2017 a las 7:51

  • Útil, pero no creo que sea una respuesta apropiada aquí. La pregunta está etiquetada como “javascript” que indica “vainilla” en mi opinión. 🙂

    – yo me

    1 de noviembre de 2017 a las 14:37


¿La mejor manera de encontrar si un elemento esta en
daniel james

Primero, implementar indexOf en JavaScript para navegadores que aún no lo tienen. Por ejemplo, ver Array extras de Erik Arvidsson (también el publicación de blog asociada). Y luego puedes usar indexOf sin preocuparse por el soporte del navegador. Aquí hay una versión ligeramente optimizada de su indexOf implementación:

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

Se cambió para almacenar la longitud para que no necesite buscarla en cada iteración. Pero la diferencia no es enorme. Una función de propósito menos general podría ser más rápida:

var include = Array.prototype.indexOf ?
    function(arr, obj) { return arr.indexOf(obj) !== -1; } :
    function(arr, obj) {
        for(var i = -1, j = arr.length; ++i < j;)
            if(arr[i] === obj) return true;
        return false;
    };

Prefiero usar la función estándar y dejar este tipo de microoptimización para cuando sea realmente necesario. Pero si está interesado en la microoptimización, adapté el puntos de referencia ese roosteronoácido vinculado en los comentarios, para búsqueda de puntos de referencia en matrices. Sin embargo, son bastante crudos, una investigación completa probaría matrices con diferentes tipos, diferentes longitudes y encontraría objetos que ocurren en diferentes lugares.

  • Los ejemplos de código a los que está vinculando son lentos en matrices grandes. Vea los comentarios en mi ejemplo de implementación de una función hasItem().

    – cierre

    27 de septiembre de 2008 a las 23:06

  • Echa un vistazo a estos puntos de referencia: blogs.sun.com/greimer/resource/loop-test.htm Los bucles for son lentos. Pero supongo que las matrices utilizadas en los puntos de referencia son bastante grandes 🙂

    – cierre

    28 de septiembre de 2008 a las 11:28

  • blogs.sun.com/greimer/resource/loop-test.html

    – cierre

    28 de septiembre de 2008 a las 11:37

  • Estoy de acuerdo. También soy bastante pragmático. Pero en el caso de optimizar los conceptos básicos del lenguaje, creo que es un buen diseño implementar la funcionalidad de la manera más efectiva posible.

    – cierre

    28 de septiembre de 2008 a las 15:14

  • use mozilla Array.indexOf polyfill: desarrollador.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

    – usuario1742529

    22 de febrero de 2020 a las 3:55

1646757017 60 ¿La mejor manera de encontrar si un elemento esta en
surtidoslog

Si la matriz no está ordenada, realmente no hay una mejor manera (aparte de usar el indexOf mencionado anteriormente, que creo que equivale a lo mismo). Si la matriz está ordenada, puede hacer una búsqueda binaria, que funciona así:

  1. Elija el elemento medio de la matriz.
  2. ¿El elemento que está buscando es más grande que el elemento que eligió? Si es así, ha eliminado la mitad inferior de la matriz. Si no es así, ha eliminado la mitad superior.
  3. Elija el elemento central de la mitad restante de la matriz y continúe como en el paso 2, eliminando las mitades de la matriz restante. Eventualmente, encontrará su elemento o no le quedará ninguna matriz para mirar.

La búsqueda binaria se ejecuta en un tiempo proporcional al logaritmo de la longitud de la matriz, por lo que puede ser mucho más rápido que mirar cada elemento individual.

1646757018 238 ¿La mejor manera de encontrar si un elemento esta en
bortunac

[ ].has(obj)

asumiendo .indexOf() está implementado

Object.defineProperty( Array.prototype,'has',
{
    value:function(o, flag){
    if (flag === undefined) {
        return this.indexOf(o) !== -1;
    } else {   // only for raw js object
        for(var v in this) {
            if( JSON.stringify(this[v]) === JSON.stringify(o)) return true;
        }
        return false;                       
    },
    // writable:false,
    // enumerable:false
})

!!! No hagas Array.prototype.has=function(){... porque agregará un elemento enumerable en cada matriz y js está roto.

//use like          
[22 ,'a', {prop:'x'}].has(12) // false
["a","b"].has("a") //  true

[1,{a:1}].has({a:1},1) // true
[1,{a:1}].has({a:1}) // false

el uso de 2nd arg (bandera) fuerza la comparación por valor en lugar de referencia

comparando objetos en bruto

[o1].has(o2,true) // true if every level value is same

1646757019 484 ¿La mejor manera de encontrar si un elemento esta en
Pedro Mortensen

Depende de tu propósito. Si programa para la Web, evite indexOfno es compatible con Internet Explorer 6 (¡muchos de ellos todavía se usan!), o hacen un uso condicional:

if (yourArray.indexOf !== undefined) result = yourArray.indexOf(target);
else result = customSlowerSearch(yourArray, target);

indexOf probablemente esté codificado en código nativo, por lo que es más rápido que cualquier cosa que pueda hacer en JavaScript (excepto búsqueda binaria/dicotomía si la matriz es apropiada). Nota: es cuestión de gustos, pero yo haría una return false; al final de su rutina, para devolver un valor booleano verdadero…

1646757020 306 ¿La mejor manera de encontrar si un elemento esta en
Dan Dascalescu

Aquí hay algunos metaconocimientos para usted: si desea saber qué puede hacer con un Array, consulte la documentación: aquí está la página de Array para Mozilla

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

Allí verá una referencia a indexOf, agregada en Javascript 1.6

  • ¡URL extraña para un manual que contiene información sobre Javascript 1.8 y más allá! 🙂

    -Vinko Vrsalovic

    27 de septiembre de 2008 a las 15:56

  • esto no cubre matrices de objetos como el autor preguntó sobre

    – 29er

    31 de mayo de 2012 a las 6:12

  • @VinkoVrsalovic: la URL ha cambiado a desarrollador.mozilla.org/en-US/docs/JavaScript/Reference/…

    – Dan Dascalescu

    2 de noviembre de 2012 a las 2:14

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad