为什么要避免在 JavaScript 中使用递增（“”）和递减（“--”）运算符？

Question

jslint 工具的提示之一是：

++ 和 --
++（递增）和 --（递减） 众所周知，操作符会导致不良代码 鼓励过度狡猾。 他们 仅次于错误的架构 使病毒和其他 安全威胁。 有一个加号 禁止使用这些选项 运算符。

我知道像 $foo[$bar++] 这样的 PHP 结构可能很容易导致差一错误，但我找不到比 a:

while( a < 10 ) do { /* foo */ a++; }

或

for (var i=0; i<10; i++) { /* foo */ }

更好的控制循环的方法jslint 突出显示它们，因为有一些类似的语言缺少“++”和“--”语法或以不同的方式处理它，或者是我可能缺少避免“++”和“--”的其他理由吗？

Answer 1

我的观点是始终在一行中单独使用 ++ 和 -- ，例如：

i++;
array[i] = foo;

而不是

array[++i] = foo;

除此之外的任何内容都可能会让某些程序员感到困惑，并且在我看来这是不值得的。 For 循环是一个例外，因为增量运算符的使用是惯用的，因此总是清晰的。

Answer 2

C 语言有这样的历史：

while (*a++ = *b++);

复制字符串，也许这就是他所指的过度欺骗的根源。

总是存在“做什么”

++i = i++;

或

i = i++ + ++i;

“实际做什么”的问题。 它是在某些语言中定义的，而在其他语言中则不能保证会发生什么。

除了这些例子之外，我认为没有什么比使用 ++ 递增的 for 循环更惯用的了。 在某些情况下，您可以使用 foreach 循环或检查不同条件的 while 循环。 但是扭曲代码来尝试避免使用递增是荒谬的。

Answer 3

如果您阅读过 JavaScript The Good Parts，您会发现 Crockford 在 for 循环中对 i++ 的替换是 i+=1（而不是 i=i+1）。 这是非常干净和可读的，并且不太可能演变成“棘手”的东西。

Crockford 在 jsLint 中将禁止自动递增和自动递减作为一个选项。 您选择是否听从建议。

我个人的规则是不要做任何与自动递增或自动递减相结合的事情。

我从多年的 C 经验中了解到，如果我保持简单的使用方式，就不会出现缓冲区溢出（或数组索引越界）的情况。 但我发现，如果我陷入在同一语句中执行其他操作的“过于棘手”的做法，我确实会遇到缓冲区溢出。

因此，对于我自己的规则，使用 i++ 作为 for 循环中的增量是可以的。

Answer 4

在循环中它是无害的，但在赋值语句中它可能会导致意外结果：

var x = 5;
var y = x++; // y is now 5 and x is 6
var z = ++x; // z is now 7 and x is 7

变量和运算符之间的空格也可能导致意外结果：

a = b = c = 1; a ++ ; b -- ; c; console.log('a:', a, 'b:', b, 'c:', c)

在闭包中，意外结果也可能是一个问题：

var foobar = function(i){var count = count || i; return function(){return count++;}}

baz = foobar(1);
baz(); //1
baz(); //2


var alphabeta = function(i){var count = count || i; return function(){return ++count;}}

omega = alphabeta(1);
omega(); //2
omega(); //3

并且它会触发自动换行符后插入分号：

var foo = 1, bar = 2, baz = 3, alpha = 4, beta = 5, delta = alpha
++beta; //delta is 4, alpha is 4, beta is 6

预增量/后增量混淆可能会产生非常难以诊断的相差一错误。 幸运的是，它们也是完全没有必要的。 有更好的方法将变量加 1。

参考

• JSLint 帮助：递增和递减运算符

Answer 5

递增和递减运算符的“前”和“后”性质对于那些不熟悉它们的人来说往往会令人困惑； 这是他们可能会变得棘手的一种方式。

Answer 6

考虑以下代码，

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[i++] = i++;
    a[i++] = i++;
    a[i++] = i++;

因为 i++ 被评估两次，输出为
（来自 vs2005 调试器）

    [0] 0   int
    [1] 0   int
    [2] 2   int
    [3] 0   int
    [4] 4   int

现在考虑以下代码：

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[++i] = ++i;
    a[++i] = ++i;
    a[++i] = ++i;

请注意，输出是相同的。 现在您可能认为 ++i 和 i++ 是相同的。 它们不是

    [0] 0   int
    [1] 0   int
    [2] 2   int
    [3] 0   int
    [4] 4   int

