High-performance JAVASCRIPT_javascript tips you don't know

This article will share some best practices for efficient JavaScript to improve everyone’s understanding of the underlying and implementation principles of JS.

Data Storage

A classic problem in computer science is to obtain the best read and write performance by changing the location of data storage. In JavaScript, the location of data storage will have a significant impact on code performance. – If you can use {} to create an object, don’t use new Object. If you can use [] to create an array, don’t use new Array. The access speed of literals in JS is higher than that of objects. – The deeper a variable is in the scope chain, the longer it takes to access it. For this kind of variable, you can save it using local variables through caching to reduce the number of accesses to the scope chain - there is not much difference between using dot notation (object.name) and operator (object[name]), only Safari will There is a difference, click is always faster

Loop

Common loops in JS include the following types:

for(var i = 0; i < 10; i++) { // do something} 
for(var prop in object) { // for loop object}  
[1,2].forEach(function(value, index, array) { // 基于函数的循环})

There is no doubt that the first method is native, has the lowest performance consumption and is the fastest. The second method of for-in will generate more overhead (local variables) for each iteration, and its speed is only 1/7 of the first method. The third method obviously provides a more convenient loop method, but its speed Only 1/8 of the normal cycle. Therefore, you can choose the appropriate recycling method according to your project situation.

Event Delegate

Imagine adding an event to each A tag on the page. Will we add an onClick to each tag? When there are a large number of elements in the page that need to be bound to the same event handler, this situation may affect performance. Each event bound increases the load on the page or during runtime. For a rich front-end application, too many bindings will occupy too much memory on pages with heavy interaction. A simple and elegant way is event delegation. It is an event-based workflow: capture layer by layer, reach the target, and bubble layer by layer. Since there is a bubbling mechanism for events, we can handle events from all child elements by binding events to the outer layer.

document.getElementById('content').onclick = function(e) { 
  e = e || window.event;  
  var target = e.target || e.srcElement;  //如果不是 A标签，我就退出  
  if(target.nodeNmae !=== 'A') { return }  //打印A的链接地址  
  console.log(target.href) }

Redraw and rearrange

After the browser downloads HTMl, CSS, and JS, it will generate two trees: DOM tree and rendering tree. When the geometric properties of the Dom change, such as the width, height, color, and position of the Dom, the browser needs to recalculate the geometric properties of the element and rebuild the rendering tree. This process is called redrawing and rearrangement.

bodystyle = document.body.style; 
bodystyle.color = red; 
bodystyle.height = 1000px; 
bodystyke.width = 100%;

Modifying the three properties in the above method will cause the browser to reflow and redraw three times. In some cases, reducing this reflow can improve browser rendering performance. The recommended method is as follows, only perform one operation and complete three steps:

bodystyle = document.body.style; 
bodystyle.cssText 'color:red;height:1000px;width:100%';

JavaScript loading

IE8, Firefox3.5, and Chrome2 all allow JavaScript files to be downloaded. So 3f1c4e4b6b16bbbd69b2ee476dc4f83a will not block other tags from downloading. Unfortunately, the JS download process will still block the download of other resources, such as pictures. Although the latest browsers have improved performance by allowing parallel downloads, script blocking remains a problem. Therefore, it is recommended to place all 3f1c4e4b6b16bbbd69b2ee476dc4f83a tags at the bottom of the 6c04bd5ca3fcae76e30b72ad730ca86d tag to minimize the impact on the rendering of the entire page and prevent users from seeing a blank

High performance deployment of JS files

Now that everyone knows that multiple 3f1c4e4b6b16bbbd69b2ee476dc4f83a tags will affect the page rendering speed, it is not difficult to understand that "reducing the HTTP required for page rendering" is a classic rule for improving website speed. Therefore, merging all JS files in a production environment will reduce the number of requests and thus speed up page rendering. In addition to merging JS files, we can also compress JS files. Compression refers to stripping away parts of a file that are not relevant to running the file. Stripped content includes whitespace characters, and comments. The modification process can usually reduce the file size by half. There are also some compression tools that will reduce the length of local variables, such as:

var myName = "foo" + "bar"; 
//压缩后变成 
var a = "foobar";

Caching JS files

Caching HTTP components can greatly improve the user experience of return visits to the website. The web server uses the "Expires HTTP response header" to tell the client how long a resource should be cached. Of course, caching has its own drawbacks: when your application is upgraded, you need to ensure that users download the latest static content. This problem can be solved by changing the file name of the static resources. You may see the browser referencing jsapplication-20151123201212.js in the production environment. This saves the new JS file as a timestamp to solve the problem of cache not being updated.

Summary

Of course, efficient JS does not only have these areas that can be improved. If we can reduce some performance losses, we can use JavaScript to develop more efficiently.

Everything you didn’t know about high-performance JAVASCRIPT, now you know it!