Как изменить порядок в цикле FOR

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 ); }

РЕДАКТИРОВАТЬ:

Как отмечено в комментариях ниже, если i не объявлен где-либо еще и вы не собираетесь делать его глобальным, то объявите его с другими объявленными вами переменными.

И если вы не хотите изменять значение num, сначала назначьте его 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 ); }

Попробуйте использовать 2 петли:

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

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);
}

Это эквивалентно следующему, более удобочитаемому, но менее компактному:

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);
}

Изменить:
На самом деле, эти два решения не идентичны, потому что первое имеет дополнительную операцию приращения. Тем не менее, с точки зрения производительности это ничтожно мало. Если вы действительно хотите получить компактное решение с наилучшей производительностью, вы можете сделать следующее (не для слабонервных):

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);
}

Это дает преимущество наличия единой структуры управления, единственного теста в каждом цикле и единственного добавления итератора. Это не так быстро, как увеличение / уменьшение итератора, но лишь незначительно.

Я просто на днях столкнулся с необходимостью в этом. Вот как я это сделал:

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

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

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

Нет необходимости в отдельных циклах и математике для вычисления правильного i в цикле.

So if reverse is true...

• i (который представляет наш первый элемент) становится num - 1, поэтому теперь мы начинаем с того, что было бы последним элементом

• num (который представляет собой выход за пределы) становится -1, поэтому теперь мы останавливаемся на том, что было бы первым элементом

• direction равно -1, что означает, что он будет уменьшаться, когда мы сделаем i += direction

Таким образом, поменяв местами начальную точку на конечную и изменив изменение i с 1 на -1, мы будем двигаться вверх или вниз в зависимости от этих изменений.

Думаю, это соответствует вашим требованиям:

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));
}

Вот как я всегда делал обратные циклы:

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

А в чем проблема:

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

}

Рой похож на мой, но вот о чем я думал. Я расскажу вам то, что я написал на C #, и то, как я думаю, это переводится на 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);
    }

А вот еще один способ
Javascript

    var num = 10,
        reverse = false;

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

    }

Вроде работает:

  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);
  }

Конечно, в таком языке, как Javascript, должен быть способ определить локальную функцию и использовать ее в цикле?

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));
}

Однако, не зная Javascript, я не знаю, какую фактическую форму могли бы принять определения функций.