Timer

Interval timers abstract to a large extent the possibilities offered according to standard by JavaScript. Absolutely use the Node variant, in order to get no problems later with other parallel running modules.

Syntax: setTimeout(callback, delay[, arg][, ...])

Syntax: clearTimeout(timeoutObject)

Syntax: setInterval(callback, delay[, arg][, ...])

Syntax: clearInterval(intervalObject)

Syntax: setImmediate(callback[, arg][, ...])
                clearImmediate stops the execution of the timer indicated by immediateObject.
Syntax: clearImmediate(immediateObject)

Global Objects

Global objects are active in all modules. They do not have to be agreed upon separately.

console.log(__filename);

console.log(__dirname);

Basics

HTTP consists of a command line and head fields , which describe the instruction more clearly. In Node, the head fields are made available as JSON . An appropriate object would thus look as follows:

1   {
2     'content-length': '123',
3     'content-type': 'text/plain',
4     'connection': 'keep-alive',
5     'host': 'mysite.com',
6     'accept': '*/*'
7   }

The keys are always converted according to the specification in small letters. The values are never changed. That is already the whole interface of Node. Generally, Node is very simple with this module. Neither the head fields nor contents of a message are examined, evaluated, or treated internally.

Head fields , which have several values use “,” (comma) for the separation of the values. The only exceptions are the head fields for Cookies, which an array accepts. If fields permit only one value, Node controls this and throws an exception.

Arriving or sent head fields are made available as a rough object. This is an array with sequential pairs of keys and values that looks as follows:

1   [ 'Content-Length', '123456',
2      'content-type', 'text/plain',
3      'CONNECTION', 'keep-alive',
4      'Host', 'mysite.com',
5      'accept', '*/*' ]

Transformation and control actions take place thereafter so that the head files actually made available or sent can deviate from it.

Fields

The section describes fields , which make values available and which refer to the internal configuration.

http.METHODS returns in the form of arrays a list with HTTP verbs, which are supported. http.STATUS_codes is an array with the status codes, which know HTTP and the assigned summary. For 404 this is defined exemplarily as follows:

http.STATUS_CODES[404] === 'Not Found'

Methods

The methods make the appropriate actions possible regarding the protocol processing “http.createServer” a new instance of the HTTP server returns. Thus HTTP requests can be received and processed. The syntax looks as follows:

http.createServer([requestListener])

The callback function requestListener is a method, which gets the received data.

With http.request(option[,callback]), Node sends a request to another server. Node is thus, in this case, the client. Node uses several connections, if this is possible. However, the method treats this internally, so that you must give no consideration with programming to it. The following syntax is used:

http.request(options [, callback])

The options can be JSON or a character string. If it is a character string, url.parse() will automatically be used, in order to parse the character string. The callback method supplies an object with the answer (response).

The options have the following meaning:

• host: the domain name or the IP address, where the request is sent. Without information, this is called “localhost.”

• hostname: If url.parse() is used, you should use hostname instead of host.

• port: the port for the request. Standard is the port 80.

• localAddress: If you have several network cards, you can hereby instruct which local address (network card with the appropriate connection) is to be used by Node.

• socketPath: Under Unix, this refers to Unix domain Sockets.

• These are terminals for interprocess communication. You can use this on a local system or host:port syntax.

• method: The verb (HTTP method) is in capital letters. Default value is here: GET.

• path: the path to resources for the requirement. The default value is ‘/’. The path should contain the Querystring, if this is to be used, e.g., /index.html?=12. Illegal indications lead to an exception.

• headers: a JSON object with the information of the header fields

• auth: the kind of authentication. It produces the header field.

• Authorization.

• agent: the behavior of the Clients steers. If the information takes place, the head field Connection: keep-alive is produced. Possible values for this parameter are:

  • undefined (default): Global information for the mentioned combination is host and port.

  • object of the type agent: explicit information of all values

  • No connecting pool is formed. Each request ends with Connection: close.

• keepAlive: The connection is kept open in a connecting pool, so that other connecting desires can access at a later time. The standard is false.

• keepAliveMsecs: If keepAlive is used, hereby the time can be indicated in milliseconds, to which a TCP package is sent as a sign of life. The default value is 1000.

