Was ist der Unterschied zwischen Dnode und Nowjs?

Question

Wie vergleichen sich die beiden miteinander?

Answer 1

Tl; dr

Dnode

• liefert RMI;
• Remote -Funktionen können Rückrufe als Argumente akzeptieren.
• Was schön ist, da es vollständig asynchron ist;
• führt eigenständig oder über einen vorhandenen HTTP-Server aus;
• kann Browser- und Knotenclients haben;
• Unterstützt Middleware genau wie connect;
• Es gibt länger als heute.

Jetzt

• geht über nur RMI hinaus und implementiert eine "gemeinsame Zielfernrohr" -API. Es ist wie Dropbox, nur mit Variablen und Funktionen anstelle von Dateien;
• Fernfunktionen Akzeptieren Sie auch Rückrufe (Vielen Dank an Sridatta und Eric von NOWJS für die Klärung);
• hängt von einem Hör -HTTP -Server ab, der funktioniert.
• kann nur Browser -Kunden haben;
• wurde vor kurzem öffentlich;
• ist momentan etwas fehlerhaft.

Fazit

Nowjs ist momentan eher ein Spielzeug - aber behalten Sie eine Uhr, wie es reift. Für ernsthafte Sachen gehen Sie vielleicht mit Dnode. Für eine detailliertere Überprüfung dieser Bibliotheken lesen Sie mit.

Dnode

DNODE bietet ein Remote -Methode -Aufruf -Framework. Sowohl der Client als auch der Server können Funktionen miteinander aussetzen.

// 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!')
})

Die Funktion, die an übergeben wird DNode() ist ein Handler nicht anders als der, an den man übergeben isthttp.createServer. Es hat zwei Parameter: client kann verwendet werden, um auf die vom Client exportierten Funktionen zuzugreifen und connection Kann verwendet werden, um verbindungsbezogene Ereignisse zu verarbeiten:

// 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)

Die exportierten Methoden können alles übergeben werden, einschließlich Funktionen. Sie werden von Dnode ordnungsgemäß als Proxies eingewickelt und können am anderen Endpunkt zurückgerufen werden. Dies ist grundlegend: Dnode ist vollständig asynchron; Es blockiert nicht, während es auf eine Remote -Methode wartet, die zurückgibt:

// 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
})

Rückrufe müssen weitergegeben werden, um Antworten vom anderen Endpunkt zu erhalten. Komplizierte Gespräche können ziemlich schnell unlesbar werden. Diese Frage Erörtert mögliche Lösungen für dieses Problem.

// 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)
        })
    })
})

Der Dnode -Client kann ein Skript sein, das in einer Knoteninstanz ausgeführt wird oder in eine Webseite eingebettet werden kann. In diesem Fall wird nur eine Verbindung zu dem Server hergestellt, der die Webseite bedient. Verbinden ist in diesem Fall von großer Hilfe. Dieses Szenario wurde mit allen modernen Browsern und mit Internet Explorer 5.5 und 7 getestet.

DNODE wurde vor weniger als einem Jahr am Juni 2010 gestartet. Es ist so reif wie eine Knotenbibliothek. In meinen Tests fand ich keine offensichtlichen Probleme.

Jetzt

Nowjs bietet eine Art magische API, die an süßem Sein grenzt. Der Server hat eineeveryone.now Umfang. Alles, was hineingesteckt wird everyone.now wird für jeden Kunden durch seinen sichtbar now Umfang.

Dieser Code auf dem Server wird eine gemeinsam genutzt echo Funktion mit jedem Client, der eine Nachricht an die Serverkonsole schreibt:

// 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.')

Wenn eine serverseitige "freigegebene" Funktion ausgeführt wird, this wird a haben now Attribut, das spezifisch für den Kunden ist, der diesen Anruf getätigt hat.

// 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.')
}

Funktionen in NowJs können Rückgabewerte haben. Um sie zu bekommen, muss ein Rückruf bestanden werden:

// On the client

now.twice(10, function (r) { console.log(r) }

// On the server

everyone.now.twice = function(n) {
    return 2 * n
}

Dies hat eine Implikation, wenn Sie einen Rückruf als ehrliches Argument verabschieden möchten (um keinen Rückgabewert zu sammeln) - man muss immer den Rückgabewertsammler übergeben, oder jetzt kann JSJs verwirrt werden. Laut den Entwicklern wird sich diese Art zum Abrufen des Rückrufwerts mit einem impliziten Rückruf wahrscheinlich in der Zukunft ändern:

// 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
}

Und das ist es für die Nowjs -API. Nun, eigentlich gibt es 3 weitere Funktionen, mit denen die Client -Verbindung und eine Trennung erfasst werden können. Ich weiß nicht, warum sie diese Funktionen nicht benutzt haben EventEmitter, obwohl.

Im Gegensatz zu DNODE verlangt NowJS, dass der Client ein Skript in einem Webbrowser ist. Die Seite, die das Skript enthält, muss von demselben Knoten bedient werden, auf dem der Server ausgeführt wird.

Auf der Serverseite benötigt NowJS auch ein HTTP -Serverhören. Es muss beim Initialisieren von Nowjs bestanden werden:

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)

Der erste Commit ist von vor ein paar Wochen (März 2011). Erwarten Sie daher, dass es fehlerhaft ist. ich fand Ausgaben Ich selbst beim Schreiben dieser Antwort. Erwarten Sie auch, dass sich seine API stark ändert.

Positiv zu vermerken ist, dass die Entwickler sehr zugänglich sind - Eric hat mich sogar dazu gebracht, Rückrufe zum Laufen zu bringen. Der Quellcode ist nicht dokumentiert, ist jedoch glücklicherweise einfach und kurz und der Benutzerhandbuch und Beispiele reichen aus, um einen zu beginnen.

Answer 2

Jetztjs Teammitglied hier. Korrektur auf Andrefs Antwort:

Jetzt Unterstützt vollständige "Remote -Methodenaufruf". Sie können Funktionen als Argumente in Remote -Anrufen übergeben und auch Funktionen als Rückgabewerte haben.

Diese Funktionen werden von NowJs so eingewickelt, wie sie sich in Dnode befinden, so dass sie auf der Maschine ausgeführt werden, auf der die Funktion definiert wurde. Dies erleichtert es einfach, neue Funktionen dem Remote -Ende aufzusetzen, genau wie in Dnode.

PS Außerdem weiß ich nicht, ob Andref implizieren soll, dass Remote -Anrufe auf DNODE nur asynchron sind. Remote -Anrufe sind auch auf Nowjs asynchron. Sie blockieren Ihren Code nicht.

Answer 3

Ich habe Dnode nicht ausprobiert, also ist meine Antwort kein Vergleich. Aber ich würde gerne nur wenige Erfahrungen mit NowJs machen.

Nowjs basiert auf Socket.io Das ist ziemlich fehlerhaft. Ich habe häufig Sitzungszeit-Outs, Trennung und Trennung und now.ready Ereignis mehrmals in kurzer Dauer. Kasse dieses Problem Auf Nowjs Github -Seite.

Außerdem fand ich auf bestimmten Plattformen die Verwendung von Websockets unrentabel. Dies kann jedoch durch explizit Deaktivieren von Websockets umgangen werden.

Ich hatte geplant, eine Produktions -App mit NowJS zu erstellen, aber es scheint nicht ausgereift genug zu sein, sich darauf zu verlassen. Ich werde es mit Dnode versuchen, wenn es meinen Zweck erfüllt, sonst wechsle ich zu Plain-Old express.

Aktualisieren:

Jetzt scheint Verschrottet werden. Keine Commits seit 8 Monaten.