Маленькая библиотека для получения данных сайта в стиле jQuery AJAX.
Файл init.js
var request = require('./request');
var cheerio = require('cheerio');
var data = JSON.stringify({
'key1': 'value1'
, 'key2': 'value2'
});
request.httpRequest({
host: 'www.google.com'
, port: 80
, url: '/'
, type: 'POST'
, headers: {
'Content-Type': 'application/x-www-form-urlencoded'
, 'Content-Length': data.length
}
, data: data
, timeout: 120000
, success: function (data) {
var $ = cheerio.load(data);
console.log('Request body text inside <p></p>: ' + $('p').first().text());
}
, error: function (error) {console.log('New request error');}
});
Файл request.js
var http = require('http');
function randomNumber (min, max) {
min = parseInt(min, 10);
max = parseInt(max, 10);
return Math.floor(Math.random() * (max - min + 1)) + min;
}
var commonHeaders = {
'Accept': 'text/xml,application/xml,application/xhtml+xml,text/html;q=0.9,text/plain;q=0.8,image/png,*/*;q=0.' + randomNumber(2, 5)
, 'Accept-Language': 'en-us,en;q=0.' + randomNumber(5, 9)
, 'Accept-Charset': 'utf-8,windows-1251;q=0.7,*;q=0.' + randomNumber(5, 7)
, 'Keep-Alive': '300'
, 'Expect': ''
};
function httpRequest (options) {
if (!options.hasOwnProperty('host')) {options.host = 'localhost';}
if (!options.hasOwnProperty('port')) {options.port = 80;}
if (!options.hasOwnProperty('url')) {options.url = '/';}
if (!options.hasOwnProperty('type')) {options.type = 'GET';}
if (!options.hasOwnProperty('headers')) {options.headers = {};}
if (!options.hasOwnProperty('data')) {options.data = {};}
if (!options.hasOwnProperty('timeout')) {options.timeout = 120000;}
if (!options.hasOwnProperty('success')) {options.success = function(){};}
if (!options.hasOwnProperty('error')) {options.error = function(error){console.log('Request error: ' + error);};}
for (var key in options.headers) {
commonHeaders[key] = options.headers[key];
}
var requestOptions = {
hostname: options.host
, port: options.port
, path: options.url
, method: options.type
, headers: options.headers
};
var request = http.request(requestOptions, function(response) {
console.log('Response status code: ' + response.statusCode);
console.log('Response header: ' + JSON.stringify(response.headers));
response.setEncoding('utf8');
var data = '';
response.on('data', function(chunk){data += chunk;});
response.on('end', function(){options.success(data);});
});
request.setTimeout(options.timeout, function(){console.log('Request timeout');});
request.on('error', options.error);
if (options.data.length > 0) {request.write(options.data);}
request.end();
}
exports.httpRequest = httpRequest;
Пример запуска кода в консоли командной строки
node init.js
Пример полного взаимодействия клиента и сервера на Node JS.
Файл client.js
var http = require('http');
var postData = JSON.stringify({
'msg' : 'Hello World!'
});
var options = {
hostname: '127.0.0.1',
port: 80,
path: '/',
method: 'POST',
headers: {
'Content-Type': 'application/x-www-form-urlencoded',
'Content-Length': postData.length
}
};
var request = http.request(options, function(response) {
console.log('STATUS: ' + response.statusCode);
console.log('HEADERS: ' + JSON.stringify(response.headers));
response.setEncoding('utf8');
response.on('data', function (chunk) {
console.log('BODY: ' + chunk);
});
});
request.on('error', function(error) {
console.log('problem with request: ' + error.message);
});
// write data to request body
request.write(postData);
request.end(); // Always need to write request.end();
Файл server.js
var server = require("./export");
var router = require("./router");
var requestHandlers = require("./requestHandlers");
var handle = {}
handle["/"] = requestHandlers.start;
handle["/start"] = requestHandlers.start;
handle["/upload"] = requestHandlers.upload;
handle["/show"] = requestHandlers.show;
server.start(router.route, handle);
Файл export.js
var http = require("http");
var url = require("url");
function start(route, handle) {
function onRequest(request, response) {
var pathname = url.parse(request.url).pathname;
console.log("Request for " + pathname + " received.");
/*
var postData = "";
request.setEncoding("utf8");
request.addListener("data", function(postDataChunk) {
postData += postDataChunk;
console.log("Received POST data chunk '"+
postDataChunk + "'.");
});
request.addListener("end", function() {
route(handle, pathname, response, postData);
});
*/
route(handle, pathname, response, request);
}
http.createServer(onRequest).listen(80);
console.log("Server has started.");
}
exports.start = start;
Файл router.js
function route(handle, pathname, response, request/*postData*/) {
console.log("About to route a request for " + pathname);
if (typeof handle[pathname] === 'function') {
handle[pathname](response, request/*postData*/);
} else {
console.log("No request handler found for " + pathname);
response.writeHead(404, {"Content-Type": "text/plain"});
response.write("404 Not found");
response.end();
}
}
exports.route = route;
Файл requestHandler.js
var querystring = require("querystring"),
fs = require("fs"),
formidable = require("formidable");
function start(response) {
console.log("Request handler 'start' was called.");
var body = '<html>'+
'<head>'+
'<meta http-equiv="Content-Type" '+
'content="text/html; charset=UTF-8" />'+
'</head>'+
'<body>'+
'<form action="/upload" enctype="multipart/form-data" '+
'method="post">'+
'<input type="file" name="upload" multiple="multiple">'+
'<input type="submit" value="Upload file" />'+
'</form>'+
'</body>'+
'</html>';
response.writeHead(200, {"Content-Type": "text/html"});
response.write(body);
response.end();
}
function upload(response, request) {
console.log("Request handler 'upload' was called.");
var form = new formidable.IncomingForm();
console.log("about to parse");
form.parse(request, function(error, fields, files) {
console.log("parsing done");
/* Возможна ошибка в Windows: попытка переименования уже существующего файла */
fs.rename(files.upload.path, "/tmp/test.png", function(err) {
if (err) {
fs.unlink("/tmp/test.png");
fs.rename(files.upload.path, "/tmp/test.png");
}
});
response.writeHead(200, {"Content-Type": "text/html"});
response.write("received image:<br/>");
response.write("<img src='/show' />");
response.end();
});
}
function show(response) {
console.log("Request handler 'show' was called.");
fs.readFile("/tmp/test.png", "binary", function(error, file) {
if(error) {
response.writeHead(500, {"Content-Type": "text/plain"});
response.write(error + "\n");
response.end();
} else {
response.writeHead(200, {"Content-Type": "image/png"});
response.write(file, "binary");
response.end();
}
});
}
exports.start = start;
exports.upload = upload;
exports.show = show;
Пример запуска кода сервера в консоли командной строки
node server.js
Пример запуска кода клиента в консоли командной строки
node client.js
среда, 25 февраля 2015 г.
понедельник, 16 февраля 2015 г.
Node.js Complete Cheat Sheet
Загрузка и установка Node.js.
// Скачать инсталятор Node.js можно по этому адресу: http://nodejs.org/download/
// Адрес документации по Node.js: http://nodejs.org/api/all.html
0. краткий пример.
// http://nodejs.org/api/synopsis.html
var http = require('http');
// Пример сервера, возвращающего страницу с текстом 'Hello World'.
// Поместите код в файл с именем example.js и запустите его из командной строки, выполнив команду node example.js
http.createServer(function (request, response) {
response.writeHead(200, {'Content-Type': 'text/plain'});
response.end('Hello World\n');
}).listen(8124);
console.log('Server running at http://127.0.0.1:8124/');
1. GLOBAL OBJECTS.
В браузере, если переменная объявлена с ключевым словом var, то она является глобальной переменной независимо от того, в каком файле она прописана. В Node.js переменная объявленная с ключевым словом var внутри файла является локальной переменной видимой только внутри этого файла.
// http://nodejs.org/api/globals.html
__filename; // Имя файла, код которого выполняется в данный момент. (абсолютный путь)
__dirname; // Имя директории, в которой находится исполняемый в данный момент файл. (абсолютный путь)
module; // Ссылка на текущий модуль. Обычно module.exports используется для экспортирования переменных и функций вне модуля, чтобы они были доступны через функцию require().
exports; // Укороченный вариант записи module.exports.
process; // Объект процесса являетс глобальным объектом, который доступен отовсюду.Этот объект является экземпляром EventEmitter.
Buffer; // Buffer - это глобальный класс, предназначенный для обработки напрямую двоичных данных.
2. CONSOLE.
// http://nodejs.org/api/console.html
console.log([data], [...]); // Выводит сообщение в консоль stdout командной строки с переходом на другую строку.
console.info([data], [...]); // Тоже самое, что и console.log.
console.error([data], [...]); // Тоже самое, что и console.log, но выводит сообщение в консоль stderr командной строки с переходом на другую строку.console.warn([data], [...]); // Тоже самое, что и console.error.console.dir(obj); // Использует util.inspect на объекте obj и выводит результат в виде строки в консоль stdout командной строки.console.time(label); // Выводит в консоль командной строки отметку о текущем времени.
console.timeEnd(label); // Завершает работу таймера и выводит результат в консоль командной строки.
console.trace(label); // Выводит стэк вызовов в консоль stderr командной строки с указанием текущей позиции выполнения кода программы.
console.assert(expression, [message]); // Тоже самое, что и assert.ok(), в котором если результатом выполняемого выражения является false, то выбрасывается исключение AssertionError с заданным сообщением message.3. TIMERS.
// http://nodejs.org/api/timers.html
setTimeout(callback, delay, [arg], [...]); // Устанавливает выполнение одноразового вызова функции callback через определенное число миллисекунд delay. Дополнительно вы можете передать аргументы args в вызываемую функциюcallback.
clearTimeout(t); // Удаляет срабатывание таймера, который до этого был установлен с помощью функции setTimeout().
setInterval(callback, delay, [arg], [...]); // Устанавливает выполнение овызова функции callback каждый раз через определенное число миллисекунд delay. Дополнительно вы можете передать аргументы args в вызываемую функциюcallback.clearInterval(t); // Удаляет срабатывание таймера, который до этого был установлен с помощью функции setInterval().setImmediate(callback, [arg], [...]); // Устанавливает немедленное выполнение функции callback до событий, установленных в setTimeout и setInterval сразу после того как все события ввода-вывода и команды в стэке вызовов будут выполнены.clearImmediate(immediateObject); // Удаляет срабатывание таймера, который до этого был установлен с помощью функции setImmediate().
unref(); // Позволяет создать таймер, который будет активным, но если он единственный элемент оставшийся в цикле событий, то программа завершиться.ref(); // Если ранее вы установили таймер unref(), то теперь вы можете вызвать функцию ref() чтобы оставить программу открытой.
4. MODULES.
// http://nodejs.org/api/modules.html
var module = require('./module.js'); // Загружает модуль module.js, находящийся в той же директории, что и выполняемый файл.
module.require('./another_module.js'); // Загружает модуль load another_module так, как если бы функция require() была вызвана изнутри модуля.
module.id; // Идентификатор модуля. Обычно это полное имя файла.
module.filename; // Имя файла модуля.
module.loaded; // Показывает загружен модуль или нет или он находится в процессе загрузки.
module.parent; // Родительский модуль, который требуется для работы данного модуля.
module.children; // Объекты данного модуля, которые используются для работы в дочерних модулях.
exports.area = function (r) {
return 3.14 * r * r;
};
// Если вы хотите, чтобы экспорт из модуля был функцией, например конструктором, или если вы хотите экспортировать большой объект за один раз, то используйте module.exports вместо exports.
module.exports = function(width) {
return {
area: function() {
return width * width;
}
};
}
5. PROCESS.
// http://nodejs.org/api/process.html
process.on('exit', function(code) {}); // Излучает событие, когда процесс готов совершить выход
process.on('uncaughtException', function(err) {}); // Излучает событие, когда исключение всплывает в цикле событий. (не следует использовать)
process.stdout; // Поток для записи в stdout.
process.stderr; // Поток для записи в stderr.process.stdin; // Поток для чтения из stdin.
process.argv; // Массив, содержащий в себе введенные аргументы из командной строки.
process.env; // Объект содержащий в себе информацию о пользовательском окружении.
process.execPath; // Абсолютный путь исполняемого файла, который запустил процесс.
process.execArgv; // Особый набор опций командной строки для исполняемого файла, который запустил процесс.
process.arch; // Показывает какой процессор вы используете: 'arm', 'ia32' или 'x64'.
process.config; // Объект, содержащий в себе набор JavaScript опций, которые были использованы для компиляции текущего процесс node.
process.pid; // PID процесса.
process.platform; // Показывает какую операционную системы вы используете: 'darwin', 'freebsd', 'linux', 'sunos' или 'win32'.
process.title; // Getter/setter для установки того, что отображается в 'ps'.
process.version; // Скомпилированное свойство, которое показываетNODE_VERSION.
process.versions; // Свойство показывающее номер версии Node и его зависимости.
process.abort(); // Вызывает перервыние процесса и выход из программы.
process.chdir(dir); // Изменяет текущую рабочую директорию процесса или выбрасывает исключение в случае ошибки.
process.cwd(); // Возвращает текущую рабочую директорию процесса.
process.exit([code]); // Завершает процесс с определенным кодом. Успешный выход происходит с кодом 0.
process.getgid(); // Получает идентификатор группы процесса.
process.setgid(id); // Устанавливает идентификатор группы процесса.process.getuid(); // Получает идентификатор пользователя процесса.
process.setuid(id); // Устанавливает идентификатор пользователя процесса.process.getgroups(); // Возвращает массив идентификаторов групп.
process.setgroups(grps); // Устанавливает массив идентификаторов групп.
process.initgroups(user, extra_grp); // Читает содержимое /etc/group и инициализирует список групп доступа, используя все группы, в которых данный пользователь является членом.
process.kill(pid, [signal]); // Посылает сигнал процессу. pid - это идентификатор процесса. signal - это строка, описывающая какой сигнал надо послать.
process.memoryUsage(); // Возвращает объект, описывающий используемую память в байтах.
process.nextTick(callback); // На следующем шаге цикла событий будет вызвана функция callback.
process.maxTickDepth; // Callbacks переданные process.nextTick будут вызваны в конце текущего потока выполнения, как если бы данная функция была вызвана синхронно.
process.umask([mask]); // Устанавливает или считывает маску файла процесса.
process.uptime(); // Показывает время работы Node в секундах.
process.hrtime(); // Возвращает точное время в виде массива [seconds, nanoseconds].
6. CHILD PROCESS.
Node provides a tri-directional popen facility through the child_process module. It is possible to stream data through a child's stdin, stdout, and stderr in a fully non-blocking way.
// http://nodejs.org/api/child_process.html
ChildProcess; // Class. ChildProcess is an EventEmitter.
child.stdin; // A Writable Stream that represents the child process's stdin
child.stdout; // A Readable Stream that represents the child process's stdout
child.stderr; // A Readable Stream that represents the child process's stderr.
child.pid; // The PID of the child process
child.connected; // If .connected is false, it is no longer possible to send messages
child.kill([signal]); // Send a signal to the child process
child.send(message, [sendHandle]); // When using child_process.fork() you can write to the child using child.send(message, [sendHandle]) and messages are received by a 'message' event on the child.
child.disconnect(); // Close the IPC channel between parent and child, allowing the child to exit gracefully once there are no other connections keeping it alive.
child_process.spawn(command, [args], [options]); // Launches a new process with the given command, with command line arguments in args. If omitted, args defaults to an empty Array.
child_process.exec(command, [options], callback); // Runs a command in a shell and buffers the output.
child_process.execFile(file, [args], [options], [callback]); // Runs a command in a shell and buffers the output.
child_process.fork(modulePath, [args], [options]); // This is a special case of the spawn() functionality for spawning Node processes. In addition to having all the methods in a normal ChildProcess instance, the returned object has a communication channel built-in.
7. UTIL.
These functions are in the module 'util'. Use
require('util') to access them.// http://nodejs.org/api/util.html
util.format(format, [...]); // Returns a formatted string using the first argument as a printf-like format. (%s, %d, %j)
util.debug(string); // A synchronous output function. Will block the process and output string immediately to stderr.
util.error([...]); // Same as util.debug() except this will output all arguments immediately to stderr.
util.puts([...]); // A synchronous output function. Will block the process and output all arguments to stdout with newlines after each argument.
util.print([...]); // A synchronous output function. Will block the process, cast each argument to a string then output to stdout. (no newlines)
util.log(string); // Output with timestamp on stdout.
util.inspect(object, [opts]); // Return a string representation of object, which is useful for debugging. (options: showHidden, depth, colors, customInspect)
util.isArray(object); // Returns true if the given "object" is an Array. false otherwise.
util.isRegExp(object); // Returns true if the given "object" is a RegExp. false otherwise.
util.isDate(object); // Returns true if the given "object" is a Date. false otherwise.
util.isError(object); // Returns true if the given "object" is an Error. false otherwise.
util.inherits(constructor, superConstructor); // Inherit the prototype methods from one constructor into another.
8. EVENTS.
All objects which emit events are instances of events.EventEmitter. You can access this module by doing:
require("events"); To access the EventEmitter class, require('events').EventEmitter. All EventEmitters emit the event 'newListener' when new listeners are added and 'removeListener' when a listener is removed.// http://nodejs.org/api/events.html
emitter.addListener(event, listener); // Adds a listener to the end of the listeners array for the specified event.
emitter.on(event, listener); // Same as emitter.addListener().
emitter.once(event, listener); // Adds a one time listener for the event. This listener is invoked only the next time the event is fired, after which it is removed.
emitter.removeListener(event, listener); // Remove a listener from the listener array for the specified event.
emitter.removeAllListeners([event]); // Removes all listeners, or those of the specified event.
emitter.setMaxListeners(n); // By default EventEmitters will print a warning if more than 10 listeners are added for a particular event.
emitter.listeners(event); // Returns an array of listeners for the specified event.
emitter.emit(event, [arg1], [arg2], [...]); // Execute each of the listeners in order with the supplied arguments. Returns true if event had listeners, false otherwise.
EventEmitter.listenerCount(emitter, event); // Return the number of listeners for a given event.
9. STREAM.
A stream is an abstract interface implemented by various objects in Node. For example a request to an HTTP server is a stream, as is stdout. Streams are readable, writable, or both. All streams are instances of EventEmitter.
// http://nodejs.org/api/stream.html
// The Readable stream interface is the abstraction for a source of data that you are reading from.
// In other words, data comes out of a Readable stream.
// A Readable stream will not start emitting data until you indicate that you are ready to receive it.
// Examples of readable streams include: http responses on the client, http requests on the server, fs read streams
// zlib streams, crypto streams, tcp sockets, child process stdout and stderr, process.stdin.
var readable = getReadableStreamSomehow();
readable.on('readable', function() {}); // When a chunk of data can be read from the stream, it will emit a 'readable' event.
readable.on('data', function(chunk) {}); // If you attach a data event listener, then it will switch the stream into flowing mode, and data will be passed to your handler as soon as it is available.
readable.on('end', function() {}); // This event fires when there will be no more data to read.
readable.on('close', function() {}); // Emitted when the underlying resource (for example, the backing file descriptor) has been closed. Not all streams will emit this.
readable.on('error', function() {}); // Emitted if there was an error receiving data.
// The read() method pulls some data out of the internal buffer and returns it. If there is no data available, then it will return null.
// This method should only be called in non-flowing mode. In flowing-mode, this method is called automatically until the internal buffer is drained.
readable.read([size]);
readable.setEncoding(encoding); // Call this function to cause the stream to return strings of the specified encoding instead of Buffer objects.
readable.resume(); // This method will cause the readable stream to resume emitting data events.
readable.pause(); // This method will cause a stream in flowing-mode to stop emitting data events.
readable.pipe(destination, [options]); // This method pulls all the data out of a readable stream, and writes it to the supplied destination, automatically managing the flow so that the destination is not overwhelmed by a fast readable stream.
readable.unpipe([destination]); // This method will remove the hooks set up for a previous pipe() call. If the destination is not specified, then all pipes are removed.
readable.unshift(chunk); // This is useful in certain cases where a stream is being consumed by a parser, which needs to "un-consume" some data that it has optimistically pulled out of the source, so that the stream can be passed on to some other party.
// The Writable stream interface is an abstraction for a destination that you are writing data to.
// Examples of writable streams include: http requests on the client, http responses on the server, fs write streams,
// zlib streams, crypto streams, tcp sockets, child process stdin, process.stdout, process.stderr.
var writer = getWritableStreamSomehow();
writable.write(chunk, [encoding], [callback]); // This method writes some data to the underlying system, and calls the supplied callback once the data has been fully handled.
writer.once('drain', write); // If a writable.write(chunk) call returns false, then the drain event will indicate when it is appropriate to begin writing more data to the stream.
writable.end([chunk], [encoding], [callback]); // Call this method when no more data will be written to the stream.
writer.on('finish', function() {}); // When the end() method has been called, and all data has been flushed to the underlying system, this event is emitted.
writer.on('pipe', function(src) {}); // This is emitted whenever the pipe() method is called on a readable stream, adding this writable to its set of destinations.
writer.on('unpipe', function(src) {}); // This is emitted whenever the unpipe() method is called on a readable stream, removing this writable from its set of destinations.
writer.on('error', function(src) {}); // Emitted if there was an error when writing or piping data.
// Duplex streams are streams that implement both the Readable and Writable interfaces. See above for usage.
// Examples of Duplex streams include: tcp sockets, zlib streams, crypto streams.
// Transform streams are Duplex streams where the output is in some way computed from the input. They implement both the Readable and Writable interfaces. See above for usage.
// Examples of Transform streams include: zlib streams, crypto streams.
10. FILE SYSTEM.
To use this module do
require('fs'). All the methods have asynchronous and synchronous forms.// http://nodejs.org/api/fs.html
fs.rename(oldPath, newPath, callback); // Asynchronous rename. No arguments other than a possible exception are given to the completion callback.Asynchronous ftruncate. No arguments other than a possible exception are given to the completion callback.
fs.renameSync(oldPath, newPath); // Synchronous rename.
fs.ftruncate(fd, len, callback); // Asynchronous ftruncate. No arguments other than a possible exception are given to the completion callback.
fs.ftruncateSync(fd, len); // Synchronous ftruncate.
fs.truncate(path, len, callback); // Asynchronous truncate. No arguments other than a possible exception are given to the completion callback.
fs.truncateSync(path, len); // Synchronous truncate.
fs.chown(path, uid, gid, callback); // Asynchronous chown. No arguments other than a possible exception are given to the completion callback.
fs.chownSync(path, uid, gid); // Synchronous chown.
fs.fchown(fd, uid, gid, callback); // Asynchronous fchown. No arguments other than a possible exception are given to the completion callback.
fs.fchownSync(fd, uid, gid); // Synchronous fchown.
fs.lchown(path, uid, gid, callback); // Asynchronous lchown. No arguments other than a possible exception are given to the completion callback.
fs.lchownSync(path, uid, gid); // Synchronous lchown.
fs.chmod(path, mode, callback); // Asynchronous chmod. No arguments other than a possible exception are given to the completion callback.
fs.chmodSync(path, mode); // Synchronous chmod.
fs.fchmod(fd, mode, callback); // Asynchronous fchmod. No arguments other than a possible exception are given to the completion callback.
fs.fchmodSync(fd, mode); // Synchronous fchmod.
fs.lchmod(path, mode, callback); // Asynchronous lchmod. No arguments other than a possible exception are given to the completion callback.
fs.lchmodSync(path, mode); // Synchronous lchmod.
fs.stat(path, callback); // Asynchronous stat. The callback gets two arguments (err, stats) where stats is a fs.Stats object.
fs.statSync(path); // Synchronous stat. Returns an instance of fs.Stats.
fs.lstat(path, callback); // Asynchronous lstat. The callback gets two arguments (err, stats) where stats is a fs.Stats object. lstat() is identical to stat(), except that if path is a symbolic link, then the link itself is stat-ed, not the file that it refers to.
fs.lstatSync(path); // Synchronous lstat. Returns an instance of fs.Stats.
fs.fstat(fd, callback); // Asynchronous fstat. The callback gets two arguments (err, stats) where stats is a fs.Stats object. fstat() is identical to stat(), except that the file to be stat-ed is specified by the file descriptor fd.
fs.fstatSync(fd); // Synchronous fstat. Returns an instance of fs.Stats.
fs.link(srcpath, dstpath, callback); // Asynchronous link. No arguments other than a possible exception are given to the completion callback.
fs.linkSync(srcpath, dstpath); // Synchronous link.
fs.symlink(srcpath, dstpath, [type], callback); // Asynchronous symlink. No arguments other than a possible exception are given to the completion callback. The type argument can be set to 'dir', 'file', or 'junction' (default is 'file') and is only available on Windows (ignored on other platforms)
fs.symlinkSync(srcpath, dstpath, [type]); // Synchronous symlink.
fs.readlink(path, callback); // Asynchronous readlink. The callback gets two arguments (err, linkString).
fs.readlinkSync(path); // Synchronous readlink. Returns the symbolic link's string value.
fs.unlink(path, callback); // Asynchronous unlink. No arguments other than a possible exception are given to the completion callback.
fs.unlinkSync(path); // Synchronous unlink.
fs.realpath(path, [cache], callback); // Asynchronous realpath. The callback gets two arguments (err, resolvedPath).
fs.realpathSync(path, [cache]); // Synchronous realpath. Returns the resolved path.
fs.rmdir(path, callback); // Asynchronous rmdir. No arguments other than a possible exception are given to the completion callback.
fs.rmdirSync(path); // Synchronous rmdir.
fs.mkdir(path, [mode], callback); // Asynchronous mkdir. No arguments other than a possible exception are given to the completion callback. mode defaults to 0777.
fs.mkdirSync(path, [mode]); // Synchronous mkdir.
fs.readdir(path, callback); // Asynchronous readdir. Reads the contents of a directory. The callback gets two arguments (err, files) where files is an array of the names of the files in the directory excluding '.' and '..'.
fs.readdirSync(path); // Synchronous readdir. Returns an array of filenames excluding '.' and '..'.
fs.close(fd, callback); // Asynchronous close. No arguments other than a possible exception are given to the completion callback.
fs.closeSync(fd); // Synchronous close.
fs.open(path, flags, [mode], callback); // Asynchronous file open.
fs.openSync(path, flags, [mode]); // Synchronous version of fs.open().
fs.utimes(path, atime, mtime, callback); // Change file timestamps of the file referenced by the supplied path.
fs.utimesSync(path, atime, mtime); // Synchronous version of fs.utimes().
fs.futimes(fd, atime, mtime, callback); // Change the file timestamps of a file referenced by the supplied file descriptor.
fs.futimesSync(fd, atime, mtime); // Synchronous version of fs.futimes().
fs.fsync(fd, callback); // Asynchronous fsync. No arguments other than a possible exception are given to the completion callback.
fs.fsyncSync(fd); // Synchronous fsync.
fs.write(fd, buffer, offset, length, position, callback); // Write buffer to the file specified by fd.
fs.writeSync(fd, buffer, offset, length, position); // Synchronous version of fs.write(). Returns the number of bytes written.
fs.read(fd, buffer, offset, length, position, callback); // Read data from the file specified by fd.
fs.readSync(fd, buffer, offset, length, position); // Synchronous version of fs.read. Returns the number of bytesRead.
fs.readFile(filename, [options], callback); // Asynchronously reads the entire contents of a file.
fs.readFileSync(filename, [options]); // Synchronous version of fs.readFile. Returns the contents of the filename. If the encoding option is specified then this function returns a string. Otherwise it returns a buffer.
fs.writeFile(filename, data, [options], callback); // Asynchronously writes data to a file, replacing the file if it already exists. data can be a string or a buffer.
fs.writeFileSync(filename, data, [options]); // The synchronous version of fs.writeFile.
fs.appendFile(filename, data, [options], callback); // Asynchronously append data to a file, creating the file if it not yet exists. data can be a string or a buffer.
fs.appendFileSync(filename, data, [options]); // The synchronous version of fs.appendFile.
fs.watch(filename, [options], [listener]); // Watch for changes on filename, where filename is either a file or a directory. The returned object is a fs.FSWatcher. The listener callback gets two arguments (event, filename). event is either 'rename' or 'change', and filename is the name of the file which triggered the event.
fs.exists(path, callback); // Test whether or not the given path exists by checking with the file system. Then call the callback argument with either true or false. (should not be used)
fs.existsSync(path); // Synchronous version of fs.exists. (should not be used)
// fs.Stats: objects returned from fs.stat(), fs.lstat() and fs.fstat() and their synchronous counterparts are of this type.
stats.isFile();
stats.isDirectory()
stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() // (only valid with fs.lstat())
stats.isFIFO()
stats.isSocket()
fs.createReadStream(path, [options]); // Returns a new ReadStream object.
fs.createWriteStream(path, [options]); // Returns a new WriteStream object.
11. PATH.
Use
require('path') to use this module. This module contains utilities for handling and transforming file paths. Almost all these methods perform only string transformations. The file system is not consulted to check whether paths are valid.// http://nodejs.org/api/fs.html
path.normalize(p); // Normalize a string path, taking care of '..' and '.' parts.
path.join([path1], [path2], [...]); // Join all arguments together and normalize the resulting path.
path.resolve([from ...], to); // Resolves 'to' to an absolute path.
path.relative(from, to); // Solve the relative path from 'from' to 'to'.
path.dirname(p); // Return the directory name of a path. Similar to the Unix dirname command.
path.basename(p, [ext]); // Return the last portion of a path. Similar to the Unix basename command.
path.extname(p); // Return the extension of the path, from the last '.' to end of string in the last portion of the path.
path.sep; // The platform-specific file separator. '\\' or '/'.
path.delimiter; // The platform-specific path delimiter, ';' or ':'.
12. HTTP.
To use the HTTP server and client one must
require('http').// http://nodejs.org/api/http.html
http.STATUS_CODES; // A collection of all the standard HTTP response status codes, and the short description of each.
http.request(options, [callback]); // This function allows one to transparently issue requests.
http.get(options, [callback]); // Set the method to GET and calls req.end() automatically.
server = http.createServer([requestListener]); // Returns a new web server object. The requestListener is a function which is automatically added to the 'request' event.
server.listen(port, [hostname], [backlog], [callback]); // Begin accepting connections on the specified port and hostname.
server.listen(path, [callback]); // Start a UNIX socket server listening for connections on the given path.
server.listen(handle, [callback]); // The handle object can be set to either a server or socket (anything with an underlying _handle member), or a {fd: <n>} object.
server.close([callback]); // Stops the server from accepting new connections.
server.setTimeout(msecs, callback); // Sets the timeout value for sockets, and emits a 'timeout' event on the Server object, passing the socket as an argument, if a timeout occurs.
server.maxHeadersCount; // Limits maximum incoming headers count, equal to 1000 by default. If set to 0 - no limit will be applied.
server.timeout; // The number of milliseconds of inactivity before a socket is presumed to have timed out.
server.on('request', function (request, response) { }); // Emitted each time there is a request.
server.on('connection', function (socket) { }); // When a new TCP stream is established.
server.on('close', function () { }); // Emitted when the server closes.
server.on('checkContinue', function (request, response) { }); // Emitted each time a request with an http Expect: 100-continue is received.
server.on('connect', function (request, socket, head) { }); // Emitted each time a client requests a http CONNECT method.
server.on('upgrade', function (request, socket, head) { }); // Emitted each time a client requests a http upgrade.
server.on('clientError', function (exception, socket) { }); // If a client connection emits an 'error' event - it will forwarded here.
request.write(chunk, [encoding]); // Sends a chunk of the body.
request.end([data], [encoding]); // Finishes sending the request. If any parts of the body are unsent, it will flush them to the stream.
request.abort(); // Aborts a request.
request.setTimeout(timeout, [callback]); // Once a socket is assigned to this request and is connected socket.setTimeout() will be called.
request.setNoDelay([noDelay]); // Once a socket is assigned to this request and is connected socket.setNoDelay() will be called.
request.setSocketKeepAlive([enable], [initialDelay]); // Once a socket is assigned to this request and is connected socket.setKeepAlive() will be called.
request.on('response', function(response) { }); // Emitted when a response is received to this request. This event is emitted only once.
request.on('socket', function(socket) { }); // Emitted after a socket is assigned to this request.
request.on('connect', function(response, socket, head) { }); // Emitted each time a server responds to a request with a CONNECT method. If this event isn't being listened for, clients receiving a CONNECT method will have their connections closed.
request.on('upgrade', function(response, socket, head) { }); // Emitted each time a server responds to a request with an upgrade. If this event isn't being listened for, clients receiving an upgrade header will have their connections closed.
request.on('continue', function() { }); // Emitted when the server sends a '100 Continue' HTTP response, usually because the request contained 'Expect: 100-continue'. This is an instruction that the client should send the request body.
response.write(chunk, [encoding]); // This sends a chunk of the response body. If this merthod is called and response.writeHead() has not been called, it will switch to implicit header mode and flush the implicit headers.
response.writeContinue(); // Sends a HTTP/1.1 100 Continue message to the client, indicating that the request body should be sent.
response.writeHead(statusCode, [reasonPhrase], [headers]); // Sends a response header to the request.
response.setTimeout(msecs, callback); // Sets the Socket's timeout value to msecs. If a callback is provided, then it is added as a listener on the 'timeout' event on the response object.
response.setHeader(name, value); // Sets a single header value for implicit headers. If this header already exists in the to-be-sent headers, its value will be replaced. Use an array of strings here if you need to send multiple headers with the same name.
response.getHeader(name); // Reads out a header that's already been queued but not sent to the client. Note that the name is case insensitive.
response.removeHeader(name); // Removes a header that's queued for implicit sending.
response.addTrailers(headers); // This method adds HTTP trailing headers (a header but at the end of the message) to the response.
response.end([data], [encoding]); // This method signals to the server that all of the response headers and body have been sent; that server should consider this message complete. The method, response.end(), MUST be called on each response.
response.statusCode; // When using implicit headers (not calling response.writeHead() explicitly), this property controls the status code that will be sent to the client when the headers get flushed.
response.headersSent; // Boolean (read-only). True if headers were sent, false otherwise.
response.sendDate; // When true, the Date header will be automatically generated and sent in the response if it is not already present in the headers. Defaults to true.
response.on('close', function () { }); // Indicates that the underlying connection was terminated before response.end() was called or able to flush.
response.on('finish', function() { }); // Emitted when the response has been sent.
message.httpVersion; // In case of server request, the HTTP version sent by the client. In the case of client response, the HTTP version of the connected-to server.
message.headers; // The request/response headers object.
message.trailers; // The request/response trailers object. Only populated after the 'end' event.
message.method; // The request method as a string. Read only. Example: 'GET', 'DELETE'.
message.url; // Request URL string. This contains only the URL that is present in the actual HTTP request.
message.statusCode; // The 3-digit HTTP response status code. E.G. 404.
message.socket; // The net.Socket object associated with the connection.
message.setTimeout(msecs, callback); // Calls message.connection.setTimeout(msecs, callback).
13. URL.
This module has utilities for URL resolution and parsing. Call
require('url') to use it.// http://nodejs.org/api/url.html
url.parse(urlStr, [parseQueryString], [slashesDenoteHost]); // Take a URL string, and return an object.
url.format(urlObj); // Take a parsed URL object, and return a formatted URL string.
url.resolve(from, to); // Take a base URL, and a href URL, and resolve them as a browser would for an anchor tag.
14. QUERY STRING.
This module provides utilities for dealing with query strings. Call
require('querystring') to use it.// http://nodejs.org/api/querystring.html
querystring.stringify(obj, [sep], [eq]); // Serialize an object to a query string. Optionally override the default separator ('&') and assignment ('=') characters.
querystring.parse(str, [sep], [eq], [options]); // Deserialize a query string to an object. Optionally override the default separator ('&') and assignment ('=') characters.
15. ASSERT.
This module is used for writing unit tests for your applications, you can access it with
require('assert').// http://nodejs.org/api/assert.html
assert.fail(actual, expected, message, operator); // Throws an exception that displays the values for actual and expected separated by the provided operator.
assert(value, message); assert.ok(value, [message]); // Tests if value is truthy, it is equivalent to assert.equal(true, !!value, message);
assert.equal(actual, expected, [message]); // Tests shallow, coercive equality with the equal comparison operator ( == ).
assert.notEqual(actual, expected, [message]); // Tests shallow, coercive non-equality with the not equal comparison operator ( != ).
assert.deepEqual(actual, expected, [message]); // Tests for deep equality.
assert.notDeepEqual(actual, expected, [message]); // Tests for any deep inequality.
assert.strictEqual(actual, expected, [message]); // Tests strict equality, as determined by the strict equality operator ( === )
assert.notStrictEqual(actual, expected, [message]); // Tests strict non-equality, as determined by the strict not equal operator ( !== )
assert.throws(block, [error], [message]); // Expects block to throw an error. error can be constructor, RegExp or validation function.
assert.doesNotThrow(block, [message]); // Expects block not to throw an error, see assert.throws for details.
assert.ifError(value); // Tests if value is not a false value, throws if it is a true value. Useful when testing the first argument, error in callbacks.
16. OS.
Provides a few basic operating-system related utility functions. Use
require('os') to access this module.// http://nodejs.org/api/os.html
os.tmpdir(); // Returns the operating system's default directory for temp files.
os.endianness(); // Returns the endianness of the CPU. Possible values are "BE" or "LE".
os.hostname(); // Returns the hostname of the operating system.
os.type(); // Returns the operating system name.
os.platform(); // Returns the operating system platform.
os.arch(); // Returns the operating system CPU architecture.
os.release(); // Returns the operating system release.
os.uptime(); // Returns the system uptime in seconds.
os.loadavg(); // Returns an array containing the 1, 5, and 15 minute load averages.
os.totalmem(); // Returns the total amount of system memory in bytes.
os.freemem(); // Returns the amount of free system memory in bytes.
os.cpus(); // Returns an array of objects containing information about each CPU/core installed: model, speed (in MHz), and times (an object containing the number of milliseconds the CPU/core spent in: user, nice, sys, idle, and irq).
os.networkInterfaces(); // Get a list of network interfaces.
os.EOL; // A constant defining the appropriate End-of-line marker for the operating system.
17. BUFFER.
Buffer is used to dealing with binary data Buffer is similar to an array of integers but corresponds to a raw memory allocation outside the V8 heap.
// http://nodejs.org/api/buffer.html
new Buffer(size); // Allocates a new buffer of size octets.
new Buffer(array); // Allocates a new buffer using an array of octets.
new Buffer(str, [encoding]); // Allocates a new buffer containing the given str. encoding defaults to 'utf8'.
Buffer.isEncoding(encoding); // Returns true if the encoding is a valid encoding argument, or false otherwise.
Buffer.isBuffer(obj); // Tests if obj is a Buffer
Buffer.concat(list, [totalLength]); // Returns a buffer which is the result of concatenating all the buffers in the list together.
Buffer.byteLength(string, [encoding]); // Gives the actual byte length of a string.
buf.write(string, [offset], [length], [encoding]); // Writes string to the buffer at offset using the given encoding
buf.toString([encoding], [start], [end]); // Decodes and returns a string from buffer data encoded with encoding (defaults to 'utf8') beginning at start (defaults to 0) and ending at end (defaults to buffer.length).
buf.toJSON(); // Returns a JSON-representation of the Buffer instance, which is identical to the output for JSON Arrays
buf.copy(targetBuffer, [targetStart], [sourceStart], [sourceEnd]); // Does copy between buffers. The source and target regions can be overlapped
buf.slice([start], [end]); // Returns a new buffer which references the same memory as the old, but offset and cropped by the start (defaults to 0) and end (defaults to buffer.length) indexes. Negative indexes start from the end of the buffer.
buf.fill(value, [offset], [end]); // Fills the buffer with the specified value
buf[index]; // Get and set the octet at index
buf.length; // The size of the buffer in bytes, Note that this is not necessarily the size of the contents
buffer.INSPECT_MAX_BYTES; // How many bytes will be returned when buffer.inspect() is called. This can be overridden by user modules.
Подписаться на:
Сообщения (Atom)