Wie kann festgestellt werden, ob das Javascript-Array ein Objekt mit einem Attribut enthält, das einem bestimmten Wert entspricht?

Ich habe ein Array wie

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    } //and so on goes array... 
];

Wie überprüfe ich dieses Array, um festzustellen, ob Magenic vorhanden ist? Ich möchte keine Schleife machen, es sei denn, ich muss. Ich arbeite mit möglicherweise ein paar tausend Datensätzen.

AKTUALISIERT

Da dies ein beliebter Beitrag war, dachte ich, ich würde etwas Neues teilen, das ich gefunden habe. Und es scheint, dass @CAFxX dies bereits geteilt hat! Ich sollte diese öfter lesen. Ich bin auf https://benfrain.com/understanding-native-javascript-array-methods/ gestoßen .

vendors.filter(function(vendor){ return vendor.Name === "Magenic" })

Mit ECMAScript 2015 ist die Verwendung der neuen Pfeilfunktionen noch einfacher:

vendors.filter(vendor => vendor.Name === "Magenic")

Bearbeiten 2018 : Diese Antwort stammt aus dem Jahr 2011, bevor Browser Array-Filtermethoden und Pfeilfunktionen weitgehend unterstützt hatten. Schauen Sie sich die Antwort von CAFxX an .

Es gibt keine "magische" Möglichkeit, in einem Array ohne Schleife nach etwas zu suchen. Selbst wenn Sie eine Funktion verwenden, verwendet die Funktion selbst eine Schleife. Was Sie tun können, ist aus der Schleife auszubrechen, sobald Sie das finden, wonach Sie suchen, um die Rechenzeit zu minimieren.

var found = false;
for(var i = 0; i < vendors.length; i++) {
    if (vendors[i].Name == 'Magenic') {
        found = true;
        break;
    }
}

Keine Notwendigkeit, das neu zu erfinden RadSchleife, zumindest nicht explizit (mit Pfeilfunktionen , nur moderne Browser ):

if (vendors.filter(e => e.Name === 'Magenic').length > 0) {
  /* vendors contains the element we're looking for */
}

oder noch besser :

if (vendors.some(e => e.Name === 'Magenic')) {
  /* vendors contains the element we're looking for */
}

BEARBEITEN: Wenn Sie Kompatibilität mit miesen Browsern benötigen, ist Ihre beste Wahl:

if (vendors.filter(function(e) { return e.Name === 'Magenic'; }).length > 0) {
  /* vendors contains the element we're looking for */
}

Keine Schleife notwendig. Drei Methoden, die mir in den Sinn kommen:

Array.prototype.some ()

Dies ist die genaueste Antwort auf Ihre Frage, dh "Überprüfen Sie, ob etwas vorhanden ist", was ein booles Ergebnis impliziert. Dies ist wahr, wenn es 'Magen'-Objekte gibt, andernfalls falsch:

let hasMagenicVendor = vendors.some( vendor => vendor['Name'] === 'Magenic' )

Array.prototype.filter ()

Dies gibt ein Array aller 'Magenic'-Objekte zurück, auch wenn es nur eines gibt (gibt ein Ein-Element-Array zurück):

let magenicVendors = vendors.filter( vendor => vendor['Name'] === 'Magenic' )

Wenn Sie versuchen, dies zu einem Booleschen Wert zu erzwingen, funktioniert dies nicht, da ein leeres Array (keine 'Magen'-Objekte) immer noch wahr ist. Also einfach magenicVendors.lengthin deiner Bedingung verwenden.

Array.prototype.find ()

Dies gibt das erste 'Magenic'-Objekt zurück (oder undefinedfalls es keine gibt):

let magenicVendor = vendors.find( vendor => vendor['Name'] === 'Magenic' );

Dies zwingt zu einem booleschen Okay (jedes Objekt ist wahr, undefinedist falsch).

Hinweis: Ich verwende den Anbieter ["Name"] anstelle des Anbieters. Name wegen der seltsamen Schreibweise der Eigenschaftsnamen.

Hinweis 2: Kein Grund, bei der Überprüfung des Namens lose Gleichheit (==) anstelle von strikter Gleichheit (===) zu verwenden.

Die akzeptierte Antwort funktioniert immer noch, aber jetzt haben wir eine native ECMAScript 6-Methode [Array.find][1], um den gleichen Effekt zu erzielen.

