相关疑难解决方法(0)

我编写的代码看起来像:

function getStuffDone(param) {           | function getStuffDone(param) {
    var d = Q.defer(); /* or $q.defer */ |     return new Promise(function(resolve, reject) {
    // or = new $.Deferred() etc.        |     // using a promise constructor
    myPromiseFn(param+1)                 |         myPromiseFn(param+1)
    .then(function(val) { /* or .done */ |         .then(function(val) {
        d.resolve(val);                  |             resolve(val);
    }).catch(function(err) { /* .fail */ |         }).catch(function(err) {
        d.reject(err);                   |             reject(err);
    });                                  |         });
    return d.promise; /* or promise() */ |     });
}                                        | }

有人告诉我这个被称为" 延迟反模式 "或" Promise构造函数反模式 ",这个代码有什么不好,为什么这被称为 …

for (let i = 0; i < 10; i++) {
    const promise = new Promise((resolve, reject) => {
        const timeout = Math.random() * 1000;
        setTimeout(() => {
            console.log(i);
        }, timeout);
    });

    // TODO: Chain this promise to the previous one (maybe without having it running?)
}

以上将给出以下随机输出:

6
9
4
8
5
1
7
2
3
0

任务很简单:确保每个promise只在另一个(.then())之后运行.

出于某种原因,我找不到办法.

我尝试了生成函数(yield),尝试了返回promise的简单函数,但在一天结束时它总是归结为同样的问题:循环是同步的.

使用异步我只是使用async.series().

你是如何解决的？

我想重复执行一个操作,每次操作之间的超时时间增加,直到成功或经过一定的时间.我如何用Q中的承诺来构建它？

我有一些在App.tsx. App.tsx用于Index.tsx渲染并附加到body.

   const IndexPage = lazy(() => import("../features//IndexPage"));
    const TagsPage = lazy(
      () => import("../features/tags/TagsPage")
    );
    const ArticlePage = lazy(() => import("../features/article/ArticlePage"));

    const SearchResultPage = lazy(
      () => import("../features/search-result/SearchResultPage")
    );

    const ErrorPage = lazy(() => import("../features/error/ErrorPage"));

    ----

    <BrowserRouter basename={basename}>
      <Suspense fallback={<Fallback />}>
        <Routes>
          <Route path={INDEX} element={<IndexPage />} />
          <Route path={ARTICLE} element={<ArticlePage />} />
          <Route path={TAGS} element={<TagsPage />} />
          <Route path={SEARCH} element={<SearchResultPage />} />
          <Route path={ERROR} element={<ErrorPage />} />
          <Route path="/*" element={<ErrorPage />} /> …

我有一个功能downloadItem可能会因网络原因而失败，我希望能够在实际拒绝该项目之前重试几次。重试需要超时，因为如果出现网络问题，则立即重试是没有意义的。

这是我到目前为止所拥有的：

function downloadItemWithRetryAndTimeout(url, retry, failedReason) {
    return new Promise(function(resolve, reject) {
        try {
            if (retry < 0 && failedReason != null) reject(failedReason);

            downloadItem(url);
            resolve();
        } catch (e) {
            setTimeout(function() {
                downloadItemWithRetryAndTimeout(url, retry - 1, e);
            }, 1000);
        }
    });
}

显然，这会失败，因为我第二次（以及第二次）打电话时，downloadItemWithRetryAndTimeout我没有按要求返回承诺。

我如何让它与第二个承诺一起正常工作？

PS，如果代码在 NodeJS 中运行很重要。

我想要一些 JavaScript 代码将 3 个东西作为参数：

• 返回 Promise 的函数。
• 最大尝试次数。
• 每次尝试之间的延迟。

我最终做的是使用for循环。我不想使用递归函数：这样，即使有 50 次尝试，调用堆栈也不会长 50 行。

这是代码的打字稿版本：

