Основные функции NodeJs, добавляй в закладки и пользуйся
/* *******************************************************************************************
* SYNOPSIS
* http://nodejs.org/api/synopsis.html
* ******************************************************************************************* */
var http = require('http');
// Пример веб-сервера, написанного с помощью Node, который отвечает «Hello World».
// Чтобы запустить сервер, поместите код в файл с именем 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/');
/* *******************************************************************************************
* GLOBAL OBJECTS
* http://nodejs.org/api/globals.html
* ******************************************************************************************* */
// В браузерах область верхнего уровня - это глобальная область.
// Это означает, что в браузерах, если вы находитесь в глобальной области видимости var, что-то определит глобальную переменную.
// В Node все по-другому. Область верхнего уровня не является глобальной областью; var что-то внутри модуля Node будет локальным для этого модуля.
filename; // Имя исполняемого кода. (абсолютный путь)
dirname; // Имя каталога, в котором находится исполняемый в данный момент скрипт. (Абсолютный путь)
module; // Ссылка на текущий модуль. В частности, module.exports используется для определения того, что модуль экспортирует и делает доступным через require ().
exports; // Ссылка на module.exports, более короткая для ввода.
process; // Объект процесса - это глобальный объект, к которому можно получить доступ откуда угодно. Это экземпляр EventEmitter.
Buffer; // Класс Buffer - это глобальный тип для непосредственной работы с двоичными данными.
/* *******************************************************************************************
* CONSOLE
* http://nodejs.org/api/console.html
* ******************************************************************************************* */
console.log([data], [...]); // Печатает в стандартный вывод с новой строкой.
console.info([data], [...]); // То же, что и console.log.
console.error([data], [...]); // То же, что console.log, но выводится в stderr.
console.warn([data], [...]); // То же, что и console.error.
console.dir(obj); // Использует util.inspect для obj и выводит результирующую строку на стандартный вывод.
console.time(label); // Отметьте время.
console.timeEnd(label); // Завершить таймер, записать вывод.
console.trace(label); // Выводим трассировку стека в stderr текущей позиции.
console.assert(expression, [message]); // То же, что и assert.ok (), где, если выражение оценивается как ложное, генерирует AssertionError с сообщением.
/* *******************************************************************************************
* TIMERS
* http://nodejs.org/api/timers.html
* ******************************************************************************************* */
setTimeout(callback, delay, [arg], [...]); // Запланировать выполнение одноразового обратного вызова после задержки в миллисекундах. При желании вы также можете передать аргументы обратному вызову.
clearTimeout(t); // Остановить таймер, который был ранее создан с помощью setTimeout ().
setInterval(callback, delay, [arg], [...]); // Чтобы запланировать повторное выполнение обратного вызова каждые миллисекунды задержки. При желании вы также можете передать аргументы обратному вызову.
clearInterval(t); // Остановка таймера, который был ранее создан с помощью setInterval ().
setImmediate(callback, [arg], [...]); // Чтобы запланировать "немедленное" выполнение обратного вызова после обратных вызовов событий ввода-вывода и до setTimeout и setInterval.
clearImmediate(immediateObject); // Остановка таймера, который был ранее создан с помощью setImmediate ().
unref(); // Позволяет вам создать активный таймер, но если это единственный элемент, оставшийся в цикле событий, Node не будет поддерживать выполнение программы.
ref(); // Если у вас ранее был unref () d таймер, вы можете вызвать ref (), чтобы явно запросить таймер, удерживающий программу открытой.
/* *******************************************************************************************
* MODULES
* http://nodejs.org/api/modules.html
* ******************************************************************************************* */
var module = require('./module.js'); // Загружает модуль module.js в тот же каталог.
module.require('./another_module.js'); // загружаем another_module, как если бы require () был вызван из самого модуля.
module.id; // Идентификатор модуля. Обычно это полностью разрешенное имя файла.
module.filename; // Полностью разрешенное имя файла для модуля.
module.loaded; // Независимо от того, завершена ли загрузка модуля, или он находится в процессе загрузки.
module.parent; // Модуль, которому он нужен.
module.children; // Объекты модуля, необходимые для этого.
exports.area = function(r) {
return Math.PI * r * r;
};
// Если вы хотите, чтобы корень экспорта вашего модуля был функцией (например, конструктором)
// или если вы хотите экспортировать весь объект в одном назначении вместо того, чтобы строить его по одному свойству за раз,
// присвоить его module.exports вместо экспорта.
module.exports = function(width) {
return {
area: function() {
return width * width;
}
};
}
/* *******************************************************************************************
* PROCESS
* http://nodejs.org/api/process.html
* ******************************************************************************************* */
process.on('exit', function(code) {
}); // Выдается, когда процесс готов к завершению
process.on('uncaughtException', function(err) {
}); // Генерируется, когда исключение возвращается обратно в цикл обработки событий. (не следует использовать)
process.stdout; // Доступный для записи поток на стандартный вывод.
process.stderr; // Доступный для записи поток в stderr.
process.stdin; // Читаемый поток для stdin.
process.argv; // Массив, содержащий аргументы командной строки.
process.env; // Объект, содержащий пользовательскую среду.
process.execPath; // Это абсолютный путь к исполняемому файлу, запустившему процесс.
process.execArgv; // Это набор параметров командной строки для конкретного узла из исполняемого файла, запустившего процесс.
process.arch; // На какой архитектуре процессора вы работаете: arm, ia32 или x64.
process.config; // Объект, содержащий представление JavaScript параметров конфигурации, которые использовались для компиляции исполняемого файла текущего узла.
process.pid; // PID процесса.
process.platform; // На какой платформе вы работаете: 'darwin', 'freebsd', 'linux', 'sunos' или 'win32'.
process.title; // Получатель / установщик для установки того, что отображается в 'ps'.
process.version; // Вкомпилированное свойство, которое предоставляет NODE_VERSION.
process.versions; // Свойство, отображающее строки версии узла и его зависимости.
process.abort(); // Это заставляет Node генерировать прерывание. Это заставит Node выйти и сгенерировать файл ядра.
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(); // Возвращает объект, описывающий использование памяти процессом Node, измеренное в байтах.
process.nextTick(callback); // В следующем цикле цикла событий вызываем этот обратный вызов.
process.maxTickDepth; // Обратные вызовы, переданные в process.nextTick, обычно будут вызываться в конце текущего потока выполнения и, таким образом, работают примерно так же быстро, как синхронный вызов функции.
process.umask([mask]); // Устанавливает или считывает маску создания файлового режима процесса.
process.uptime(); // Количество секунд работы узла.
process.hrtime(); // Возвращает текущее реальное время с высоким разрешением в массиве кортежей [секунды, наносекунды].
/* *******************************************************************************************
* CHILD PROCESS
* http://nodejs.org/api/child_process.html
* ******************************************************************************************* */
// Node предоставляет возможность трехстороннего открытия через модуль child_process.
// Можно передавать данные через дочерние stdin, stdout и stderr полностью неблокирующим способом.
ChildProcess; // Класс. ChildProcess - это EventEmitter.
child.stdin; // Доступный для записи поток, представляющий стандартный ввод дочернего процесса
child.stdout; // Читаемый поток, представляющий стандартный вывод дочернего процесса
child.stderr; // Читаемый поток, представляющий stderr дочернего процесса.
child.pid; // PID дочернего процесса
child.connected; // Если .connected - false, отправлять сообщения больше нельзя
child.kill([signal]); // Отправляем сигнал дочернему процессу
child.send(message, [sendHandle]); // При использовании child_process.fork () вы можете писать дочернему элементу, используя child.send (message, [sendHandle]), и сообщения принимаются дочерним событием 'message'.
child.disconnect(); // Закрываем канал IPC между родительским и дочерним объектами, позволяя дочернему элементу корректно выйти, если нет других соединений, поддерживающих его работу.
child_process.spawn(command, [args], [options]); // Запускает новый процесс с заданной командой с аргументами командной строки в args. Если опущено, args по умолчанию представляет собой пустой массив.
child_process.exec(command, [options], callback); // Запускает команду в оболочке и буферизует вывод.
child_process.execFile(file, [args], [options], [callback]); // Запускает команду в оболочке и буферизует вывод.
child_process.fork(modulePath, [args], [options]); // Это частный случай функции spawn () для порождения процессов Node. Помимо наличия всех методов в обычном экземпляре ChildProcess, возвращаемый объект имеет встроенный канал связи.
/* *******************************************************************************************
* UTIL
* http://nodejs.org/api/util.html
* ******************************************************************************************* */
// Эти функции находятся в модуле util. Используйте require ('util') для доступа к ним.
util.format(format, [...]); // Возвращает отформатированную строку, используя первый аргумент в формате, подобном printf. (% s,% d,% j)
util.debug(string); // Функция синхронного вывода. Блокирует процесс и выводит строку немедленно в stderr.
util.error([...]); // То же, что и util.debug (), за исключением того, что все аргументы будут немедленно выведены в stderr.
util.puts([...]); // Функция синхронного вывода. Блокирует процесс и выводит все аргументы в стандартный вывод с символами новой строки после каждого аргумента.
util.print([...]); // Функция синхронного вывода. Блокирует процесс, приводит каждый аргумент к строке, а затем выводит на стандартный вывод. (без новой строки)
util.log(string); // Вывод с отметкой времени на стандартный вывод.
util.inspect(object, [opts]); // Возвращаем строковое представление объекта, которое полезно для отладки. (параметры: showHidden, глубина, цвета, customInspect)
util.isArray(object); // Возвращает истину, если данный «объект» является массивом. в противном случае - ложь.
util.isRegExp(object); // Возвращает истину, если данный «объект» является RegExp. в противном случае - ложь.
util.isDate(object); // Возвращает истину, если данный «объект» является датой. в противном случае - ложь.
util.isError(object); // Возвращает истину, если данный «объект» является ошибкой. в противном случае - ложь.
util.promisify(fn) // Принимает функцию, последний аргумент которой является обратным вызовом, и возвращает версию, возвращающую обещания.
util.inherits(constructor, superConstructor); // Наследовать методы прототипа от одного конструктора к другому.
/* *******************************************************************************************
* EVENTS
* http://nodejs.org/api/events.html
* ******************************************************************************************* */
// Все объекты, которые испускают события, являются экземплярами событий .EventEmitter. Вы можете получить доступ к этому модулю, выполнив: require ("events");
// Для доступа к классу EventEmitter, require ('events'). EventEmitter.
// Все EventEmitter генерируют событие newListener, когда добавляются новые слушатели, и removeListener, когда слушатель удаляется.
emitter.addListener(event, listener); // Добавляет слушателя в конец массива слушателей для указанного события.
emitter.on(event, listener); // То же, что и emitter.addListener ().
emitter.once(event, listener); // Добавляет одноразового прослушивателя для события. Этот слушатель вызывается только при следующем запуске события, после чего он удаляется.
emitter.removeListener(event, listener); // Удаляем слушателя из массива слушателей для указанного события.
emitter.removeAllListeners([event]); // Удаляет всех слушателей или слушателей указанного события.
emitter.setMaxListeners(n); // По умолчанию EventEmitters выводит предупреждение, если для определенного события добавлено более 10 слушателей.
emitter.listeners(event); // Возвращает массив слушателей для указанного события.
emitter.emit(event, [arg1], [arg2], [...]); // Выполнение каждого из слушателей по порядку с предоставленными аргументами. Возвращает истину, если у события есть слушатели, в противном случае - ложь.
EventEmitter.listenerCount(emitter, event); // Возвращаем количество слушателей для данного события.
/* *******************************************************************************************
* STREAM
* http://nodejs.org/api/stream.html
* ******************************************************************************************* */
// Поток - это абстрактный интерфейс, реализованный различными объектами в Node. Например, запрос к HTTP-серверу - это поток, как и стандартный вывод.
// Потоки доступны для чтения, записи или и того, и другого. Все потоки являются экземплярами EventEmitter.
// Интерфейс потока для чтения - это абстракция для источника данных, из которого вы читаете.
// Другими словами, данные поступают из потока для чтения.
// Читаемый поток не начнет передавать данные, пока вы не укажете, что готовы их получить.
// Примеры доступных для чтения потоков: HTTP-ответы на клиенте, HTTP-запросы на сервере, потоки чтения fs
// потоки zlib, криптопотоки, сокеты tcp, stdout дочернего процесса и stderr, process.stdin.
var readable = getReadableStreamSomehow();
readable.on('readable', function() {
}); // Когда часть данных может быть прочитана из потока, он генерирует «читаемое» событие.
readable.on ('данные', функция (чанк) {
}); // Если вы прикрепите прослушиватель событий данных, он переключит поток в текущий режим, и данные будут переданы вашему обработчику, как только они станут доступны.
readable.on ('конец', function () {
}); // Это событие возникает, когда больше не будет данных для чтения.
readable.on ('закрыть', function () {
}); // Генерируется, когда базовый ресурс (например, дескриптор резервного файла) был закрыт. Не все потоки испускают это.
readable.on ('ошибка', function () {
}); // Выдается, если произошла ошибка при получении данных.
// Метод read () извлекает некоторые данные из внутреннего буфера и возвращает их. Если данных нет, он вернет null.
// Этот метод следует вызывать только в непроточном режиме. В потоковом режиме этот метод вызывается автоматически до тех пор, пока не будет опустошен внутренний буфер.
readable.read([size]);
readable.setEncoding(encoding); // Вызов этой функции, чтобы поток возвращал строки указанной кодировки вместо объектов буфера.
readable.resume(); // Этот метод заставит читаемый поток возобновить передачу событий данных.
readable.pause(); // Этот метод заставит поток в потоковом режиме прекратить генерировать события данных.
readable.pipe(destination, [options]); // Этот метод извлекает все данные из читаемого потока и записывает их в указанное место назначения, автоматически управляя потоком, чтобы место назначения не было перегружено быстро читаемым потоком.
readable.unpipe([destination]); // Этот метод удалит перехватчики, настроенные для предыдущего вызова pipe (). Если место назначения не указано, все трубы удаляются.
readable.unshift(chunk); // Это полезно в определенных случаях, когда поток потребляется парсером, которому необходимо "не потреблять" некоторые данные, оптимистично извлеченные из источника, чтобы поток мог быть передан какой-либо другой стороне .
// Интерфейс записываемого потока - это абстяга к месту назначения, которое вы пишете данные.
// Примеры доступных для записи потоков: http-запросы на клиенте, http-ответы на сервере, потоки записи fs,
// потоки zlib, криптопотоки, сокеты tcp, stdin дочернего процесса, process.stdout, process.stderr.
var writer = getWritableStreamSomehow();
writable.write(chunk, [encoding], [callback]); // Этот метод записывает некоторые данные в базовую систему и вызывает предоставленный обратный вызов после того, как данные были полностью обработаны.
writer.once('drain', write); // Если вызов Writable.write (chunk) возвращает false, то событие слива укажет, когда следует начать запись дополнительных данных в поток.
writable.end([chunk], [encoding], [callback]); // Вызов этого метода, когда в поток больше не будут записываться данные.
writer.on('finish', function() {
}); // Когда был вызван метод end () и все данные были сброшены в базовую систему, это событие генерируется.
writer.on('pipe', function(src) {
}); // Это излучается всякий раз, когда метод pipe () вызывается в читаемом потоке, добавляя этот доступный для записи набору пунктов назначения.
writer.on('unpipe', function(src) {
}); // Это испускается всякий раз, когда метод unpipe () вызывается в читаемом потоке, удаляя этот доступный для записи поток из набора его адресатов.
writer.on('error', function(src) {
}); // Выдается, если произошла ошибка при записи или передаче данных.
// Дуплексные потоки - это потоки, которые реализуют интерфейсы как для чтения, так и для записи. См. Использование выше.
// Примеры дуплексных потоков: TCP-сокеты, zlib-потоки, криптопотоки.
// Потоки преобразования - это дуплексные потоки, в которых вывод каким-либо образом вычисляется из ввода. Они реализуют интерфейсы как для чтения, так и для записи. См. Использование выше.
// Примеры потоков преобразования: потоки zlib, криптопотоки.
/* *******************************************************************************************
* FILE SYSTEM
* http://nodejs.org/api/fs.html
* ******************************************************************************************* */
// Для использования этого модуля требуется require ('fs').
// Все методы имеют асинхронную и синхронную формы.
fs.rename(oldPath, newPath, callback); // Асинхронное переименование. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения. Асинхронный ftruncate. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.renameSync(oldPath, newPath); // Синхронное переименование.
fs.ftruncate(fd, len, callback); // Асинхронный ftruncate. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.ftruncateSync(fd, len); // Синхронный ftruncate.
fs.truncate(path, len, callback); // Асинхронное усечение. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.truncateSync(path, len); // Синхронное усечение.
fs.chown(path, uid, gid, callback); // Асинхронный chown. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.chownSync(path, uid, gid); // Синхронное упражнение.
fs.fchown(fd, uid, gid, callback); // Асинхронный fchown. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.fchownSync(fd, uid, gid); // Синхронный fchown.
fs.lchown(path, uid, gid, callback); // Асинхронный lchown. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.lchownSync(path, uid, gid); // Синхронный lchown.
fs.chmod(path, mode, callback); // Асинхронный chmod. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.chmodSync(path, mode); // Синхронный chmod.
fs.fchmod(fd, mode, callback); // Асинхронный fchmod. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.fchmodSync(fd, mode); // Синхронный fchmod.
fs.lchmod(path, mode, callback); // Асинхронный lchmod. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.lchmodSync(path, mode); // Синхронный lchmod.
fs.stat(path, callback); // Асинхронный стат. Обратный вызов получает два аргумента (err, stats), где stats - это объект fs.Stats.
fs.statSync(path); // Синхронный стат. Возвращает экземпляр fs.Stats.
fs.lstat(path, callback); // Асинхронный lstat. Обратный вызов получает два аргумента (err, stats), где stats - это объект fs.Stats. lstat () идентичен stat (), за исключением того, что если путь является символьной ссылкой, то указывается сама ссылка, а не файл, на который она ссылается.
fs.lstatSync(path); // Синхронный lstat. Возвращает экземпляр fs.Stats.
fs.fstat(fd, callback); // Асинхронный fstat. Обратный вызов получает два аргумента (err, stats), где stats - это объект fs.Stats. fstat () идентичен stat (), за исключением того, что файл, который нужно обработать, определяется файловым дескриптором fd.
fs.fstatSync(fd); // Синхронный fstat. Возвращает экземпляр fs.Stats.
fs.link(srcpath, dstpath, callback); // Асинхронная ссылка. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.linkSync(srcpath, dstpath); // Синхронная ссылка.
fs.symlink(srcpath, dstpath, [type], callback); // Асинхронная символическая ссылка. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения. Аргумент типа может иметь значение 'dir', 'file' или 'junction' (по умолчанию 'file') и доступен только в Windows (игнорируется на других платформах).
fs.symlinkSync(srcpath, dstpath, [type]); // Синхронная символическая ссылка.
fs.readlink(path, callback); // Асинхронная ссылка для чтения. Обратный вызов получает два аргумента (err, linkString).
fs.readlinkSync(path); // Синхронная ссылка для чтения. Возвращает строковое значение символьной ссылки.
fs.unlink(path, callback); // Асинхронное отключение. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.unlinkSync(path); // Синхронное отключение.
fs.realpath(path, [cache], callback); // Асинхронный реальный путь. Обратный вызов получает два аргумента (err, resolvedPath).
fs.realpathSync(path, [cache]); // Синхронный реальный путь. Возвращает разрешенный путь.
fs.rmdir(path, callback); // Асинхронный rmdir. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.rmdirSync(path); // Синхронный rmdir.
fs.mkdir(path, [mode], callback); // Асинхронный mkdir. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения. режим по умолчанию 0777.
fs.mkdirSync(path, [mode]); // Синхронный mkdir.
fs.readdir(path, callback); // Асинхронный каталог чтения. Читает содержимое каталога. Обратный вызов получает два аргумента (err, files), где files - это массив имен файлов в каталоге, исключая '.' а также '..'.
fs.readdirSync(path); // Синхронный каталог чтения. Возвращает массив имен файлов, исключая '.' а также '..'.
fs.close(fd, callback); // Асинхронное закрытие. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.closeSync(fd); // Синхронное закрытие.
fs.open(path, flags, [mode], callback); // Асинхронный файл открыт.
fs.openSync(path, flags, [mode]); // Синхронная версия fs.open ().
fs.utimes(path, atime, mtime, callback); // Изменить временные метки файла, на который ссылается указанный путь.
fs.utimesSync(path, atime, mtime); // Синхронная версия fs.utimes ().
fs.futimes(fd, atime, mtime, callback); // Измените временные метки файла, на который ссылается предоставленный файловый дескриптор.
fs.futimesSync(fd, atime, mtime); // Синхронная версия fs.futimes ().
fs.fsync(fd, callback); // Асинхронный fsync. Обратному вызову завершения не передаются никакие аргументы, кроме возможного исключения.
fs.fsyncSync(fd); // Синхронный fsync.
fs.write(fd, buffer, offset, length, position, callback); // Записываем буфер в файл, указанный в fd.
fs.writeSync(fd, buffer, offset, length, position); // Синхронная версия fs.write (). Возвращает количество записанных байтов.
fs.read(fd, buffer, offset, length, position, callback); // Считываем данные из файла, указанного в fd.
fs.readSync(fd, buffer, offset, length, position); // Синхронная версия fs.read. Возвращает количество bytesRead.
fs.readFile(filename, [options], callback); // Асинхронно считывает все содержимое файла.
fs.readFileSync(filename, [options]); // Синхронная версия fs.readFile. Возвращает содержимое имени файла. Если указана опция кодирования, эта функция возвращает строку. В противном случае он возвращает буфер.
fs.writeFile(filename, data, [options], callback); // Асинхронно записывает данные в файл, заменяя файл, если он уже существует. данные могут быть строкой или буфером.
fs.writeFileSync(filename, data, [options]); // Синхронная версия fs.writeFile.
fs.appendFile(filename, data, [options], callback); // Асинхронно добавляем данные в файл, создавая файл, если он еще не существует. данные могут быть строкой или буфером.
fs.appendFileSync(filename, data, [options]); // Синхронная версия fs.appendFile.
fs.watch(filename, [options], [listener]); // Следим за изменениями в имени файла, где имя файла - это либо файл, либо каталог. Возвращенный объект - fs.FSWatcher. Обратный вызов слушателя получает два аргумента (событие, имя файла). событие - это либо «переименовать», либо «изменить», а имя файла - это имя файла, который вызвал событие.
fs.exists(path, callback); // Проверяем, существует ли данный путь, проверяя файловую систему. Затем вызовите аргумент обратного вызова со значением true или false. (не следует использовать)
fs.existsSync(path); // Существует синхронная версия fs.exists. (не следует использовать)
// fs.Stats: объекты, возвращаемые из fs.stat (), fs.lstat () и fs.fstat () и их синхронные аналоги, относятся к этому типу.
stats.isFile();
stats.isDirectory()
stats.isBlockDevice()
stats.isCharacterDevice()
stats.isSymbolicLink() // (действует только с fs.lstat ())
stats.isFIFO()
stats.isSocket()
fs.createReadStream(path, [options]); // Возвращает новый объект ReadStream.
fs.createWriteStream(path, [options]); // Возвращает новый объект WriteStream.
/* *******************************************************************************************
* PATH
* http://nodejs.org/api/fs.html
* ******************************************************************************************* */
// Используйте require ('path') для использования этого модуля.
// Этот модуль содержит утилиты для обработки и преобразования путей к файлам.
// Почти все эти методы выполняют только преобразования строк.
// Файловая система не проверяет правильность путей.
path.normalize(p); // Нормализуем строковый путь, заботясь о '..' и '.' части.
path.join([path1], [path2], [...]); // Объединяем все аргументы вместе и нормализуем полученный путь.
path.resolve([from ...], to); // Преобразует "в" в абсолютный путь.
path.relative(from, to); // Решаем относительный путь от "от" до "к".
path.dirname(p); // Возвращаем имя каталога пути. Аналогично команде Unix dirname.
path.basename(p, [ext]); // Возвращаем последнюю часть пути. Подобно команде Unix basename.
path.extname(p); // Возвращаем расширение пути от последнего '.' до конца строки в последней части пути.
path.sep; // Разделитель файлов, зависящий от платформы. '\\' или '/'.
path.delimiter; // Разделитель пути, зависящий от платформы, ';' или ':'.
/* *******************************************************************************************
* HTTP
* http://nodejs.org/api/http.html
* ******************************************************************************************* */
// Для использования HTTP-сервера и клиента необходимо указать ('http').
http.STATUS_CODES; // Коллекция всех стандартных кодов состояния HTTP-ответа и краткое описание каждого из них.
http.request(options, [callback]); // Эта функция позволяет прозрачно отправлять запросы.
http.get(options, [callback]); // Устанавливаем метод на GET и автоматически вызывает req.end ().
server = http.createServer([requestListener]); // Возвращает новый объект веб-сервера. RequestListener - это функция, которая автоматически добавляется к событию request.
server.listen(port, [hostname], [backlog], [callback]); // Начинаем принимать соединения на указанном порту и имени хоста.
server.listen(path, [callback]); // Запускаем сервер сокетов UNIX, ожидающий соединений по заданному пути.
server.listen(handle, [callback]); // Объект дескриптора может быть установлен либо на сервер, либо на сокет (что угодно, имеющее базовый член _handle), либо на объект {fd: <n>}.
server.close([callback]); // Останавливает сервер от приема новых подключений.
server.setTimeout(msecs, callback); // Устанавливает значение тайм-аута для сокетов и генерирует событие «тайм-аут» для объекта Server, передавая сокет в качестве аргумента, если истекает тайм-аут.
server.maxHeadersCount; // Ограничивает максимальное количество входящих заголовков, по умолчанию равное 1000. Если установлено значение 0 - ограничение не применяется.
server.timeout; // Количество миллисекунд бездействия до истечения тайм-аута сокета.
server.on('request', function(request, response) {
}); // Генерируется каждый раз, когда есть запрос.
server.on('connection', function(socket) {
}); // Когда установлен новый поток TCP.
server.on('close', function() {
}); // Выдается при закрытии сервера.
server.on('checkContinue', function(request, response) {
}); // Выдается каждый раз, когда получен запрос с http Expect: 100-continue.
server.on('connect', function(request, socket, head) {
}); // Генерируется каждый раз, когда клиент запрашивает метод http CONNECT.
server.on('upgrade', function(request, socket, head) {
}); // Выдается каждый раз, когда клиент запрашивает обновление по http.
server.on('clientError', function(exception, socket) {
}); // Если клиентское соединение выдает событие «ошибка» - оно будет перенаправлено сюда.
request.write(chunk, [encoding]); // Отправляет кусок тела.
request.end([data], [encoding]); // Завершаем отправку запроса. Если какие-либо части тела не отправлены, он смывает их в поток.
request.abort(); // Отменяет запрос.
request.setTimeout(timeout, [callback]); // Как только сокет назначен этому запросу и будет подключен, будет вызван socket.setTimeout ().
request.setNoDelay([noDelay]); // Как только сокет назначен этому запросу и будет подключен, будет вызван socket.setNoDelay ().
request.setSocketKeepAlive([enable], [initialDelay]); // Как только сокет будет назначен этому запросу и будет подключен, будет вызван socket.setKeepAlive ().
request.on('response', function(response) {
}); // Генерируется при получении ответа на этот запрос. Это событие генерируется только один раз.
request.on('socket', function(socket) {
}); // Испускается после того, как сокет назначен этому запросу.
request.on('connect', function(response, socket, head) {
}); // Испускается каждый раз, когда сервер отвечает на запрос методом CONNECT. Если это событие не прослушивается, клиенты, получающие метод CONNECT, будут закрывать свои соединения.
request.on('upgrade', function(response, socket, head) {
}); // Излучается каждый раз, когда сервер отвечает на запрос с обновлением. Если это событие не прослушивается, клиенты, получающие заголовок обновления, будут закрывать свои соединения.
request.on('continue', function() {
}); // Генерируется, когда сервер отправляет HTTP-ответ «100 Continue», обычно потому, что запрос содержит «Expect: 100-continue». Это инструкция о том, что клиент должен отправить тело запроса.
response.write(chunk, [encoding]); // Это отправляет кусок тела ответа. Если этот метод вызван и response.writeHead () не был вызван, он переключится в режим неявного заголовка и сбрасывает неявные заголовки.
response.writeContinue(); // Отправляет клиенту сообщение HTTP / 1.1 100 Continue, указывающее, что тело запроса должно быть отправлено.
response.writeHead(statusCode, [reasonPhrase], [headers]); // Отправляет заголовок ответа на запрос.
response.setTimeout(msecs, callback); // Устанавливает значение тайм-аута сокета в миллисекунды. Если предоставляется обратный вызов, он добавляется как прослушиватель события «тайм-аут» в объекте ответа.
response.setHeader(name, value); // Устанавливает одно значение заголовка для неявных заголовков. Если этот заголовок уже существует в заголовках для отправки, его значение будет заменено. Используйте здесь массив строк, если вам нужно отправить несколько заголовков с одним и тем же именем.
response.getHeader(name); // Считывает заголовок, который уже поставлен в очередь, но не отправлен клиенту. Обратите внимание, что имя не чувствительно к регистру.
response.removeHeader(name); // Удаляет заголовок, поставленный в очередь для неявной отправки.
response.addTrailers(headers); // Этот метод добавляет к ответу завершающие заголовки HTTP (заголовок, но в конце сообщения).
response.end([data], [encoding]); // Этот метод сигнализирует серверу, что все заголовки и тело ответа отправлены; этот сервер должен считать это сообщение завершенным. Метод response.end () ДОЛЖЕН быть вызван для каждого ответа.
response.statusCode; // При использовании неявных заголовков (без явного вызова response.writeHead ()) это свойство контролирует код состояния, который будет отправлен клиенту, когда заголовки будут сброшены.
response.headersSent; // Логическое значение (только для чтения). Истина, если заголовки были отправлены, в противном случае - ложь.
response.sendDate; // Если установлено значение true, заголовок Date будет автоматически сгенерирован и отправлен в ответе, если он еще не присутствует в заголовках. По умолчанию true.
response.on('close', function() {
}); // Указывает, что базовое соединение было прервано до вызова response.end () или его возможности сбросить.
response.on('finish', function() {
}); // Генерируется, когда ответ был отправлен.
message.httpVersion; // В случае запроса сервера - версия HTTP, отправленная клиентом. В случае ответа клиента - версия HTTP подключенного сервера.
message.headers; // Объект заголовков запроса / ответа.
message.trailers; // Объект трейлеров запроса / ответа. Заполняется только после "конечного" события.
message.method; // Метод запроса в виде строки. Только чтение. Пример: «ПОЛУЧИТЬ», «УДАЛИТЬ».
message.url; // Запросить строку URL. Он содержит только URL-адрес, который присутствует в фактическом HTTP-запросе.
message.statusCode; // 3-значный код состояния ответа HTTP. НАПРИМЕР. 404.
message.socket; // Объект net.Socket, связанный с подключением.
message.setTimeout(msecs, callback); // Вызывает message.connection.setTimeout (msecs, callback).
/* *******************************************************************************************
* URL
* http://nodejs.org/api/url.html
* ******************************************************************************************* */
// В этом модуле есть утилиты для разрешения и анализа URL. Позвоните require ('url'), чтобы использовать его.
url.parse(urlStr, [parseQueryString], [slashesDenoteHost]); // Возьмите строку URL и верните объект.
url.format(urlObj); // Возьмите проанализированный объект URL и верните отформатированную строку URL.
url.resolve(from, to); // Возьмите базовый URL-адрес и URL-адрес href и разрешите их, как браузер для тега привязки.
/* *******************************************************************************************
* QUERY STRING
* http://nodejs.org/api/querystring.html
* ******************************************************************************************* */
// Этот модуль предоставляет утилиты для работы со строками запроса. Вызовите require ('querystring'), чтобы использовать его.
querystring.stringify(obj, [sep], [eq]); // Сериализуем объект в строку запроса. При необходимости переопределите символы разделителя ('&') и присваивания ('=') по умолчанию.
querystring.parse(str, [sep], [eq], [options]); // Десериализовать строку запроса в объект. При необходимости переопределите символы разделителя ('&') и присваивания ('=') по умолчанию.
/* *******************************************************************************************
* ASSERT
* http://nodejs.org/api/assert.html
* ******************************************************************************************* */
// Этот модуль используется для написания модульных тестов для ваших приложений, вы можете получить к нему доступ с помощью require ('assert').
assert.fail(actual, expected, message, operator); // Выдает исключение, которое отображает фактические и ожидаемые значения, разделенные предоставленным оператором.
assert(value, message);
assert.ok(value, [message]); // Проверяет, истинно ли значение, эквивалентно assert.equal (true, !! value, message);
assert.equal(actual, expected, [message]); // Проверяет неглубокое принудительное равенство с помощью оператора сравнения равенства (==).
assert.notEqual(actual, expected, [message]); // Проверяет неглубокое принудительное неравенство с помощью оператора сравнения неравенства (! =).
assert.deepEqual(actual, expected, [message]); // Тесты на глубокое равенство.
assert.notDeepEqual(actual, expected, [message]); // Тесты на наличие глубокого неравенства.
assert.strictEqual(actual, expected, [message]); // Проверяет строгое равенство, как определено оператором строгого равенства (===)
assert.notStrictEqual(actual, expected, [message]); // Проверяет строгое неравенство, как определено оператором строгого неравенства (! ==)
assert.throws(block, [error], [message]); // Ожидает, что блок выдаст ошибку. error может быть конструктором, RegExp или функцией проверки.
assert.doesNotThrow(block, [message]); // Ожидается, что блок не выдаст ошибку, подробности см. В assert.throws.
assert.ifError(value); // Проверяет, не является ли значение ложным значением, бросает, истинное ли значение. Полезно при тестировании первого аргумента, ошибки в обратных вызовах.
/* *******************************************************************************************
* OS
* http://nodejs.org/api/os.html
* ******************************************************************************************* */
// Предоставляет несколько основных служебных функций, связанных с операционной системой.
// Используйте require ('os') для доступа к этому модулю.
os.tmpdir(); // Возвращает каталог операционной системы по умолчанию для временных файлов.
os.endianness(); // Возвращает порядок байтов ЦП. Возможные значения: «BE» или «LE».
os.hostname(); // Возвращает имя хоста операционной системы.
os.type(); // Возвращает имя операционной системы.
os.platform(); // Возвращает платформу операционной системы.
os.arch(); // Возвращает архитектуру ЦП операционной системы.
os.release(); // Возвращает версию операционной системы.
os.uptime(); // Возвращает время безотказной работы системы в секундах.
os.loadavg(); // Возвращает массив, содержащий средние значения нагрузки за 1, 5 и 15 минут.
os.totalmem(); // Возвращает общий объем системной памяти в байтах.
os.freemem(); // Возвращает объем свободной системной памяти в байтах.
os.cpus(); // Возвращает массив объектов, содержащих информацию о каждом установленном ЦП / ядре: модель, скорость (в МГц) и время (объект, содержащий количество миллисекунд, в которых ЦП / ядро потрачено: user, nice, sys, idle и irq).
os.networkInterfaces(); // Получаем список сетевых интерфейсов.
os.EOL; // Константа, определяющая соответствующий маркер конца строки для операционной системы.
/* *******************************************************************************************
* BUFFER
* http://nodejs.org/api/buffer.html
* ******************************************************************************************* */
// Буфер используется для работы с двоичными данными
// Буфер похож на массив целых чисел, но соответствует необработанному выделению памяти вне кучи V8
Buffer.from(size); // Выделяет новый буфер размером октетов.
Buffer.from(array); // Выделяет новый буфер, используя массив октетов.
Buffer.from(str, [encoding]); // Выделяет новый буфер, содержащий заданную строку. кодировка по умолчанию "utf8".
Buffer.isEncoding(encoding); // Возвращает true, если кодировка является допустимым аргументом кодировки, или false в противном случае.
Buffer.isBuffer(obj); // Проверяет, является ли obj буфером
Buffer.concat(list, [totalLength]); // Возвращает буфер, который является результатом объединения всех буферов в списке вместе.
Buffer.byteLength(string, [encoding]); // Дает фактическую длину строки в байтах.
buf.write(string, [offset], [length], [encoding]); // Записывает строку в буфер по смещению, используя заданную кодировку
buf.toString([encoding], [start], [end]); // Декодирует и возвращает строку из данных буфера, закодированных с кодировкой (по умолчанию 'utf8'), начиная с начала (по умолчанию 0) и заканчивая концом (по умолчанию buffer.length).
buf.toJSON(); // Возвращает JSON-представление экземпляра Buffer, которое идентично выводу для массивов JSON
buf.copy(targetBuffer, [targetStart], [sourceStart], [sourceEnd]); // Копирует между буферами. Исходная и целевая области могут перекрываться
buf.slice([start], [end]); // Возвращает новый буфер, который ссылается на ту же память, что и старый, но смещенный и обрезанный по начальному (по умолчанию 0) и конечному (по умолчанию buffer.length) индексам. Отрицательные индексы начинаются с конца буфера.
buf.fill(value, [offset], [end]); // Заполняет буфер указанным значением
buf[index]; // Получить и установить октет по индексу
buf.length; // Размер буфера в байтах, обратите внимание, что это не обязательно размер содержимого
buffer.INSPECT_MAX_BYTES; // Сколько байтов будет возвращено при вызове buffer.inspect (). Это может быть отменено пользовательскими модулями.