basic understanding and implement of node.js
TRANSCRIPT
Basic Understanding and Implement of Node.js
Gary2014/04/18
Outline
• Review of Node.js
• Event Loop• Basic Thesis
• Callback
• Asynchronous Mechanism
• Module
• Express
• Conclusion
Review of Node.js
• A platform built on Chrome’s JavaScript runtime for easily building fast, scalable network applications.
• Uses an event-driven, non-blocking I/O model that makes it lightweight and efficient
• Perfect for data-intensive real-time applications that run across distributed devices
• Contains a built-in HTTP server library
• Making it possible to run a web server without the use of external software, such as Apache or Lighttpd
• Allowing more control of how the web server works
Review of Node.js
• Feature of Node.js• V8 JavaScript Engine
• Single-threaded
• Event-driven
• Non-blocking I/O model
Review of Node.js
Event Loop – Basic Thesis
• The first basic thesis of node.js is that I/O is expensive
• So the largest waste with current programming technologies comes from waiting for I/O to complete.
Event Loop – Basic Thesis
• There are several ways in which one can deal with the performance impact• Synchronous
• you handle one request at a time, each in turn.
• fork a new process: • you start a new process to handle each request.
• threads: • start a new thread to handle each request.
Event Loop – Basic Thesis
• The second basis thesis is that thread-per-connection is memory-expensive
• Apache is multithreaded. It spawns a thread per request (or process, it depends on the conf).
• Node.js is not multithreaded, because threads and processes carry a heavy memory cost.
Event Loop – Basic Thesis
Node.js App
Read file
Send file I/O request
Send HTTP request
Send Internet I/O request
SQL inquire
Send database I/O requestfile I/O response Internet I/O reponse
database I/O response
Event Loop – Callback
Node.js App
Event Loop
Read file
Send file I/O request
Send HTTP request
Send Internet I/O request
SQL inquire
Send database I/O request
file I/O response
Internet I/O request
database I/O request
Event Loop – Callback
• An event loop is “an entity that handles and processes external events and converts them into callback invocations”.
• At an I/O call, your code saves the callback and returns control to the node.js runtime environment.
• The callback will be called later when the data actually is available.
Event Loop – Callback
• First-class functions• E.g. we pass around functions as data, shuffle them around and execute them
when needed.
• Function composition• Also known as having anonymous functions or closures that are executed
after something happens in the evented I/O.
function say(word) {
console.log(word);
}
function execute(someFunction, value) {
someFunction(value);
}
execute(say, "Hello");
function execute(someFunction, value) {
someFunction(value);
}
execute(function(word){ console.log(word) }, "Hello");
Event Loop – Callback
• Run the node.js app, it will immediately output “Server has started”
• When sending request to server, “Request received” is shown
• This is an event-driven asynchronous server-side JavaScript and its callback
var http = require("http");
function onRequest(request, response) {
console.log("Request received.");
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
Event Loop – Asynchronous Mechanism
• Node.js is event-driven design
• In web application, it is said to have the fastest real-time response
• The principle is to use libuv to implement event polling, constantly check for events that need to be processed
• If it finds an event on standby, run and trigger the corresponding handler.
Event Loop – Asynchronous Mechanism
• Node.js keeps a single thread for your code
• Doing a “sleep” will block the server
• So while that code is running, node.js will not respond to any other requests from clients, since it only has one thread for executing your code.
• Or if you would have some CPU -intensive code, say, for resizing images, that would still block all other requests.
Event Loop – Asynchronous Mechanism
• The console will shown “blah…” after the fileis read
file.open();
while(true) {
result = file.read();
if (!result)
break;
/* Do something... */
}
console.log('blah blah blah...');
Difficult task
Easy task
Difficult taskdone on time
Easy taskdelayed
Event Loop – Asynchronous Mechanism
• process.nextTick(callback)• On the next loop around the event loop call this callback.
• This is not a simple alias to setTimeout(fn, 0), it's much more efficient. It typically runs before any other I/O events fires
• Node.js implements a queue storing events
• All event triggers are driven by the engine of a polling event.
• process.nextTick () is that we can put a program into the event queue, the next time the event polling is driven.
Event Loop – Asynchronous Mechanism
Difficult task
Easy task
Easy task done.Strill delayed
difficult taskdone
function readLoop() {result = file.read();if (!result)
return;/* Do something... */process.nextTick(readLoop);
}file.open();process.nextTick(readLoop);console.log('blah blah blah...');
Event Loop – Asynchronous Mechanism
• child_process.fork• Spawn Node processes
• Having all the methods in a normal ChildProcess instance, the returned object has a communication channel built-in.
• Assume at least 30ms startup and 10mb memory for each new Node. That is, you cannot create many thousands of them.
Event Loop – Asynchronous Mechanism
var n = child_process.fork('./child.js');n.on('message', function(m) {
console.log('PARENT got message:', m);});n.send({ hello: 'world' });
process.on('message', function(m) {console.log('CHILD got message:', m);
});process.send({ foo: 'bar' });
Difficult task
Easy task 1
difficult taskdone
Easy task 2
Easy task 1 done
Easy task 2 done
Event Loop – Asynchronous Mechanism
• Cluster• A single instance of Node runs in a single thread.
• To take advantage of multi-core systems the user will sometimes want to launch a cluster of Node processes to handle the load.
• The cluster module allows you to easily create child processes that all share server ports.
Event Loop – Asynchronous Mechanismvar cluster = require('cluster');
var http = require('http');
var numCPUs = require('os').cpus().length;
if (cluster.isMaster) { // Fork workers.
for (var i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on('exit', function(worker, code, signal) {
console.log('worker ' +
worker.process.pid + ' died');
});
} else { // Workers can share any TCP connection
// In this case its a HTTP server
http.createServer(function(req, res) {
res.writeHead(200);
res.end("hello world\n");
}).listen(8000);
}
Difficult task
Easy task 1
Easy task 2
Easy task 1 done
v
Easy task 2 done
difficult taskdone
Event Loop – Asynchronous Mechanism
Module
• NPM(Node Package Manager)• The official package manager for Node.js.
• As of Node.js version 0.6.3, npm is bundled and installed automatically with the environment.
• Runs through the command line and manages dependencies for an application.
• Allows users to install Node.js applications that are available on the npmregistry.
• Written entirely in JavaScript, and runs on the Node.js platform.
Module
• We use require and exports to connect with module
var http = require("http");
function start() {
function onRequest(request, response) {
console.log("Request received.");
response.writeHead(200, {"Content-Type": "text/plain"});
response.write("Hello World");
response.end();
}
http.createServer(onRequest).listen(8888);
console.log("Server has started.");
}
exports.start = start;
Module can be download with npm
var server = require("./server");
server.start();
Module can be written by requirements
server.js index.js
Express
• Express is a minimal and flexible node.js web application framework
• Providing a robust set of features for building single and multi-page, and hybrid web applications.
Express
• >npm info express version
• edit package.json
• >npm install
{"name": "hello-world","description": "hello world test app","version": "0.0.1","private": true,"dependencies": {
"express": "4.0.0"}
}
Express
• Node.js has more and more resources related to development,
• No need to write many features, you can directly use the module has been developed via official NPM tool from the others on the network
• Developers can focus wholeheartedly on the current development of applications.
• We always depend on a lot of third-party modules, and whenever we change the develop environment, it is necessary manually installing modules
• package.json file directly manage project dependencies and modules which being used by project
Express
• Three outstanding features• routing distribution
• request processing
• rendering the view
var app = express();
app.get("/hello/:who", function(req, res) {
res.end("Hello, " + req.params.who + ".");
});
// 啓動Express
var express = require("express");
var app = express();
// 設置view目錄app.set("views", __dirname + "/views");
// 設置模板引擎app.set("view engine", "jade");
Conclusion
• Web applications typically have bottleneck in I/O of network, and Node.js solves them well.
• Node.js uses JavaScript, which web developers already familiar with.
• NPM let everyone easily put theirs modules on.
• The disadvantage is that Node.js is new, not stable enough, API regularly updated.