Wie prüfe ich, ob ein Array einen Wert in JavaScript enthält?

Question

Wie kann man am einfachsten und effizientesten herausfinden, ob ein JavaScript-Array einen Wert enthält?

Das ist die einzige Möglichkeit, die ich kenne:

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

Gibt es eine bessere und prägnantere Möglichkeit, dies zu erreichen?

Answer 1

ECMAScript 6 hat einen eleganten Vorschlag zu find.

Die Find-Methode führt die Callback-Funktion einmal für jedes Element aus Element im Array aus, bis sie eines findet, bei dem callback den Wert true Wert zurückgibt. Wenn ein solches Element gefunden wird, gibt find sofort den Wert dieses Elements zurück. Andernfalls gibt find undefiniert zurück. callback wird wird nur für Indizes des Arrays aufgerufen, denen Werte zugewiesen sind; es wird nicht für Indizes aufgerufen, die gelöscht wurden oder denen nie Werte zugewiesen wurden.

Hier ist die MDN-Dokumentation dazu.

Die Suchfunktion funktioniert folgendermaßen.

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

Sie können dies in ECMAScript 5 und darunter verwenden, indem Sie Definition der Funktion .

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

Answer 2

Verwendung:

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

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

Demo

Um genau zu wissen, was die tilde ~ an dieser Stelle auf diese Frage verweisen Was bewirkt eine Tilde, wenn sie einem Ausdruck vorangestellt ist? .

Answer 3

Ich bin überrascht, dass diese Frage immer noch nicht mit der neuesten Syntax versehen ist und füge meine 2 Cents hinzu.

Nehmen wir an, wir haben ein Array von Objekten arrObj und wollen obj darin suchen.

Array.prototype. indexOf -> (gibt zurück Index oder -1 ) wird im Allgemeinen verwendet, um den Index eines Elements in einem Array zu finden. Dies kann auch für die Suche nach Objekten verwendet werden, funktioniert aber nur, wenn Sie einen Verweis auf dasselbe Objekt übergeben.

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. enthält -> (gibt zurück wahr o falsch )

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. finden. -> (nimmt Rückruf, gibt zuerst zurück Wert/Objekt die in CB true zurückgibt).

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 -> (nimmt Rückruf, gibt zurück Index des ersten Wertes/Objekts, das in CB den Wert "true" liefert).

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

Da find und findIndex einen Callback benötigt, können wir jedes Objekt (auch wenn wir die Referenz nicht haben) aus dem Array holen, indem wir kreativ die Bedingung true setzen.

Answer 4

OK, Sie können einfach Optimieren Sie Ihr Code, um das Ergebnis zu erhalten!

Es gibt viele Möglichkeiten, dies sauberer und besser zu tun, aber ich wollte einfach nur Ihr Muster übernehmen und mich darauf beziehen, indem ich JSON.stringify Machen Sie in Ihrem Fall einfach etwas Ähnliches:

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

Answer 5

    function countArray(originalArray) {

        var compressed = [];
        // make a copy of the input array
        var copyArray = originalArray.slice(0);

        // first loop goes over every element
        for (var i = 0; i < originalArray.length; i++) {

            var count = 0;  
            // loop over every element in the copy and see if it's the same
            for (var w = 0; w < copyArray.length; w++) {
                if (originalArray[i] == copyArray[w]) {
                    // increase amount of times duplicate is found
                    count++;
                    // sets item to undefined
                    delete copyArray[w];
                }
            }

            if (count > 0) {
                var a = new Object();
                a.value = originalArray[i];
                a.count = count;
                compressed.push(a);
            }
        }

        return compressed;
    };

    // It should go something like this:

    var testArray = new Array("dog", "dog", "cat", "buffalo", "wolf", "cat", "tiger", "cat");
    var newArray = countArray(testArray);
    console.log(newArray);