L'identification de la dernière boucle lors de l'utilisation de chaque

Comment sur l'obtention d'un référence à la dernier élément d'abord et ensuite l'utiliser pour la comparaison à l'intérieur de la boucle foreach? Je ne suis pas dire que vous devriez le faire que je me serait d'utiliser l'indice de boucle, comme mentionné par KlauseMeier. Et désolé, je ne connais pas Ruby donc l'exemple suivant est en C#! L'espérance de u dont l'esprit 🙂

string lastItem = list[list.Count - 1];
foreach (string item in list) {
    if (item != lastItem)
        Console.WriteLine("Looping: " + item);
    else    Console.Writeline("Lastone: " + item);
}

J'ai revu le code suivant pour comparer par référence non valeur (utiliser uniquement les types de référence pas de types de valeur). le code suivant devrait soutenir plusieurs objets contenant de la même chaîne (mais pas le même objet de type string) depuis MattChurcy l'exemple ne précise pas que les cordes doivent être distinctes et j'ai utilisé LINQ Dernière méthode de calcul de l'indice.

string lastItem = list.Last();
foreach (string item in list) {
    if (!object.ReferenceEquals(item, lastItem))
        Console.WriteLine("Looping: " + item);
    else        Console.WriteLine("Lastone: " + item);
}

Limites du code ci-dessus. (1) Il ne peut fonctionner que pour des chaînes ou des types de référence pas de types de valeur. (2) Même objet ne peut apparaître qu'une fois dans la liste. Vous pouvez avoir différents objets contenant le même contenu. Les chaînes littérales ne peut pas être utilisé à plusieurs reprises depuis C# ne pas créer un objet unique pour les chaînes qui ont le même contenu.

Et j'ai pas stupide. Je connais un indice de boucle est celle à utiliser. Je l'ai déjà dit quand j'ai posté la réponse initiale. J'ai apporté la meilleure réponse que je peux dans la contexte de la question. Je suis trop fatigué pour garder expliquant ce donc, pouvez-vous tout simplement voter pour supprimer ma réponse. Je serai donc heureux si celui-ci s'en va. grâce

Je vois beaucoup de complexe, difficilement lisible le code ici... pourquoi ne pas faire simple:

var count = list.Length;

foreach(var item in list)
    if (--count > 0)
        Console.WriteLine("Looping: " + item);
    else
        Console.Writeline("Lastone: " + item);

C'est seulement une déclaration de!

Une autre commune de la situation, c'est que vous voulez faire quelque chose de plus ou moins avec le dernier élément, comme mettre un séparateur entre les éléments:

var count = list.Length;

foreach(var item in list)
{
    Console.Write(item);
    if (--count > 0)
        Console.Write(",");
}

En Ruby, j'utiliserais each_with_index dans cette situation

list = ['A','B','C']
last = list.length-1
list.each_with_index{|i,index|
  if index == last 
    puts "Last one: "+i 
  else 
    puts "Looping: "+i # if not last loop iteration
  end
}

C# 3.0 ou plus récent

Tout d'abord, je voudrais écrire une méthode d'extension:

public static void ForEachEx<T>(this IEnumerable<T> s, Action<T, bool> act)
{
    IEnumerator<T> curr = s.GetEnumerator();

    if (curr.MoveNext())
    {
        bool last;

        while (true)
        {
            T item = curr.Current;
            last = !curr.MoveNext();

            act(item, last);

            if (last)
                break;
        }
    }
}

Puis à l'aide de la nouvelle foreach est très simple:

int[] lData = new int[] { 1, 2, 3, 5, -1};

void Run()
{
    lData.ForEachEx((el, last) =>
    {
        if (last)
            Console.Write("last one: ");
        Console.WriteLine(el);
    });
}

Foreach est à la fois élégante qu'il n'a aucun souci pour le nombre d'éléments dans une liste et traite chaque élément également, je pense que votre seule solution sera à l'aide d'une boucle qui s'arrête à itemcount-1 et ensuite vous présenter votre dernier point à l'extérieur de la boucle conditionnelle à l'intérieur de la boucle qui gère cet état spécifique, c'est à dire si (i==itemcount) { ... } else { ... }

Ruby a également each_index méthode:

list = ['A','B','C']
list.each_index{|i|
  if i < list.size - 1
    puts "Looping:"+list[i]
  else
    puts "Last one:"+list[i]
}

EDIT:

Ou de l'utilisation de chacun (corrigé TomatoGG et Kirschstein solution):

list = ['A', 'B', 'C', 'A']
list.each { |i|
   if (i.object_id != list.last.object_id)
      puts "Looping:#{i}"
   else
      puts "Last one:#{i}"
   end
}

Looping:A
Looping:B
Looping:C
Last one:A

Ou

list = ['A', 'B', 'C', 'A']
list.each {|i| 
  i.object_id != list.last.object_id ? puts "Looping:#{i}" : puts "Last one:#{i}"       
}

Si vous utilisez une collection qui expose une Count bien - une hypothèse faite par de nombreux autres réponses, je vais donc en faire trop - ensuite, vous pouvez faire quelque chose comme ceci à l'aide de C# et de LINQ:

foreach (var item in list.Select((x, i) => new { Val = x, Pos = i }))
{
    Console.Write(item.Pos == (list.Count - 1) ? "Last one: " : "Looping: ");
    Console.WriteLine(item.Val);
}

