NodeJs javascript: wait until the previous object property is assigned before assigning the next pro-CodePudding

Suppose I have code like this:

let result = {
  name: downloadNameFromInternetVerySlow(),
  isFamous: determineIfNameIsFamous(this.name);
}

const downloadNameFromInternetVerySlow = () => {
    path = "/home";
    const folders = fs.readdirSync(path).filter(file => fs.lstatSync(path).isDirectory());
    console.log(folders);
    return folders[0];
}

downloadNameFromInternetVerySlow can take a long time, meanwhile determineIfNameIsFamous depends on downloadNameFromInternetVerySlow's result to return correct value.

How do I make sure determineIfNameIsFamous only runs after downloadNameFromInternetVerySlow is done?

CodePudding user response：

The code you show is entirely synchronous so asynchronous results aren't actually the issue here like people were guessing. The issue is that this.name cannot be used to refer to a prior property in an object literal definition for several reasons, not the least of which this isn't set to the object you want.

Instead, you can do this:

let result = {};
result.name = downloadNameFromInternetVerySlow();
result.isFamous = determineIfNameIsFamous(result.name);

CodePudding user response：

You can convert downloadNameFromInternetVerySlow to a Promise(if not already). and then user await to wait till it finished. Otherwise you can use Promise.then()

(This should be inside an async function)

let name =  await downloadNameFromInternetVerySlow(),
let isFamous = determineIfNameIsFamous(this.name);

let result = {
  name,
  isFamous
}

Another method using Promise.then

let name, isFamous;
downloadNameFromInternetVerySlow().then(result => {
    name = result;
    isFamous = determineIfNameIsFamous(this.name);
});

CodePudding user response：

Async/await

There’s a special syntax to work with promises in a more comfortable fashion, called “async/await”.

An async function returns a promise, like in this example:

const doSomethingAsync = () => {
  return new Promise(resolve => {
    setTimeout(() => resolve('I did something'), 3000)
  })
}

When you want to call this function you prepend await, and the calling code will stop until the promise is resolved or rejected. One caveat: the client function must be defined as async. Here's an example :

const doSomething = async () => {
  console.log(await doSomethingAsync())
}

CodePudding user response：

Assuming downloadNameFromInternetVerySlow is asynchrononous (otherwise it would already work like you want), the solution is to use await.

Please note, to be able to do that, this code needs to be wrapped in an async function (or or top level with top level await available.)

async function getAndUseResult(){
  let result = {
    name: await downloadNameFromInternetVerySlow(),
    isFamous: determineIfNameIsFamous(this.name);
  }
  console.log(JSON.stringify(result))
}
getAndUseResult();

CodePudding user response：

function downloadNameFromInternetVerySlow(){
  return new Promise(resolve => setTimeout(() => {
    console.log("Set timeout resolving...");
    return resolve("Sample Name");
  }, 5000))
}

function determineIfNameIsFamous(name){
  if(name === "Sample Name"){
    return true;
  }
  
  return false;
}

async function myFunc(){
   let result = {};
   result.name = await downloadNameFromInternetVerySlow();
   console.log(result);
   result.isFamous = determineIfNameIsFamous(result.name);

    return result;
}

myFunc().then(res => console.log("result : ", res))