now - javascript date format

¿Cuál es la diferencia entre dnode y nowjs?

Question

¿Cómo se comparan los dos?

Answer 1

TL; DR

DNode

• proporciona RMI;
• las funciones remotas pueden aceptar devoluciones de llamada como argumentos;
• lo cual es bueno, ya que es completamente asincrónico;
• se ejecuta de forma independiente oa través de un servidor http existente;
• puede tener clientes de navegador y nodo;
• admite middleware, al igual que connect ;
• ha existido por más tiempo que NowJS.

AhoraJS

• va más allá de solo RMI e implementa una API de "alcance compartido". Es como Dropbox , solo con variables y funciones en lugar de archivos;
• las funciones remotas también aceptan devoluciones de llamada ( gracias a Sridatta y Eric de NowJS para la aclaración );
• depende de que un servidor http de escucha funcione;
• solo puede tener clientes de navegador;
• se hizo público recientemente;
• es algo problemático en este momento.

Conclusión

Ahora JS es más un juguete en este momento, pero mantén un reloj mientras madura. Para cosas serias, tal vez vaya con DNode. Para una revisión más detallada de estas bibliotecas, lea a lo largo.

DNode

DNode proporciona un marco de Invocación de método remoto. Tanto el cliente como el servidor pueden exponer funciones entre sí.

// On the server
var server = DNode(function () {
this.echo = function (message) {
console.log(message)
}
}).listen(9999)
// On the client
dnode.connect(9999, function (server) {
server.echo(''Hello, world!'')
})

La función que se pasa a DNode() es un controlador no muy diferente al que se pasó a http.createServer . Tiene dos parámetros: el client se puede usar para acceder a las funciones exportadas por el cliente y la connection se puede usar para manejar eventos relacionados con la conexión:

// On the server
var server = DNode(function (client, connection) {
this.echo = function (message) {
console.log(message)
connection.on(''end'', function () {
console.log(''The connection %s ended.'', conn.id)
})
}
}).listen(9999)

Los métodos exportados se pueden pasar cualquier cosa, incluidas las funciones. Están debidamente envueltos como proxies por DNode y se pueden devolver en el otro punto final. Esto es fundamental: DNode es completamente asincrónico; no se bloquea mientras se espera que regrese un método remoto:

// A contrived example, of course.
// On the server
var server = DNode(function (client) {
this.echo = function (message) {
console.log(message)
return ''Hello you too.''
}
}).listen(9999)
// On the client
dnode.connect(9999, function (server) {
var ret = server.echo(''Hello, world!'')
console.log(ret) // This won''t work
})

Las retrollamadas se deben pasar para recibir respuestas del otro punto final. Las conversaciones complicadas pueden volverse ilegibles con bastante rapidez. Esta pregunta discute posibles soluciones para este problema.

// On the server
var server = DNode(function (client, callback) {
this.echo = function (message, callback) {
console.log(message)
callback(''Hello you too.'')
}
this.hello = function (callback) {
callback(''Hello, world!'')
}
}).listen(9999)
// On the client
dnode.connect(9999, function (server) {
server.echo("I can''t have enough nesting with DNode!", function (response) {
console.log(response)
server.hello(function (greeting) {
console.log(greeting)
})
})
})

El cliente DNode puede ser una secuencia de comandos que se ejecuta dentro de una instancia de nodo o puede incrustarse dentro de una página web. En este caso, solo se conectará al servidor que sirvió la página web. Connect es de gran ayuda en este caso. Este escenario se probó con todos los navegadores modernos y con Internet Explorer 5.5 y 7.

DNode se inició hace menos de un año, en junio de 2010. Es tan maduro como una biblioteca de nodos. En mis pruebas, no encontré problemas obvios.

AhoraJS

NowJS proporciona un tipo de API mágica que raya en ser lindo. El servidor tiene un alcance de everyone.now . Todo lo que se pone dentro de everyone.now vuelve visible para cada cliente a través de su alcance now .

Este código, en el servidor, compartirá una función de echo con cada cliente que escribe un mensaje en la consola del servidor:

// Server-side:
everyone.now.echo = function (message) {
console.log(message)
}
// So, on the client, one can write:
now.echo(''This will be printed on the server console.'')

Cuando se ejecuta una función "compartida" del lado del servidor, this tendrá un atributo now que es específico del cliente que realizó esa llamada.

