【问题标题】:How do I promisify native XHR?我如何承诺原生 XHR?
【发布时间】:2020-03-12 19:24:42
【问题描述】:

我想在我的前端应用程序中使用(原生)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);
});

【问题讨论】:

标签: javascript xmlhttprequest promise


【解决方案1】:

我假设你知道如何发出原生 XHR 请求(你可以复习herehere

由于any browser that supports native promises 也将支持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 构造函数接受一个函数,该函数将传递两个参数(我们称它们为resolvereject)。您可以将这些视为回调,一个代表成功,一个代表失败。例子很棒,让我们用这个构造函数更新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)。

【讨论】:

  • 您可能还想为responseType、身份验证、凭据、timeout... 添加选项,而params 对象应该支持 blobs/bufferviews 和 FormData 实例
  • 拒绝时返回一个新的错误会更好吗?
  • 此外,在错误时返回 xhr.statusxhr.statusText 是没有意义的,因为在这种情况下它们是空的。
  • 这段代码似乎像宣传的那样工作,除了一件事。我预计将参数传递给 GET 请求的正确方法是通过 xhr.send(params)。但是,GET 请求会忽略发送到 send() 方法的任何值。相反,它们只需要成为 URL 本身的查询字符串参数。因此,对于上述方法,如果您希望将“params”参数应用于 GET 请求,则需要修改例程以识别 GET 与 POST,然后有条件地将这些值附加到传递给 xhr 的 URL .open().
  • 应该使用resolve(xhr.response | xhr.responseText); 同时在大多数浏览器中,repsonse 在 responseText 中。
【解决方案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
    });

【讨论】:

  • @MadaraUchiha 我猜这是它的 tl;dr 版本。它为 OP 提供了对他们问题的答案,仅此而已。
  • POST 请求的主体在哪里?
  • @crl 就像在常规 XHR 中一样:xhr.send(requestBody)
  • 我喜欢这个答案,因为它提供了非常简单的代码,可以立即使用它来回答问题。
  • 最佳答案。简单有效。还有其他人想知道,要将响应转换为 JSON,只需使用 JSON.parse(e.target.response)
【解决方案3】:

对于现在搜索此内容的任何人,您都可以使用fetch 函数。 它有一些相当不错的support

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

我首先使用了@SomeKittens 的答案,但后来发现fetch 开箱即用:)

【讨论】:

【解决方案4】:

我认为我们可以通过不创建XMLHttpRequest 对象来使the top answer 更加灵活和可重用。这样做的唯一好处是我们不必自己编写 2 或 3 行代码来完成它,而且它的巨大缺点是剥夺了我们对许多 API 功能的访问权限,例如设置标头。它还从应该处理响应的代码中隐藏了原始对象的属性(对于成功和错误)。因此,我们只需接受XMLHttpRequest 对象作为input 并将其作为result 传递,就可以制作出更灵活、更广泛适用的函数。

此函数将任意XMLHttpRequest对象转换为promise,默认将非200状态码视为错误:

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();
    });
}

此函数非常自然地适合Promises 链,而不会牺牲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);
});

【讨论】:

  • 这应该是投票率最高的答案,因为它使代码干净
【解决方案5】:

在我看来,jpmc26 的答案非常接近完美。不过,它也有一些缺点:

  1. 它只在最后一刻公开 xhr 请求。这不允许POST-requests 设置请求正文。
  2. 由于关键的send-call 隐藏在函数中,因此更难阅读。
  3. 它在实际发出请求时引入了相当多的样板文件。

Monkey 修补 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.'));

当然,这带来了一个不同的缺点:Monkey-patching 确实会损害性能。但是,假设用户主要等待 xhr 的结果,请求本身比设置调用花费的时间长几个数量级,并且 xhr 请求不经常发送,这应该不是问题。

PS:当然,如果针对现代浏览器,请使用 fetch!

PPS:在 cmets 中已经指出,此方法更改了标准 API,这可能会造成混淆。为了更清楚起见,可以将不同的方法修补到 xhr 对象sendAndGetPromise()

【讨论】:

  • 我避免使用猴子补丁,因为它令人惊讶。大多数开发人员期望标准 API 函数名称调用标准 API 函数。这段代码仍然隐藏了实际的send 调用,但也会让知道send 没有返回值的读者感到困惑。使用更显式的调用可以更清楚地表明已经调用了附加逻辑。我的答案确实需要调整以处理send 的参数;不过,现在使用fetch 可能会更好。
  • 我想这取决于。如果您返回/公开 xhr 请求(无论如何这似乎很可疑),那么您是绝对正确的。但是我不明白为什么人们不会在模块中这样做并且只公开结果承诺。
  • 我特别指的是任何必须维护你在其中执行的代码的人。
  • 就像我说的:这取决于。如果您的模块太大以至于 promisify 函数在其余代码之间丢失,那么您可能会遇到其他问题。如果您有一个模块,您只想调用一些端点并返回承诺,我认为没有问题。
  • 我不同意这取决于您的代码库的大小。看到一个标准的 API 函数做一些不同于标准行为的事情是令人困惑的。
【解决方案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 polyfill:

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,因此您还需要对它进行 polyfill,这可以使用 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]-->

【讨论】:

  • 在拒绝承诺后处理 catch 块中的所有 400 个响应会很好,因此您应该将 if 语句更改为 && 运算符 (xhr.status&gt;=200 &amp;&amp; xhr.status&lt;400) 否则所有 400 个响应都将落入第一个语句并且总是说实话。
  • 这是一个偏好问题。我认为 fetch() 的工作方式相同,并且不会拒绝返回 400+ 状态代码的承诺。这对我来说是最有意义的,因为从技术上讲,如果 HTTP 请求收到响应而不是被拒绝,即使该响应是 400+ 状态代码,承诺也已实现。
  • 确实很有道理。你是对的,fetch 不会拒绝 400+。
猜你喜欢
  • 1970-01-01
  • 2014-12-29
  • 2015-03-23
  • 1970-01-01
  • 2018-04-26
  • 2017-07-16
  • 2020-04-06
  • 1970-01-01
  • 2016-10-16
相关资源
最近更新 更多