我如何承诺本地XHR？

Question

我想在我的前端应用程序中使用（本机）Promise 来执行 XHR 请求，但又不想出现大型框架的所有愚蠢行为。

我希望我的 xhr 返回一个承诺，但这不起作用（给我：Uncaught TypeError: Promise resolver undefined is not a function）

function makeXHRRequest (method, url, done) {
  var xhr = new XMLHttpRequest();
  xhr.open(method, url);
  xhr.onload = function() { return new Promise().resolve(); };
  xhr.onerror = function() { return new Promise().reject(); };
  xhr.send();
}

makeXHRRequest('GET', 'http://example.com')
.then(function (datums) {
  console.log(datums);
});

Answer 1

我假设您知道如何发出本机 XHR 请求（您可以温习此处和此处)

自 任何支持原生 Promise 的浏览器也将支持 xhr.onload，我们可以跳过所有的 onReadyStateChange 蠢事。让我们退后一步，从使用回调的基本 XHR 请求函数开始：

function makeRequest (method, url, done) {
  var xhr = new XMLHttpRequest();
  xhr.open(method, url);
  xhr.onload = function () {
    done(null, xhr.response);
  };
  xhr.onerror = function () {
    done(xhr.response);
  };
  xhr.send();
}

// And we'd call it as such:

makeRequest('GET', 'http://example.com', function (err, datums) {
  if (err) { throw err; }
  console.log(datums);
});

万岁！这并不涉及任何非常复杂的内容（例如自定义标头或 POST 数据），但足以让我们继续前进。

Promise 构造函数

我们可以像这样构造一个 Promise：

new Promise(function (resolve, reject) {
  // Do some Async stuff
  // call resolve if it succeeded
  // reject if it failed
});

Promise 构造函数接受一个函数，该函数将被传递两个参数（我们称它们为 resolve 和 reject）。您可以将这些视为回调，一个用于成功，一个用于失败。例子很棒，让我们用这个构造函数更新 makeRequest ：

function makeRequest (method, url) {
  return new Promise(function (resolve, reject) {
    var xhr = new XMLHttpRequest();
    xhr.open(method, url);
    xhr.onload = function () {
      if (xhr.status >= 200 && xhr.status < 300) {
        resolve(xhr.response);
      } else {
        reject({
          status: xhr.status,
          statusText: xhr.statusText
        });
      }
    };
    xhr.onerror = function () {
      reject({
        status: xhr.status,
        statusText: xhr.statusText
      });
    };
    xhr.send();
  });
}

// Example:

makeRequest('GET', 'http://example.com')
.then(function (datums) {
  console.log(datums);
})
.catch(function (err) {
  console.error('Augh, there was an error!', err.statusText);
});

现在我们可以利用 Promise 的力量，链接多个 XHR 调用（并且 .catch 将触发错误任一调用）：

makeRequest('GET', 'http://example.com')
.then(function (datums) {
  return makeRequest('GET', datums.url);
})
.then(function (moreDatums) {
  console.log(moreDatums);
})
.catch(function (err) {
  console.error('Augh, there was an error!', err.statusText);
});

我们可以进一步改进这一点，添加 POST/PUT 参数和自定义标头。让我们使用选项对象而不是多个参数，其签名为：

{
  method: String,
  url: String,
  params: String | Object,
  headers: Object
}

makeRequest 现在看起来像这样：

function makeRequest (opts) {
  return new Promise(function (resolve, reject) {
    var xhr = new XMLHttpRequest();
    xhr.open(opts.method, opts.url);
    xhr.onload = function () {
      if (xhr.status >= 200 && xhr.status < 300) {
        resolve(xhr.response);
      } else {
        reject({
          status: xhr.status,
          statusText: xhr.statusText
        });
      }
    };
    xhr.onerror = function () {
      reject({
        status: xhr.status,
        statusText: xhr.statusText
      });
    };
    if (opts.headers) {
      Object.keys(opts.headers).forEach(function (key) {
        xhr.setRequestHeader(key, opts.headers[key]);
      });
    }
    var params = opts.params;
    // We'll need to stringify if we've been given an object
    // If we have a string, this is skipped.
    if (params && typeof params === 'object') {
      params = Object.keys(params).map(function (key) {
        return encodeURIComponent(key) + '=' + encodeURIComponent(params[key]);
      }).join('&');
    }
    xhr.send(params);
  });
}

// Headers and params are optional
makeRequest({
  method: 'GET',
  url: 'http://example.com'
})
.then(function (datums) {
  return makeRequest({
    method: 'POST',
    url: datums.url,
    params: {
      score: 9001
    },
    headers: {
      'X-Subliminal-Message': 'Upvote-this-answer'
    }
  });
})
.catch(function (err) {
  console.error('Augh, there was an error!', err.statusText);
});

