Comment inverser l'ordre dans une boucle

Question

J'ai un simple pour la déclaration comme ceci:

var num = 10, 
    reverse = false; 

for(i=0;i<num;i++){ 
    console.log(i); 
} 

lorsque inverse est faux, je veux revenir quelque chose comme [0,1,2,3 , 4,5,6,7,8,9]

mais, quand inverse est vrai, il devrait retourner [9,8,7,6,5,4,3,2,1,0]

Quel est le moyen le plus efficace pour obtenir ce résultat, sans vérifier à chaque fois si re le verset est vrai ou faux dans la boucle?

Je ne veux pas faire:

var num = 10, 
    reverse = false; 

for(i=0;i<num;i++){ 
    if(reverse) console.log(num-i) 
    else console.log(i) 
} 

Je voudrais vérifier inverse une seule fois en dehors de la boucle.

Answer 1

var num = 10, 
reverse = false; 

if(!reverse) for(var i=0;i<num;i++) log(i); 
else   while(num--)  log(num); 

    // to avoid duplication if the code gets long 
function log(num) { console.log(num); } 

---

EDIT:

Comme indiqué dans les commentaires ci-dessous, si i n'est pas déclaré ailleurs et vous ne voulez pas qu'il soit global, puis déclarez avec les autres variables que vous déclaré.

Et si vous ne souhaitez pas modifier la valeur de num, attribuez-le d'abord à i.

var num = 10, 
reverse = false, 
i; 

if(!reverse) for(var i=0;i<num;i++) log(i); // Count up 
else   {var i=num; while(i--) log(i);} // Count down 

function log(num) { console.log(num); } 

Answer 2

var start; var end; var inc; 
if (reverse) { 
    start = num-1; end = 0; inc = -1; 
} 
else { 
    start = 0; end = num-1; inc = 1; 
} 
for(i=start;i!=end;i+=inc){ 
    console.log(i) 
} 

Answer 3

Utiliser 2 boucles:

if (reverse) { 
    for(i=num-1;i>=0;i--){ 
     console.log(i) 
    } 
} 
else { 
    for(i=0;i<num;i++){ 
     console.log(i) 
    } 
} 

Answer 4

Et quel est votre problème avec:

if (reverse) 
    { 
    for(i=num-1; i>=0;i--){ 
      console.log(i); 
     } 
    } 
    else 
    { 
     for(i=0;i<num;i++){ 
     console.log(i) 
     } 
    } 

}

Answer 5

var num = 10, 
    reverse = false; 

for (var i = 0, n = reverse?num-1:0, d = reverse?-1:1; i < num; i++, n+=d) { 
    console.log(n); 
} 

C'est Equival ent à ce qui suit, qui est plus lisible, mais moins compact:

var num = 10, 
    reverse = false; 

var start = reverse ? num-1 : 0, 
    end = reverse ? -1 : num, 
    step = reverse ? -1 : 1; 
for (var i = start; i != end; i += step) { 
    console.log(i); 
} 

Edit:
En fait, ces deux solutions ne sont pas identiques, parce que le premier a une opération d'augmentation supplémentaire. Pourtant, il est négligeable du point de vue de la performance. Si vous voulez vraiment obtenir une solution compacte qui a les meilleures performances, vous pouvez faire ce qui suit (pas pour les faibles de cœur):

var num = 10, 
    reverse = false; 

for (var r=reverse, i=r?num-1:0, n=r?-1:num, d=r?-1:1; i!=n; i+=d) { 
    console.log(i); 
} 

Cela a l'avantage d'avoir une structure de contrôle unique, un seul test dans chaque boucle, et un seul ajout d'itérateur. Ce n'est pas aussi rapide que d'avoir un itérateur incrément/décrément, mais seulement marginalement.

Answer 6

Je pense que cela répond à vos besoins:

var num = 10; 
var reverse = false; 
var diff = 0; 

if (reverse) { 
    diff = num - 1; 
} 

for (i = 0; i < num; i++) { 
    console.log(Math.abs(diff - i)); 
} 

Answer 7

Roy est semblable à la mienne, mais voici ce que je pensais. Je vais vous donner ce que j'ai écrit en C# et comment je pense que cela se traduit par Javascript.

C#

int num = 10; 
    bool reverse = true; 

    for (int i = reverse ? num : 0; (reverse ? 0 : i) < (reverse ? i : num); i += reverse ? -1 : 1) 
    { 
     Console.Write((reverse ? i - 1 : i).ToString()); 
    } 
    Console.ReadKey(); 

Javascript

 var num = 10, 
     reverse = true; 

    for (int i = reverse ? num : 0; (reverse ? 0 : i) < (reverse ? i : num); i += reverse ? -1 : 1) 
    { 
     console.log(reverse ? i - 1 : i); 
    } 

Et voici une autre façon
Javascript

var num = 10, 
     reverse = false; 

    for (int i = 0; i < num; i++) 
    { 
     console.log((reverse ? abs(-num + (i + 1)) : i)); 

    } 

Answer 8

Il semble fonctionner:

var num = 10; 
    var z = 1; 
    var k = -10; 
    if (reverse){ 
    k = -1; 
    z = -1; 
    } 
    for(int i = 0; i < 10; i++){ 
    console.log(num+i*z+k); 
    } 

Answer 9

Sûrement dans une langue comme Javascript il doit y avoir un moyen de définir une fonction locale et l'utiliser dans la boucle?

function SubtractFrom(val, subtractor) { 
    return val - subtractor; 
} 

function PassThrough(val) { 
    return val; 
} 

var num = 10; 
var processor = reverse ? SubtractFrom(num-1) : PassThrough; 

for (i = 0; i < num; i++) { 
    console.log(processor(i)); 
} 

Je ne connais pas le format Javascript, mais je ne sais pas quelle forme prendrait la fonction.

Answer 10

Voilà comment je l'ai toujours fait des boucles inversées:

for (i = num; --i >= 0;) ... 

Answer 11

Je viens suis tombé sur la nécessité de l'autre jour. Voici comment je l'ai fait:

var num = 10, 
    i = 0, 
    direction = 1, 
    reverse = false; 

if(reverse) 
    i = num + (direction = num = -1); 

for(; i !== num; i += direction) { 
    console.log(i); 
} 

Pas besoin de boucles distinctes, et pas besoin de faire des mathématiques pour calculer la i appropriée dans la boucle.

Donc, si reverse est true ...

• i (qui représente notre premier article) devient num - 1, donc nous commençons maintenant sur ce qui aurait été le dernier élément

• num (qui représente hors limites) devient -1, donc nous nous arrêtons maintenant sur ce qui aurait été le premier élément

• direction est -1, ce qui signifie qu'il décrémenter quand nous faisons i += direction

Donc en échangeant notre point de départ de notre point de fin et en changeant la modification de i de 1 à -1, nous allons aller vers le haut ou vers le bas en fonction de ces modifications.