The method gives an instant to the class http.ClientRequest back. This is a writable stream. For the request, if data is needed (for example because during a POST requirement a form is sent), then these data will be written in the stream.

 1   var postData = querystring.stringify({
 2     'msg' : 'Hello World!'
 3   });
 4
 5   var options = {
 6     hostname: 'www.google.com',
 7     port: 80,
 8     path: '/upload',
 9     method: 'POST',
10     headers: {
11       'Content-Type': 'application/x-www-form-urlencoded',
12       'Content-Length': postData.length
13     }
14   };
15
16   var req = http.request(options, function(res) {
17     console.log('STATUS: ' + res.statusCode);
18     console.log('HEADERS: ' + JSON.stringify(res.headers));
19     res.setEncoding('utf8');
20     res.on('data', function (chunk) {
21       console.log('BODY: ' + chunk);
22     });
23   });
24
25   req.on('error', function(e) {
26     console.log('problem with request: ' + e.message);
27   });
28
29   req.write(postData);
30   req.end();

The actual writing takes place with req.write(postData). The use of req.end() is necessary here because the stream is otherwise closed. After terminating, no further data can be written. The requirement object req knows an even error, to which you can react in order to intercept errors. Errors can occur if one of the procedures fails with sending (dissolution of DNS, TCP error, error when parsing the head fields, etc.).

If the head filed Connection: keep-alive is manually inserted, Node recognizes this and keeps the connection open until the next request is sent.

If the head field Content-length is sent, then the use of computer field is switched off. Computer field is block-by-block sending of data. The information takes place via the head field Transfer- Encoding: chunked.

If an Except head field is used, then the head fields are sent immediately. After Expect: 100-continue, you should listen immediately to the appropriate event (with timeout). RFC2616 section 8.2.3 gives more information in addition.

If the head field Authorization is indicated, the data produced by the option auth is overwritten.

With http.get a shortened variant of the method request stands ready, the one request initiated by means of GET. Since no data is sent with GET, req.end() produces it automatically:

http.get(options[, callback])

An example shows how it goes:

1   http.get("http://www.google.com/index.html", function(res) {
2     console.log("Got response: " + res.statusCode);
3   }).on('error', function(e) {
4     console.log("Got error: " + e.message);
5   });

Classes

Some classes supply further functionality.

1   var http = require("http");
2   var server = http.createServer();
3
4   server.on("request", function (req, res) {
5       res.end("this is the response");
6   });
7
8   server.listen(3000);

server.listen(port[, hostname][, backlog][, callback]) server.listen(path[, callback])
server.listen(handle[, callback])

server.close([callback])

server.setTimeout(msecs, callback)

close: function () { }                  

response.writeHead(statusCode[, statusMessage][, headers])
1   var body = 'hello world';
2   response.writeHead(200, {
3     'Content-Length': body.length,
4     'Content-Type': 'text/plain' }
5   );

response.setTimeout(msecs, callback)

response.statusCode = 404;

response.statusMessage = 'Not found';

response.setHeader(name, value)

