Подтвердить что ты не робот

Как обрабатывать if-else в обещании?

В каком-то случае, когда я получаю возвращаемое значение от объекта -обещания, мне нужно запустить две разные прецессии then(), зависящие от условия значения, например:

promise().then(function(value){
    if(//true) {
        // do something
    } else {
        // do something 
    }
})

Я думаю, может быть, я могу написать это как:

promise().then(function(value){
    if(//true) {
        // call a new function which will return a new promise object
        ifTruePromise().then();
    } else {
        ifFalsePromise().then();
    }
})

но с этим у меня есть два вопроса:

  • Я не уверен, стоит ли начинать новое обещание - затем процесс в обещании;

  • Что делать, если мне нужно, чтобы два процесса вызывали одну функцию в последнем? Это означает, что у них есть один и тот же "терминал"

Я попытался вернуть новое обещание сохранить исходную цепочку:

promise().then(function(value){
    if(//true) {
        // call a new function which will return a new promise object
        // and return it
        return ifTruePromise();
    } else {
        // do something, no new promise
        // hope to stop the then chain
    }
}).then(// I can handle the result of ifTruePromise here now);

но в этом случае, будь то true или false, будет работать следующий then.

SO, что лучше всего справиться с этим?

4b9b3361

ОТВЕТЫ

Ответ 1

Пока ваши функции возвращают обещание, вы можете использовать первый метод, который вы предлагаете.

Скрипка ниже показывает, как вы можете использовать разные пути цепочки в зависимости от того, что будет первым разрешенным значением.

function myPromiseFunction() {
	//Change the resolved value to take a different path
    return Promise.resolve(true);
}

function conditionalChaining(value) {
    if (value) {
        //do something
        return doSomething().then(doSomethingMore).then(doEvenSomethingMore);
    } else {
        //do something else
        return doSomeOtherThing().then(doSomethingMore).then(doEvenSomethingMore);
    }
}

function doSomething() {
    console.log("Inside doSomething function");
    return Promise.resolve("This message comes from doSomeThing function");
}

function doSomeOtherThing() {
    console.log("Inside doSomeOtherthing function");
    return Promise.resolve("This message comes from doSomeOtherThing function");
}

function doSomethingMore(message) {
    console.log(message);
    return Promise.resolve("Leaving doSomethingMore");
}

function doEvenSomethingMore(message) {
    console.log("Inside doEvenSomethingMore function");
    return Promise.resolve();
}

myPromiseFunction().then(conditionalChaining).then(function () {
    console.log("All done!");
}).
catch (function (e) {

});

Ответ 2

Я написал простой пакет для условного использования обещаний.

Если вы хотите проверить это:

npm страница: https://www.npmjs.com/package/promise-tree

и github: https://github.com/shizongli94/promise-tree

В ответ на комментарии, спрашивающие, как пакет решает проблему:

1, Он имеет два объекта.

2, объект Branch в этом пакете является временным местом хранения для таких функций, как onFulfilled и onRejected, которые вы хотите использовать в then() или catch(). Он имеет такие методы, как then() и catch(), которые принимают те же аргументы, что и аналоги в Promise. Когда вы передаете обратный вызов в Branch.then() или Branch.catch(), используйте тот же синтаксис, что и Promise.then() и Promise.catch(). Затем не делайте ничего, кроме сохранения обратных вызовов в массиве.

3 Условие - это объект JSON, который хранит условия и другую информацию для проверки и разветвления.

4, вы указываете условия (логическое выражение), используя объект условия в ответных обратных вызовах. Затем состояние хранит информацию, которую вы передаете. После того, как вся необходимая информация предоставляется пользователем, объект условия использует метод для создания совершенно нового объекта Promise, который использует информацию о цепочке и обратном вызове, ранее сохраненную в объекте Branch. Небольшая сложная часть здесь заключается в том, что вы (как разработчик, а не пользователь) должны решить/отклонить обещание, которое вы сначала создали вручную, прежде чем связывать сохраненные обратные вызовы. Это связано с тем, что в противном случае новая цепочка обещаний не начнется.

5, благодаря циклу событий, объекты ветвления могут быть созданы до или после того, как у вас есть объект Promise, и они не будут мешать друг другу. Здесь я использую термины "ветвь" и "стебель", потому что структура напоминает дерево.

Пример кода можно найти на страницах npm и github.

Кстати, эта реализация также позволяет вам иметь ветки внутри ветки. И ветки не обязательно должны находиться на том же месте, где вы проверяете условия.