A brief summary of basic web page performance optimization rules

Some optimization rules for browser web pages

Page Optimization

Static resource compression

Use build tools (webpack, gulp) to appropriately compress web page static resources such as images, scripts, and styles.

CSS sprites, base64 inline images

Combine the small icons on the site into one image, use CSS to locate and capture the corresponding icons; use inline images appropriately.

Styles are placed at the top and scripts are placed at the bottom

The page is presented gradually. Putting the style at the top can present the page to the user faster. Putting the <script> tag at the top will block the download of resources behind the page.

Use external css and js

Multiple pages reference common static resources, and resource reuse reduces additional HTTP requests.

Avoid images with empty src

Avoid unnecessary http requests.

<!-- Images with empty src will still initiate http requests-->
<img src="" alt="image" />

Avoid scaling images in HTML

Try to use the specified size of the image as required, instead of loading a large image and then shrinking it.

<!-- The actual image size is 600x300, scaled to 200x100 in HTML -->
<img src="/static/images/a.png" width="200" height="100" alt="image" />

Preload

Setting the preload attribute on the rel of the link tag allows the browser to preload resources before the main rendering mechanism intervenes. This mechanism can obtain resources earlier and does not block the initialization of the page.

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document</title>
  <link ref="preload" href="style.css" as="style">
  <link ref="preload" href="main.js" as="script">
  
  <link ref="stylesheet" href="style.css">
</head>
<body>
  
  <script src="main.js"></script>
</body>
</html>

In the example, css and js files are preloaded, and they will be called immediately once they are used in subsequent page rendering.

You can specify the as type to load different types of resources.

style
script
video
audio
image
font
document
...

This method can also preload resources across domains by setting the crossorigin attribute.

<link rel="preload" href="fonts/cicle_fina-webfont.woff2" as="font" type="font/woff2" crossorigin="anonymous">

CSS

Selector

The selectors have the following precedence order from highest to lowest:

ID Selector
Class Selectors
Tag selector
Adjacent Selector

h1 + p{ margin-top: 15px; }

Selects the paragraph that appears immediately after an h1 element. The h1 and p elements have a common parent element.

Child selectors

h1 > strong {color:red;}

Descendant Selectors

h1 em {color:red;}

Wildcard Selector

Attribute Selectors

*[title] {color:red;}
img[alt] {border: 5px solid red;}

Pseudo-class selectors

Selector usage experience:

Give priority to class selectors, which can replace multi-layer tag selectors;
Use ID selectors with caution. Although they are efficient, they are unique on the page, which is not conducive to team collaboration and maintenance.
Make reasonable use of the inheritance of selectors;
Avoid CSS expressions.

Reduce the level of selectors

Based on the priority of the previous selector, you should try to avoid nesting multiple levels of selectors, preferably no more than 3 levels.

.container .text .logo{ color: red; }

/*Change to*/
.container .text-logo{ color: red; }

Streamline page style files and remove unused styles

The browser will perform unnecessary style matching, which will affect the rendering time. In addition, excessively large style files will also affect the loading speed.

Using CSS inheritance to reduce the amount of code

By using the inheritable properties of CSS, the parent element sets the style, and the child element does not need to set it again.

Common inherited properties include: color, font-size, font-family, etc.; non-inherited properties include: position, display, float, etc.

When the attribute value is 0, no unit is added

When the CSS attribute value is 0, no unit is required to reduce the amount of code.

.text{ width: 0px; height: 0px; }

/*Change to*/
.text{ width: 0; height: 0; }

JavaScript

Using event delegation

Use event delegation to bind events to multiple similar DOM elements.

<ul id="container">
  <li class="list">1</li>
  <li class="list">2</li>
  <li class="list">3</li>
</ul>

// Unreasonable way: bind click event to each element $('#container .list').on('click', function() {
  var text = $(this).text();
  console.log(text);
});

// Event delegation method: Use the event bubbling mechanism to delegate events to the parent element$('#container').on('click', '.list', function() {
  var text = $(this).text();
  console.log(text);    
});

It should be noted that although events can be delegated to document when using event delegation, this is unreasonable. One is that it is easy to cause event misjudgment, and the other is that the scope chain search efficiency is low. The closest parent element should be selected as the delegate object.

In addition to better performance, event delegation also eliminates the need to bind events to dynamically created DOM elements.

DOMContentLoaded

You can start processing the DOM tree after the DOM elements are loaded (DOMContentLoaded), without having to wait until all image resources are downloaded.

// Native javascript
document.addEventListener("DOMContentLoaded", function(event) {
  console.log("DOM fully loaded and parsed");
}, false);

// jquery
$(document).ready(function() {
  console.log("ready!");
});

// A simplified version of $(document).ready()$(function() {
  console.log("ready!");
});

Preloading and lazy loading

Preloading

Use the browser's idle time to preload resources that may be used in the future, such as images, styles, and scripts.

Unconditional preloading

Once onload is triggered, immediately obtain the resources that will be needed in the future.

