问题描述
code优化这里说，这样分析是优化的JavaScript的第一步，建议引擎是Chrome和Firefox的剖析。这些问题是他们的一些不可思议的方式告诉大家，每次执行功能的时间，但我还没有得到他们任何很好的理解。最有用的方法是，该分析器会告诉，多少次被执行的每一行，如果以往任何时候都可能也是花费在每行的时间。这样才有可能看到瓶颈严格。但实现这样的工具前/发现，我们有两个选择：
1）做自己的小算盘，计数的时间和多少次某些code座或行执行
2）学会区分哪些是缓慢的方法，哪些不是。
对于选择2 是很大的帮助。我曾试图学习优化阵列，并取得了速度测试。下图显示了在5个主要的浏览器的结果，并发现了一些瓶颈，我不知道前面
主要研究结果：
1）指定值数组比分配给尽管其中用于分配方法正常变量显著慢。
2）preinitializing和/或prefilling前阵性能的关键循环可以显著提高速度
3）数学三角函数都没有这么慢相比，推值代入阵列（！）
下面是每个测试说明：
1。 non_array（100％）：
变量分别获得了predefined价值是这样的：
VAR non_array_0 = 0;
变种non_array_1 = 0;
变种non_array_2 = 0;
...
和在定时地区，他们被称为是这样的：
non_array_0 = 0;
non_array_1 = 1;
non_array_2 = 2;
non_array_3 = 3;
non_array_4 = 4;
non_array_5 = 5;
non_array_6 = 6;
non_array_7 = 7;
non_array_8 = 8;
non_array_9 = 9;
以上是一个类似数组的变量，但似乎有没有办法来迭代或引用这些变量在其他的方式oppocite数组。还是有？
在这个测试中，没有什么比分配数量可变的速度更快。
2。 non_array_non_ pre（83.78％）
完全一样的测试1，但这些变量并没有pre-初始化，也不prefilled。速度是试验1的速度在每一个测试器prefilled变量的速度比非prefilled更快的83,78％。 所以初始化（也可能是pre灌注）变量以外的任何速度关键回路。
测试code是在这里：
VAR non_array_non_ pre_0 = 0;
VAR non_array_non_ pre_1 = 0;
VAR non_array_non_ pre_2 = 0;
VAR non_array_non_ pre_3 = 0;
VAR non_array_non_ pre_4 = 0;
VAR non_array_non_ pre_5 = 0;
VAR non_array_non_ pre_6 = 0;
VAR non_array_non_ pre_7 = 0;
VAR non_array_non_ pre_8 = 0;
VAR non_array_non_ pre_9 = 0;
3。 pre_filled_array（19.96％）：
数组是邪恶的！：当我们丢掉正常的变量（TEST1和TEST2），并采取阵列中的图片，速度显著下降。 尽管我们尽了所有优化（preinitialize和pre灌注数组），然后直接赋值不用循环或推，速度降低到19.96％左右。这是非常可悲的，我真不'不懂为什么发生这种情况。这是在该试验的主要冲击箱中的一个。数组是如此重要，我还没有找到一种方法，使许多事情没有数组。
测试数据是在这里：
pre_filled_array [0] = 0;
pre_filled_array [1] = 1;
pre_filled_array [2] = 2;
pre_filled_array [3] = 3;
pre_filled_array [4] = 4;
pre_filled_array [5] = 5;
pre_filled_array [6] = 6;
pre_filled_array [7] = 7;
pre_filled_array [8] = 8;
pre_filled_array [9] = 9;
4。 non_ pre_filled_array（8.34％）：
这是相同的测试为3，但数组成员不是preinitialized也不prefilled，只有优化是初始化数组事先： VAR non_ pre_filled_array = [ ];
相比，preinitilized测试速度下降58,23％3. 所以preinitializing和/或prefilling阵列上增加一倍的速度。
测试code是在这里：
non_ pre_filled_array [0] = 0;
non_ pre_filled_array [1] = 1;
non_ pre_filled_array [2] = 2;
non_ pre_filled_array [3] = 3;
non_ pre_filled_array [4] = 4;
non_ pre_filled_array [5] = 5;
non_ pre_filled_array [6] = 6;
non_ pre_filled_array [7] = 7;
non_ pre_filled_array [8] = 8;
non_ pre_filled_array [9] = 9;
5。 pre_filled_array [I]（7.10％）：
接着向环路。最快的循环在这种测试方法。该阵列preinitialized和prefilled。
的速度下降相比线版本（试验3）为64,44％。这是如此显着的区别，我会说，如果没有必要不要循环。如果数组大小小（不知道有多小，它需要单独测试），使用内联任务，而不是循环是明智的。
和因为速度下降是如此巨大，我们真正需要的循环，这是明智的做法是找到（例如：而（I - ）。）
测试code是在这里：
为（VAR I = 0;我小于10;我++）
{
pre_filled_array [我] =我;
}
6。 non_ pre_filled_array [I]（5.26％）：
如果我们不preinitialize和pre灌注阵列，速度下降25,96％。前速关键回路同样，preinitializing和/或prefilling是明智的。
在code是在这里：
为（VAR I = 0;我小于10;我++）
{
non_ pre_filled_array [我] =我;
}
7。数学计算（1.17％）：
每一次测试都必须有一定的参考点。数学函数被认为是缓慢的。测试包括十重数学计算，但现在来袭击我在这个测试中的其他事情。看看8和9的速度，我们在循环推10整数数组。计算这些10数学函数比推10整数到数组中循环快30％以上。因此，可能会更容易将一些阵列推向preinitialized非阵列，保留那些trigonometrics。当然，如果有一百个或数千个每帧计算，明智的做法是使用如。而不是正弦/余弦/棕褐色和使用出租车的距离为距离比较和的，但仍是主要瓶颈可能是在别处：循环比内联慢，推比使用与preinitilization和/或prefilling，code逻辑，绘制算法和访问DOM直接赋值可能会很慢慢。所有不能在Javascript的优化（我们要在屏幕上看到的东西！），但所有容易，我们可以做的显著，是明智的事情。有人在这里SO曾表示，code是人类可读code比快速code更重要，因为维护成本是最大的成本。这是经济的观点，但我发现，code优化可以得到两个：优雅和可读性和性能。如果5％的性能提升，实现与code更straightforwad，给人一种美好的感觉！
在code是在这里：
non_array_0 =的Math.sqrt（10435.4557）;
non_array_1 = Math.atan2（12345,24869）;
non_array_2 = Math.sin（35.345262356547）;
non_array_3 = Math.cos（232.43575432）;
non_array_4 = Math.tan（325）;
non_array_5 = Math.asin（3459.35498534536）;
non_array_6 = Math.acos（3452.35）;
non_array_7 = Math.atan（34.346）;
non_array_8 = Math.pow（234222）;
non_array_9 = 9374.34524 / 342734.255;
8。 pre_filled_array.push（I）（0.8％）：
推是邪恶的！推相结合，循环恶意邪恶！这是因为某些原因很慢的方法来赋值到数组。测试5（环路直接分配），比这个方法快近9倍，这两种方法做同样的事情：整型的0-9到preinitialized和prefilled阵列。如果此推for循环恶是由于推力或循环或两者的组合或循环计数我没有测试。有在该给出矛盾的结果JSPERF.COM其它实例。这是明智的做法只是测试与实际数据和做出决策。这个测试可能不会比使用什么其它数据相兼容。
这里是code：
为（VAR I = 0;我小于10;我++）
{
pre_filled_array.push（ⅰ）;
}
9。 non_ pre_filled_array.push（I）（0.74％）：
在本试验中的最后和最慢的方法是相同的试验8，但数组不是prefilled。超过900慢一点，但差别并不显著（7.23％）。但是，让我们举个例子，这最慢的方法比较，以最快的。 此方法的速度是方法1，这意味着，方法1比这个快135倍的速度的0.74％。所以仔细一想，如果在所有需要特定用例的阵列。如果只有一个或几个推，总的速度差异并不明显，但如果只有少数推另一方面，他们是非常简单而优雅转换到非数组变量。
这是code：
为（VAR I = 0;我小于10;我++）
{
non_ pre_filled_array.push（ⅰ）;
}
最后强制性的SO问题：
因为按照本次测试的速度差似乎非数组可变分配和阵列的任务之间如此之大，有没有方法来获取非数组变量，assigments和速度阵列的动态？
我不能使用 VAR variable_ $ I = 1 在一个循环，这样$ I转化为某个整数。我必须使用 var变量。[I] = 1 比 VAR变量1 = 1 显著慢作为试验证明。只有当有大的阵列，这可能是关键的，而且在许多情况下，它们是
编辑：
我做了一个新的测试，以确认数组访问缓慢，并试图找到更快的方法：
阵列的读取和/或阵列的写比使用正常变量显著慢。如果某些操作完成数组成员，这是明智的数组成员值存储到一个临时变量，做出临时变量的操作，最后存储值到数组成员。虽然code变大，这是显著更快地使这些操作直列比循环。
结论：阵列与正常变量类似于磁盘VS内存。通常内存访问比磁盘访问和正常变量访问比数组访问速度更快。并可以串联操作也比使用中间变量快，但是这使得code有点不可读。
That's because normal variables are statically scoped and can be (and are) easily optimised. The compiler/interpreter will learn their type, and might even avoid repeated assignments of the same value.
These kind of optimisations will be done for arrays as well, but they're not so easy and will need longer to take effect. There is additional overhead when resolving the property reference, and since JavaScript arrays are auto-growing lists the length needs to be checked as well.
Prepopulating the arrays will help to avoid reallocations for capacity changes, but for your little arrays (length=10) it shouldn't make much difference.
No. Dynamics do cost, but they are worth it - as are loops.
You hardly ever will be in the case to need such a micro-optimisation, don't try it. The only thing I can think of are fixed-sized loops (n <= 4) when dealing with ImageData, there inlining is applicable.
Nope, only your test was flawed. The jsperf snippets are executed in a timed loop without tearup and -down, and only there you have been resetting the size. Your repeated pushes have been producing arrays with lengths of hundredth thousands, with correspondent need of memory (re-)allocations. See the console at http://jsperf.com/pre-filled-array/11.
Actually push is just as fast as property assignment. Good measurements are rare, but those that are done properly show varying results across different browser engine versions - changing rapidly and unexpected. See Appending to array, Why is array.push sometimes faster than array[n] = value? and Is there a reason JavaScript developers don't use Array.push()? - the conclusion is that you should use what is most readable / appropriate for your use case, not what you think could be faster.
这篇关于数组赋值的性能的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！