Implementation principle of JSONP

This time I will bring you the implementation principle of JSONP, what are the precautions when using JSONP, the following is a practical case, let's take a look.

The implementation principle of JSONP

I believe that many people who are engaged in front-end and back-end separation are often exposed to JSONP. However, many novices do not know how to implement JSONP and its implementation principle. , this article will introduce it to you in detail. If you are interested, take a look.

Fundamental

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", and 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 operates normally.

Quote1 ensures that the main thread will not be blocked when making a JSONP request. Quote 2 ensures that there will be no errors when the JSONP code is executed immediately after loading.

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 parentheses outside the returned data. For example, 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 piece of self-executing code, and only one function of this code is 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 have declared. If the server returns normally, 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 the code of jsonp1, jsonp2, etc. being accumulated in sequence?

This is because many 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.

Therefore, 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 cleanup, there is another important point that needs to be dealt 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

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

How to pass parameters between vue-router components

Vue.js mobile component library Instructions

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