javascript - servidor - Node.js: ¿Qué técnicas existen para escribir un código de devolución de llamada simple y limpio?

nodebeginner español

Question

El código node.js es conocido por convertirse en espagueti de devolución de llamada.

¿Cuáles son las mejores técnicas para superar este problema y escribir un código de devolución de llamada limpio, sin complejos y fácil de entender en node.js?

Answer 1

Eche un vistazo a Promesas: http://promises-aplus.github.io/promises-spec/

Es un estándar abierto que pretende resolver este problema.

Estoy usando el módulo de nodo ''q'', que implementa este estándar: https://github.com/kriskowal/q

Caso de uso simple:

var Q = require(''q'');

Por ejemplo tenemos métodos como:

var foo = function(id) {
var qdef = Q.defer();
Model.find(id).success(function(result) {
qdef.resolve(result);
});
return (qdef.promise);
}

Entonces podemos encadenar promesas por el método .then ():

foo(<any-id>)
.then(function(result) {
// another promise
})
.then(function() {
// so on
});

También es posible crear promesas a partir de valores como:

Q([]).then(function(val) { val.push(''foo'') });

Y mucho más, ver docs.

Ver también:

• http://jeditoolkit.com/2012/04/26/code-logic-not-mechanics.html#post
• http://wiki.commonjs.org/wiki/Promises/A

Answer 2