Preload image resources. (3 ways to implement image preloading).

Preloading based on user behavior

Determine the possible operations of user behavior and preload resources that may be needed in the future.

When the user types in the search input box, preload the resources that may be used in the search results page;
When a user operates a Tab, one of them is displayed by default. When the user clicks other options, the resources that will be used in the future can be loaded when the mouse hovers over them.

Lazy Loading

Except for the content or components required for page initialization, all others can be loaded lazily, such as JS libraries for cutting images, images that are not in the visible range, etc.

Lazy loading of images. (Judge whether the image is within the visible area. If so, assign the real path to the image)

Avoiding global lookups

Any non-local variable that is used more than once in a function should be made a local variable.

function updateUI(){
  var imgs = document.getElementsByTagName("img");
  for (var i=0, len=imgs.length; i < len; i++){
    imgs[i].title = document.title + " image " + i;
  }
  var msg = document.getElementById("msg");
  msg.innerHTML = "Update complete.";
}

The document global variable is used many times in the above function, especially in the for loop. Therefore, it is a better solution to store the document global variable as a local variable and then use it.

function updateUI(){
  var doc = document;
  var imgs = doc.getElementsByTagName("img");
  for (var i=0, len=imgs.length; i < len; i++){
    imgs[i].title = doc.title + " image " + i;
  }
  var msg = doc.getElementById("msg");
  msg.innerHTML = "Update complete.";
}

One thing worth noting is that in JavaScript code, any variable that is not declared using var will become a global variable, and improper use will cause performance problems.

Avoid unnecessary property queries

Using variables and arrays is more efficient than accessing properties on objects, because the object must search the prototype chain for a property with that name.

// Using array var values = [5, 10];
var sum = values[0] + values[1];
alert(sum);

// Using objects var values = { first: 5, second: 10};
var sum = values.first + values.second;
alert(sum);

In the above code, object properties are used for calculation. A single or two property lookup will not cause performance problems, but if multiple lookups are required, such as in a loop, performance will be affected.

When looking up multiple properties to obtain a single value, such as:

var query = window.location.href.substring(window.location.href.indexOf("?"));

Should reduce unnecessary property lookups, caching window.location.href as a variable.

var url = window.location.href;
var query = url.substring(url.indexOf("?"));

Function throttling

Suppose there is a search box, bind the onkeyup event to the search box, so that a request will be sent every time the mouse is lifted. The use of throttling functions can ensure that multiple consecutive operations within a specified time during user input only trigger one request.

<input type="text" id="input" value="" />

// Bind event document.getElementById('input').addEventListener('keyup', function() {
  throttle(search);
}, false);

//Logical function function search() {
  console.log('search...');
}

//Throttling function function throttle(method, context) {
  clearTimeout(method.tId);
  method.tId = setTimeout(function() {
    method.call(context);
  }, 300);
}

The application scenarios of throttling functions are not limited to search boxes. For example, throttling functions should be used to improve performance in page scrolling, onscroll, and stretching window onresize.

Minimize the number of statements

The number of statements also affects the speed of operation execution.

Merge multiple variable declarations into one

// Use multiple var declarations var count = 5;
var color = "blue";
var values = [1,2,3];
var now = new Date();

// After improvement var count = 5,
  color = "blue",
  values = [1,2,3],
  now = new Date();

An improved version would be to use just one var declaration, separated by commas. When there are many variables, using only one var declaration is much faster than declaring each var separately.

Using array and object literals

Use array and object literals instead of statement-by-statement assignment.

var values = new Array();
values[0] = 123;
values[1] = 456;
values[2] = 789;

// After improvement var values = [123, 456, 789];

var person = new Object();
person.name = "Jack";
person.age = 28;
person.sayName = function(){
  alert(this.name);
};

// Improved var person = {
  name : "Jack",
  age: 28,
  sayName : function(){
    alert(this.name);
  }
};

String Optimization

String concatenation

Early browsers did not optimize the method of concatenating strings with plus signs. Since strings are immutable, this means that an intermediate string must be used to store the result, so frequent creation and destruction of strings is the reason why it is inefficient.

var text = "Hello";
text+= " ";
text+= "World!";

Adding the string to the array and then calling the array's join method to convert it to a string avoids the use of the addition operator.

var arr = [],
  i = 0;
arr[i++] = "Hello";
arr[i++] = " ";
arr[i++] = "World!";
var text = arr.join('');

Modern browsers have optimized string concatenation with the addition operator, so in most cases, the addition operator is still the preferred choice.

Reduce reflows and repaints

The browser rendering process involves reflow and redrawing, which is a performance-consuming process. You should pay attention to reducing actions that trigger reflow and redrawing during script operations.

Reflow: The geometric properties of the element have changed and the rendering tree needs to be rebuilt. The process of rendering tree changes is called reflow;
Repaint: The geometric size of the element has not changed, but the CSS style (background color or color) of an element has changed.

What actions trigger a reflow or repaint?