// Client-side
now.receiveResponse = function (response) {
console.log(''The server said: %s'')
}
// We just touched "now" above and it must be synchronized
// with the server. Will things happen as we expect? Since
// the code is not multithreaded and NowJS talks through TCP,
// the synchronizing message will get to the server first.
// I still feel nervous about it, though.
now.echo(''This will be printed on the server console.'')
// Server-side:
everyone.now.echo = function (message) {
console.log(message)
this.now.receiveResponse(''Thank you for using the "echo" service.'')
}

Las funciones en NowJS pueden tener valores de retorno. Para obtenerlos, se debe pasar una devolución de llamada:

// On the client
now.twice(10, function (r) { console.log(r) }
// On the server
everyone.now.twice = function(n) {
return 2 * n
}

Esto tiene una implicación si desea pasar una devolución de llamada como argumento honesto (no para recopilar un valor devuelto): siempre debe pasar el recopilador de valor devuelto, o NowJS puede confundirse. Según los desarrolladores, esta forma de recuperar el valor de retorno con una devolución de llamada implícita probablemente cambie en el futuro:

// On the client
now.crunchSomeNumbers(''compute-primes'',
/* This will be called when our prime numbers are ready to be used. */
function (data) { /* process the data */ },
/* This will be called when the server function returns. Even if we
didn''t care about our place in the queue, we''d have to add at least
an empty function. */
function (queueLength) { alert(''You are number '' + queueLength + '' on the queue.'') }
)
// On the server
everyone.now.crunchSomeNumbers = function(task, dataCallback) {
superComputer.enqueueTask(task, dataCallback)
return superComputer.queueLength
}

Y esto es todo por la API NowJS. Bueno, en realidad hay 3 funciones más que se pueden utilizar para detectar la conexión y desconexión del cliente. EventEmitter embargo, no sé por qué no exponen estas características usando EventEmitter .

A diferencia de DNode, NowJS requiere que el cliente sea un script que se ejecuta dentro de un navegador web. La página que contiene el script debe ser servida por el mismo nodo que está ejecutando el servidor.

En el lado del servidor, NowJS también necesita un servidor http escuchando. Se debe pasar al inicializar NowJS:

var server = http.createServer(function (req, response) {
fs.readFile(__dirname + ''/now-client.html'', function (err, data) {
response.writeHead(200, {''Content-Type'':''text/html''})
response.write(data)
response.end()
})
})
server.listen(8080)
var everyone = now.initialize(server)

El primer compromiso de NowJS es de hace un par de semanas (marzo de 2011). Como tal, espera que tenga errores. Encontré issues yo mismo al escribir esta respuesta. También espera que su API cambie mucho.

En el lado positivo, los desarrolladores son muy accesibles: Eric incluso me guió para hacer que las devoluciones de llamadas funcionen. El código fuente no está documentado, pero afortunadamente es simple y corto, y la guía del usuario y los ejemplos son suficientes para comenzar.

Answer 2

Ahora miembro del equipo de JS aquí. Corrección a la respuesta de andref:

NowJS es totalmente compatible con la "Invocación de método remoto" . Puede pasar funciones como argumentos en llamadas remotas y también puede tener funciones como valores de retorno.

Estas funciones están envueltas por NowJS tal como están en DNode para que se ejecuten en la máquina en la que se definió la función. Esto hace que sea más fácil exponer nuevas funciones al extremo remoto, al igual que en DNode.

PS Además, no sé si andref significa que las llamadas remotas solo son asincrónicas en DNode. Las llamadas remotas también son asincrónicas en NowJS. Ellos no bloquean tu código.

Answer 3

No he probado Dnode, así que mi respuesta no es una comparación. Pero me gustaría presentar algunas experiencias usando nowjs.

Nowjs se basa en socket.io que es bastante defectuoso . Con frecuencia experimento tiempos de espera de sesión, desconexiones y now.ready disparo de eventos múltiples en una corta duración. Mira este problema en la página nowjs github.

También encontré el uso de websockets inviable en ciertas plataformas, sin embargo, esto puede evitarse mediante la desactivación explícita de websockets.

Había planeado crear una aplicación de producción usando nowjs, pero parece que no está lo suficientemente madura como para confiar en ella. Trataré de dnode si sirve para mi propósito, de lo contrario cambiaré a express antiguo.

Actualizar:

Nowjs seems ser eliminado. No se compromete desde hace 8 meses.