En outre, si nous supposons que les éléments de la collection peut être consulté directement par index - actuellement accepté de répondre à assume cette - puis une plaine for boucle sera plus élégant/lisible qu'un foreach:

for (int i = 0; i < list.Count; i++)
{
    Console.Write(i == (list.Count - 1) ? "Last one: " : "Looping: ");
    Console.WriteLine(list[i]);
}

Si la collection n'expose pas de Count de propriété et ne peut être accédé par l'indice, il n'y a pas vraiment de moyen élégant pour ce faire, au moins pas en C#. Un bogue-fixe variation de Thomas Levesque réponse est probablement aussi proche que vous obtiendrez.

---

Voici le bug-version fixe de La réponse de Thomas:

string previous = null;
bool isFirst = true;
foreach (var item in list)
{
    if (!isFirst)
    {
        Console.WriteLine("Looping: " + previous);
    }
    previous = item;
    isFirst = false;
}
if (!isFirst)
{
    Console.WriteLine("Last one: " + previous);
}

Et voici comment j'allais le faire en C# si la collection n'expose pas de Count propriété et les éléments ne sont pas directement accessibles par un index. (Notez qu'il n'y a pas foreach et le code n'est pas particulièrement succincte, mais elle donnera des performances décentes sur à peu près tout énumérable collection).

//i'm assuming the non-generic IEnumerable in this code
//wrap the enumerator in a "using" block if dealing with IEnumerable<T>
var e = list.GetEnumerator();
if (e.MoveNext())
{
    var item = e.Current;

    while (e.MoveNext())
    {
        Console.WriteLine("Looping: " + item);
        item = e.Current;
    }
    Console.WriteLine("Last one: " + item);
}

Je pense que je préfère kgiannakakis's solution, cependant, vous pouvez toujours faire quelque chose comme cela;

list = ['A','B','C']
list.each { |i|
   if (i != list.last)
      puts "Looping:#{i}"
   else
      puts "Last one:#{i}"
   end
}

Serait-il une solution viable pour votre cas il suffit de prendre la première/dernière éléments de votre tableau avant de faire le "général" chaque course?

Comme ceci:

list = ['A','B','C','D']
first = list.shift
last = list.pop

puts "First one: #{first}"
list.each{|i|
  puts "Looping: "+i
}
puts "Last one: #{last}"

Je ne sais pas comment les boucles for-each fonctionne dans d'autres langues, mais java.
En java pour chacun utilise le Itératif de l'interface qui est utilisée par le pour-chaque pour obtenir un Itérateur et boucle avec elle. Itérateur est une méthode hasNext que vous pouvez utiliser si vous pouviez voir l'itérateur à l'intérieur de la boucle.
Vous pouvez réellement faire le tour, en enfermant un déjà obtenu Itérateur dans un objet iterable objet de sorte que la boucle for a obtenu ce dont elle a besoin et vous pouvez obtenir une méthode hasNext l'intérieur de la boucle.

List<X> list = ...

final Iterator<X> it = list.iterator();
Iterable<X> itw = new Iterable<X>(){
  public Iterator<X> iterator () {
    return it;
  }
}

for (X x: itw) {
  doSomething(x);
  if (!it.hasNext()) {
    doSomethingElse(x);
  }
}

Vous pouvez créer une classe qui encapsule tout ce itérable et itérateur de choses donc le code ressemble à ceci:

IterableIterator<X> itt = new IterableIterator<X>(list);
for (X x: itit) {
  doSomething(x);
  if (!itit.hasNext()) {
    doSomethingElse(x);
  }
}

Comment à ce sujet? juste appris un peu de Ruby. hehehe

list.collect {|x|(x!=list.last ? "Looping:"+x:"Lastone:"+x) }.each{|i|puts i}      

Un autre modèle qui fonctionne, sans avoir à les réécrire foreach boucle:

var delayed = null;
foreach (var X in collection)
{
    if (delayed != null)
    {
        puts("Looping");
        //Use delayed
    }
    delayed = X;
}

puts("Last one");
//Use delayed

De cette façon, le compilateur maintient la boucle de droite, les itérateurs (y compris ceux sans compte) fonctionnent comme prévu, et le dernier est séparé des autres.

J'utilise aussi ce modèle quand je veux quelque chose se passe dans entre les itérations, mais pas après la dernière. Dans ce cas, X est utilisé normalement, delayed se réfère à quelque chose d'autre, et l'usage de retard est seulement au début de la boucle et rien ne doit être fait qu'après la boucle se termine.

<hello> que pensons-nous ici?

public static void main(String[] args) {
    //TODO Auto-generated method stub
    String str = readIndex();
    String comp[] = str.split("}");

    StringBuffer sb = new StringBuffer();
    for (String s : comp) {
        sb.append(s);
        sb.append("}\n");
    }
    System.out.println (sb.toString());
}

Comme une modélisation de la notation, l'influence de l'OMT notation domine (e. g., en utilisant des rectangles pour les classes et les objets). Si le Booch "cloud" de la notation a été abandonné, les Booch capacité de spécifier le niveau inférieur des détails de conception a été adopté. Le cas d'utilisation de la notation de Objectory et la composant de la notation de Booch ont été intégrées avec le reste de la notation, mais la sémantique de l'intégration a été relativement faible dans UML 1.1, et n'était pas vraiment fixe jusqu'à ce que l'UML 2.0 révision majeure.