MDN zitieren:

Die find () -Methode gibt den Wert des ersten Elements im Array zurück, das die bereitgestellte Testfunktion erfüllt. Andernfalls wird undefined zurückgegeben.

var arr = []; 
var item = {
  id: '21',
  step: 'step2',
  label: 'Banana',
  price: '19$'
};

arr.push(item);
/* note : data is the actual object that matched search criteria 
  or undefined if nothing matched */
var data = arr.find( function( ele ) { 
    return ele.id === '21';
} );

if( data ) {
 console.log( 'found' );
 console.log(data); // This is entire object i.e. `item` not boolean
}

Siehe meinen jsfiddle-Link. Es gibt eine Polyfüllung für IE, die von Mozilla bereitgestellt wird

So würde ich es machen

const found = vendors.some(item => item.Name === 'Magenic');

array.some()Die Methode prüft, ob ein Array mindestens einen Wert enthält, der den Kriterien entspricht, und gibt einen Booleschen Wert zurück. Ab hier können Sie gehen mit:

if (found) {
// do something
} else {
// do something else
}

Es sei denn, Sie möchten es wie folgt umstrukturieren:

vendors = {
    Magenic: {
      Name: 'Magenic',
      ID: 'ABC'
     },
    Microsoft: {
      Name: 'Microsoft',
      ID: 'DEF'
    } and so on... 
};

was du tun kannst if(vendors.Magnetic)

Sie müssen eine Schleife durchführen

Gemäß der ECMAScript 6-Spezifikation können Sie verwenden findIndex.

const magenicIndex = vendors.findIndex(vendor => vendor.Name === 'Magenic');

magenicIndexwird entweder halten 0(das ist der Index im Array) oder -1wenn es nicht gefunden wurde.

Da hat das OP die Frage gestellt, ob der Schlüssel existiert oder nicht .

Eine elegantere Lösung, die mit der ES6-Reduktionsfunktion einen Booleschen Wert zurückgibt, kann sein

const magenicVendorExists =  vendors.reduce((accumulator, vendor) => (accumulator||vendor.Name === "Magenic"), false);

Hinweis: Der Anfangsparameter von reduct ist a. falseWenn das Array den Schlüssel hat, wird true zurückgegeben.

Hoffe, es hilft für eine bessere und sauberere Code-Implementierung

Sie können nicht, ohne wirklich in das Objekt zu schauen.

Sie sollten wahrscheinlich Ihre Struktur ein wenig ändern, wie

vendors = {
    Magenic:   'ABC',
    Microsoft: 'DEF'
};

Dann können Sie es einfach wie einen Lookup-Hash verwenden.

vendors['Microsoft']; // 'DEF'
vendors['Apple']; // undefined

Sie müssen eine Schleife machen, daran führt kein Weg vorbei.

function seekVendor(vendors, name) {
  for (var i=0, l=vendors.length; i<l; i++) {
    if (typeof vendors[i] == "object" && vendors[i].Name === name) {
      return vendors[i];
    }
  }
}

Natürlich können Sie eine Bibliothek wie linq.js verwenden , um dies angenehmer zu gestalten:

Enumerable.From(vendors).Where("$.Name == 'Magenic'").First();

( Eine Demo finden Sie unter jsFiddle. )

Ich bezweifle, dass linq.js schneller sein wird als eine einfache Schleife, aber es ist sicherlich flexibler, wenn die Dinge etwas komplizierter werden.

Testen auf Array-Elemente:

JS Bietet Array-Funktionen, mit denen Sie dies relativ einfach erreichen können. Sie sind die folgenden:

1. Array.prototype.filter: Nimmt eine Rückruffunktion auf, die ein Test ist, wird das Array dann mit dem Rückruf iteriert und gemäß diesem Rückruf gefiltert. Ein neues gefiltertes Array wird zurückgegeben.
2. Array.prototype.some: Nimmt eine Rückruffunktion auf, die ein Test ist, das Array wird dann mit dem Rückruf iteriert, und wenn ein Element den Test besteht, wird der boolesche Wert true zurückgegeben. Andernfalls wird false zurückgegeben

Die Einzelheiten lassen sich am besten anhand eines Beispiels erklären:

Beispiel:

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    } //and so on goes array... 
];

// filter returns a new array, we instantly check if the length 
// is longer than zero of this newly created array
if (vendors.filter(company => company.Name === 'Magenic').length ) {
  console.log('I contain Magenic');
}