Resize the window
Modify font
Adding or removing style sheets
Content changes, such as when a user enters text in an <input/> box
Manipulating class attributes
Script operations on DOM (adding, deleting or modifying DOM elements)
Calculating the offsetWidth and offsetHeight properties
Set the value of the style attribute

How to reduce reflow and repaint to improve web page performance?

1. Script operations on DOM elements

Setting the DOM element to display:none will trigger a reflow during the setting process, but it can be modified at will and displayed after the modification;
Clone the element into memory and then operate on it, then replace the element after modification.

2. Modify the style of the element

Try to modify in batches rather than one by one;
Set the id and class in advance, and then set the className of the element.

3. When adding animation to an element, set the element’s CSS style to position:fixed or position:absolute. This will prevent the element from reflowing after it leaves the document flow.

4. Use the throttling function (mentioned above) when adjusting window size, inputting input boxes, scrolling pages, etc.

HTTP

Browser Cache

Reasonable setting of browser cache is one of the important means of web page optimization.

Expires and Cache-Control

Expires comes from HTTP1.0, and Cache-Control comes from HTTP1.1. When both are set at the same time, Cache-Control will override Expires.

Expires specifies the actual expiration date rather than a number of seconds. But Expires has some problems, such as server time being out of sync or inaccurate. So it is better to express the expiration time as the remaining seconds rather than the absolute time.
Cache-Control can set the max-age value in seconds to specify the cache expiration time. For example: Cache-Control: max-age=3600.

ETag and Last-Modified

Both ETag and Last-Modified are returned by the server in the response headers, where ETag has a higher priority than Last-Modified, which means that the server will prioritize the ETag value.

ETag is an arbitrary label attached to a document, which may be a serial number or version number of the document, or a checksum of the document content. When the document changes, the ETag value will also change. Related to ETag is If-None-Match. When the browser initiates a request, it will send the ETag value to the server in the If-None-Match field.
Last-Modified is the time when the document was last modified on the server. Related to Last-Modified is If-Modified-Since. When the browser initiates a request, it sends the Last-Modified value to the server in the If-Modified-Since field.

Strong caching and negotiated caching

The cache types are strong cache and negotiated cache. The difference between the two is that the strong cache will not send a request to the server, while the negotiated cache will send a request. If the match is successful, 304 Not Modified will be returned, and if the match is unsuccessful, 200 will be returned. The browser will first check the strong cache. If the strong cache does not hit, it will then perform a negotiated cache check.

How to configure browser cache

Add Expires and Cache-Control to the response returned by the web server;
Configure Expires and Cache-Control in the nginx or apache configuration file.

Why reduce HTTP requests?

Measures to reduce http requests account for a large part of performance optimization, such as: using CSS sprites instead of multiple image requests, avoiding images with empty src, using inline images, using externally linked CSS and JS, caching, etc.

The process from entering the URL to the page loading is as follows:

DNS resolution
TCP Connection
HTTP Request and Response
The browser renders the page
Close the connection

A complete http request has to go through these processes, which is time-consuming and resource-consuming, so it becomes necessary to reduce the number of requests.

References:

High-Performance Website Construction vs. High-Performance Website Construction Advanced Guide
JavaScript Advanced Programming (Third Edition)
HTTP Definitive Guide
Best Practices for Speeding Up Your Web Site

The above is the full content of this article. I hope it will be helpful for everyone’s study. I also hope that everyone will support 123WORDPRESS.COM.

<<: isPrototypeOf Function in JavaScript

>>: Comprehensive analysis of MySql master-slave replication mechanism

idea combines docker to realize image packaging and one-click deployment

A brief summary of basic web page performance optimization rules

idea combines docker to realize image packaging and one-click deployment

WeChat applet to achieve automatic video playback imitating GIF animation effect example

Problem analysis of using idea to build springboot initializer server

How to set mysql5.7 encoding set to utf8mb4

Detailed analysis of compiling and installing vsFTP 3.0.3

Practical method of deleting a row in a MySql table

Using HTML+CSS to track mouse movement

Mysql 5.6 adds a method to modify username and password

The vue configuration file automatically generates routing and menu instance code

A graphic tutorial on how to install MySQL in Windows

Recommend

Docker enables seamless calling of shell commands between container and host

This article will help you thoroughly understand the specific use of cgroup in Docker

Interviewers often ask questions about React's life cycle

Centos6.9 installation Mysql5.7.18 step record

Specific implementation methods of MySQL table sharding and partitioning

Nginx uses Lua+Redis to dynamically block IP

CentOS 7 builds hadoop 2.10 high availability (HA)

Methods and steps for Etcd distributed deployment based on Docker

MySQL 5.6.23 Installation and Configuration Environment Variables Tutorial

100 ways to change the color of an image using CSS (worth collecting)

Detailed explanation of two quick ways to write console.log in vscode

Mysql uses stored procedures to quickly add millions of data sample code

How to install docker and portainer in kali

MySQL 8.0.12 installation and configuration method graphic tutorial (windows10)

Docker automated build Automated Build implementation process diagram