web-dev-qa-db-fra.com

Trouver le dernier index de l'élément dans un tableau selon certaines conditions

Disons que j'ai un tableau d'objets:

[{'a': 'something', 'b':12},
{'a': 'something', 'b':12},
{'a': 'somethingElse', 'b':12},
{'a': 'something', 'b':12},
{'a': 'somethingElse', 'b':12}]

Quel serait le moyen le plus propre d’obtenir le dernier index de l’élément où a a la valeur 'quelque chose'. Dans ce cas, 3. Y a-t-il un moyen d'éviter les boucles ...

javascriptarrays
8
Jacob

Vous pouvez utiliser findIndex pour obtenir un index. Cela vous donnera le premier index, vous devrez donc inverser le tableau.

var d = [{'a': "something", 'b':12}, {'a': "something", 'b':12}, {'a': "somethingElse", 'b':12}, {'a': "something", 'b':12}, {'a': "somethingElse", 'b':12}]

function findLastIndex(array, searchKey, searchValue) {
  var index = array.slice().reverse().findIndex(x => x[searchKey] === searchValue);
  var count = array.length - 1
  var finalIndex = index >= 0 ? count - index : index;
  console.log(finalIndex)
  return finalIndex;
}

findLastIndex(d, 'a', 'something')
findLastIndex(d, 'a', 'nothing')

15
Rajesh
let newArray = yourArray.filter((each)=>{
    return (each.a === something)
});
newArray[newArray.length-1];

Tu peux aussi faire

let reversedArray = yourArray.reverse();
reversedArray.find((each)=>{return each.a === something})
4
Amoolya S Kumar

Vous pouvez itérer à partir de la fin et quitter la boucle si trouvé.

var data = [{ a: 'something', b: 12 }, { a: 'something', b: 12 }, { a: 'somethingElse', b: 12 }, { a: 'something', b: 12 }, { a: 'somethingElse', b: 12 }],
    l = data.length;

while (l--) {
    if (data[l].a ==='something') {
        break;
    }
}

console.log(l);

4
Nina Scholz
var arr = [
   {'a': 'something', 'b':12},
   {'a': 'something', 'b':12},
   {'a': 'somethingElse', 'b':12},
   {'a': 'something', 'b':12},
   {'a': 'somethingElse', 'b':12}
];

var item_count = 0;
var traverse_count = 0;
var last_item_traverse_count = 0;    
arr = arr.reverse();

arr.filter(function(element) {
   traverse_count += 1;
   if(item_count < 1 && element.a == 'something') {
       last_item_traverse_count = traverse_count;
       item_count += 1;
       return true;
   }

   return false;
});

var item_last_index = arr.length - last_item_traverse_count;

console.log(item_last_index);

J'espère que ce code fonctionne vraiment. Le code peut ne pas suivre les conventions de nommage. Je suis désolé à ce sujet. Vous pouvez simplement nommer ces variables comme bon vous semble.

1
Wolverine

S'il vous plaît jeter un oeil à cette méthode.

var array=[{a: 'something', b:12},
           {a: 'something', b:12},
           {a: 'somethingElse', b:12},
           {a: 'something', b:12},
           {a: 'somethingElse', b:12}
          ];

console.log(array.filter(function(item){
		return item.a=='something';
}).length);

1
Mihai Alexandru-Ionut

voici ce que j'ai utilisé pour obtenir le dernier élément actif:

return this._scenarios.reverse().find(x => x.isActive);
1
Julien d'Adhemar

Premièrement, il ne s'agit pas d'un tableau d'objets, mais d'un tableau de tableaux. Un tableau d'objets ressemblerait à ceci:

[{'a': something, 'b':12},
{'a': something, 'b':12},
{'a': somethingElse, 'b':12},
{'a': something, 'b':12},
{'a': somethingElse, 'b':12}]

En règle générale, il est recommandé d'utiliser la syntaxe d'objet lorsque vous utilisez des index non numériques.

Deuxièmement, pour répondre à votre question, vous pouvez simplement utiliser une boucle inverse:

for(let i=(arr.length - 1); i>=0; i--){
    if(arr[i].a === "something"){
        index = i;
        break;
    }
}
0
dimlucas

Vous pouvez utiliser reverse et mapper ensemble pour empêcher la mutation du tableau d'origine.

var arr = [{'a': 'something', 'b':12},
{'a': 'something', 'b':12},
{'a': 'somethingElse', 'b':12},
{'a': 'something', 'b':12},
{'a': 'somethingElse', 'b':12}];

var index = arr.length - 1 - arr.map(x => x)
   .reverse()
   .findIndex(x => (x.a === 'something'))
if (index === arr.length) {
  index = -1;
}
0
Iman Mohamadi

Je me demande pourquoi beaucoup de gens aimeraient toujours éviter les boucles de nos jours. Ce sont des structures aussi naturelles que ifs et une séquence pure de lignes de code. Pour éviter de vous répéter, écrivez une fonction, ce que vous pourriez même ajouter à Array.prototype. Ce qui suit est un exemple simple, non testé, juste pour l’idée.

Pour obtenir l'index

Array.prototype.lastIndex = function(cond) {
  if (!this.length) return -1;
  if (!cond) return this.length-1;

  for (var i=this.length-1; i>=0; --i) {
    if (cond(this[i])) return i;
  }

  return -1;
}

Ou pour des éléments directement

Array.prototype.lastOrDefault = function(cond, defaultValue) {
  if (!this.length) return defaultValue;
  if (!cond) return this[this.length-1];

  for (var i=this.length-1; i>=0; --i) {
    if (cond(this[i])) return this[i];
  }

  return defaultValue;
}

Exemple d'utilisation:

myArr = [1,2,3,4,5];
var ind1 = myArr.lastIndex(function(e) { return e < 3; }); 
var num2 = myArr.lastOrDefault(function(e) { return e < 3; });
var num8 = myArr.lastOrDefault(function(e) { return e > 6; }, /* explicit default */ 8);
0
Zoltán Tamási

pourquoi ne pas simplement obtenir la longueur et utiliser comme un pointeur de tableau par exemple.

var arr = [ 'test1', 'test2', 'test3' ];

puis obtenir le dernier index du tableau en obtenant la longueur du tableau et moins '1' puisque l'index du tableau commence toujours à '0'

var last arrIndex = arr[arr.length - 1];
0
Juliver Galleto

Voici une version TypeScript réutilisable qui reflète la signature de la fonction findIndex ES2015:

/**
* Returns the index of the last element in the array where predicate is true, and -1
* otherwise.
* @param array The source array to search in
* @param predicate find calls predicate once for each element of the array, in descending
* order, until it finds one where predicate returns true. If such an element is found,
* findLastIndex immediately returns that element index. Otherwise, findLastIndex returns -1.
*/
export function findLastIndex<T>(array: Array<T>, predicate: (value: T, index: number, obj: T[]) => boolean): number {
    let l = array.length;
    while (l--) {
        if (predicate(array[l], l, array))
            return l;
    }
    return -1;
}
0
Nico Timmerman

const arrSome = [{'a': 'something', 'b':12},
    {'a': 'something', 'b':12},
    {'a': 'somethingElse', 'b':12},
    {'a': 'something', 'b':12},
    {'a': 'somethingElse', 'b':12}]

const lastIndex = arrSome.reverse().findIndex(el=> el.a == 'something');//?
let index;
if (~lastIndex) {
    index =arrSome.length - lastIndex;
} else {
    index = -1
}

console.log(index)

0
bad4iz