Dfyjkt

I'm trying to learn pomise and I used code which I found in Internet... I don't understand everything. It looks for me very nasty but it works...

I initialized promise

function initialize(city) 
 var options = 
 url: 'https://api.weatherbit.io/v2.0//forecast/', 
 headers: 
 'User-Agent': 'request'
 
 ;

 return new Promise(function(resolve, reject) 
 request.get(options, function(err, resp, body) 
 if (err) 
 reject(err);
 else 
 resolve(JSON.parse(body));
 
 )
 )

I don't understand why I need to put return after initializePromise. Is it possible to refactor the code without return?

 var initializePromise = initialize("Berlin");
 return initializePromise.then(function(result) 
 weather = result;

 var rain = result["data"][0]["precip"];
 console.log(rain);

 , function(err) 
 console.log(err);
 )

This all depends upon what you want to do. If you wrote this version, which is slightly altered from your original but functionally the same:

function f1(city) 
 return initialize(city).then(function(result) 
 const weather = result
 const rain = result["data"][0]["precip"];
 console.log(rain)
 , function(err) 
 console.log(err)
 )

then when you call

f1('Berlin')

you would request the Berlin result from the server, When the server responds, you would either pass to console.log the error received from the request or turn the returned body into a JS object, extract the appropriate precip property from it, and log that to the console. The resulting Promise value returned from f1 is useless, and the weather variable is unused and unusable.

If you want to log that precipitation, but still keep a useful return value, you can write:

function f2(city) 
 return initialize(city).then(function(result) 
 const weather = result
 const rain = result["data"][0]["precip"];
 console.log(rain)
 return weather // *** NOTE new line here ***
 , function(err) 
 console.log(err)
 )

This time calling with Berlin (and ignoring the error case from now on), you would log the precipitation returned, but also return a Promise for the whole Berlin weather node. That means you can still do this:

f2('Berlin')

to log Berlin's first precipitation value, but that now returns a useful value, so you could do

f2('Berlin').then(console.log)

to do that same logging, and then log the entire Berlin result.

Or you could do

f2('Berlin').then(function(weather) 
 // do something useful with `weather` here.
, errorHandler)

But now note the cleanup that is available. First of all the rain variable in f2 is only used on the next line, and the weather one is simply a reference to the original result argument. So we can simplify it this way:

function f3(city) 
 return initialize(city).then(function(result) 
 console.log(result["data"][0]["precip"])
 return result
 , function(err) 
 console.log(err)
 )

This does the same thing more simply. But now there is a much more important simplification. It's quite possible that we don't need this function at all! If we have an error handler of some sort (even if it's just console.err), and we already have a function that does most of the weather handling we want, then instead of

f3('Berlin').then(function(weather) 
 // do something useful with `weather` here.
, errorHandler)

we can add the logging line from f3 into this first callbak, and get the same result by calling directly to initialize:

initialize('Berlin').then(function(weather) 
 console.log(weather["data"][0]["precip"])
 // do something useful with `weather` here.
, errorHandler)

The reason this works is because initialize returns the result of calling then on the Promise, and then f2 and f3 also return either an altered value or the original one, keeping a Promise chain intact.

I would suggest that if you're in doubt you return something in any of these situations. It makes it much easier to continue working with values.