可以在 MDN。

或者，您可以使用 fetch API (polyfill）。

Answer 2

这可以像下面的代码一样简单。

请记住，此代码仅在调用 onerror 时触发 reject 回调（仅限网络错误），而不是在 HTTP 状态代码表示一个错误。这也将排除所有其他例外。 IMO，处理这些问题应该由你决定。

此外，建议使用 Error 实例调用 reject 回调，而不是事件本身，但为了简单起见，我保持原样。

function request(method, url) {
    return new Promise(function (resolve, reject) {
        var xhr = new XMLHttpRequest();
        xhr.open(method, url);
        xhr.onload = resolve;
        xhr.onerror = reject;
        xhr.send();
    });
}

调用它可能是这样的：

request('GET', 'http://google.com')
    .then(function (e) {
        console.log(e.target.response);
    }, function (e) {
        // handle errors
    });

Answer 3

对于现在搜索此此此搜索的任何人，您可以使用 fetch 功能。
它具有一些很好的支持。

fetch('http://example.com/movies.json')
  .then(response => response.json())
  .then(data => console.log(data));

我首先使用了 @somekittens的答案，但随后发现了fetch，可以为我提供框架:)

Answer 4

我认为我们可以制作最佳答案通过创建xmlhtttprequest 对象。这样做的唯一好处是，我们不必自己编写2或3行代码即可完成此操作，并且它具有巨大的缺点，即带走我们访问许多API功能（例如设置标头）的障碍。它还将原始对象的属性隐藏在应该处理响应的代码中（对于成功和错误）。因此，我们只需接受xmlhttprequest对象作为 input 并将其作为 result 传递，就可以通过接受XMLHTTPREQUEST对象来制作更灵活，更广泛的功能。

此函数将任意xmlhttprequest对象转换为诺言，将非2000状态代码视为错误：默认情况下：

function promiseResponse(xhr, failNon2xx = true) {
    return new Promise(function (resolve, reject) {
        // Note that when we call reject, we pass an object
        // with the request as a property. This makes it easy for
        // catch blocks to distinguish errors arising here
        // from errors arising elsewhere. Suggestions on a 
        // cleaner way to allow that are welcome.
        xhr.onload = function () {
            if (failNon2xx && (xhr.status < 200 || xhr.status >= 300)) {
                reject({request: xhr});
            } else {
                resolve(xhr);
            }
        };
        xhr.onerror = function () {
            reject({request: xhr});
        };
        xhr.send();
    });
}

此函数非常自然地适合Promise> Promise s的链条，而没有 上面省略了xmlhttprequest api的灵活性

Promise.resolve()
.then(function() {
    // We make this a separate function to avoid
    // polluting the calling scope.
    var xhr = new XMLHttpRequest();
    xhr.open('GET', 'https://stackoverflow.com/');
    return xhr;
})
.then(promiseResponse)
.then(function(request) {
    console.log('Success');
    console.log(request.status + ' ' + request.statusText);
});

catch ，以使示例代码更简单。您应该始终拥有一个，当然我们可以：

Promise.resolve()
.then(function() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', 'https://stackoverflow.com/doesnotexist');
    return xhr;
})
.then(promiseResponse)
.catch(function(err) {
    console.log('Error');
    if (err.hasOwnProperty('request')) {
        console.error(err.request.status + ' ' + err.request.statusText);
    }
    else {
        console.error(err);
    }
});

禁用HTTP状态代码处理并不需要太多的代码更改：

Promise.resolve()
.then(function() {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', 'https://stackoverflow.com/doesnotexist');
    return xhr;
})
.then(function(xhr) { return promiseResponse(xhr, false); })
.then(function(request) {
    console.log('Done');
    console.log(request.status + ' ' + request.statusText);
});

我们的呼叫代码更长，但是从概念上讲，了解正在发生的事情仍然很简单。而且，我们不必仅仅为支持其功能重建整个Web请求API。

我们也可以添加一些便利功能来整理我们的代码：

function makeSimpleGet(url) {
    var xhr = new XMLHttpRequest();
    xhr.open('GET', url);
    return xhr;
}

function promiseResponseAnyCode(xhr) {
    return promiseResponse(xhr, false);
}

然后我们的代码变为：

Promise.resolve(makeSimpleGet('https://stackoverflow.com/doesnotexist'))
.then(promiseResponseAnyCode)
.then(function(request) {
    console.log('Done');
    console.log(request.status + ' ' + request.statusText);
});

