Javascript 如何在FOR循环中反转顺序

我有一个简单的FOR语句，如下所示：

var num = 10,
    reverse = false;

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

var num=10，
反向=假；
对于（i=0；i尝试使用2个循环：

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

if（反向）{
对于（i=num-1；i>=0；i--）{
控制台日志（i）
}
}
否则{
对于（i=0；i），您有什么问题：

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

if（反向）
{
对于（i=num-1；i>=0；i--）{
控制台日志（i）；
}
}
其他的
{
对于（i=0；i
编辑：

实际上，这两个解决方案并不相同，因为第一个解决方案有一个额外的增量操作。但是，从性能的角度来看，它是可以忽略不计的。如果您真的想得到一个性能最好的紧凑解决方案，您可以做以下几点（不适用于胆小的人）：

这样做的优点是有一个单一的控制结构，每个循环中有一个单独的测试，以及一个迭代器的添加。它没有迭代器的递增/递减速度快，但只是略微如此。
我认为这满足了您的要求：

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

var num=10；
var反向=假；
var-diff=0；
如果（反向）{
diff=num-1；
}
对于（i=0；i
罗伊的与我的相似，但我的想法是这样的。我会告诉你我用C#写的东西，以及我认为它是如何翻译成Javascript的

C#

int num=10；
布尔反向=真；
对于（int i=反向？数值：0；（反向？0:i）<（反向？i:num）；i+=反向？-1:1）
{
Write（（反向？i-1:i）.ToString（））；
}
Console.ReadKey（）；

Javascript

var num=10，
反向=真；
对于（int i=反向？数值：0；（反向？0:i）<（反向？i:num）；i+=反向？-1:1）
{
控制台日志（反向？i-1:i）；
}

还有另一种方法


Javascript

var num=10，
反向=假；
for（int i=0；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);
  }

var num=10；
var z=1；
var k=-10；
如果（反向）{
k=-1；
z=-1；
}
对于（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));
}

函数减法（val，减法器）{
返回值-减法器；
}
函数传递（val）{
返回val；
}
var-num=10；
var处理器=反向？从（num-1）中减去：通过；
对于（i=0；i

虽然不知道Javascript，但我不知道函数定义的实际形式是什么。
我一直都是这样做的：

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

前几天我才意识到需要这样做。我是这样做的：

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

因此，如果
reverse
为
true


i
（代表我们的第一个项目）变成了
num-1
，所以我们现在开始讨论最后一个项目

num
（表示越界）变为
-1
，因此我们现在停止讨论第一项

direction
是
-1
，这意味着当我们执行
i+=direction


因此，通过将我们的起点与终点交换，并将
i
的更改从
1
更改为
-1
，我们将根据这些修改向上或向下移动。
i=0
相反。在第一个子句中，它应该是
end=-1
，在第二个子句中，它应该是
end=num
。lol。你知道吗我写的是你的（当新的答案被张贴时，页面刷新了）：P我滥用三元语句。很高兴看到像我这样写的人。那里没有滥用TynRead…我认为只有当你不使用三态表达式的返回值，如条件。；---虽然完全超出了重点……我喜欢你的解决方案，但我发现patrick的解决方案更清晰。也许在生产代码中，循环内部的活动将比简单的
控制台更多。log
？@meagar:如果是这样，将循环内部的所有内容都推到一个函数中。所有这些仍然会在循环的每次迭代中测试反向标志loop.lol.我的错，我没有看到问题中的那一部分。谢谢你让我知道。但是，对于OP，如果你担心性能，我不会。如果可以的话，我会想一些其他的事情。我认为OP没有意识到三元语句，认为他们的循环中必须有if/else。我仍然在想另一种方法gh.我正要发布与此几乎相同的内容。在我看来，这是最自然、可读的解决方案，也是最有效的，反向标志只测试一次，而不是每次都通过循环。很好。我打算为（I=num；I--；）log（I）建议
；
，但似乎您的方法是最快的。对op来说：请注意，
num
在反向打印时会被修改，所以如果您计划在将来使用原始值，请务必复制原始值。@Daniel-非常正确。如果这是一个问题，下面是对
else
语句的快速替换：
else{i=num；而（i--）log（i）}；
别忘了声明
var i
somewhere@cobbal-OP没有在问题中声明它，所以我假设它是在其他地方声明的，或者是打算全局声明的。如果不是，那么是的，它可以添加到OP的其他声明中。
var num=10，reverse=false，I；
你实际上想做什么？因为如果它是cre当你使用一个数组，或者在一个数组上循环时，你可以调用的javascript函数reverse总是不太好的。
//reverse a number
let c = [2,3,5,67,4]
let sum = '';
let d = c.toString().split('')
console.log(d)
for(let i = d.length-1; i >= 0; i--) {
    sum += d[i]
}
console.log(sum)

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;
var reverse = false;
var diff = 0;

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

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

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

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

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

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

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

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

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

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

//reverse a number
let c = [2,3,5,67,4]
let sum = '';
let d = c.toString().split('')
console.log(d)
for(let i = d.length-1; i >= 0; i--) {
    sum += d[i]
}
console.log(sum)