Цепь обещаний с setTimeout

Question

Я новичок в javascript, и сейчас изучаю часть Обещания.

Ниже я пытаюсь написать цепочку обещаний с setTimeout и ожидать, что она напечатает «первый результат» после 2 секунды и выведите «второй результат» через 2 секунды. Однако он печатает «первый результат» и «второй результат» одновременно.

Может кто-нибудь сказать мне, где я допустил ошибку?

var doSomething = new Promise(function(resolve,reject){ 
    setTimeout(function(){ 
        resolve('first result');  
    },2000); 
});

var doSomethingElse = new Promise(function(resolve,reject){ 
    setTimeout(function(){
        resolve('second result');  
    },2000); 
});

doSomething
    .then(function(result){
    console.log("This is the "+result); 
    return doSomethingElse;
    })
    .then(function(result){
        console.log("This is the "+result);
});

====== ======================

EDIT : поэтому, когда я пишу обещание, как показано ниже, функция executor (setTimeout) отсчет начинается сразу же и становится разрешенным через 2 секунды.

var doSomething = new Promise(function(resolve,reject){   // starts counting here
    setTimeout(function(){ 
        resolve('first result');  
    },2000); 
});

Однако, если я обертываю обещание внутри функции, как показано ниже, функция исполнителя (setTimeout) начинает подсчет только после I вызвать функцию. Это правильно?

function doSomething(){
    return new Promise(function(resolve,reject){
        setTimeout(function(){
            resolve('first result');
        },2000);
    })
}
doSomething(); // starts counting here

Answer 1

Как написано, обещание doSomething и обещание doSomethingElse создаются в очень быстрой последовательности и разрешаются в очень быстрой последовательности через 2 секунды.

В коде нет ничего, что могло бы вызвать два процессы должны быть последовательными. Для этого вам нужно убедиться, что doSomethingElse запускается через 2 секунды после завершения doSomething.

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

Например, вы можете записать выражения new Promise(...) непосредственно в цепочку Promise, не выполняя никаких назначений:

new Promise(function(resolve, reject) {
    setTimeout(function() {
        resolve('first result');
    }, 2000);
})
.then(function(result) {
    console.log("This is the " + result);
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            resolve('second result');
        }, 2000);
    });
})
.then(function(result) {
    console.log("This is the " + result);
});

Или вы можете написать doSomething и doSomethingElse как функции:

function doSomething() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            resolve('first result');
        }, 2000);
    });
}
function doSomethingElse() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            resolve('second result');
        }, 2000);
    });
}

doSomething()
.then(function(result) {
    console.log("This is the " + result); 
    return doSomethingElse();
})
.then(function(result) {
    console.log("This is the " + result);
});

Или вы можете написать одну doSomething() функцию и вызвать ее дважды:

function doSomething(value) {
    return new Promise(function(resolve,reject) {
        setTimeout(function() {
            resolve(value);
        },2000);
    });
}

doSomething('first result')
.then(function(result) {
    console.log("This is the " + result); 
    return doSomething('second result');
})
.then(function(result) {
    console.log("This is the " + result);
});

Или, возвращаясь к doSomething() и doSomethingElse() в качестве отдельных функций, вы можете добавить третью logResult() функцию для ведения журнала:

function doSomething() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            resolve('first result');
        }, 2000);
    });
}
function doSomethingElse() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            resolve('second result');
        }, 2000);
    });
}
function logResult(result) {
    console.log("This is the " + result); 
}

doSomething()
.then(function(result) {
    logResult(result);
    return doSomethingElse();
})
.then(function(result) {
    logResult(result);
});

Приятной особенностью предыдущего примера является то, что цепочка Promise упростится следующим образом:

function doSomething() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            resolve('first result');
        }, 2000);
    });
}
function doSomethingElse() {
    return new Promise(function(resolve, reject) {
        setTimeout(function() {
            resolve('second result');
        }, 2000);
    });
}
function logResult(result) {
    console.log("This is the " + result); 
}

doSomething()
.then(logResult)
.then(doSomethingElse)
.then(logResult);

Как видите, уникального решения не существует.

Answer 2

Вы создаете обещание и назначаете его на doSomething. Первый таймер начинает обратный отсчет.

Затем вы немедленно создаете еще одно обещание и присваиваете ему doSomethingElse. Второй таймер начинает обратный отсчет.

---

Создайте второе обещание после первого разрешения.