CODEWITHSUNDEEP
javascriptnode.js
user3729632
user3729632

Reputation: 25

return data with JavaScript

I have a problem when I call my function JavaScript I can not return my Buffer because it's in other function

index.js: 

var client = require('./sender'); 
//envoyer le paquet au seveur blizzard.com
var received =client.sendAndreceive(bufenc);
console.log('received: '+received);

sender.js:

var Http = require('http');
var Url = require('url');


function sendAndreceive(data) {

console.log('##########################################################################');
// connexion au serveur
var options = {
    //proxy 
    host: "proxya.u-pec.fr",
    port: 3128,
    //hostname : 'http://m.eu.mobileservice.blizzard.com',
    //port : 80,
    path : 'http://m.eu.mobileservice.blizzard.com/enrollment/enroll.htm',
    method : 'POST',
    headers: {
        Host: "http://m.eu.mobileservice.blizzard.com"
    }
};
var req = Http.request(options, callback );

req.on('error', function(e) {
    console.log('problem with request: ' + e.message);
});

req.write(data);
req.end();
}
exports.sendAndreceive = sendAndreceive; 

function callback (res) {
    res.on('data', function(chunk) {
        buf = new Buffer(chunk);
        console.log('data length: ' + buf.length);
                    return buf; // my problem is her !!!!!!!!!!!!!!!!!!!!!!
    });
}

output:

       ##########################################################################
       received: undefined
       data length: 45

Upvotes: 0

Views: 100

Answers (2)

peter_the_oak
peter_the_oak

Reputation: 3710

You are calling sendAndreceive(), and sendAndreceive() is starting a HTTP request that asynchronously calls callback(). So the return value of callback() is a return value given to the invoker inside the HTTP request object, while sendAndreceive() returns nothing.

There is no way to force asynchronous calls behave like one step-by-step-flow. Therefore I support the recommendation of Boy, using a callback.

OK, I see the promise pattern by Boy :-) cool. I will take a deeper look. It seems you can make asynchronous steps at least looking like synchronously written with constructs like .then(). Thx!

Upvotes: 0

user771071
user771071

Reputation:

Using the JavaScript callback pattern

You won't get a result as you returning the result from the callback function, which is nothing and wouldn't work either as your request to the server is asynchronously. Take a look at the example below, and see how it can work:

function callback (res, callback) {
    res.on('data', function(chunk) {
        buf = new Buffer(chunk);
        console.log('data length: ' + buf.length);

        // Make sure the argument is indeed a callable function
        if (typeof callback === 'function') {
            callback(buf);
        }
    });
}

Now what you do is simply implement a callback, that is executed when the result is finished.

var client = require('./sender'); 

//envoyer le paquet au seveur blizzard.com
client.sendAndreceive(bufenc, function(received) {
    console.log('Received', received);
});

This JavaScript pattern is called the callback pattern, and can be very useful in these kinds of situations.

Using a promise

Another more sexy way of doing stuff like this, is through promises. I don't want to fully explain what a promise is or does (you can use search, right?), so I'll just show you an example:

// This is part of the node-promise module: https://github.com/kriszyp/node-promise
var deferred = require("promise").defer;
var client = require('./sender'); 

function callback (res) {
    // Create a deffered object that will be returned
    var deferred = defer();

    res.on('data', function(chunk) {
        buf = new Buffer(chunk);
        console.log('data length: ' + buf.length);

        // Now let the listeners know that this promise 
        // has been completed successfully, and return the buf
        deffered.resolve(buf);


        // Or if something went wrong, you could do the following:
        // deffered.reject('Everything is wrong!');
    });

    return deferred;
}


//envoyer le paquet au seveur blizzard.com
client.sendAndreceive(bufenc)
.then(
    // Function ended successfully
    function(received) {
        console.log('Received', received);
    },

    // Function returned an error
    function(err) {
        console.log('Oh noes!', err);
    }
)
;

Upvotes: 2

Related Questions