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

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

i++;
array[i] = foo;

代替

array[++i] = foo;

除此之外的任何事情都会让一些程序员感到困惑，而且在我看来是不值得的。 For 循环是一个例外，因为增量运算符的使用是惯用的，因此总是很清楚。

---

坦率地说，我对这个建议感到困惑。我的一部分想知道这是否与 javascript 编码人员缺乏经验（感知或实际）有关。

我可以看到有人只是“破解”一些示例代码可能会在使用 ++ 和 -- 时犯下一个无辜的错误，但我不明白为什么有经验的专业人士会避免它们。

---

在 C 中有这样的历史：

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

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

总是有什么问题

++i = i++;

或者

i = i++ + ++i;

实际上做。它在某些语言中定义，而在其他语言中则无法保证会发生什么。

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

---

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

Crockford 在 jsLint 中将禁止自动增量和自动减量作为一个选项。您可以选择是否遵循建议。

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

我从多年的 C 语言经验中了解到，如果我继续简单地使用它，就不会出现缓冲区溢出（或数组索引越界）。但是我发现如果我陷入在同一个语句中做其他事情的“过于棘手”的做法，我确实会遇到缓冲区溢出。

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

---

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

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

preincrement/postincrement 混淆会产生非常难以诊断的错误。幸运的是，它们也完全没有必要。有更好的方法将 1 添加到变量中。

参考

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

---

考虑以下代码

    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 循环可以使用 ++，但是当您在同一行或同一指令上有多个 ++ 符号时要小心

---

递增和递减运算符的“前”和“后”性质可能会让不熟悉它们的人感到困惑；这是他们可能很棘手的一种方式。

---

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

---

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

过去它在其他语言中被用来打破数组的界限并导致各种不良行为，而且它更令人困惑，没有经验的 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 了如指掌的团队，那么你就不用担心了。如果没有，请评论它，以不同的方式写它，等等。做你必须做的。我不认为增量和减量本质上是坏的或产生错误或产生漏洞，可能只是不太可读，具体取决于您的受众。

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

虽然我活着被证明是错误的......

---

避免 ++ 或 -- 的最重要理由是运算符返回值并同时引起副作用，这使得对代码的推理变得更加困难。

为了效率，我更喜欢：

++i 不使用返回值时（非临时）

i++ 使用返回值时（无管道停顿）

我是克罗克福德先生的粉丝，但在这种情况下我不得不不同意。 ++i 比 i+=1 少 25% 的文本解析，并且可以说更清晰。

---

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

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
}

---

我认为程序员应该能够胜任他们使用的语言；清楚地使用它；并很好地使用它。我认为他们不应该人为地削弱他们使用的语言。我根据经验说话。我曾经在一家 Cobol 商店隔壁工作，他们没有使用 ELSE，因为它太复杂了。减少荒谬。

---

以我的经验，++i 或 i++ 从未引起混淆，除非是在第一次了解运算符的工作原理时。对于任何高中或大学课程所教授的最基本的 for 循环和 while 循环来说，它都是必不可少的，这些课程以您可以使用运算符的语言教授。我个人发现做一些类似下面的事情看起来和阅读比 a++ 在单独的行上更好。

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

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

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

---

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

我不同意这种过于严格是由于许多 JS 程序员缺乏经验的说法。这正是“过于聪明”的程序员典型的写作类型，我相信它在更传统的语言和具有此类语言背景的 JS 开发人员中更为常见。

---

我的 2cents 是在两种情况下应该避免使用它们：

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 ) ...

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

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

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

考试和专业测试会询问上述示例，实际上我在寻找有关其中一个示例的文档时偶然发现了这个问题，但在现实生活中，不应该被迫对一行代码进行太多思考。

---

Fortran 是类 C 语言吗？它既没有 ++ 也没有 --。这是how you write a loop：

     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 是否更容易吸引错误？我没有证据。

我声称 Fortran 和 Python 类似于 C，因为我从来没有遇到过不能以 90% 的准确率正确猜测非混淆 Fortran 或 Python 意图的人。

---

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

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 中是一个真实值。

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

---

++ 的论点是 ++ 不适用于会导致 TypeError 的字符串，这几乎总是可取的。

---