• JavaScript Ajax + Promise

    AJAX

    在现代浏览器上写AJAX主要依靠XMLHttpRequest对象：

    function success(text) {
   var textarea = document.getElementById('test-response-text');
   textarea.value = text;
}
function fail(code) {
   var textarea = document.getElementById('test-response-text');
   textarea.value = 'Error code: ' + code;
}
var request = new XMLHttpRequest(); // 新建XMLHttpRequest对象
request.onreadystatechange = function () { // 状态发生变化时，函数被回调
   if (request.readyState === 4) { // 成功完成
       // 判断响应结果:
       if (request.status === 200) {
           // 成功，通过responseText拿到响应的文本:
           return success(request.responseText);
       } else {
           // 失败，根据响应码判断失败原因:
           return fail(request.status);
       }
   } else {
       // HTTP请求还在继续...
   }
}
// 发送请求:
request.open('GET', '/api/categories');
request.send();
alert('请求已发送，请等待响应...');

    如果想把标准写法和IE写法混在一起，可以这么写：

    var request;
if (window.XMLHttpRequest) {
    request = new XMLHttpRequest();
} else {
    request = new ActiveXObject('Microsoft.XMLHTTP');
}

    通过检测window对象是否有XMLHttpRequest属性来确定浏览器是否支持标准的XMLHttpRequest。注意，不要根据浏览器的navigator.userAgent来检测浏览器是否支持某个JavaScript特性，一是因为这个字符串本身可以伪造，二是通过IE版本判断JavaScript特性将非常复杂。

    当创建了XMLHttpRequest对象后，要先设置onreadystatechange的回调函数。在回调函数中，通常我们只需通过readyState === 4判断请求是否完成，如果已完成，再根据status === 200判断是否是一个成功的响应。

    XMLHttpRequest对象的open()方法有3个参数，第一个参数指定是GET还是POST，第二个参数指定URL地址，第三个参数指定是否使用异步，默认是true，所以不用写。注意，千万不要把第三个参数指定为false，否则浏览器将停止响应，直到AJAX请求完成。 最后调用send()方法才真正发送请求。GET请求不需要参数，POST请求需要把body部分以字符串或者FormData对象传进去。

    安全限制JSONP

    默认情况下，JavaScript在发送AJAX请求时，URL的域名必须和当前页面完全一致。

    完全一致的意思是，域名要相同 (www.example.com和example.com不同) ，协议要相同（http和https不同），端口号要相同（默认是:80端口，它和:8080就不同）。有的浏览器口子松一点，允许端口不同，大多数浏览器都会严格遵守这个限制。

    JSONP，它有个限制，只能用GET请求，并且要求返回JavaScript。这种方式跨域实际上是利用了浏览器允许跨域引用JavaScript资源：

    <html><head>
    <script src="http://example.com/abc.js"></script>
    ...</head><body>...</body></html>

    JSONP通常以函数调用的形式返回，例如，返回JavaScript内容如下：

    foo('data');

    这样一来，我们如果在页面中先准备好foo()函数，然后给页面动态加一个<script>节点，相当于动态读取外域的JavaScript资源，最后就等着接收回调了。

    以163的股票查询URL为例，对于URL：http://api.money.126.net/data/feed/0000001,1399001?callback=refreshPrice，你将得到如下返回：

    refreshPrice({"0000001":{"code": "0000001", ... });

    因此我们需要首先在页面中准备好回调函数：

    function refreshPrice(data) {
    var p = document.getElementById('test-jsonp');
    p.innerHTML = '当前价格：' +
        data['0000001'].name +': ' + 
        data['0000001'].price + '；' +
        data['1399001'].name + ': ' +
        data['1399001'].price;
}

    最后用getPrice()函数触发：

    function getPrice() {
    var
        js = document.createElement('script'),
        head = document.getElementsByTagName('head')[0];
    js.src = 'http://api.money.126.net/data/feed/0000001,1399001?callback=refreshPrice';
    head.appendChild(js);
}

    就完成了跨域加载数据。

    CORS

    如果浏览器支持HTML5，那么就可以一劳永逸地使用新的跨域策略：CORS了。

    CORS全称Cross-Origin Resource Sharing，是HTML5规范定义的如何跨域访问资源。

    了解CORS前，我们先搞明白概念：

    Origin表示本域，也就是浏览器当前页面的域。当JavaScript向外域（如sina.com）发起请求后，浏览器收到响应后，首先检查Access-Control-Allow-Origin是否包含本域，如果是，则此次跨域请求成功，如果不是，则请求失败，JavaScript将无法获取到响应的任何数据。

    用一个图来表示就是：

    假设本域是my.com，外域是sina.com，只要响应头Access-Control-Allow-Origin为http://my.com，或者是*，本次请求就可以成功。

    可见，跨域能否成功，取决于对方服务器是否愿意给你设置一个正确的Access-Control-Allow-Origin，决定权始终在对方手中。

    上面这种跨域请求，称之为“简单请求”。简单请求包括GET、HEAD和POST（POST的Content-Type类型 仅限application/x-www-form-urlencoded、multipart/form-data和text/plain），并且不能出现任何自定义头（例如，X-Custom: 12345），通常能满足90%的需求。

    无论你是否需要用JavaScript通过CORS跨域请求资源，你都要了解CORS的原理。最新的浏览器全面支持HTML5。在引用外域资源时，除了JavaScript和CSS外，都要验证CORS。例如，当你引用了某个第三方CDN上的字体文件时：

    /* CSS */@font-face {  font-family: 'FontAwesome';
  src: url('http://cdn.com/fonts/fontawesome.ttf') format('truetype');}

    如果该CDN服务商未正确设置Access-Control-Allow-Origin，那么浏览器无法加载字体资源。

    对于PUT、DELETE以及其他类型如application/json的POST请求，在发送AJAX请求之前，浏览器会先发送一个OPTIONS请求（称为preflighted请求）到这个URL上，询问目标服务器是否接受：

    OPTIONS /path/to/resource HTTP/1.1
Host: bar.com
Origin: http://my.com
Access-Control-Request-Method: POST

    服务器必须响应并明确指出允许的Method：

    HTTP/1.1 200 OK
Access-Control-Allow-Origin: http://my.com
Access-Control-Allow-Methods: POST, GET, PUT, OPTIONS
Access-Control-Max-Age: 86400

    浏览器确认服务器响应的Access-Control-Allow-Methods头确实包含将要发送的AJAX请求的Method，才会继续发送AJAX，否则，抛出一个错误。

    由于以POST、PUT方式传送JSON格式的数据在REST中很常见，所以要跨域正确处理POST和PUT请求，服务器端必须正确响应OPTIONS请求。

    Promise

    在JavaScript的世界中，所有代码都是单线程执行的。

    由于这个“缺陷”，导致JavaScript的所有网络操作，浏览器事件，都必须是异步执行。异步执行可以用回调函数实现：

    function callback() {
    console.log('Done');
}
console.log('before setTimeout()');
setTimeout(callback, 1000); // 1秒钟后调用callback函数console.log('after setTimeout()');

    观察上述代码执行，在Chrome的控制台输出可以看到：

    before setTimeout()
after setTimeout()
(等待1秒后)
Done

    可见，异步操作会在将来的某个时间点触发一个函数调用。

    AJAX就是典型的异步操作。以上一节的代码为例：

    request.onreadystatechange = function () {
    if (request.readyState === 4) {
        if (request.status === 200) {
            return success(request.responseText);
        } else {
            return fail(request.status);
        }
    }
}

    把回调函数success(request.responseText)和fail(request.status)写到一个AJAX操作里很正常，但是不好看，而且不利于代码复用。

    有没有更好的写法？比如写成这样：

    var ajax = ajaxGet('http://...');
ajax.ifSuccess(success)
    .ifFail(fail);

    这种链式写法的好处在于，先统一执行AJAX逻辑，不关心如何处理结果，然后，根据结果是成功还是失败，在将来的某个时候调用success函数或fail函数。

    古人云：“君子一诺千金”，这种“承诺将来会执行”的对象在JavaScript中称为Promise对象。

    Promise有各种开源实现，在ES6中被统一规范，由浏览器直接支持。

    new Promise(function () {});
alert("支持Promise");

    先看一个最简单的Promise例子：生成一个0-2之间的随机数，如果小于1，则等待一段时间后返回成功，否则返回失败：

    function test(resolve, reject) {
    var timeOut = Math.random() * 2;
    log('set timeout to: ' + timeOut + ' seconds.');
    setTimeout(function () {
        if (timeOut < 1) {
            log('call resolve()...');
            resolve('200 OK');
        } else {
            log('call reject()...');
            reject('timeout in ' + timeOut + ' seconds.');
        }
    }, timeOut * 1000);
}

    这个test()函数有两个参数，这两个参数都是函数，如果执行成功，我们将调用resolve('200 OK')，如果执行失败，我们将调用reject('timeout in ' + timeOut + ' seconds.')。可以看出，test()函数只关心自身的逻辑，并不关心具体的resolve和reject将如何处理结果。

    有了执行函数，我们就可以用一个Promise对象来执行它，并在将来某个时刻获得成功或失败的结果：

    var p1 = new Promise(test);
var p2 = p1.then(function (result) {
    console.log('成功：' + result);
});
var p3 = p2.catch(function (reason) {
    console.log('失败：' + reason);
});

    变量p1是一个Promise对象，它负责执行test函数。由于test函数在内部是异步执行的，当test函数执行成功时，我们告诉Promise对象：

    // 如果成功，执行这个函数：
p1.then(function (result) {
    console.log('成功：' + result);
});

    当test函数执行失败时，我们告诉Promise对象：

    p2.catch(function (reason) {
    console.log('失败：' + reason);
});

    Promise对象可以串联起来，所以上述代码可以简化为：

    new Promise(test).then(function (result) {
    console.log('成功：' + result);
}).catch(function (reason) {
    console.log('失败：' + reason);
});

    实际测试一下，看看Promise是如何异步执行的：

    'use strict';

// 清除log:
var logging = document.getElementById('test-promise-log');
while (logging.children.length > 1) {
    logging.removeChild(logging.children[logging.children.length - 1]);
}

// 输出log到页面:
function log(s) {
    var p = document.createElement('p');
    p.innerHTML = s;
    logging.appendChild(p);
}

new Promise(function (resolve, reject) {
    log('start new Promise...');
    var timeOut = Math.random() * 2;
    log('set timeout to: ' + timeOut + ' seconds.');
    setTimeout(function () {
        if (timeOut < 1) {
            log('call resolve()...');
            resolve('200 OK');
        }
        else {
            log('call reject()...');
            reject('timeout in ' + timeOut + ' seconds.');
        }
    }, timeOut * 1000);
}).then(function (r) {
    log('Done: ' + r);
}).catch(function (reason) {
    log('Failed: ' + reason);
});

    输出结果为：

    start new Promise...

    set timeout to: 1.7587399336588674 seconds.

    call reject()...

    Failed: timeout in 1.7587399336588674 seconds.

    可见Promise最大的好处是在异步执行的流程中，把执行代码和处理结果的代码清晰地分离了：

     

    Promise还可以做更多的事情，比如，有若干个异步任务，需要先做任务1，如果成功后再做任务2，任何任务失败则不再继续并执行错误处理函数。

    要串行执行这样的异步任务，不用Promise需要写一层一层的嵌套代码。有了Promise，我们只需要简单地写：

    job1.then(job2).then(job3).catch(handleError);

    其中，job1、job2和job3都是Promise对象。

    下面的例子演示了如何串行执行一系列需要异步计算获得结果的任务：

     
    var logging = document.getElementById('test-promise2-log');
while (logging.children.length > 1) {
    logging.removeChild(logging.children[logging.children.length - 1]);
}

function log(s) {
    var p = document.createElement('p');
    p.innerHTML = s;
    logging.appendChild(p);
}

// 0.5秒后返回input*input的计算结果:
function multiply(input) {
    return new Promise(function (resolve, reject) {
        log('calculating ' + input + ' x ' + input + '...');
        setTimeout(resolve, 500, input * input);
    });
}

// 0.5秒后返回input+input的计算结果:
function add(input) {
    return new Promise(function (resolve, reject) {
        log('calculating ' + input + ' + ' + input + '...');
        setTimeout(resolve, 500, input + input);
    });
}

var p = new Promise(function (resolve, reject) {
    log('start new Promise...');
    resolve(123);
});

p.then(multiply)
 .then(add)
 .then(multiply)
 .then(add)
 .then(function (result) {
    log('Got value: ' + result);
});

    start new Promise...

    calculating 123 x 123...

    calculating 15129 + 15129...

    calculating 30258 x 30258...

    calculating 915546564 + 915546564...

    Got value: 1831093128

    setTimeout可以看成一个模拟网络等异步执行的函数。现在，我们把上一节的AJAX异步执行函数转换为Promise对象，看看用Promise如何简化异步处理：

    // ajax函数将返回Promise对象:
function ajax(method, url, data) {
    var request = new XMLHttpRequest();
    return new Promise(function (resolve, reject) {
        request.onreadystatechange = function () {
            if (request.readyState === 4) {
                if (request.status === 200) {
                    resolve(request.responseText);
                } else {
                    reject(request.status);
                }
            }
        };
        request.open(method, url);
        request.send(data);
    });
}

var log = document.getElementById('test-promise-ajax-result');
var p = ajax('GET', '/api/categories');
p.then(function (text) { // 如果AJAX成功，获得响应内容
    log.innerText = text;
}).catch(function (status) { // 如果AJAX失败，获得响应代码
    log.innerText = 'ERROR: ' + status;
});

    除了串行执行若干异步任务外，Promise还可以并行执行异步任务。

    试想一个页面聊天系统，我们需要从两个不同的URL分别获得用户的个人信息和好友列表，这两个任务是可以并行执行的，用Promise.all()实现如下：

    var p1 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 500, 'P1');
});
    var p2 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 600, 'P2');
});
// 同时执行p1和p2，并在它们都完成后执行then:
Promise.all([p1, p2]).then(function (results) {
    console.log(results); // 获得一个Array: ['P1', 'P2']
});

    有些时候，多个异步任务是为了容错。比如，同时向两个URL读取用户的个人信息，只需要获得先返回的结果即可。这种情况下，用Promise.race()实现：

    var p1 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 500, 'P1');
});
    var p2 = new Promise(function (resolve, reject) {
    setTimeout(resolve, 600, 'P2');
});
Promise.race([p1, p2]).then(function (result) {
    console.log(result); // 'P1'
});

    由于p1执行较快，Promise的then()将获得结果'P1'。p2仍在继续执行，但执行结果将被丢弃。

    如果我们组合使用Promise，就可以把很多异步任务以并行和串行的方式组合起来执行。 

    jQuery ajax

    jQuery在全局对象jQuery（也就是$）绑定了ajax()函数，可以处理AJAX请求。ajax(url, settings)函数需要接收一个URL和一个可选的settings对象，常用的选项如下：

    • async：是否异步执行AJAX请求，默认为true，千万不要指定为false；

    • method：发送的Method，缺省为'GET'，可指定为'POST'、'PUT'等；

    • contentType：发送POST请求的格式，默认值为'application/x-www-form-urlencoded; charset=UTF-8'，也可以指定为text/plain、application/json；

    • data：发送的数据，可以是字符串、数组或object。如果是GET请求，data将被转换成query附加到URL上，如果是POST请求，根据contentType把data序列化成合适的格式；

    • headers：发送的额外的HTTP头，必须是一个object；

    • dataType：接收的数据格式，可以指定为'html'、'xml'、'json'、'text'等，缺省情况下根据响应的Content-Type猜测。

    下面的例子发送一个GET请求，并返回一个JSON格式的数据：

    var jqxhr = $.ajax('/api/categories', {
    dataType: 'json'
});// 请求已经发送了

    不过，如何用回调函数处理返回的数据和出错时的响应呢？

    function ajaxLog(s) {
    var txt = $('#test-response-text');
    txt.val(txt.val() + '
' + s);
}

$('#test-response-text').val('');

var jqxhr = $.ajax('/api/categories', {
    dataType: 'json'
}).done(function (data) {
    ajaxLog('成功, 收到的数据: ' + JSON.stringify(data));
}).fail(function (xhr, status) {
    ajaxLog('失败: ' + xhr.status + ', 原因: ' + status);
}).always(function () {
    ajaxLog('请求完成: 无论成功或失败都会调用');
});

    get

    对常用的AJAX操作，jQuery提供了一些辅助方法。由于GET请求最常见，所以jQuery提供了get()方法，可以这么写：

    var jqxhr = $.get('/path/to/resource', {
        name: 'Bob Lee',    check: 1
    });

    第二个参数如果是object，jQuery自动把它变成query string然后加到URL后面，实际的URL是：

    /path/to/resource?name=Bob%20Lee&check=1

    这样我们就不用关心如何用URL编码并构造一个query string了。

    post

    post()和get()类似，但是传入的第二个参数默认被序列化为application/x-www-form-urlencoded：

    var jqxhr = $.post('/path/to/resource', {
        name: 'Bob Lee',
        check: 1
    });

    实际构造的数据name=Bob%20Lee&check=1作为POST的body被发送。 

    getJSON

    由于JSON用得越来越普遍，所以jQuery也提供了getJSON()方法来快速通过GET获取一个JSON对象：

    var jqxhr = $.getJSON('/path/to/resource', {
    name: 'Bob Lee',
    check: 1}).done(function (data) {
    // data已经被解析为JSON对象了
});

    安全限制

    jQuery的AJAX完全封装的是JavaScript的AJAX操作，所以它的安全限制和前面讲的用JavaScript写AJAX完全一样。

    如果需要使用JSONP，可以在ajax()中设置jsonp: 'callback'，让jQuery实现JSONP跨域加载数据。
  • 相关阅读:
    学习进度笔记
    博雅数据机器学习07
    学习进度笔记
    博雅数据机器学习06
    《一级架构师》阅读笔记
    学习进度笔记
    博雅数据机器学习05
    递归的概念
    CSS学习笔记3：选择器及优先级
    CSS学习笔记2：伪类
  • 原文地址：https://www.cnblogs.com/284628487a/p/5556144.html
Copyright © 2020-2023  润新知