Detailed interpretation of JSONP principles

The editor below recommends an analysis based on JSONP principles, which has a good reference value and I hope it will be helpful to everyone. Let’s follow the editor and take a look.

Preface

The first project I came into contact with since I started working was the front-end and back-end separation, and the front-end was static The file has its own independent domain name, and 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 the html page that are not subject to crossing. 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.

Creating script tags

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

1. The file is used in this element. Start downloading when added to 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 needs to determine whether there is a callback parameter. If so, it needs to be included in the returned Add a method name and parentheses outside the 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 is normal When returning, 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 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 cleanup, 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 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

The above is what I compiled for everyone. I hope it will be helpful to everyone in the future.

Related articles:

How to implement explicit conversion and implicit conversion in javascript

How to use Redux architecture in ReactNative

What problems do you encounter when using MathJax in Angular?

Using NodeJS to write crawler examples

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