Detailed explanation based on JSONP principle

This article mainly recommends an analysis based on JSONP principles, which has good reference value. I hope it will be helpful to everyone. Let’s follow the editor to take a look, I hope it can help everyone.

Preface

The first project I came into contact with since working was the separation of front-end and back-end. The front-end static files have their own independent domain names, and the data is obtained through the interface for rendering and other operations.

There is no need to say much about cross-domain methods. If you search casually, there are many, but the most commonly used ones are jsonp and CORS. jsonp focuses on the front-end, which can be regarded as front-end Hack skills. CORS is more important than the back-end, and the server needs to be configured more.

This article analyzes the implementation principle of jsonp.

Basic Principle

The basic principle is easy to explain. There are some tags in HTML pages that are not subject to cross-domain restrictions, such as img, script, link, etc. If we put the data we need in a js file, then we can break through the browser's same-origin limitation.

Create script tag

Dynamic script elements are mentioned in "High Performance JavaScript". The author writes:

1. The file starts downloading when the element is added to the page. . The key point of this technology is that whenever a download is initiated, the download and execution of the file does not block other processes on the page.

2. When using dynamic script nodes to download files, the returned code will usually be executed immediately (except for Firefox and Oprea, which will wait for all previous dynamic script nodes to complete execution.) When the script executes itself, this mechanism Operating normally.

Quote 1 ensures that the main thread will not be blocked when making JSONP requests. Quote 2 ensures that there will be no errors when the JSONP code executes itself immediately after loading is completed.

callback

After receiving the GET request, the server usually determines whether there is a callback parameter. If so, it needs to add a method name and brackets outside the returned data. For example, if you initiate the following request:

http://www.a.com/getSomething?callback=jsonp0

, then the server will return the following content:

jsonp0({code:200,data:{}})

Obviously, since this is the content contained in the dynamically loaded Script tag, then this is a paragraph Self-executing code, this code only has one function called - jsonp0.

Of course, if there is execution, it must be created first, otherwise an error will be reported. This step of creation needs to be executed before calling.

The specific implementation is as follows:

function jsonp (url, successCallback, errorCallback, completeCallback) {

 // 声明对象，需要将函数声明至全局作用域
 window.jsonp0 = function (data) {
  successCallback(data);
  if (completeCallback) completeCallback();
 }
 // 创建script标签，并将url后加上callback参数
 var 
  script = document.createElement('script')
  , url = url + (url.indexOf('?') == -1 ? '?' : '&') + 'callback=jsonp0'
 ;
 script.src = url;
 document.head.parentNode.insertBefore(script, document.head);
 // 等到script加载完毕以后，就会自己执行
}

The above basically completes the core of a jsonp method. At this time, jsonp0 is a function we declared. If the server returns normally, it will The jsonp0 function will be executed, and the successCallback callback inside will also be executed.

Improve it

In actual situations, there are usually many jsonp requests being called at the same time.

So since jsonp0 can meet our needs, why do we often see What about the codes that add jsonp1, jsonp2, etc. in sequence?

This is because the requests may be made asynchronously. When the jsonp method is executed for the first time, window.jsonp0 is function A. At this time, the js file is loaded. When js is not loaded, the jsonp method is called again. At this time, window.jsonp0 points to function B. Then after the two js are loaded, the second callback will be executed.

So, we need to make a distinction in the name of the callback, and accumulation can meet the needs.

Modify the code:

var jsonpCounter = 0;
function jsonp (url, successCallback, errorCallback, completeCallback) {
 
 var jsId = 'jsonp' + jsonpCounter++;
 
 // 声明对象，需要将函数声明至全局作用域
 window[jsId] = function (data) {
  successCallback(data);
  if (completeCallback) completeCallback();
  clean();
 }
 // 创建script标签，并将url后加上callback参数
 var 
  script = document.createElement('script')
  , url = url + (url.indexOf('?') == -1 ? '?' : '&') + 'callback=' + jsId
 ;
 script.src = url;
 document.head.parentNode.insertBefore(script, document.head);
 // 等到script加载完毕以后，就会自己执行
 
 //在执行完我们这个方法以后，会有很多script标签出现在head之前，我们需要手动的删除掉他们。
 function clean () {
  script.parentNode.removeChild(script);
  window[jsId] = function(){};
 }
}

After adding accumulation and cleaning, there is still an important place to deal with, which is the error callback. Normally, when we request jsonp, we will set a timeout. If this time is exceeded, a timeout exception will be thrown.

The implementation is as follows:

var jsonpCounter = 0;
function jsonp (url, successCallback, errorCallback, completeCallback, timeout) {
 // 略去上面写过的代码
 var 
  timeout = timeout || 10000
  , timer
 ;
 if (timeout) {
  timer = setTimeout(function () {
   if (errorCallback) {
    errorCallback(new Error('timeout'));
   }
   clean();
  }, timeout)
 }
 
 function clean () {
  script.parentNode.removeChild(script);
  window[jsId] = function(){};
  if (timer) clearTimeout(timer);
 }
}

In this way, all the functions of jsonp are basically completed, and the rest may require some compatible modifications to be considered a complete jsonp method.

REFER

《High Performance JavaScript》

A jsonp implementation on npm, JSONP

Related recommendations:

Summary of how to use Ajax and jsonp

How native JS implements AJAX and JSONP

##The principles of Jsonp and simple implementation methods

The above is the detailed content of Detailed explanation based on JSONP principle. For more information, please follow other related articles on the PHP Chinese website!