/**
 * @async
 * @function tryNTimes<T> Tries to resolve a {@link Promise<T>} N times, with a delay between each attempt.
 * @param {Object} options Options for the attempts.
 * @param {() => Promise<T>} options.toTry The {@link Promise<T>} to try to resolve.
 * @param {number} [options.times=5] The maximum number of attempts (must be greater than 0).
 * @param {number} [options.interval=1] The interval …

我仍然是一个Promise noob,我正试图弄清楚如何让我的Promise重演.

如果没有设置某个全局标志,则拒绝ES6.我需要它每500ms重试一次,直到:

• 承诺回归决心,
• 或者达到最大尝试次数(比方说10).

由于Promise是异步的,我真的不想使用setInterval()检查,因为我不认为它可以正常使用异步代码.一旦promise成功解决(或达到超时),我需要检查终止.

我正在使用ES6 + React + ES6 Promises(所以请不要使用Q或Bluebird特定的答案!)

http://jsfiddle.net/2k2kz9r9/8/

// CLASS
class Test extends React.Component {
    constructor() {
      this.state = {
        status: 'setting up..',
      }
    }
    componentDidMount() {
      // TODO: how do I get this to loop with a timeout?
      this.createSlot()
        .then((slot) => {
          this.setState({
            status: slot
          });
        })
        .catch((e) => {
          this.setState({
            status: e.message
          });
        })
    }
    createSlot() {
      return new Promise((resolve, reject) => {
        if (!this.checkIsReady()) {
          reject(new Error('Global isnt ready yet')); …

我有一个函数说myMainFunction是从客户端调用,然后调用mypromisified函数.

场景: mypromisified函数可以间歇性地失败,我需要延迟调用此函数(以指数增长)直到成功或直到达到最大尝试次数.

到目前为止我有什么

以下代码说明了我的场景,并重复直到成功,但它会无限期地尝试,直到达到某些计数

// called once from the client
myMainFuntion();

function rejectDelay(delay, reason) {
   // call main function at a delayed interval until success 
   // but would want to call this only a limited no of times
    setTimeout(() => {
      myMainFuntion(); // calling main function again here but with a delay
    }, delay);
}


function myMainFuntion() {
  var delay = 100;
  var tries = 3;
  tryAsync().catch(rejectDelay.bind(null, delay));
}

function tryAsync() {
  return …

我有一个函数,它返回一个javascript Promise,并在其中运行一些异步代码.异步代码需要在失败的情况下重试几次.我这样做,直到我观察到一些奇怪的行为让我想知道我是否正确行事.所以我不得不改变它.这两种方法都在这里.我知道为什么第一种方法(asyncFunc)不起作用,如果有人可以分享一些技术清晰度,我将不胜感激.对于第二种方法(ayncFunc_newer)有关如何更好地完成任何建议吗？

var _retryCount = 0;

// this is what I was doing
function asyncFunc () {
	return new Promise(function(fulfill, reject) {
		doAsync()
			.then(fulfill)
			.catch(retry);

		function retry(promiseResult) {
			if(_retryCount < 3) {
				_retryCount++;
				return asyncFunc();
			}
			else {
				reject(promiseResult);
			}
		}
	});
}

// this what I'm doing now
function ayncFunc_newer() {
    return new Promise(function(fulfill, reject) {
        var retryCount = 0;

        doAsync()
            .then(fulfill)
            .catch(onReject);

        function onReject(bmAuthError) {
            if(retryCount < 3) {
                retryCount++;
                logWarning(error);
                
                doAsync()
                	.then(fulfill)
                	.catch(onReject);
            }
            else {
                fulfill(false); …

我正在执行 useEffect() 以使用 JSON 数据更新状态。但是，获取请求有时会失败，因此如果发生这种情况，我想重新执行 useEffect 钩子：

...
import React, {useState, useEffect} from 'react';
import {getJsonData} from './getJsonData';

const myApp = () => {
    var ErrorFetchedChecker = false;
    const [isLoading,setIsLoading] = useState(true);
    const [data,setData] = useState(null);

    const updateState = jsonData => {
      setIsloading(false);
      setData(jsonData);
    };

    useEffect(() => {
      //console.log('EXECUTING');
      getJsonData().then(
        data => updateState(data),
        error => {
          Alert.alert('DATA FETCHING ERROR !', 'Refreshing ?...');
          ErrorFetchedChecker = !ErrorFetchedChecker;
          //console.log('LOG__FROM_CountriesTable: Executed');
        },
      );
    }, [ErrorFetchedChecker]);//Shouldn't the change on this variable
                              //be enough to re-execute …

我正在尝试从数据库中获取记录。由于竞争条件，当我第一次尝试获取记录时，记录可能甚至可能不存在。我如何将其包装在重试逻辑中而不发疯？我似乎太愚蠢了

  const booking = await strapi.query("api::booking.booking").findOne({
    where: {
      id: id,
    },
  });

此代码应n延迟几t毫秒重试。谢谢并充满爱意。

我尝试过的：

async function tryFetchBooking(
  id,
  max_retries = 3,
  current_try = 0,
  promise
) {
  promise = promise || new Promise();

  // try doing the important thing
  const booking = await strapi.query("api::booking.booking").findOne({
    where: {
      id: id,
    },
  });

  if (!booking) {
    if (current_try < max_retries) {
      console.log("No booking. Retrying");
      setTimeout(function () {
        tryFetchBooking(id, max_retries, current_try + 1, promise);
      }, 500);
    } else {
      console.log("No …

TL;DR：我正在寻找一种策略或示例来处理未知数量的承诺拒绝，并X在用于多个异步调用时重试它们一段时间Promise.allSettled()。

读完这篇文章后：https://www.coreycleary.me/better-handling-of-rejections-using-promise-allsettled 我对这句话感到非常兴奋：

这很棒，因为我们仍然可以加载用户帐户信息，并稍后重试获取用户活动。（重试超出了本文的范围，并且有多种策略）

然而，在网上研究时，我发现完全没有具体的例子，甚至没有直接处理这个问题的帖子。

这是一些示例代码：

  public async test() {
    try {
      console.log('trying..');
      const multiAsync = [this.somethingA(), this.somethingB(), this.somethingC()];
      const [a, b, c] = await Promise.allSettled(multiAsync);
    } catch (e) {
      console.log('catch');
      console.log(e);
    }
  }

现在假设对于上面的代码，A 和 C 都失败了，我想重试它们，比如说——再试一次。即使我有a, b, c，我也只知道哪些是fullfilled:true，哪些不是。但我不知道如何链接a回somethingA()和仅c重somethingC()试这两个函数，而且我绝对不想调用somethingB()两次。

有任何想法吗？