c# strip - Trova l'indice di un valore in una matrice




html agility (8)

Per gli array è possibile utilizzare: Array.FindIndex<T> :

int keyIndex = Array.FindIndex(words, w => w.IsKey);

Per gli elenchi è possibile utilizzare List<T>.FindIndex :

int keyIndex = words.FindIndex(w => w.IsKey);

Puoi anche scrivere un metodo di estensione generico che funzioni per qualsiasi Enumerable<T> :

///<summary>Finds the index of the first item matching an expression in an enumerable.</summary>
///<param name="items">The enumerable to search.</param>
///<param name="predicate">The expression to test the items against.</param>
///<returns>The index of the first matching item, or -1 if no items match.</returns>
public static int FindIndex<T>(this IEnumerable<T> items, Func<T, bool> predicate) {
    if (items == null) throw new ArgumentNullException("items");
    if (predicate == null) throw new ArgumentNullException("predicate");

    int retVal = 0;
    foreach (var item in items) {
        if (predicate(item)) return retVal;
        retVal++;
    }
    return -1;
}

E puoi usare anche LINQ:

int keyIndex = words
    .Select((v, i) => new {Word = v, Index = i})
    .First(x => x.Word.IsKey).Index;

Si prega di notare che questo non metterà in corto circuito il ciclo (itererà sempre sull'intera collezione) e genererà un'eccezione se la condizione non viene soddisfatta, piuttosto che restituire -1.

Linq può essere usato in qualche modo per trovare l'indice di un valore in un array?

Ad esempio, questo ciclo individua l'indice chiave all'interno di un array.

for (int i = 0; i < words.Length; i++)
{
    if (words[i].IsKey)
    {
        keyIndex = i;
    }
}

int keyIndex = Array.FindIndex(words, w => w.IsKey);

In questo modo ottieni l'indice intero e non l'oggetto, indipendentemente dalla classe personalizzata che hai creato



Prova questo...

var key = words.Where(x => x.IsKey == true);

Questa soluzione mi ha aiutato di più, da msdn microsoft :

var result =  query.AsEnumerable().Select((x, index) =>
              new { index,x.Id,x.FirstName});

la query è la tua query toList()


int index = -1;
index = words.Any (word => { index++; return word.IsKey; }) ? index : -1;

Se vuoi trovare la parola che puoi usare

var word = words.Where(item => item.IsKey).First();

Questo ti dà il primo elemento per il quale IsKey è vero (se potrebbe esserci non potresti voler usare .FirstOrDefault()

Puoi ottenere sia l'oggetto che l'indice che puoi usare

KeyValuePair<WordType, int> word = words.Select((item, index) => new KeyValuePair<WordType, int>(item, index)).Where(item => item.Key.IsKey).First();

Modifica : questa risposta è irrimediabilmente obsoleta. Per un approccio più moderno, guarda i metodi disponibili su un array . I metodi di interesse potrebbero essere:

  • per ciascuno
  • carta geografica
  • filtro
  • cerniera lampo
  • ridurre
  • ogni
  • alcuni

Il modo standard per iterare un array in JavaScript è una vaniglia for -loop:

var length = arr.length,
    element = null;
for (var i = 0; i < length; i++) {
  element = arr[i];
  // Do something with element
}

Si noti, tuttavia, che questo approccio è valido solo se si dispone di un array denso e ogni indice è occupato da un elemento. Se la matrice è sparsa, è possibile che si verifichino problemi di prestazioni con questo approccio, dal momento che si andrà a scorrere su molti indici che non esistono realmente nell'array. In questo caso, un for .. in -loop potrebbe essere un'idea migliore. Tuttavia , è necessario utilizzare le protezioni appropriate per garantire che vengano applicate solo le proprietà desiderate dell'array (ovvero, gli elementi dell'array), dal momento che il for..in -loop verrà enumerato anche nei browser legacy, o se il comando aggiuntivo le proprietà sono definite come enumerable .

In ECMAScript 5 ci sarà un metodo forEach sul prototipo dell'array, ma non è supportato nei browser legacy. Pertanto, per poterlo utilizzare in modo coerente, è necessario disporre di un ambiente che lo supporti (ad esempio, Node.js per JavaScript lato server) o utilizzare un "Polyfill". Il Polyfill per questa funzionalità è, tuttavia, banale e poiché rende il codice più facile da leggere, è un buon polyfill da includere.





c# arrays linq