最后考虑这段代码

    int a[10];
    a[0] = 0;
    a[1] = 0;
    a[2] = 0;
    a[3] = 0;
    int i = 0;
    a[++i] = i++;
    a[++i] = i++;
    a[++i] = i++;

现在的输出是：

    [0] 0   int
    [1] 1   int
    [2] 0   int
    [3] 3   int
    [4] 0   int
    [5] 5   int

所以它们不一样，混合两者会导致不那么直观的行为。 我认为 for 循环对于 ++ 来说是可以的，但是当同一行或同一条指令上有多个 ++ 符号时要小心

Answer 7

在我看来，“显式总是比隐式好。”因为在某些时候，您可能会对这个增量语句 y+ = x++ + ++y 感到困惑。 优秀的程序员总是让他或她的代码更具可读性。

Answer 8

我一直在观看 Douglas Crockford 的视频，他对不使用增量和减量的解释是，

1. 过去在其他语言中使用它来打破数组的界限并导致各种不好的情况，而且
2. 它更令人困惑和没有经验的 JS 开发人员不知道它到底做什么。

首先，JavaScript 中的数组是动态调整大小的，因此，如果我错了，请原谅我，不可能打破数组的边界并访问不应在 JavaScript 中使用此方法访问的数据。

其次，我们是否应该避免复杂的事情，当然问题不在于我们有这个设施，而是问题在于有些开发人员声称可以使用 JavaScript，但不知道这些运算符是如何工作的？ 这很简单。 value++，给我当前值，并在表达式后加一，++value，在给我之前增加值。

如果您记住上面的内容，像 a ++ + ++ b 这样的表达式很容易计算出来。

var a = 1, b = 1, c;
c = a ++ + ++ b;
// c = 1 + 2 = 3; 
// a = 2 (equals two after the expression is finished);
// b = 2;

我想你只需要记住谁必须通读代码，如果你有一个对 JS 了如指掌的团队，那么你就不需要担心。 如果没有，那么评论它，以不同的方式写它，等等。做你必须做的事情。 我不认为增量和减量本质上是不好的，或者会产生错误，或者产生漏洞，可能只是可读性较差，具体取决于您的受众。

顺便说一句，我认为道格拉斯·克罗克福德无论如何都是一个传奇人物，但我认为他对一个不值得的操作员造成了很大的恐慌。

但我活着就是为了被证明是错的……

Answer 9

避免使用 ++ 或 -- 的最重要的理由是，运算符返回值的同时会产生副作用，从而使代码的推理变得更加困难。

为了效率起见，我更喜欢：

• ++i 当不使用时返回值（不是临时的）
• i++ 当使用时> 返回值（无管道停顿）

我是 Crockford 先生的粉丝，但在这种情况下我不得不不同意。 ++i 比 i+=1 需要解析的文本少了 25% 而且 可以说更清晰。

Answer 10

另一个例子，比其他一些简单返回递增值更简单：

function testIncrement1(x) {
    return x++;
}

function testIncrement2(x) {
    return ++x;
}

function testIncrement3(x) {
    return x += 1;
}

console.log(testIncrement1(0)); // 0
console.log(testIncrement2(0)); // 1
console.log(testIncrement3(0)); // 1

如您所见，如果您希望此运算符影响结果，则不应在 return 语句中使用后递增/递减。 但 return 不会“捕获”后递增/递减运算符：

function closureIncrementTest() {
    var x = 0;

    function postIncrementX() {
        return x++;
    }

    var y = postIncrementX();

    console.log(x); // 1
}

Answer 11

我认为程序员应该胜任他们所使用的语言； 清楚地使用它； 并好好利用它。 我认为他们不应该人为地削弱他们正在使用的语言。 我是根据经验说话的。 我曾经在 Cobol 商店的隔壁工作过，那里他们不使用 ELSE，“因为它太复杂了”。 反证法。

Answer 12

根据我的经验，除了第一次了解运算符如何工作时之外，++i 或 i++ 从未引起混乱。 对于以可以使用该运算符的语言教授的任何高中或大学课程所教授的最基本的 for 循环和 while 循环来说，它都是必不可少的。 我个人发现，像下面这样的操作比将 a++ 放在单独的行上看起来和阅读起来更好。

while ( a < 10 ){
    array[a++] = val
}

最后，这是一种风格偏好，仅此而已，更重要的是，当您在代码中执行此操作时，您会保持一致，以便其他处理相同代码的人可以遵循，而不必以不同的方式处理相同的功能。

另外，Crockford 似乎使用 i-=1，我发现它比 --i 或 i-- 更难阅读