// some would be a better option then filter since it directly returns a boolean
if (vendors.some(company => company.Name === 'Magenic')) {
  console.log('I also contain Magenic');
}

Browserunterstützung:

Diese 2 Funktionen sind ES6Funktionen, die möglicherweise nicht von allen Browsern unterstützt werden. Um dies zu überwinden, können Sie eine Polyfüllung verwenden. Hier ist die Polyfüllung für Array.prototype.some(von MDN):

if (!Array.prototype.some) {
  Array.prototype.some = function(fun, thisArg) {
    'use strict';

    if (this == null) {
      throw new TypeError('Array.prototype.some called on null or undefined');
    }

    if (typeof fun !== 'function') {
      throw new TypeError();
    }

    var t = Object(this);
    var len = t.length >>> 0;

    for (var i = 0; i < len; i++) {
      if (i in t && fun.call(thisArg, t[i], i, t)) {
        return true;
      }
    }

    return false;
  };
}

Möglicherweise ist es zu spät, aber das Javascript-Array verfügt über zwei Methoden someund everyMethoden, die einen Booleschen Wert zurückgeben und Ihnen dabei helfen können.

Ich denke, es somewäre am besten geeignet für das, was Sie erreichen wollen.

vendors.some( vendor => vendor['Name'] !== 'Magenic' )

Einige überprüfen, ob eines der Objekte im Array die angegebene Bedingung erfüllt.

vendors.every( vendor => vendor['Name'] !== 'Magenic' )

Jeder überprüft, ob alle Objekte im Array die angegebene Bedingung erfüllen.

Wenn Sie jquery verwenden, können Sie grep nutzen, um ein Array mit allen übereinstimmenden Objekten zu erstellen:

var results = $.grep(vendors, function (e) {
    return e.Name == "Magenic";
});

und verwenden Sie dann das Ergebnisarray:

for (var i=0, l=results.length; i<l; i++) {
    console.log(results[i].ID);
}

Korrigieren Sie mich, wenn ich falsch liege. Ich hätte eine forEachMethode wie diese verwenden können.

var found=false;
vendors.forEach(function(item){
   if(item.name === "name"){
       found=true;

   }
});

Heutzutage bin ich daran gewöhnt, weil es einfach und selbsterklärend ist. Vielen Dank.

Sie können dies seine Arbeit für mich versuchen.

const _ = require('lodash');

var arr = [
  {
    name: 'Jack',
    id: 1
  },
  {
    name: 'Gabriel',
    id: 2
  },
  {
    name: 'John',
    id: 3
  }
]

function findValue(arr,value) {
  return _.filter(arr, function (object) {
    return object['name'].toLowerCase().indexOf(value.toLowerCase()) >= 0;
  });
}

console.log(findValue(arr,'jack'))
//[ { name: 'Jack', id: 1 } ]

Sie können lodash verwenden . Wenn die lodash-Bibliothek für Ihre Anwendung zu schwer ist, sollten Sie unnötige Funktionen entfernen, die nicht verwendet werden.

let newArray = filter(_this.props.ArrayOne, function(item) {
                    return find(_this.props.ArrayTwo, {"speciesId": item.speciesId});
                });

Dies ist nur eine Möglichkeit, dies zu tun. Ein anderer kann sein:

var newArray=  [];
     _.filter(ArrayOne, function(item) {
                        return AllSpecies.forEach(function(cItem){
                            if (cItem.speciesId == item.speciesId){
                            newArray.push(item);
                          }
                        }) 
                    });

console.log(arr);

Das obige Beispiel kann auch ohne Verwendung von Bibliotheken wie den folgenden umgeschrieben werden :

var newArray=  [];
ArrayOne.filter(function(item) {
                return ArrayTwo.forEach(function(cItem){
                    if (cItem.speciesId == item.speciesId){
                    newArray.push(item);
                  }
                }) 
            });
console.log(arr);

Hoffe meine Antwort hilft.

Viele Antworten hier sind gut und ziemlich einfach. Wenn Ihr Objektarray jedoch einen festen Wertesatz hat, können Sie den folgenden Trick verwenden:

Ordnen Sie den gesamten Namen eines Objekts zu.

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    }
];

var dirtyObj = {}
for(var count=0;count<vendors.length;count++){
   dirtyObj[vendors[count].Name] = true //or assign which gives you true.
}

