增量很有趣
#javascript #循环 #while #increments

C，C ++，Java，JavaScript和其他语言中的增量运算符很有趣。

简而言之，i++或++i等于使用i += 1或i = i + 1 ...但是有一个扭曲。增量操作员，取决于您的何处，更重要的是，如果是提及之前，或者是在进行其他事情之前或之后执行其他操作员。

让我们从基本的东西开始。

您可能在MDN网站上看到了此示例。

let x = 3;
const y = x++;

console.log(`x:${x}, y:${y}`);
// Expected output: "x:4, y:3"

let a = 3;
const b = ++a;

console.log(`a:${a}, b:${b}`);
// Expected output: "a:4, b:4"

作为灌溉后，x在后增加到4 ，它被分配给y。作为提前，a在之前增加到4 。

上周，我正在为作业编写分类算法，并注意到我正在寻找的代码，仅在自己的行上就有很大的增长和减少操作员。因此，我想知道如何在特定位置调用数组时如何使用它们。

假设我们有一个带有四个元素的数组。即使第一个索引位于0，我们也将i和j分配给1。

let arr = [4, 8, 12, 16];

let i = 1;
let c = arr[i];   // arr[1]
let d = arr[++i]; // arr[2]
let e = arr[i];   // arr[2]
console.log(`c:${c}, d:${d}, e:${e}`);
// Expected output: "c:8, d:12, e:12"

let j = 1;
let f = arr[j];   // arr[1]
let g = arr[j++]; // arr[1]
let h = arr[j];   // arr[2]
console.log(`f:${f}, g:${g}, h:${h}`);
// Expected output: "f:8, g:8, h:12"

我们可以假设，在上述代码中，c和f是“之前”，d和g是“ ofer ofer”，而e和h是after。

。

作为预先介绍，“期间”与“后”相同。作为插入后，“期间”与“之前”相同。

这意味着在调用或使用元素之前进行预告，并且在调用或使用元素之后进行插入。

。

我们只有减少值而不是增加值，我们会看到相同的行为。

。

让我们看看当我们在不同类型的循环结构中使用它们时会发生什么。

让我们避开for循环。这些结构的结果是可以预见的，因为在执行了循环内部的内容之后，增量步骤和测试似乎发生。

for(let a = 0; a < 5; ++a){
 console.log(`For Loop A: ${a}`);
}

/*
> "For Loop A: 0"
> "For Loop A: 1"
> "For Loop A: 2"
> "For Loop A: 3"
> "For Loop A: 4"
*/

for(let b = 0; b < 5; b++){
 console.log(`For Loop B: ${b}`);
}

/*
> "For Loop B: 0"
> "For Loop B: 1"
> "For Loop B: 2"
> "For Loop B: 3"
> "For Loop B: 4"
*/

非常无聊，不友善？这就是为什么在许多计算机科学书籍中，对while和do-while的重视程度更多，因为while循环测试在执行迭代（步骤）和do-while循环测试后进行迭代后进行迭代。

在下表中，我们将演示16个示例。第一列和第二列将显示一个while循环的示例。第三列和第四列将显示DO-时循环的示例。第一列和第三列是源代码，第二和第四列是输出。

行A到达D将使用预插入显示示例，而e行E到H将使用后插入显示示例。在A和E行中，增量将在测试中完成（可能是在代码块之前或之后）；在B和F行中，增量将在输出语句之前；在输出期间，在C和G行中；在输出语句之后，在D和H中。让我们看看我们可以从这些测试中学到哪些模式。

行 代码 输出 代码 输出
a 
			令A = 0;
			while（++ a <5）{
			console.log（`while loop a：$ {a}`）;
			}
			    
			>“循环A：1”
			>“循环A：2”
			>“循环A：3”
			>“循环A：4”
			    
			令A = 0;
			做{
			console.log（`do-while loop a：$ {a}`）;
			} while（++ a <5）;
			    
			>“ do-while循环a：0”
			>“ do-while循环a：1”
			>“ do-while循环a：2”
			>“ do-同时循环A：3”
			>“ do-同时循环A：4”
b 
			令B = 0;
			而（b <5）{
			++ b;
			console.log（`while loop b：$ {b}`）;
			}
			    
			>“循环B：1”
			>“循环B：2”
			>“循环B：3”
			>“循环B：4”
			>“循环B：5”
			    
			令B = 0;
			做{
			++ b;
			console.log（`do-while loop b：$ {b}`）;
			} while（b <5）;
			    
			>“ do-while循环b：1”
			>“ do-while循环b：2”
			>“ do-while循环b：3”
			>“ do-while循环b：4”
			>“ do-while循环b：5”
