Find() calls in Mongoose

Question

What is the difference in these calls, why in first case my console logs 'undefined', and in second I get the right answer (an integer).

When calling count() - undefined.

function count() {
  let answer;
  Url.findOne({}).sort({short_url:-1}).exec(function (err,ur) { if (err) return err; answer = ur.short_url });
  console.log(answer);
}

When calling count() - an integer.

function count() {

  Url.findOne({}).sort({short_url:-1}).exec(function (err,ur) { if (err) return err; console.log(ur.short_url) });

}

In general, I want to achieve that such a call (count()) would return highest value of 'short_url'.

Answer 1

The findOne call is asynchronous. So the console.log statement is called before the findOnde statement returned.

The second one is you are using a callback. This means when the findOne function finishes call this function. And this time it is going to work.

But as a best practice I suggest you to use async and await if you are using ES6 javascript.

async function count() {
   let answer;
   await Url.findOne({}).sort({short_url:-1}).exec(function (err,ur) { if (err) return err; answer = ur.short_url });
   console.log(answer);
}

Answer 2

Bereket is correct.

You can also use callbacks,

function count() {
   let answer;
   await Url.findOne({}).sort({short_url:-1}).exec(function (err,ur) { 
       if (err) return err; 
       answer = ur.short_url
       console.log(answer);
    });
}

Or with promises.

function count() {
   let answer;
   await Url.findOne({}).sort({short_url:-1}).exec().then((ans) => {
       console.log(ans);
   }).catch(err => {
       console.log(err);
   });
}

However count() will still be asynchronous so it will not print immeditiely.

You should look into asynchronous methods more here

Answer 3

It would be useful to read further on closures async nature of javascript, where control flow, closures, scope, are the keys to understand how async code executes in the future

function count() {
  //count function scope

  let answer; //undefined at execution

  Url.findOne({}).sort({short_url:-1}).exec(function (err,ur) {

   //callback function scope 

   if (err) return err; 
  //answer is still undefined

  answer = ur.short_url 

  //answer is assigned ur.short_url only in the callback scope 
  //answer is defined here, and will print the content
  console.log(answer);

  });
  //back to count function scope
  //answer is still undefined in this scope (called function scope)
  console.log(answer);
   }

If you want to return the value of your query you can use a return statement with async

async function count() {
  const answer = await Url.findOne({}).sort({short_url:-1});

  console.log(answer);      //logs answer

  return answer;
}

It's also important to know that you can await an async function execution only from within an async function context