Выполнить (не выполнять) обещание другим обещанием

Кажется, что нет решения, кроме обходного пути, который я уже описал в вопросе. Для справки в будущем: если вы хотите выполнить (а не разрешить) обещание p со значением val, где val - другое обещание, тогда простой вызов функции разрешения обещания для p с аргументом val не будет работать должным образом. Это приведет к тому, что p будет "заблокирован" в состоянии val, так что p будет выполняться со значением разрешения val после выполнения val (см. spec).

Вместо этого оберните val другим объектом и разрешите p этим объектом:

var resolveP;  // Promise resolution function for p

var p = new Promise(
    function(resolve, reject) {
        resolveP = resolve;
    }
);

function fulfillPwithPromise(val) {  // Fulfills p with a promise val
    resolveP({promise: val});
}

p.then(function(res) {
    // Do something as soon as p is fulfilled...

    return res.promise;
}).then(function(res) {
    // Do something as soon as the second promise is fulfilled...
});

Это решение работает, если вы уже знаете, что val является обещанием. Если вы не можете сделать никаких предположений о типе val, то вам, похоже, не повезло. Либо вам нужно всегда переносить значения разрешения обещаний в другой объект, либо вы можете попытаться определить, есть ли у val поле then типа «функция», и условно обернуть его.

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

Хотя разные люди используют разные термины, в общей терминологии «выполнить» означает перевести обещание в состояние «успех» (в отличие от «отклонить») - состояние, которое будет запускать then обработчики, висящие на нем.

Другими словами, вы не можете «выполнить» обещание с помощью обещания. Вы можете наполнить его ценностью. (Между прочим, термин «решимость» обычно означает либо выполнение, либо отказ.)

Что вы можете сделать, так это вернуть обещание из .then обработчика, что приведет к замене исходного обещания возвращенным обещанием.

Вот простой пример этого:

asyncTask1 . then(asyncTask2) . then(processData)

где asyncTask1 - это обещание, а asyncTask2 - функция, возвращающая обещание. Итак, когда asyncTask1 выполнено (выполнено успешно), тогда asyncTask2 выполняется, и обещание, возвращаемое .then, "берется" на себя обещанием asyncTask2, так что когда оно завершается, данные могут быть обработаны.

Я могу сделать нечто подобное, вызвав Promise.resolve с обещанием в качестве параметра. Это немного неправильно, потому что я не разрешаю обещание в техническом смысле. Вместо этого новое созданное обещание «населяется» обещанием, которое я передал. Это также бесполезно, потому что использование результата точно такое же, как использование обещания, которое я передал:

Promise.resolve(asyncTask2)

ведет себя точно так же, как

asyncTask2

(при условии, что asyncTask2 уже является обещанием; в противном случае Promise.resolve создает обещание, которое немедленно выполняется с переданным значением.)

Так же, как вы можете передать обещание Promise.resolve, вы можете передать обещание функции resolve, предоставленной вам в качестве параметра обратного вызова конструктора обещаний. Если параметр, который вы передаете resolve, не является обещанием, обещание немедленно выполняется с этим значением. Однако, если параметр, который вы передаете resolve, является другим обещанием, это обещание «берет на себя тело» создаваемого вами обещания. Другими словами, создаваемое вами обещание начинает вести себя точно так же, как обещание, переданное resolve.

Под «вести себя точно» я имею в виду, что если обещание, которое вы передаете resolve, уже выполнено, обещание, которое вы конструируете, мгновенно выполняется с тем же значением. Если обещание, которое вы передаете resolve, уже отклонено, создаваемое вами обещание немедленно отклоняется по той же причине. Если обещание, которое вы передаете resolve, еще не разрешено, то любые then обработчики, которые вы зависаете от создаваемого обещания, будут вызваны, если и когда обещание, которое вы передаете resolve, будет разрешено.

Точно так же, как сбивает с толку то, что Promise.resolve может привести к обещанию, которое фактически не разрешено, также сбивает с толку то, что вызов функции resolve, переданной вам в качестве параметра конструктора обещания, может не фактически разрешить обещание. создается, если вы вызываете его с неразрешенным обещанием. Вместо этого, как я уже говорил несколько раз, это приводит к тому, что создаваемое обещание приводится в состояние полного соответствия с обещанием, переданным в resolve.

Поэтому, если я не упущу суть вашего вопроса, pickfile можно записать как

function pickFile() {
  return new Promise(function(resolve, reject) {
    ...display the file picker...

    // Mock code to pretend the user picked a file
    window.setTimeout(function() {
        resolve('thefile');
    });
}

Я не совсем понял ваш вопрос, так что это может быть не то, что вам нужно. Пожалуйста, поясните, если вам интересно.

Нашел аналогичное решение в процессе перехода от Angular $ q к встроенной функции Promise. Promise.all может быть вариантом (в случаях независимых параллельных асинхронных задач), передавая соответствующий объект или что-то, украшенное состоянием, передавая его всему, что готово, когда это необходимо. В приведенном ниже примере Promise.all обратите внимание, как он восстанавливается в одном из обещаний - мне потребовалось некоторое время, чтобы понять, как перенаправить результат цепочки. Результатом всего этого является возврат последнего обещания. Хотя это не отвечает на заголовок вопроса, использование return Promise.reject(<an-object-including-a-promise>) (или решение) дает серию и / или группу асинхронных задач, разделяемых на общий доступ и управление на этом пути. В случае выбора, загрузки, а затем работы с файлом, я бы взял обработку события прогресса, а затем сделал: pickFile.then(download,orFailGracefully) с downloadProgress, обработанным в обработчике download onResolve (загрузка-прогресс не выглядит асинхронной задачей). Ниже приведены похожие эксперименты в консоли.

var q = {
defer: function _defer(){
    var deferred = { };
    deferred.promise = new Promise(function(resolve, reject){
        deferred.resolve = resolve;
        deferred.reject = reject;
    });
    return deferred;
    }
};

var communityThatCares = q.defer();
communityThatCares.promise.then(function(someGood){
    console.log('someGood', someGood);
    return someGood;
}, function(someBad){
    console.warn('someBad', someBad);
    return someBad;
});

(new Promise(function(resolve, reject){ communityThatCares.about = 'communityThatCares'; setTimeout(resolve,1000, communityThatCares); }))
.then(
function(e){
    console.log(3,e); return e.resolve(e);
}, function(e){
    console.warn(3, e); return e.reject(e);
});

var todo = {
    find:'swan'
};

var greaterGood = [(
(new Promise(function(res,rej){ res(todo); })).then(function(e){ e.stuff = 'things'; return e; }),
(new Promise(function(res,reject){ 
    reject(todo);
})).then(function(e){ return e; }
,function(e){
    console.warn(1,e);
    e.recover = 'uh oh';
    return Promise.resolve(e);
}).then(function(e){ console.log(2,e); return e; }),
(new Promise(function(res,rej){ res(todo); })).then(function(e){ console.log(1,e); e.schedule = 'today'; return e; },function(e){ console.warn(1,e); return e; }).then(function(e){ console.log(2,e); return e; }))
];

var nkay = Promise.all( greaterGood )
.then(function(todo){
    console.log('all',todo[0]); return todo;
}, function(todo){
    console.warn('all',todo[0]); return todo;
});