c 
			令C = 0;
			而（c <5）{
			console.log（`while loop c：$ {++ c}`）;
			}
			    
			>“循环C：1”
			>“循环C：2”
			>“循环C：3”
			>“循环C：4”
			>“循环C：5”
			    
			令C = 0;
			做{
			console.log（`do-while loop c：$ {++ c}`）;
			} while（c <5）;
			    
			>“ do-while循环C：1”
			>“ do-while循环c：2”
			>“ do-while循环C：3”
			>“ do-while循环C：4”
			>“ do-while循环C：5”
d 
			令d = 0;
			而（d <5）{
			console.log（`while loop d：$ {d}`）;
			++ d;
			}
			    
			>“循环D：0”
			>“循环D：1”
			>“循环D：2”
			>“循环D：3”
			>“循环D：4”
			    
			令d = 0;
			做{
			console.log（`do-while loop d：$ {d}`）;
			++ d;
			} while（d <5）;
			    
			>“ do-while循环d：0”
			>“ do-while循环d：1”
			>“ do-while循环d：2”
			>“ do-while循环d：3”
			>“ do-同时循环d：4”
e 
			令E = 0;
			while（e ++ <5）{
			console.log（`while loop e：$ {e}`）;
			}
			    
			>“循环E：1”
			>“循环E：2”
			>“循环E：3”时
			>“循环E：4”
			>“循环E：5”
			    
			令E = 0;
			做{
			console.log（`do-while loop e：$ {e}`）;
			} while（e ++ <5）;
			    
			>“ do-while循环e：0”
			>“ do-while循环e：1”
			>“ do-while循环e：2”
			>“ do-while循环E：3”
			>“ do-while循环E：4”
			>“ do-while循环E：5”
f 
			令F = 0;
			而（f <5）{
			F ++
			console.log（`while loop f：$ {f}`）;
			}
			    
			>“循环F：1”时
			>“循环F：2”时
			>“循环F：3”时
			>“循环F：4”时
			>“循环F：5”时
			    
			令F = 0;
			做{
			F ++
			console.log（`do-while loop f：$ {f}`）;
			} while（f <5）;
			    
			>“ do-while循环F：1”
			>“ do-while循环f：2”
			>“ do-while循环f：3”
			>“ do-同时循环F：4”
			>“ do-while循环F：5”
g 
			令G = 0;
			而（g <5）{
			console.log（`while loop g：$ {g ++}`）;
			}
			    
			>“循环g：0”
			>“循环g：1”
			>“循环g：2”
			>“循环G：3”
			>“循环G：4”
			    
			令G = 0;
			做{
			console.log（`do-while loop g：$ {g ++}`）;
			} while（g <5）;
			    
			>“ do-时循环g：0”
			>“ do-同时循环g：1”
			>“ do-同时循环g：2”
			>“ do-同时循环g：3”
			>“ do-同时循环g：4”
h 
			令H = 0;
			而（h <5）{
			console.log（`while loop h：$ {h}`）;
			H ++;
			}
			    
			>“循环H：0”
			>“循环H：1”
			>“循环H：2”
			>“循环H：3”
			>“循环H：4”
			    
			令H = 0;
			做{
			console.log（`do-while loop h：$ {h}`）;
			H ++;
			} while（h <5）;
			    
			>“ do-while循环h：0”
			>“ do-while循环h：1”
			>“ do-while循环h：2”
			>“ do-while循环h：3”
			>“ do-while循环h：4”

while循环b，c，e和f的输出都是相同的。而循环B，C和F都具有与DO-while同行相同的输出。 do-whore循环C中的第三行等效于在do-liop B中组合第2和3行B中的第2行。而do-wherile loop f的输出看起来像B和C，因为在输出语句之前发生了增量。循环C可能是此循环的最佳实现。

while循环d，g和h的输出都是相同的，它们的输出与do-nile同行相同。
循环g中的第三行等效于H.

的第三行和第四行。

让我们看一下循环A。在此处，在测试之前进行预先提示，因此没有a = 0输出。相比之下，循环e包括e = 5，就像循环B，C和F一样。在执行之前，在测试中进行增量可能不是最好的主意。

do-wher lile循环a，d，g和h的输出都是相同的。在do-while循环A和D中，增量在输出后发生。 do-where loops g和h的输出等效，我们已经描述了几段以前的方式。

do-do-wher lile循环A可能是此循环的最佳版本，因为在一个组合语句中执行时进行了预先插入和测试。

。

do-wher循环b，c和f的输出都是相同的。 do-while循环C可能是此循环的最佳实现。

让我们看一下do-while循环E。在这里，我们有一个使该循环运行六次（最多的次），可以将其描述为与运行四次的循环A相反的行为（至少时间）。如果我们使用的是不到或平等的操作员而不是运算符，那么此输出会相同吗？我们可能会再探索这一次。

今天帖子的目的是找到更有效的方法来编写代码，通过在使用循环时查找最佳模式。

我正在考虑将来更好地利用带有柜台的do-while循环，但是使用数组，我可能会使用循环g或do-do-do-do loopg。

时使用更多的东西。