En su mayor parte, ejemplo de solo trabajo de Twitter OAuth2, utilizando la biblioteca de promesa de Kris con https.request , Nodejs Express api route. Primer intento del usuario en la línea de tiempo GET. Si el 401 responde, actualice el token del portador y vuelva a intentar la línea de tiempo del usuario. Tuve que usar Q.when para manejar una promesa que devuelve otra promesa (encadenamiento) o un valor.

 /**
* Using Rails-like standard naming convention for endpoints.
* GET /things -> index
* POST /things -> create
* GET /things/:id -> show
* PUT /things/:id -> update
* DELETE /things/:id -> destroy
*/
''use strict'';
// var _ = require(''lodash'');
var http = require(''http'');
var https = require(''https'');
var querystring = require(''querystring'');
var Q = require(''q'')
// Get list of twtimelines
exports.index = function(req, res) {
var tid = req.query.tid
if (tid) {
Q.when(reqTimeline(tid, true, res), function(value) {
// > value
// 404
// > body1
// ''{"errors":[{"code":34,"message":"Sorry, that page does not exist."}]}''
})
} else {
res.json({
errors: [{
message: ''no tid specified in query''
}]
});
}
};
function reqPromise(options, postData) {
var deferred = Q.defer()
var req = https.request(options, function(res) {
// console.log("statusCode: ", res.statusCode);
// console.log("headers: ", res.headers);
var statusCode = res.statusCode
deferred.notify(res)
res.on(''data'', function(d) {
//process.stdout.write(d);
deferred.notify(d)
}).on(''end'', function() {
deferred.resolve(statusCode)
});
});
req.on(''error'', function(e) {
console.error(e);
deferred.reject(e)
});
req.write(postData);
req.end();
return deferred.promise
} // deferRequest
function isIncomingMessage(ot) {
return ot instanceof http.IncomingMessage
}
function isBuffer(ot) {
return ot instanceof Buffer
}
function reqTimeline(screen_name, reqBearerTokenOn401, res) {
var optionsUserTimeline = {
hostname: ''api.twitter.com'',
path: ''/1.1/statuses/user_timeline.json?'' + querystring.stringify({
count: ''3'',
screen_name: screen_name
}),
method: ''GET'',
headers: {
//''Authorization'': ''Bearer '' + JSON.parse(body1).access_token
''Authorization'': ''Bearer '' + process.env.BEARER_TOKEN
} // headers
};
console.log("optionsUserTimeline", optionsUserTimeline)
var statusCode;
var body1 = new Buffer(''''); // default utf8 string buffer ?
return reqPromise(optionsUserTimeline, '''')
.then(function(value) { // done
if (reqBearerTokenOn401 && value === 401) {
console.log("reqTimeline - requesting bearer token")
return reqBearerToken(screen_name, res)
}
console.log("reqTimeline - done done:", value)
res.end()
return value
},
function(reason) { // error
console.log("reqTimeline - error:", body1)
},
function(progress) {
console.log("reqTimeline - progress:", body1)
if (isIncomingMessage(progress)) {
body1 = body1.slice(0, 0) // re-set buffer
statusCode = progress.statusCode;
if (reqBearerTokenOn401 && statusCode === 401) {
// readyn for retry
} else {
res.writeHead(statusCode)
}
} else if (isBuffer(progress)) {
if (reqBearerTokenOn401 && statusCode === 401) {
body1 += progress
} else {
res.write(progress)
}
} else {
throw "reqTimeline - unexpected progress"
}
});
} // reqTimeline
function reqBearerToken(screen_name, res) {
var postData = querystring.stringify({
''grant_type'': ''client_credentials''
})
var optionsBearerToken = {
hostname: ''api.twitter.com'',
path: ''/oauth2/token'',
method: ''POST'',
headers: {
''Authorization'': ''Basic '' + new Buffer(
process.env.CONSUMER_KEY + ":" + process.env.CONSUMER_SECRET
).toString(''base64''),
''Content-Type'': ''application/x-www-form-urlencoded;charset=UTF-8'',
''Content-Length'': postData.length
} // headers
}
// console.log("key", process.env.CONSUMER_KEY)
// console.log("secret", process.env.CONSUMER_SECRET)
// console.log("buf", new Buffer(
// process.env.CONSUMER_KEY + ":" + process.env.CONSUMER_SECRET
// ).toString())
console.log("optionsBearerToken", optionsBearerToken)
var body2 = new Buffer(''''); // default utf8 string buffer ?
return reqPromise(optionsBearerToken, postData)
.then(function(value) { // done
console.log("reqBearerToken - done:", body2)
if (value === 200) {
console.log("reqBearerToken - done done")
process.env.BEARER_TOKEN = JSON.parse(body2).access_token;
return reqTimeline(screen_name, false, res)
}
return value
}, function(reason) {
throw "reqBearerToken - " + reason
}, function(progress) {
if (isIncomingMessage(progress)) {
body2 = body2.slice(0, 0) // reset buffer
} else if (isBuffer) {
body2 += progress
} else {
throw "reqBearerToken - unexpected progress"
}
});
} // reqBearerToken

Answer 3

Probar línea de nodo

https://github.com/kevin0571/node-line

Uso:

var line = require("line");
line(function(next) {
obj.action1(param1, function(err, rs) {
next({
err: err,
rs: rs
});
});
}, function(next, data) {
if (data.err) {
console.error(err);
return;
}
obj.action2(param2, function(err, rs) {
if (err) {
console.error(err);
return;
}
next(rs);
});
}, function(rs) {
obj.finish(rs);
});

Answer 4

Se pueden hacer varias cosas para evitar el ''estilo matrioska''.

• Puede almacenar devoluciones de llamada a variables:

  var on_read = function (foo, bar) {
  // some logic
  },
  on_insert = function (err, data) {
  someAsyncRead(data, on_read);
  };
  someAsyncInsert(''foo'', on_insert);

• Puede utilizar algunos modules que ayudan en esos escenarios.

  // Example using funk
  var funk = require(''funk'');
  for(var i = 0; i < 10; i++) {
  asyncFunction(i, funk.add(function (data) {
  this[i] = data;
  }));
  }
  funk.parallel(function () {
  console.log(this);
  });

Answer 5

Yo sugeriría 1) usar CoffeeScript y 2) usar devoluciones de llamada con nombre y pasar el estado entre ellas en un hash, en lugar de anidar devoluciones de llamada o permitir que las listas de argumentos sean muy largas. Así que en lugar de

var callback1 = function(foo) {
var callback2 = function(bar) {
var callback3 = function(baz) {
doLastThing(foo, bar, baz);
}
doSomethingElse(bar, callback3);
}
doSomething(foo, callback2);
}
someAsync(callback1);

en su lugar puedes simplemente escribir

callback1 = (state) -> doSomething state.foo, callback2
callback2 = (state) -> doSomethingElse state.bar, callback3
callback3 = (state) -> doLastThing state
someAsync callback1

una vez que tu doSomething , doLastThing y doLastThing hayan sido reescritos para usar / extender un hash. (Es posible que deba escribir envoltorios adicionales alrededor de funciones externas).

Como puede ver, el código en este enfoque se lee de forma clara y lineal. Y como todas las devoluciones de llamada están expuestas, las pruebas unitarias se vuelven mucho más fáciles.