Jquery comment trouver un Objet par un attribut dans un Tableau

ES6

    array.find((o) => { return o[propertyName] === propertyValue })

Plus sur le find méthode ici.

ES5

var findPurpose = function(purposeName) {
    for (var i = 0, len = purposeObjects.length; i < len; i++) {
        if (purposeObjects[i].purpose === purposeName)
            return purposeObjects[i]; //Return as soon as the object is found
    }
    return null; //The object was not found
}

Note

jQuery $.grep (ou une autre fonction de filtrage) n'est pas la solution optimale.

La $.grep fonction de boucle à travers tous les éléments du tableau, même si la recherche de l'objet a déjà été constaté au cours de la boucle. À partir de jQuery grep documentation :

L' $.grep() la méthode supprime les éléments d'un tableau que nécessaire afin d'
tous les éléments restants passer un test fourni. Le test est une fonction qui
est passé d'un élément de tableau et l'index de l'élément dans le tableau.
Seulement si le test renvoie vrai sera le point dans le tableau résultat.

Personnellement, je utiliser une fonction générique qui fonctionne pour n'importe quelle propriété d'un tableau:

function lookup(array, prop, value) {
    for (var i = 0, len = array.length; i < len; i++)
        if (array[i] && array[i][prop] === value) return array[i];
}

Tu viens de l'appeler comme ceci:

lookup(purposeObjects, "purpose", "daily");

Utiliser le Underscore.js findWhere fonction (http://underscorejs.org/#findWhere):

var purposeObjects = [
    {purpose: "daily"},
    {purpose: "weekly"},
    {purpose: "monthly"}
];

var daily = _.findWhere(purposeObjects, {purpose: 'daily'});

daily serait égal à:

{"purpose":"daily"}

Ici un violon: http://jsfiddle.net/spencerw/oqbgc21x/

À retourner plus d'un (si que vous avez eu plus de votre tableau) vous pouvez utiliser _.where(...)

Si votre tableau est en fait un ensemble de JQuery objets, que pensez simplement à l'aide de la .filtre() méthode ?

purposeObjects.filter('[purpose="daily"]')

J'ai créé un util de service pour mon angulaire de l'application. Il ont deux fonction qui utilise très souvent.

Par exemple, vous avez de l'objet.

De la première mise en valeur de l'objet de manière récursive, sans jeter non défini erreur.

{prop: { nestedProp1: {nestedProp2: somevalue}}};
obtenir nestedProp2 2 sans undefined contrôles.

Deuxième matrice de filtre sur la base

[{prop: { nestedProp1: {nestedProp2: somevalue1}}}, {prop: { nestedProp1: {nestedProp2: somevalue2}}}];

De trouver l'objet de tableau avec nestedProp2=somevalue2

app.service('UtilService', function(httpService) {
this.mapStringKeyVal = function(map, field) {
    var lastIdentifiedVal = null;
    var parentVal = map;
    field.split('.').forEach(function(val){
        if(parentVal[val]){
            lastIdentifiedVal = parentVal[val]; 
            parentVal = parentVal[val]; 
        }
    });
    return lastIdentifiedVal;
}


this.arrayPropFilter = function(array, field,value) {
    var lastIdentifiedVal = null;
    var mapStringKeyVal = this.mapStringKeyVal;
    array.forEach(function(arrayItem){
        var valueFound = mapStringKeyVal(arrayItem,field);
        if(!lastIdentifiedVal  && valueFound && valueFound==value){
            lastIdentifiedVal = arrayItem;
        }
    });
    return lastIdentifiedVal;
}});

Pour solution pour la question en cours. injecter UtilService et d'appel,

UtilService.arrayPropFilter(purposeArray,'purpose','daily');

Ou plus avancé

UtilService.arrayPropFilter(purposeArray,'purpose.nestedProp1.nestedProp2','daily');

copié à partir de polyfill de la Matrice.le prototype.trouver le code de la Matrice.trouver, et a ajouté le tableau en tant que premier paramètre.

vous pouvez passer le terme de recherche comme fonction de prédicat

JS:

//Example
var listOfObjects = [{key: "1", value: "one"}, {key: "2", value: "two"}]
var result = findInArray(listOfObjects, function(element) {
  return element.key == "1";
});
console.log(result);

//the function you want
function findInArray(listOfObjects, predicate) {
      if (listOfObjects == null) {
        throw new TypeError('listOfObjects is null or not defined');
      }

      var o = Object(listOfObjects);

      var len = o.length >>> 0;

      if (typeof predicate !== 'function') {
        throw new TypeError('predicate must be a function');
      }

      var thisArg = arguments[1];

      var k = 0;

      while (k < len) {
        var kValue = o[k];
        if (predicate.call(thisArg, kValue, k, o)) {
          return kValue;
        }
        k++;
      }

      return undefined;
}