Answer 13

正如一些现有答案中提到的（令人烦恼的是我无法评论），问题是 x++ ++x 评估为不同的值（增量之前和之后），这并不明显并且可能非常令人困惑 - 如果使用该值。 cdmckay 非常明智地建议允许使用增量运算符，但只能以不使用返回值的方式，例如在其自己的行上。 我还将在 for 循环中包含标准用法（但仅在第三个语句中，不使用其返回值）。 我想不出另一个例子。 我自己也被“烧伤”了，我也会为其他语言推荐同样的指南。

我不同意这种过于严格是因为很多 JS 程序员缺乏经验的说法。 这正是“过于聪明”的程序员所特有的写作方式，而且我确信这种写法在更传统的语言以及具有此类语言背景的 JS 开发人员中更为常见。

Answer 14

我的2美分是，在两种情况下应该避免它们：

1）当你有一个在许多行中使用的变量并且你在使用它的第一个语句（或最后一个，或者更糟糕的是，在中间）上增加/减少它时)：

// It's Java, but applies to Js too
vi = list.get ( ++i );
vi1 = list.get ( i + 1 )
out.println ( "Processing values: " + vi + ", " + vi1 )
if ( i < list.size () - 1 ) ...

在这样的示例中，您很容易错过变量是自动递增/递减的，甚至删除第一条语句。 换句话说，仅在非常短的块中或变量仅在几个关闭语句中出现在块中的情况下使用它。

2) 如果同一语句中的同一变量有多个 ++ 和 -- 。 很难记住在这样的情况下会发生什么：

result = ( ++x - --x ) * x++;

考试和专业测试询问上面的例子，事实上，我在寻找其中一个文档时偶然发现了这个问题，但在现实生活中，不应该强迫人们这样做对一行代码想了很多。

Answer 15

Fortran 是类 C 语言吗？ 它既没有 ++ 也没有 --。 这是如何编写循环：

     integer i, n, sum

      sum = 0
      do 10 i = 1, n
         sum = sum + i
         write(*,*) 'i =', i
         write(*,*) 'sum =', sum
  10  continue

每次循环时索引元素i都会按语言规则递增。 如果你想增加 1 以外的数字，例如倒数 2，语法是……

      integer i

      do 20 i = 10, 1, -2
         write(*,*) 'i =', i
  20  continue

Python 与 C 类似吗？ 它使用范围和列表推导式以及其他语法来绕过递增索引的需要：

print range(10,1,-2) # prints [10,8.6.4.2]
[x*x for x in range(1,10)] # returns [1,4,9,16 ... ]

因此，基于对两种替代方案的初步探索，语言设计者可以避免 ++ 和——通过预测用例并提供替代语法。

Fortran 和 Python 是否比具有 ++ 和 -- 的过程语言更不容易引起 bug ？ 我没有证据。

我声称 Fortran 和 Python 与 C 类似，因为我从未见过精通 C 的人不能以 90% 的准确度正确猜测非混淆的 Fortran 或 Python 的意图。

Answer 16

当用作前缀和后缀时，运算符的含义不同，这可能会导致难以发现的错误。 考虑以下使用 bubbleSort 的示例：

function bubbleSort(array) {
  if(array.length === 1) return array;

  let end = array.length - 2;
  do {
    for (let i = 0; i < array.length; i += 1) {
      if (array[i] > array[i + 1]) {
        swap(array, i, i + 1);
      }
    }
  } while (end--);
}

bubbleSort([6,5]);

假设在运行程序的过程中，我们将两个项目的值传递到排序函数中。 代码按原样运行良好：“do/while”循环在达到条件之前首先执行。 但是，程序发现 end 为假并在递减变量之前退出循环。

现在考虑以下代码，其中 -- 符号用作前缀，而不是后缀。 此代码将进入无限循环：

function bubbleSort(array) {
  if(array.length === 1) return array;

  let end = array.length - 2;
  do {
    for (let i = 0; i < array.length; i += 1) {
      if (array[i] > array[i + 1]) {
        swap(array, i, i + 1);
      }
    }
  } while (--end);
}

bubbleSort([6,5]);

现在，当我们遇到 while 条件时，我们会在检查之前递减最终值。 这会返回 -1，在 Javascript 中是一个真值。

我对它们的使用方式没有强烈的意见，但我只是想展示它们在不小心使用时如何导致真正的错误。

Answer 17

++ 的论点是 ++ 不适用于会导致 TypeError 的字符串，这几乎总是更好的选择。