1   response.setHeader("Content-Type", "text/html");
2   response.setHeader("Set-Cookie", ["type=ninja", "language=javascript
3   "]);

response.getHeader(name)

1   var contentType = response.getHeader('content-type');

1   response.removeHeader("Content-Encoding");

response.write(chunk[, encoding][, callback])

1   response.writeHead(200, { 'Content-Type': 'text/plain',
2                             'Trailer': 'Content-MD5' });
3   response.write(fileData);
4   response.addTrailers({
5      'Content-MD5': "7895bf4b8828b55ceaf47747b4bca667"
6   });
7   response.end();

response.end([data][, encoding][, callback])

Class http.ClientRequest

An instance of this class is provided through http.request(). This is the requirement object. The head fields are thereafter still alterable with the methods setHeader(name, value), getHeader(name), and removeHeader(name). Node is in this case the client, which sends requests to another server.

In order to get the answer of the produced and sent request, you hand an event treatment function over for the event response. The event returns an instance of the class IncomingMessage. If the answer should contain data, it can be accessed with the event data. Alternatively you can listen to it with the event readable and then read it actively with the event response.read().

 Node does not check whether the information in Content-Length is correct and fits with the content. Do not rely on this value!

 1   var http = require('http');
 2   var net = require('net');
 3   var url = require('url');
 4
 5   // Create proxy for tunnel            
 6   var proxy = http.createServer(function (req, res) {
 7     res.writeHead(200, {'Content-Type': 'text/plain'});
 8     res.end('okay');
 9   });
10   proxy.on('connect', function(req, cltSocket, head) {
11     // Connect previous server            
12     var srvUrl = url.parse('http://' + req.url);
13     var srvSocket = net.connect(srvUrl.port, srvUrl.hostname, 14                                 function() {
15       cltSocket.write('HTTP/1.1 200 Connection Established
' +
16                       'Proxy-agent: Node-Proxy
' +
17                       '
');
18       srvSocket.write(head);
19       srvSocket.pipe(cltSocket);
20       cltSocket.pipe(srvSocket);
21     }); // End function            
22   });
23
24   // Proxy runs now            
25   proxy.listen(1337, '127.0.0.1', function() {
26
27     // Anforderung erstellen            
28     var options = {
29       port: 1337,
30       hostname: '127.0.0.1',
31       method: 'CONNECT',
32       path: 'www.google.com:80'
33     };
34
35     var req = http.request(options);
36     req.end();
37
38     req.on('connect', function(res, socket, head) {
39       console.log('got connected!');
40
41       // Anforderung über Tunnel            
42       socket.write('GET / HTTP/1.1
' +
43                    'Host: www.google.com:80
' +
44                    'Connection: close
' +
45                    '
');
46       socket.on('data', function(chunk) {
47         console.log(chunk.toString());
48       });
49       socket.on('end', function() {
50         proxy.close();
51       });
52     });
53   });

A further event must be treated if necessary: upgrade. The callback function has the following signature:

function (response, socket, head)

An upgrade is necessary if the client liked to change the protocol, for example, from HTTP 1.1 to HTTP 2.0 or to WebSockets.

 1   var http = require('http');
 2
 3   // Create an HTTP server            
 4   var srv = http.createServer(function (req, res) {
 5     res.writeHead(200, {'Content-Type': 'text/plain'});
 6     res.end('okay');
 7   });
 8   srv.on('upgrade', function(req, socket, head) {
 9     socket.write('HTTP/1.1 101 Web Socket Protocol Handshake
' +
10                  'Upgrade: WebSocket
' +
11                  'Connection: Upgrade
' +
12                  '
');
13  
14     socket.pipe(socket); // Echo zurück            
15   });
16
17   // now that server is running            
18   srv.listen(1337, '127.0.0.1', function() {
19
20     // make a request            
21     var options = {
22       port: 1337,
23       hostname: '127.0.0.1',
24       headers: {
25         'Connection': 'Upgrade',
26         'Upgrade': 'websocket'
27       }
28     };
29
30     var req = http.request(options);
31     req.end();
32
33     req.on('upgrade', function(res, socket, upgradeHead) {
34       console.log('got upgraded!');
35       socket.end();
36       process.exit(0);
37     });
38   });

The event continue arises if the server sends a 100 Continue, which usually is a reaction to the request Expect: 100-continue. This is the request for the client that the data of the message may be sent.

With request.flushHeaders(), a method is available which sends the head fields actively. Normally, Node buffers head fields and sends these not immediately if they are defined. Buffering serves the optimization, so that all head fields fit ideally into a TCP package. With flush() and flushHeaders(), the optimization mechanism is ignored.

The actual writing of the data is done by request.write(chunk[, encoding][, callback]) with block-by-block (chunk) sending of the data. The head field [‘Transfer-Encoding’, ‘chunked’] should be used in order to show the receiving station that the blocks are used for this to work.

The argument chunk can be a buffer or a character string . The callback function is called if the data was sent.

With request.end([data][, encoding][, callback]), the requirement is terminated. If parts of the data were not sent yet, “flush” is forced. If blocks were used, now the final sequence “0 ” is sent.

With data the result is identical to the call of request.write(data, encoding), followed by request.end(callback). The callback function is called if the data was sent.

With request.abort(), the requirement can be canceled. With request.setTimeout(timeout[,callback]), the timeout value is specified.

1   {
2     'user-agent': 'curl/7.22.0',
3     host: '127.0.0.1:8000',
4     accept: '*/*'
5   }

 1   [
 2     'user-agent',
 3     'this is invalid because there can be only one',
 4     'User-Agent',
 5     'curl/7.22.0',
 6     'Host',
 7     '127.0.0.1:8000',
 8     'ACCEPT',
 9     '*/*'
10   ]

1   GET /status?name=ryan HTTP/1.1

2   Accept: text/plain

3   

1   var url = require('url');
2   console.log(url.parse('/status?name=ryan'));

1   {
2     href: '/status?name=ryan',
3     search: '?name=ryan',
4     query: 'name=ryan',
5     pathname: '/status'
6   }

1   var url = require('url');
2   console.log(url.parse('/status?name=ryan', true));

1   {
2     href: '/status?name=ryan',
3     search: '?name=ryan',
4     query: { name: 'ryan' },
5     pathname: '/status'
6   }

HTTPS

HTTPS is HTTP, which continues on TLS (Transport Layer Security). The actual TLS version corresponds to the earlier standard SSL 3.0. TSL is the successor of SSL.

If HTTPS is used, then you can determine the authentication data of the clients with: request.connection.verifyPeer() and request.connection.getPeerCertificate().

The server is provided as follows with HTTP:

https.createServer(options[, requestListener])

 1   // Abruf: https://localhost:8000/
 2   var https = require('https');
 3   var fs = require('fs');
 4
 5   var options = {
 6     key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
 7     cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
 8   };
 9
10   https.createServer(options, function (req, res) {
11     res.writeHead(200);
12     res.end("hello world
");
13   }).listen(8000);
14   Or
15
16   var https = require('https');
17   var fs = require('fs');
18
19   var options = {
20     pfx: fs.readFileSync('server.pfx')
21   };
22
23   https.createServer(options, function (req, res) {
24     res.writeHead(200);
25     res.end("hello world
");
26   }).listen(8000);

The used methods and features resemble to a large extent those of the module http:

 1   var https = require('https');
 2
 3   var options = {
 4     hostname: 'encrypted.google.com',
 5     port: 443,
 6     path: '/',
 7     method: 'GET'
 8   };
 9
10   var req = https.request(options, function(res) {
11     console.log("statusCode: ", res.statusCode);
12     console.log("headers: ", res.headers);
13
14     res.on('data', function(d) {
15       process.stdout.write(d);
16     });
17   });
18   req.end();
19
20   req.on('error', function(e) {
21     console.error(e);
22   });

The argument optionshas further options, unlike “HTTP”:

• pfx: certificates, private keys and information of the certificate authority (CA). The default value is “null”.

• key: the private key. The default value is “null”.

• passphrase: the pass phrase for the private key. The default value is “null”.

• cert: public x509 certificate. The default value is “null”.

• ca: an array of certificate authority, which are inquired, in order to dissolve the host

• ciphers: a character string which merges or excludes the used ciphers. See OpenSSL ² to take a look at how this is designed.

• rejectUnauthorized: If true, the certificate will be checked about its certificate authority. An error even arises if the examination fails. The default value is true. You should switch this off in test environments if necessary. This examination takes place on the level of the connection establishment, before the HTTP request was sent.

• secureProtocol: the method, for example TLSv1. Available methods stand in “SSL_METHODS”.

 1   var options = {
 2     hostname: 'encrypted.google.com',
 3     port: 443,
 4     path: '/',
 5     method: 'GET',
 6     key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
 7     cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem')
 8   };
 9   options.agent = new https.Agent(options);
10
11   var req = https.request(options, function(res) {
12   ...
13   }

You can also this without an “agent ” object.

 1   var options = {
 2     hostname: 'encrypted.google.com',
 3     port: 443,
 4     path: '/',
 5     method: 'GET',
 6     key: fs.readFileSync('test/fixtures/keys/agent2-key.pem'),
 7     cert: fs.readFileSync('test/fixtures/keys/agent2-cert.pem'),
 8     agent: false            
 9   };
10
11   var req = https.request(options, function(res) {
12     ...
13   }

Access to the File System

The file system access under Node is made available by the module fs. All calls can take place both synchronously and asynchronously. While for client page scripts (in principle only asynchronous) one of the calls is meaningful, this can be regarded on the server somewhat differently. Since the result of an action is possibly sending JSON or HTML, one usually waits anyway, until the result is present. Asynchronous calls do not have an advantage. However, if your environment is strongly burdening and scripts have noticeable running times, then Node will only always work on a request and then all synchronous actions for these will occur. All other requests wait. Now, if a script waits substantially for a file operation for this part, then the process is altogether slowed down.

Asynchronous calls always use a callback function as last argument. The callback functions have different signatures. However, it is common that the first argument of the callback function is an exception object (exception), which shows errors. In case of success, this object is undefined or “null,” so that a simple test with if(!exception) can start.

Synchronous calls always produce an immediate exception. If an error arises, use try/catch for treating the error conditions.

Here is a first example of the asynchronous use:

1   var fs = require('fs');
2
3   fs.unlink('/tmp/hello', function (err) {
4     if (err) throw err;
5     console.log('successfully deleted /tmp/hello');
6   });

Here, the same example of the synchronous use (consider the suffix Sync in line 3):

1   var fs = require('fs');
2
3   fs.unlinkSync('/tmp/hello');
4   console.log('successfully deleted /tmp/hello');

Asynchronous calls don’t return in deterministic time. If you start several calls, the sequence is not guaranteed with the return. The following example is therefore error-prone:

1   fs.rename('/tmp/hello', '/tmp/world', function (err) {
2     if (err) throw err;
3     console.log('renamed complete');
4   });
5   fs.stat('/tmp/world', function (err, stats) {
6     if (err) throw err;
7     console.log('stats: ' + JSON.stringify(stats));
8   });

Here it can happen that the call of fs.stat in line 5 is successful, before the renaming in line one with “fs.rename” has been finished. Therefore, you should concatenate several asynchronous calls that connect with each other:

1   fs.rename('/tmp/hello', '/tmp/world', function (err) {
2      if (err) throw err;
3      fs.stat('/tmp/world', function (err, stats) {
4         if (err) throw err;
5         console.log('stats: ' + JSON.stringify(stats));
6      });
7   });

You can work with absolute or relative paths. If you work with relative paths, it should be clear that the origin of the current listing is the process in which the script is implemented. This can be determined with process.cwd(). Usually this is Node core.

Sometimes it can occur that you start the action, but don’t need the result. Then you can omit the callback function. But if an error occurs now, the entrance to the exception object will be missing. In order to arrive nevertheless at this error message, you use the environment variable NODE_DEBUG. The following script shows how this takes place:

File: script.js

1   function bad() {
2     require('fs').readFile('/');
3   }
4   bad();

Use the script as follows:

1   $ env NODE_DEBUG=fs node script.js

The following output occurs:

 1   fs.js:66
 2           throw err;
 3                       ^
 4   Error: EISDIR, read
 5       at rethrow (fs.js:61:21)
 6       at maybeCallback (fs.js:79:42)
 7       at Object.fs.readFile (fs.js:153:18)
 8       at bad (/path/to/script.js:2:17)
 9       at Object.<anonymous> (/path/to/script.js:5:1)
10       <etc.>

This certainly only succeeds if the path cannot really be read. In the example, the root “/” is accessed.

Functions for the File Access

This section shows the most important file access functions. Here, only the asynchronous methods are shown. Most methods also exist synchronously. They then have the suffix “Sync” in the name (“rename” versus “renameSync”). With the synchronous methods, the callback function is void.

fs.rename(oldPath, newPath, callback) renames a file. With fs.ftruncate(fd, len, callback), you empty a file. Either a file description object or a path for the file is used for this.

The function group fs.fchown(fd, uid, gid, callback) and fs.lchown(path, uid, gid, callback) sets the owner of a file. Either a file description object is used or the path for the file. The group fs.fchown(fd, mode, callback), fs.chown(path, mode, callback) sets rights to a file. Either a file description object is used or the path for the file.

 These functions are applicable only on Unix systems.

On Windows you now use the function icals if the setting of rights is necessary, which you can access in the Windows command line, e.g., as follows: icacls onlyread.txt /inheritance:r/grant %username%:r

With fs.fstat(fd, callback), fs.stat(path, callback), or fs.lstat(path, callback), you determine information about a file. The callback function has two arguments: err and stats. stats is of the type fs.Stats. Istat processes the link if it’s a symbolic link, not the goal of the link.

With fs.realpath(path[, cache], callback), you determine the genuine path of a file.

1   var cache = {'/etc':'/private/etc'};
2   fs.realpath('/etc/passwd', cache, function (err, resolvedPath) {
3     if (err) throw err;
4     console.log(resolvedPath);
5   });

The method fs.unlink(path, callback) deletes a file. With fs.rmdir(path, callback), a folder is removed. The callback function does not have additional arguments.

With fs.mkdir(path[,mode],callback), a folder is produced. That access t o the folder is specified with 0777 (all to have all rights).

fs.readdir(path, callback) serves to read a folder and place all files in there as an array. The special folders “.” and “..” are not taken up.

The method fs.close(fd, callback) closes an opened file. The callback function does not have additional arguments. fs.open(path, flags[,mode], callback) opens a file for access. The argument flags has the following meaning:

• “r”: open for reading. An exception releases if the file cannot be opened.

• “r+”: open for reading and writing. An exception releases if the file cannot be opened or described.

• “rs”: opens for synchronous access and by avoidance local caches. This can be meaningful with external storage systems; however, it affects the performance negatively.

• “rs+”: opens for synchronous writable access and by avoidance local Caches. This can be meaningful with external storage systems; however, it affects the peformance negatively.

• “w”: opens for writing and if the file does not exist, it is produced. If it exists, it is emptied.

• “wx”: opens for writing and, if the file exists, an exception is produced

• “w+” opens for reading and writing. If the file does not exist, it is produced. If it exists, it is emptied.

• “wx+” opens for reading and writing. If the file exists, an exception is produced.

• “a”: opens for writing and, if the file exists, new data is attached

• “ax”: opens for writing and, if the file exists, an exception is released

• “a+”: opens for reading and writing and, if the file exists, new data is attached

• “ax+”: opens for reading and writing and, if the file exists, an exception is released

mode sets the right of access, if the file is produced . The default value is 0666, writing and reading.

The timestamp of a file can be changed with fs.utimes(path, atime, mtime, callback) and/or with fs.futimes(fd, atime, mtime, callback).

The writing of data happens with fs.write(fd, buffer, offset, length[,position], callback). buffer delivers bites, position the position yet to be.

written is offset, the position in the buffer. The callback function indicates the written bytes, once the number and the buffer. Alternatively fs.write(fd, data[, position[, encoding]], callback) is used.

Reading from data takes place with a description object fd by the means of fs.read(fd, buffer, offset, length, position, callback):

• buffer is the buffer, where the data is written.

• offset is the starting point of the buffer.

• length is the amount of the readable bytes.

• position is the position in the file.

The callback function indicates the number of really read bytes and the buffer.

Directly works with a file with fs.readFile(filename[,options], callback).

1   fs.readFile('/etc/passwd', function (err, data) {
2     if (err) throw err;
3     console.log(data);
4   });

The writing to a file takes place with fs.writeFile(filename, data[,options],callback).

1   fs.writeFile('message.txt', 'Hello Node', function (err) {
2     if (err) throw err;
3     console.log('It's saved!');
4   });

With fs.appendFile(filename, data[,options],callback) it will be attached directly to existing files.

1   fs.appendFile('message.txt', 'data to append',
2                 function (err) {
3     if (err) throw err;
4       console.log('The "data to append" was appended to file!');
5     });

The method fs.watch(filename[,options][,listener] serves to supervise a file during the process of renaming. The method returns an instance of the type fs.FSWatcher.

1   fs.watch('somedir', function (event, filename) {
2     console.log('event is: ' + event);
3     if (filename) {
4       console.log('filename provided: ' + filename);
5     } else {
6       console.log('filename not provided');
7     }
8   });

There is a method fs.exists(path, callback), which tests if the file exists. However, the use of this is not recommended.

With fs.access(path[, mode], callback), you test the rights of access for the current user. The return contains values from a list of constants:

• fs.F_OK: The file is visibile. It says nothing about the rights.

• fs.R_OK: readable

• fs.W_OK: writable

• fs.X_OK: executable

1   fs.access('/etc/passwd', fs.R_OK | fs.W_OK, function(err) {
2     util.debug(err ? 'no access!' : 'can read/write');
3   });                                                                      

Functions for handling Streams

Streams process data byte by byte, which usually is more efficient.

Streams

Streams are a paradigm in programming. They make data available as sequence during one period. More to the theory can be found on Wikipedia.³

The call fs.createReadStream(path[, options]) returns a ReadStream object. The argument options has these default values:

1   {
2     flags: 'r',
3     encoding: null,
4     fd: null,
5     mode: 0666,
6     autoClose: true              
7   }

1   fs.createReadStream('sample.txt', {start: 90, end: 99});

With fs.createWriteStream(path[,options]), a stream to write is provided. The object is of the type WriteStream.

1   {
2     flags: 'w',
3     encoding: null,
4     fd: null,
5     mode: 0666
6   }