Duff 装置中case情况越多性能越好

猜想：Duff装置再循环里面，直接调用的方法越多（也就是case的数量比较多），性能相对越好 ？？？！！！

我们基于Duff装置来做进一步的测试。

然后分别添加两个新的函数，一个函数式 case有4种情况，另一个是case有 12种情况。。。

 1     function duffDevice() {
 2           var testVal = 0;
 3           var n = Math.ceil(iterations / 8);
 4           var caseTest = iterations % 8;
 5           do {
 6               switch (caseTest) {
 7                   case 0:
 8                       testVal++;
 9                   case 7:
10                       testVal++;
11                   case 6:
12                       testVal++;
13                   case 5:
14                       testVal++;
15                   case 4:
16                       testVal++;
17                   case 3:
18                       testVal++;
19                   case 2:
20                       testVal++;
21                   case 1:
22                       testVal++;
23               }
24               caseTest = 0;
25           }
26           while (--n > 0);
27       }

duffDevice

 1       function duffDeviceSize4() {
 2           var testVal = 0;
 3           var n = Math.ceil(iterations / 4);
 4           var caseTest = iterations % 4;
 5           do {
 6               switch (caseTest) {
 7                   case 0:
 8                       testVal++;
 9                   case 3:
10                       testVal++;
11                   case 2:
12                       testVal++;
13                   case 1:
14                       testVal++;
15               }
16               caseTest = 0;
17           }
18           while (--n > 0);
19       }

duffDeviceSize4

 1    function duffDeviceSize12() {
 2           var testVal = 0;
 3           var n = Math.ceil(iterations / 12);
 4           var caseTest = iterations % 12;
 5           do {
 6               switch (caseTest) {
 7                   case 0:
 8                       testVal++;
 9                   case 11:
10                       testVal++;
11                   case 10:
12                       testVal++;
13                   case 9:
14                       testVal++;
15                   case 8:
16                       testVal++;
17                   case 7:
18                       testVal++;
19                   case 6:
20                       testVal++;
21                   case 5:
22                       testVal++;
23                   case 4:
24                       testVal++;
25                   case 3:
26                       testVal++;
27                   case 2:
28                       testVal++;
29                   case 1:
30                       testVal++;
31               }
32               caseTest = 0;
33           }
34           while (--n > 0);
35       }

duffDeviceSize12

测试结果如下：

以下只是我自己的结论，不一定正确，仅提供参考(不是很确定的东西，不能误人子弟):

这个结果说明了，在Duff循环中，case 情况越多,性能相对越好，但是这样代码的书写不是很方便。Duff装置提供给我的更多的只是一个思路，而不是一个死板的算法公式。

欢迎大家共同探讨。。。迎风一刀劈有礼了。。。