1. When concatenating strings in lower version browsers (such as IE6, IE7, etc.), using the join method of the array is much more efficient than using the + sign to connect (such as ['aaa', 'bbb', 'ccc'].join () more efficient than 'aaa'+'bbb'+'ccc');
2. Array:
Pop is more efficient than shift, and push is more efficient than unshift. This is important for designing a binary heap structure. It is best to place the largest or smallest element at the end of the array.
3. It is best to use shift operations when rounding numbers:
1.1 >> 0;
4. Use direct quantities to create Array and Object:
var a = [];
var o = {};
5. Don’t nest too many object levels to reduce object searches:
Don't use abcde, this design method obtains the e object.
6. Key-value corresponding value, compared with switch case, key-value corresponding, more efficient than switch case, has been tested by various browsers, you can read the article about this comparison, javascript small experiment;
7. If you use jq, there is also a comparison between $('xxxx').empty().append('xxxxxxx'); and $('xxxxx').html('xxxxx');, the result is $ ('xxxx').empty().append('xxxxxxx'); wins, the article address is jQuery small experiment;
8. Loop
In JavaScript, we can use three loops: for(;;), while(), and for(in). Among these three loops, for(in) is extremely inefficient because it needs to query the hash key. As long as it can It should be used as little as possible. The performance of for(;;) and while loop should be said to be basically equivalent (when used in daily use).
If a loop variable is incremented or decremented, do not assign a value to the loop variable alone. Use the nested ++ or -- operator when it is last read.
If you want to compare with the length of the array, you should put the length attribute of the array into a local variable in advance to reduce the number of queries.
9. Local variables and global variables
The access speed of local variables is faster than that of global variables, because global variables are actually members of the global object, while local variables are placed on the stack of the function.
10. Don’t use Eval
Using eval is equivalent to calling the interpretation engine again to run the content at runtime, which takes a lot of time. At this time, function templates can be implemented using closures supported by JavaScript (for details on closures, please refer to the relevant content on functional programming);
11. String concatenation
If you are appending a string, it is best to use the s+=anotherStr operation instead of s=s+anotherStr;
12. Convert numbers into strings and use "" + 1. Although it looks a bit ugly, in fact this is the most efficient, in terms of performance:
("" +) > String() > .toString() > new String()
This article is actually somewhat similar to the "direct quantity" below. Try to use internal operations that can be used at compile time to be faster than user operations used at runtime.
String() is an internal function, so it is very fast, while .toString() needs to query the function in the prototype, so it is not as fast. new String() is used to return an exact copy;
13. Convert floating point numbers to integers. This is more error-prone. Many people like to use parseInt(). In fact, parseInt() is used to convert strings into numbers, not between floating point numbers and integers. We should Use Math.floor() or Math.round().
14. String traversal operation
To perform loop operations on strings, such as replacement and search, regular expressions should be used, because the loop speed of JavaScript itself is relatively slow, and the operation of regular expressions is an API written in C language, and the performance is very good;
15. Timer
If you are targeting code that is constantly running, you should not use setTimeout, but setInterval. setTimeout needs to reset a timer every time;
Updating..., please stay tuned!