Jetzt können Sie dieses DirtyObj immer wieder ohne Schleife verwenden.

if(dirtyObj[vendor.Name]){
  console.log("Hey! I am available.");
}

Um ein Objekt mit einem anderen zu vergleichen, kombiniere ich eine for in-Schleife (zum Durchlaufen von Objekten) und some (). Sie müssen sich keine Sorgen machen, dass ein Array außerhalb der Grenzen usw. liegt, sodass Code gespart wird. Dokumentation zu .some finden Sie hier

var productList = [{id: 'text3'}, {id: 'text2'}, {id: 'text4', product: 'Shampoo'}]; // Example of selected products
var theDatabaseList = [{id: 'text1'}, {id: 'text2'},{id: 'text3'},{id:'text4', product: 'shampoo'}];    
var  objectsFound = [];

for(let objectNumber in productList){
    var currentId = productList[objectNumber].id;   
    if (theDatabaseList.some(obj => obj.id === currentId)) {
        // Do what you need to do with the matching value here
        objectsFound.push(currentId);
    }
}
console.log(objectsFound);

Eine alternative Möglichkeit, ein Objekt mit einem anderen zu vergleichen, besteht darin, eine verschachtelte for-Schleife mit Object.keys (). Length zu verwenden, um die Anzahl der Objekte im Array abzurufen. Code unten:

var productList = [{id: 'text3'}, {id: 'text2'}, {id: 'text4', product: 'Shampoo'}]; // Example of selected products
var theDatabaseList = [{id: 'text1'}, {id: 'text2'},{id: 'text3'},{id:'text4', product: 'shampoo'}];    
var objectsFound = [];

for(var i = 0; i < Object.keys(productList).length; i++){
        for(var j = 0; j < Object.keys(theDatabaseList).length; j++){
        if(productList[i].id === theDatabaseList[j].id){
            objectsFound.push(productList[i].id);
        }       
    }
}
console.log(objectsFound);

Um Ihre genaue Frage zu beantworten: Wenn Sie nur nach einem Wert in einem Objekt suchen, können Sie eine einzelne for-Schleife verwenden.

var vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    } 
];

for(var ojectNumbers in vendors){
    if(vendors[ojectNumbers].Name === 'Magenic'){
        console.log('object contains Magenic');
    }
}

Alternativ können Sie Folgendes tun:

const find = (key, needle) => return !!~vendors.findIndex(v => (v[key] === needle));

var without2 = (arr, args) => arr.filter(v => v.id !== args.id); Beispiel:

without2([{id:1},{id:1},{id:2}],{id:2})

Ergebnis: ohne2 ([{id: 1}, {id: 1}, {id: 2}], {id: 2})

const a = [{one:2},{two:2},{two:4}]
const b = a.filter(val => "two" in val).length;
if (b) {
   ...
}

Mein Ansatz zur Lösung dieses Problems besteht darin, ES6 zu verwenden und eine Funktion zu erstellen, die die Prüfung für uns durchführt. Der Vorteil dieser Funktion besteht darin, dass sie in Ihrem gesamten Projekt wiederverwendet werden kann, um alle Arrays von Objekten zu überprüfen , die mit keyund valueüberprüft werden sollen.

GENUG SPRECHEN, SEHEN WIR DEN CODE

Array

const ceos = [
  {
    name: "Jeff Bezos",
    company: "Amazon"
  }, 
  {
    name: "Mark Zuckerberg",
    company: "Facebook"
  }, 
  {
    name: "Tim Cook",
    company: "Apple"
  }
];

Funktion

const arrayIncludesInObj = (arr, key, valueToCheck) => {
  let found = false;

  arr.some(value => {
    if (value[key] === valueToCheck) {
      found = true;
      return true; // this will break the loop once found
    }
  });

  return found;
}

Anruf / Nutzung

const found = arrayIncludesInObj(ceos, "name", "Tim Cook"); // true

const found = arrayIncludesInObj(ceos, "name", "Tim Bezos"); // false

Ich würde lieber mit Regex gehen.

Wenn Ihr Code wie folgt lautet:

vendors = [
    {
      Name: 'Magenic',
      ID: 'ABC'
     },
    {
      Name: 'Microsoft',
      ID: 'DEF'
    }
];

ich würde empfehlen

/"Name":"Magenic"/.test(JSON.stringify(vendors))