search

Home  >  Article  >  Web Front-end  >  Detailed explanation of jQuery's Read() method instead of native JS

Detailed explanation of jQuery's Read() method instead of native JS

高洛峰
高洛峰Original
2016-12-07 14:00:17953browse

Before the jQuery 3.0 version, the classic usage of ready was to use an anonymous function, like this: 

$(document).ready(function() {
 // Handler for .ready() called.
});

jQuery 3.0 ready() changes

Before the release of jQuery 3.0, there were the following methods called ready method:

Operating on document elements: $(document).ready(handler);

Operating on empty elements: $().ready(handler);

Or directly (that is, not on a specific element ) Operation: $(handler);

All named variants above are functionally equivalent. No matter which element it is, its specified handler will be called after the DOM is loaded. In other words, the completion of DOM loading here does not mean that a specific element in the document, such as the img element, has been loaded. On the contrary, what it means here is that the entire DOM tree has been loaded.

In jQuery 3.0, all ready methods except $(handler) are deprecated.

Official statement:

This is because the selector is not connected to ready(), which is not only inefficient but also causes the browser engine to make incorrect assumptions about the behavior of this method.

The difference between ready event and load event

The ready event will be triggered when the DOM is loaded and the element can be safely accessed. On the other hand, the load event is triggered after the DOM and all resources are loaded.

You can use the load event as follows: 

$(window).on("load", function(){
 // Handler when all assets (including images) are loaded
});

In this case, not only do you have to wait until the DOM structure can be fully accessed, but you also need to wait until all image resources are completely loaded (the loading time depends on the image file size) to execute the function.

You may not need the load event for normal DOM operations, but if you want to display a rotating loader style before all resources are loaded, for example, or you want to use JS to calculate the size of the image, this Might be a good choice.

You may not need jQuery.ready()

ready method ensures that code is only executed when all DOM elements can be safely manipulated. But what does this mean? This means that when the js code you want to execute is embedded in a certain fragment in HTML, the browser must also load the following elements before it can be executed.

Like the following example:

<!doctype html>
<html>
 <head>
 <meta charset="utf-8">
 <title>.ready() tutorial</title>
 <script src="https://cdn.jsdelivr.net/jquery/latest/jquery.min.js"></script>
 <script>
  $(function(){ // .ready() callback, is only executed when the DOM is fully loaded
  var length = $("p").length;
  // The following will log 1 to the console, as the paragraph exists.
  // This is the evidence that this method is only called when the
  // DOM is fully loaded
  console.log(length);
  });
 </script>
 </head>
 <body>
 <p>I&#39;m the content of this website</p>
 </body>
</html>

If the javascript code you want to execute is placed at the end of the body, you may not need to use the ready() method, because you may try to manipulate it when the browser parses the javascript And the accessed DOM element has been loaded: 

<!doctype html>
<html>
 <head>
 <meta charset="utf-8">
 <title>.ready() tutorial</title>
 </head>
 <body>
 <p>I&#39;m the content of this website</p>
 <script src="https://cdn.jsdelivr.net/jquery/latest/jquery.min.js"></script>
 <script>
  var length = $("p").length;
  // The following will log 1 to the console, as the paragraph exists.
  console.log(length);
 </script>
 </body>
</html>

Native JavaScript ready() replacement

For modern browsers and IE9+, you can achieve the same function of ready() by listening to the DOMContentLoaded event: 

document.addEventListener("DOMContentLoaded", function(){
 // Handler when the DOM is fully loaded
});

However, please note that if the event has already been emitted, the callback will not be executed. To ensure that the callback always runs, jQuery checks the "readyState" property of the document reference) and executes the callback function immediately if the property value changes to complete: 

var callback = function(){
 // Handler when the DOM is fully loaded
};
 
if (
 document.readyState === "complete" ||
 (document.readyState !== "loading" && !document.documentElement.doScroll)
) {
 callback();
} else {
 document.addEventListener("DOMContentLoaded", callback);
}

includes the domReady library, which has implemented this solution.

Old version of IE browser

For IE8 and below browsers, you can use the onreadystatechange event to monitor the readyState property of the document: 

document.attachEvent("onreadystatechange", function(){
 // check if the DOM is fully loaded
 if(document.readyState === "complete"){
 // remove the listener, to make sure it isn&#39;t fired in future
 document.detachEvent("onreadystatechange", arguments.callee);
 // The actual handler...
 }
});

Or you can use the Load event, such as jQuery, so that you can Runs on any browser. This also causes a delay as it waits for all assets to be loaded.

Note that in this solution you also check readyState, as mentioned above, to ensure that the callback can always be executed.


Statement：
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Previous article：Analysis of AngularJS Compression JS TechniquesNext article：Analysis of AngularJS Compression JS Techniques

Related articles

See more