Answer 5

我认为JPMC26的答案非常接近完美。不过，它有一些缺点：

1. 它仅直到最后一刻才能公开XHR请求。这不允许发布 - 要求设置请求主体。
2. 当关键 send call隐藏在功能中时，很难读取。
3. 实际提出请求时，它引入了很多样板。

猴子修补XHR-Object可以解决以下问题：

function promisify(xhr, failNon2xx=true) {
    const oldSend = xhr.send;
    xhr.send = function() {
        const xhrArguments = arguments;
        return new Promise(function (resolve, reject) {
            // Note that when we call reject, we pass an object
            // with the request as a property. This makes it easy for
            // catch blocks to distinguish errors arising here
            // from errors arising elsewhere. Suggestions on a 
            // cleaner way to allow that are welcome.
            xhr.onload = function () {
                if (failNon2xx && (xhr.status < 200 || xhr.status >= 300)) {
                    reject({request: xhr});
                } else {
                    resolve(xhr);
                }
            };
            xhr.onerror = function () {
                reject({request: xhr});
            };
            oldSend.apply(xhr, xhrArguments);
        });
    }
}

现在的用法很简单：

let xhr = new XMLHttpRequest()
promisify(xhr);
xhr.open('POST', 'url')
xhr.setRequestHeader('Some-Header', 'Some-Value')

xhr.send(resource).
    then(() => alert('All done.'),
         () => alert('An error occured.'));

当然，这引入了一个不同的缺点：猴子点确实损害了性能。但是，假设用户主要等待XHR的结果，这不是一个问题，即请求本身所需的数量级要比设置呼叫更长，而XHR请求不经常发送。

PS：当然，如果针对现代浏览器，请使用获取！

pps：在评论中指出，此方法更改了可能令人困惑的标准API。为了更好的清晰，可以将不同的方法修补到XHR对象sendandgetPromise（）。

Answer 6

如果您希望代码在旧浏览器中工作，请将其放在 中。 HTML 文档的：

<script>
self.Promise||document.write("<script src=/path/to/promise/polyfill.js><\/script>");
</script>

将 /path/to/promise/polyfill.js 替换为 Promise polyfill 的路径。如果该类还不是本机的，这将创建一个 Promise 类，并允许您的代码在旧浏览器（例如 Internet Explorer）上运行。 Internet Explorer 和其他旧浏览器占据了一小部分市场份额，这可能看起来微不足道，但这仍然意味着数百万用户，因此我不建议完全忽略这些用户。

我可以建议这个 Promise 填充：

https://github.com/stefanpenner/es6-promise/

现在您可以访问 Promise 类了。

如果您希望代码在 IE 6-8 等非常旧的浏览器中工作，您需要使用 onreadystatechange 而不是 onload。这没有什么坏处，因为 onreadystatechange 仍然在所有当前浏览器中使用以实现向后兼容性：

function send_request(xhr, data, timeout) {
    return new Promise(function (resolve, reject) {
        var s, p, i;
        if (data && data.constructor==Object) {// serialize object
            s = "_="+(new Date).getTime();
            for (p in data) if (data.hasOwnProperty(p)) {
                if (!data[p] || data[p].constructor!=Array) {
                    data[p] = [data[p]]
                }
                for (i=0; i<data[p].length; i++) {
                    s+= "&"+encodeuricomponent(p)+"="+encodeuricomponent(data[p][i]);
                }
            }
            data = s;
        }
        xhr.onreadystatechange = function() {
            if (xhr.readyState==4) {
                resolve(xhr);
            }
        }
        xhr.send(data);
        if (timeout) {
            settimeout(function() {
                reject("timeout");
                xhr.abort();
            }, timeout);// milliseconds until timeout
        }
    });
}

xhr = new XMLHttpRequest();
xhr.open("GET", "/some/file", true);
send_request(xhr).then(function(xhr) {
    if (xhr.status>=200 || xhr.status<400) {
        //success
        alert(xhr.responseText);
    }
    else {
        return Promise.reject(xhr.statusText? xhr.status+" "+xhr.statusText: "error");
    }
})

请记住，IE 6 不支持 XMLHttpRequest，因此您还需要对其进行填充，这也可以使用 ActiveX 来完成。您的文档 中类似于以下内容：可能有效：

<!--[if lt IE 7]>
<script>
// This is just an example. Use at your own risk.
function XMLHttpRequest() {
    try {
        return new ActiveXObject("Msxml2.XMLHTTP.6.0")
    }
    catch (e) {
        return new ActiveXObject("Msxml2.XMLHTTP.3.0")
    }
}
</script>
<![endif]-->