Для непосредственного получения информации об операционной системе используется базовый модуль OS. Это один из полезных инструментов, упрощающих построение кросс-платформенных приложений. Кроме того, он предоставляет информацию об использовании ресурсов и возможностях текущей среды.

Обращение к модулю OS начинается с команды require, с помощью которого мы подключаем данный модуль:

const os = require('os');

Вся функциональность модуля OS направлена только на получение информации. Например, если вы хотите обеспечить кросс-платформенную поддержку, можно проверить, какой завершитель строки поддерживается текущей системой, использует она прямой (little-endian) или обратный (big endian) порядок байтов, а также узнать временный и домашний каталог:

const os = require('os');

console.log('Using end of line' + os.EOL + 'to insert a new line');
console.log(os.endianness());
console.log(os.tmpdir());
console.log(os.homedir());

На моем сервере с Ubuntu и компьютере с Windows 10 используется прямой порядок байтов, а завершитель строки (EOL, End-Of-Line) в обеих системах работает так, как и следовало ожидать (вторая часть текста начинается с новой строки). Различаются только временный и домашний каталоги, что вполне естественно.



Модуль OS также предоставляет средства для проверки доступных ресурсов текущей машины.

console.log(os.freemem());
console.log(os.loadavg());
console.log(os.totalmem());

Функция os.loadavg() специфична для Unix; в Windows она просто возвращает нули. Она возвращает показатель средней загрузки, отражающий текущую интенсивность работы системы, за 1, 5 и 15 минут. Чтобы получить значения в процентах, умножьте числа на 100.

Функции os.freemen() и os.totalmem() возвращают объем памяти в байтах.

Другая функция, os.cpus(), возвращает информацию о процессорах машины. Возвращается количество миллисекунд, проведенных процессором в разных режимах: user, nice, sys, idle и irq. Если вы не знакомы с этими концепциями: значение user определяет время, проведенное процессором за выполнением процессов пользовательского пространства, idle — время бездействия, а sys — время, проведенное за выполнением системных процессов (режим ядра). Значение nice отражает величину динамической регулировки приоритета, предотвращающей слишком частое его выполнение. Значение irq описывает прерывания — запросы на обслуживание на аппаратном уровне.

Время в миллисекундах не так удобно, как проценты. Чтобы определить их, можно просуммировать все значения, а затем вычислить проценты. Также можно воспользоваться модулями независимых разработчиков, которые возвращают значения в процентах (наряду с другой информацией).

The post Node.js — Модуль OS: Работа с операционной системой appeared first on HackerX.

Разрабатывая приложения для платформы Node.js, старайтесь не использовать си­стем модулей, отличных от той, что предлагается по умолчанию. В идеале нужно продолжать писать модули как обычно, используя require() и module.exports, а затем применять инструмент для преобразования кода в пакет, который будет нормально работать в браузере. К счастью, эта задача имеет множество решений, самым попу­ярным из которых является Webpack (https://webpack.github.io).

Webpack позволяет создавать модули с использованием соглашений о модулях Node.js, с последующей компиляцией в пакет (единственный JavaScript-файл), со­держащий все необходимое для работы в браузере (в том числе абстрактные функции require()). Такой пакет затем можно включить в веб-страницу, как обычно, и выпол­нить в браузере. Webpack рекурсивно сканирует исходный код, отыскивает ссылки на функцию require(), разрешает их и добавляет нужные модули в пакет.

Установка и знакомство с Webpack

Для быстрой демонстрации волшебства Webpack рассмотрим, как будет выглядит обычный Node.js модуль при использовании этого инст­румента. Во-первых, необходимо установить сам Webpack, что можно сделать с по­мощью следующей простой команды:

npm install webpack -g

Параметр -g указывает npm, что необходимо установить Webpack глобально, чтобы его можно было использовать из консоли, как будет показано ниже.

Далее, создадим новый проект и попробуем написать модуль. Вот так будет выглядеть его реализация для платформы Node.js (файл sayHello.js):

var mustache = require('mustache');
var template = '<h1>Hello <i>{{name}}</i></h1>';
mustache.parse(template);
module.exports.sayHello = function(toWhom) {
  return mustache.render(template, {name: toWhom});
};

Теперь создадим файл main.js, то есть точку входа в код для браузера:

window.addEventListener('load', function(){
  var sayHello = require('./sayHello').sayHello;
  var hello = sayHello('Browser!');
  var body = document.getElementsByTagName("body")[0];
  body.innerHTML = hello;
});

В приведенном выше коде загрузка модуля sayHello выполняется точно так же, как в Node.js, нет никаких дополнительных сложностей при управлении зависимостями и настройке путей, поскольку всю работу выполняет обычная функция require().

Добавим зависимость mustache в проект:

npm install mustache

А теперь волшебное действие. Запустим следующую команду в терминале:

webpack main.js bundle.js

Она скомпилирует модуль main и соберет все необходимые зависимости в один файл bundle.js, готовый к использованию в браузере!



Чтобы быстро проверить работоспособность получившегося пакета, создадим HTML-страницу magic.html со следующим кодом:

<html>
  <head>
    <title>Webpack magic</title>
    <script src="bundle.js"></script>
  </head>
  <body>
  </body>
</html>

Этого достаточно для выполнения кода в браузере. Попробуйте открыть страницу и взгляните сами. Ура!

Преимущества использования Webpack

Волшебство Webpack этим не ограничивается. Вот (неполный) перечень функцио­ нальных возможностей, которые упрощают совместное использование кода с браузером:

• Webpack автоматически предоставляет версии многих модулей ядра Node.js, совместимые с браузером. Это означает, что в браузере можно использовать такие модули, как http, assert, events, и многие другие!
• Если имеется модуль, несовместимый с браузером, его можно исключить из сборки, заменить пустым объектом или другим модулем с альтернативной реа­лизацией, которая совместима с браузером. Это играет решающую роль, и дан­ная возможность будет использоваться в примере ниже;
• Webpack может генерировать пакеты для различных модулей;
• Webpack позволяет выполнять дополнительную обработку исходных файлов с помощью сторонних загрузчиков и плагинов. Имеются загрузчики и пла­гины практически для всего, что может понадобиться, от компиляции Cof­feeScript, TypeScript и ES2015 до поддержки загрузки AMD, пакетов Bower (http://bower.io) и Component (http://component.github.io), использующих require(), от минификации до компиляции и упаковки других ресурсов, таких как шаблоны и таблицы стилей;
• Webpack с легкостью можно вызывать из диспетчеров заданий, таких как Gulp (https://npmjs.com/package/gulp-webpack) и Grunt (https://npmjs.org/package/grunt-webpack);
• Webpack позволяет управлять и выполнять предварительную обработку ресур­сов проекта, причем не только JavaScript-файлов, но и таблиц стилей, изобра­жений, шрифтов и шаблонов;
• кроме того, Webpack можно настроить для разделения дерева зависимостей на несколько частей, которые будут загружаться по требованию, когда они пона­добятся браузеру.

Потенциал и гибкость Webpack настолько привлекательны, что многие разработчи­ки начали использовать его даже для управления кода, предназначенного только для выполнения на стороне клиента. Это стало возможным потому, что многие клиентские библиотеки начали по умолчанию поддерживать CommonJS и npm, что открывает но­вые и очень интересные перспективы. Например, можно установить библиотеку jQuery:

npm install jquery

а затем загрузить ее с помощью простой строки кода:

const $ = require('jquery');

Вы будете удивлены, как много клиентских библиотек уже поддерживают CommonJS и Webpack.

The post Webpack и Node.js: Руководство по использованию appeared first on HackerX.

Объект global

В браузере переменная, объявленная на верхнем уровне, объявляется глобально. В Node дело обстоит иначе. Переменная, объявленная в модуле или приложении Node, не обладает глобальной доступностью; она ограничивается модулем или приложением. Таким образом, можно объявить «глобальную» переменную с именем str в модуле и в приложении, использующем этот модуль, и никакого конфликта не будет.

Для демонстрации создадим простую функцию, которая прибавляет число к базовому значению и возвращает результат (название файла — add2.js). Функция будет создана как библиотека JavaScript для использования в веб странице, а также как модуль для использования в приложении Node. Код объявляет переменную base, присваивает ей значение 2, после чего прибавляет переданное число:

var base = 2;
function addtwo(input) {
  return parseInt(input) + base;
}

Затем создадим очень простой модуль (название файла — addtwo.js), который делает то же самое, но с использованием синтаксиса модуля Node.

var base = 2;
exports.addtwo = function(input) {
  return parseInt(input) + base;
};

А теперь посмотрим, чем различается концепция глобальности в двух разных средах. Файл add2.js используется в веб-странице, которая также объявляет переменную base:

<!DOCTYPE html>
<html>
 <head>
  <script src="add2.js"></script>
  <script>
   var base = 10;
   console.log(addtwo(10));
  </script>
 </head>
 <body>
 </body>
</html>

При обращении к веб-странице в браузере на консоли браузера выводится значение 20 (вместо ожидаемого 12). Дело в том, что все переменные, объявленные за пределами функции в JavaScript, добавляются в один глобальный объект. Объявляя новую переменную с именем base в веб странице, мы переопределяем значение во включенном файле сценария.

Теперь используем модуль addtwo в приложении Node:

var addtwo = require('./addtwo').addtwo;
var base = 10;
console.log(addtwo(base));

В приложении Node результат равен 12. Объявление новой переменной басе в приложении Node никак не повлияло на значение base в модуле, потому что они существуют в разных глобальных пространствах имен.

Устранение общего пространства имен — безусловное усовершенствование, но оно не универсально. Объект global во всех средах предоставляет доступ к глобально доступным объектам и функциям Node , включая объект процесс (см. далее). Чтобы убедиться в этом, просто добавьте следующую команду в файл и запустите приложение. Команда выводит все глобально доступные объекты и функции:

console.log(global);

Объект process

Объект process принадлежит к числу важнейших компонентов среды Node, так как он предоставляет информацию о среде выполнения. Кроме того, через объект process выполняется стандартный ввод/вывод, вы можете корректно завершить приложение Node и даже выдать сигнал при завершении итерации в цикле событий Node.

Сейчас мы рассмотрим получение информации о среде выполнения объекта process, а также исключительно важные средства стандартного ввода/вывода.

Объект process предоставляет доступ к информации как о среде Node, так и о среде выполнения программы. Для получения информации мы воспользуемся параметром командной строки -p , который выполняет сценарий и возвращает полученный результат. Например, для проверки свойства process. versions введите следующую команду:

$ node -p "process.versions"

{ http_parser: ‘2.5.0’,
node: ‘4.2.1’,
v8: ‘4.5.103.35’,
uv: ‘1.7.5’,
zlib: ‘1.2.8’,
ares: ‘1.10.1-DEV’,
icu: ‘56.1’,
modules: ’46’,
openssl: ‘1.0.2d’ }

Команда выводит список различных компонентов Node и зависимостей, включая версии v8, OpenSSL (библиотека, используемая для безопасной передачи данных), собственно Node и т. д.

Свойство process.env предоставляет богатую информацию о том, что Нодье знает о вашей среде разработки:

$ node -p "process.env"

Особенно интересно проанализировать различия между архитектурами (например, Linux и Windows).

Чтобы просмотреть содержимое process.release, введите следующую команду:

$ node -p "process.release"

Полученный результат зависит от того, что установлено на вашем компьютере. И в LTS, и в среде текущей версии будет выведено имя приложения, а также URL исходного кода. Но в LTS также будет выведено дополнительное свойство:

$ node -p «process.release.lts»
‘Argon’

Однако при обращении к тому же значению в текущей версии (например, v6) будет получен другой результат:

$ node -p «process.release.lts»
undefined

Информация о среде позволяет разработчику понять, что видит Node до и после разработки. Не включайте зависимости от этих данных прямо в приложение, потому что, как вы уже видели, они могут различаться между версиями Node. Тем не менее не жалейте времени на анализ этих данных.

Между версиями Node в любом случае должны остаться неизменными основные объекты и функции, важные для работы приложений. В их числе стандартный ввод/вывод и возможность корректного завершения приложения Node.

Стандартные потоки представляют собой заранее определенные каналы передачи данных между приложением и средой: стандартный ввод ( stdin ), стандартный вывод ( stdout ) и стандартный поток ошибок ( stderr ). В приложении Node эти каналы обеспечивают взаимодействие между приложением Нодье и терминалом, своего рода механизм прямого «общения» с приложением.

Node поддерживает каналы с тремя функциями process:

• process.stdin : поток с поддержкой чтения для stdin;
• process.stdout : поток с поддержкой записи для stdout;
• process.stderr : поток с поддержкой записи для stderr.

Вы не можете закрывать эти потоки в своем приложении. Поддерживается только чтение данных из канала stdin и запись в каналы stdout и stderr.

Функции ввода/вывода process наследуют от EventEmitter, это означает, что они могут генерировать события, а вы можете перехватывать эти события и обрабатывать любые данные. Чтобы обработать входные данные с использованием process.stdin , прежде всего необходимо назначить кодировку потока. Если этого не сделать, вы получите результаты в виде буфера, а не в виде строки:

process.stdin.setEncoding('utf8');

Затем начинается прослушивание события readable , которое сообщает о поступлении блока данных, готового к чтению. Затем функция process.stdin. read() используется для чтения данных, и если данные отличны от null, они копируются в process.stdout при помощи функции process.stdout.write():

process.stdin.on('readable', function() {
  var input = process.stdin.read();
  if (input !== null) {
    // Эхо-вывод текста
    process.stdout.write(input);
  }
});

В принципе можно пропустить назначение кодировки и получить те же результаты; программа будет читать буфер и выводить буфер, но для пользователя приложения все выглядит так, словно вы работаете с текстом (строка). На самом деле это не так. Следующая функция process , которую мы рассмотрим, демонстрирует эти различия.

Мы раньше создали очень простой веб-сервер, который прослушивал запрос и выводил сообщение. Чтобы завершить программу, вам придется либо уничтожить процесс с использованием сигнала, либо нажать клавиши Ctrl+C. Также возможен другой вариант: завершить приложение из кода самого приложения при помощи process.exit() . Вы даже можете передать информацию о том, успешно ли завершилось приложение или произошла ошибка.

Мы изменим тестовое приложение ввода/вывода так, чтобы оно «прослушивало» строку выхода и при ее обнаружении программа завершалась.

process.stdin.setEncoding('utf8');

process.stdin.on('readable', function() {
  var input = process.stdin.read();
  if (input !== null) {
    // Эхо-вывод текста
    process.stdout.write(input);
    var command = input.trim();
    if (command == 'exit')
      process.exit(0);
  }
});

Если запустить это приложение, любая введенная строка будет немедленно повторяться в выводе. А если ввести команду exit , то приложение завершается, не требуя нажатия Ctrl+C.

Если убрать вызов функции process.stdin.setEncoding() в начале кода, произойдет ошибка. Дело в том, что буферы не поддерживают функцию trim(). Можно преобразовать буфер в строку, а затем выполнить trim:

var command = input.toString().trim();

Но лучше просто добавить команду назначения кодировки и исключить все неожиданные побочные эффекты.

Запись в объект process.stderr выполняется при возникновении ошибки. Почему именно этот объект, а не process.stdout ? По той же причине, по которой был создан канал stderr: чтобы отделить ожидаемый вывод от возникающих проблем. В некоторых системах вывод stderr даже может обрабатываться отдельно от stdout (например, сообщения stdout сохраняются в журнале, а вывод stderr выводится на консоль).

The post Глобальные объекты: Объекты global и process appeared first on HackerX.

• Знакомство с NPM
• Создание и публикация собственных модулей Node
  • Создание модуля
  • Упаковка целого каталога
  • Подготовка модуля к публикации
  • Публикация модуля

Знакомство с NPM

Значительная часть обширной функциональности, связанной с Node, реализована в модулях независимых разработчиков. Это модули маршрутизации, модули для работы с реляционными и документными СУБД, модули шаблонов, модули тестирования и даже модули платежных сервисов.

Чтобы использовать модуль, вы можете загрузить его исходный код, а затем установить его вручную в своей среде. Многие модули содержат базовые инструкции по установке, или, как минимум, требования к установке можно вычислить просмотром файлов и каталогов, включенных в модуль. Однако существует куда более простой способ установки модулей Node — менеджер npm.

Node.js поставляется с установленной копией npm, но эта версия npm не всегда является самой новой. Если вы захотите использовать другую версию npm, введите следующую команду для обновления имеющейся версии (используйте sudo , если этого требует ваша система):

npm install npm -g

Чтобы получить подробную сводку команд npm, воспользуйтесь следующей командой:

npm help npm

Модули могут устанавливаться глобально или локально. Локальная установка лучше всего подходит для работы над изолированным проектом, когда всем остальным пользователям той же системы доступ к модулю не нужен. При локальной установке (а этот вариант используется по умолчанию) модуль устанавливается в текущей позиции каталога node_modules.

npm install имя_модуля

Например, для установки Express используется следующая команда:

npm install express

Программа npm не только устанавливает модуль Express, но и находит модули, от которых он зависит, и устанавливает их. Чем сложнее модуль, тем больше зависимостей устанавливается.

После того как модуль будет установлен, он будет находиться в каталоге node_modules вашего локального каталога. Все зависимости также будут установлены в каталог node_modules этого модуля.

Чтобы установить пакет глобально, используйте параметр -g или —global :

npm install express -g

Если вы работаете в системе Linux, не забудьте использовать sudo для глобальной установки модуля.

Если пакет существует в нескольких версиях, есть возможность установить конкретную версию:

npm install module_name@0.3

Если модуль больше не используется, его можно удалить:

npm uninstall имя_модуля

Следующая команда приказывает npm проверить наличие новых модулей и обновить найденные:

npm update

Также можно обновить один модуль:

npm update имя_модуля

А если вы хотите узнать, есть ли среди пакетов устаревшие, воспользуйтесь командой:

npm outdated

Для вывода списка всех установленных пакетов и зависимостей передайте параметр list , ls , la или ll :

npm ls

С параметрами la и ll команды выводят расширенные описания. Например, в число зависимостей Request входит tunnel-agent@0.4.1 (версия 0.4.1 пакета tunnel-agent). Что это вообще такое — tunnel-agent? Ввод запроса npm la в командной строке выводит список всех зависимостей, включая tunnel-agent, с дополнительной информацией:

tunnel-agent@0.4.1
HTTP proxy tunneling agent. Formerly part of mikeal/request,
now a standalone module
git+https://github.com/mikeal/tunnel-agent.git
https://github.com/mikeal/tunnel-agent#readme

Флаг -d устанавливает все зависимости напрямую. Например, в каталоге модуля введите команду:

npm install -d

Чтобы узнать, какие модули установлены глобально, используйте следующую команду:

npm ls -g

Для получения дополнительной информации об установке npm используйте команду config. Следующая команда выводит список параметров конфигурации npm:

npm config list

Более подробное описание всех параметров конфигурации выводится командой:

npm config ls -l

Изменение или удаление параметров конфигурации из командной строки осуществляется либо командой:

npm config delete ключ
npm config set ключ значение

Также можно провести поиск модуля по условиям, которые, как вы думаете, могут вернуть лучший результат:

npm search html5 parser

При первом проведении поиска npm строит индекс, на что может потребоваться несколько минут. Впрочем, после завершения индексирования вы получаете список возможных модулей, соответствующих заданному условию (или условиям).

Сайт npm предоставляет реестр модулей с возможностью просмотра и регулярно обновляемый список модулей, чаще всего используемых другими модулями или приложениями Node. В следующем разделе я приведу подборку таких модулей.

И последнее замечание по поводу npm перед тем, как двигаться дальше. В самом начале ваших экспериментов с npm в конце вывода могут появляться предупреждения. В первой строке сообщается о том, что файл package.json не найден, а в остальных содержатся всевозможные предупреждения, связанные с отсутствующим файлом package.json .

Документация npm рекомендует создать файл package.json для сопровождения локальных зависимостей. В принципе, это не обязательно, но предупреждения слегка раздражают.

Чтобы создать файл package.json по умолчанию в каталоге проекта, выполните следующую команду:

npm init --yes

Команда создает в каталоге файл package.json по умолчанию; при этом вам будет предложено ответить на ряд вопросов по проекту: ваше имя, название проекта и т. д., причем у каждого вопроса имеется значение по умолчанию. В дальнейшем при установке модуля вы уже не будете получать часть раздражающих сообщений. Чтобы избавиться от остальных, необходимо обновить данные JSON в этом файле и включить в них описание и информацию о репозитории. Кроме того, если вы хотите, чтобы файл обновлялся при установке обновленного модуля, используйте следующий синтаксис:

npm install express --save-dev

Имя и версия модуля сохраняются в поле devDependencies файла package.json. Также можно сохранить модуль в зависимостях модулей, но об этом подробнее я расскажу в следующей части этой статьи.

Создание и публикация собственных модулей Node

Как и в случае с кодом JavaScript на стороне клиента, многократно используемый код JavaScript стоит выделить в собственные библиотеки. Единственное отличие заключается в том, что вам придется выполнить пару лишних действий для преобразования библиотеки JavaScript в модуль, рассчитанный на взаимодействие с Node.



Создание модуля

Допустим, у вас имеется библиотечная функция JavaScript concatArray, которая получает строку и массив строк, выполняет конкатенацию первой строки с каждой строкой в массиве и возвращает новый массив:

function concatArray(str, array) {
  return array.map(function(element) {
    return str + ' ' + element;
  });
}

Вы хотите использовать эту функцию наряду с другими в своих приложениях Node. Чтобы преобразовать библиотеку JavaScript для использования в Node, необходимо экспортировать все функции с помощью объекта exports , как показано в следующем примере:

exports.concatArray = function(str, array) {
  return array.map(function(element) {
    return str + ' ' + element;
  });
};

Чтобы использовать concatArray в приложении Node, импортируйте библиотеку. После этого вы сможете использовать экспортированную функцию в своем приложении:

const newArray = require('./arrayfunctions.js');
let data = newArray.concatArray('hello', ['test1','test2']);
console.log(data);

Вы также можете создать модуль, состоящий из конструктора или функции, и экспортировать его с использованием module.exports.

Например, модуль Mime , от которого могут зависеть многие другие модули, создает функцию Mime():

function Mime() { ... }

добавляет функциональность с использованием свойства prototype :

Mime.prototype.define = function(map) {...}

создает экземпляр по умолчанию:

const mime = new Mime();

присваивает функцию Mime одноименному свойству:

mime.Mime = Mime;

и после этого экспортирует экземпляр:

module.exports = mime;

После этого вы сможете использовать различные функции Mime в своем приложении:

const mime = require('mime');
console.log(mime.lookup('phoenix5a.png');

Упаковка целого каталога

Вы можете разбить свой модуль на несколько файлов JavaScript, находящихся в каталоге. Node может загружать содержимое каталогов при условии, что его содержимое организовано одним из двух способов.

Первый способ основан на создании файла package.json с информацией о каталоге. Структура содержит разнообразную информацию, но к упаковке модуля относятся два свойства — name и main:

{
  "name": "mylibrary",
  "main": "./mymodule/mylibrary.js"
}

Первое свойство, name , содержит имя модуля, а второе свойство, main, обозначает точку входа модуля.

Во втором способе загрузки содержимого в каталог добавляется файл index.js или index.node , служащий главной точкой входа модуля.

Зачем использовать каталог вместо одного модуля? Чаще всего это делается из-за того, что вы используете существующие библиотеки JavaScript и предоставляете файл — <<обертку>>, который <<упаковывает>> экспортируемые функции командой exports . А может быть, ваша библиотека настолько велика, что вы хотите разбить ее для удобства внесения изменений.

В любом случае следует помнить, что все экспортируемые объекты должны находиться в одном главном файле, загружаемом Node.

Подготовка модуля к публикации

Если вы захотите сделать свой пакет доступным для других, вы можете рекламировать его на своем сайте, но при этом вы упустите значительную аудиторию. Готовые модули лучше публиковать в реестре npm.

Ранее я упоминала о файле package.json. Документацию по JSON для npm можно найти по этому адресу https://docs.npmjs.com/files/package.json. Она базируется на рекомендациях системы модулей CommonJS.

В пакет package.json рекомендуется включать следующие поля:

• name — имя пакета (обязательно).
• description — описание пакета.
• version — текущая версия, соответствующая требованиям семантической версии (обязательно).
• keywords — массив условий поиска.
• maintainers — массив ответственных за сопровождение пакета (с именами, адресами электронной почты и сайтами).
• contributors — массив соавторов пакета (с именами, адресами электронной почты и сайтами).
• bugs — URL-адрес для отправки ошибок.
• licenses — массив лицензий.
• repository — репозиторий пакетов.
• dependencies — необходимые пакеты и их номера версий.

Обязательны только поля name и version , хотя включить рекомендуется все поля. К счастью, npm упрощает создание этого файла. Если ввести в командной строке следующую команду:

npm init

программа переберет все обязательные/рекомендованные поля, предложив вам ввести значение каждого. Когда все будет сделано, она сгенерирует файл package.json.

Сначала мы создадим в node_modules подкаталог с именем inputcheck и перенесем в него существующий код InputChecker. Файлу необходимо присвоить имя index.js . Затем в код вносятся изменения и из него извлекается часть, реализующая новый объект. Мы сохраним ее для будущего тестового файла.

const util = require('util');
const eventEmitter = require('events').EventEmitter;
const fs = require('fs');
exports.InputChecker = InputChecker;

function InputChecker(name, file) {
    this.name = name;
    this.writeStream = fs.createWriteStream(`./${file}.txt`,
        {'flags' : 'a',
            'encoding' : 'utf8',
            'mode' : 0666
        }
    );
};

util.inherits(InputChecker,eventEmitter);
InputChecker.prototype.check = (input) => {
    const command = input.toString().trim().substr(0,3);
    if (command == 'wr:') {
        this.emit('write', input.substr(3, input.length));
    } else if (command == 'en:') {
        this.emit('end');
    } else {
        this.emit('echo', input);
    }
};

Экспортировать функцию объекта напрямую не удастся, потому что util.inherits ожидает, что в файле с именем InputChecker существует объект. Прототип объекта InputChecker изменяется позднее в файле, также можно было изменить ссылки в коде и использовать exports.InputChecker , но это неуклюжее решение. С таким же успехом объект можно присвоить в отдельной команде.

Чтобы создать файл package.json, я выполнил команду npm init и ответил на все вопросы.

Сгенерированный файл package.json для модуля inputChecker:

{
  "name": "inputcheck",
  "version": "1.0.0",
  "description": "Looks for and implements commands from input",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "keywords": [
    "command",
    "check"
  ],
  "author": "HackerX.ru",
  "license": "ISC"
}

Команда npm init не запрашивает информацию о зависимостях, поэтому их придется добавить прямо в файл. Впрочем, есть другое, более правильное решение — использовать команду npm install —save при установке модулей, чтобы зависимости были добавлены автоматически. Однако модуль InputChecker не зависит от внешних модулей, поэтому эти поля можно оставить пустыми.

На этой стадии мы можем протестировать новый модуль и убедиться в том, что он действительно работает как модуль. В листинге 3.4 приведен фрагмент предыдущей версии приложения InputChecker, которая тестирует новый объект, теперь выделенный в отдельное тестовое приложение.

Тестовое приложение InputChecker:

const inputChecker = require('inputcheck').InputChecker;
const ic = new inputChecker('Shelley','output');

ic.on('write', (data) =>
  this.writeStream.write(data, 'utf8');
);

ic.addListener('echo', ( data) =>
    console.log(`${this.name} wrote ${data}`);
);

ic.on('end', () => process.exit());

process.stdin.resume();
process.stdin.setEncoding('utf8');
process.stdin.on('data', (input) => ic.check(input));

Теперь тестовое приложение можно переместить в новый подкаталог test в каталоге модуля, чтобы оно было упаковано в модуле как пример. По общепринятым правилам следует предоставить каталог test с одним или несколькими тестовыми приложениями, а также каталог doc с документацией. Для такого маленького модуля файла README должно быть достаточно.

Так как у нас теперь имеется тестовое приложение, необходимо внести изменения в файл package.json и добавить в него ссылку:

"scripts": {
  "test": "node test/test.js"
},

Это довольно примитивный тест, который не использует мощные тестовые возможности Node, но и он показывает, как может работать тестирование. Чтобы запустить тестовое приложение, введите в командной строке следующую команду:

npm test

Остается создать сжатый tar-архив модуля. Впрочем, если вы публикуете модуль так, как описано в разделе «Публикация модуля», этот шаг можно пропустить.

Публикация модуля

Создатели npm также предоставили нам руководство с подробным описанием того, что необходимо сделать для публикации модуля Node: Developer Guide (https://docs.npmjs.com/misc/developers).

В документации приведены дополнительные требования к файлу package.json. В дополнение к уже созданным полям также необходимо добавить поле directories с хешем папок, включая уже упоминавшиеся test и doc:

"directories": {
  "doc" : ".",
  "test" : "test",
  "example" : "examples"
}

Перед публикацией в руководстве рекомендуется протестировать модуль на корректность установки. Чтобы выполнить тестирование, введите следующую команду в корневом каталоге модуля:

npm install . -g

К этому моменту мы протестировали модуль inputChecker, изменили файл package.json, добавили в него каталоги и убедились в том, что пакет успешно устанавливается.

Затем необходимо добавить себя как пользователей npm, если это не было сделано ранее. Введите следующую команду:

npm adduser

после чего по отображаемым подсказкам введите имя пользователя, пароль и адрес электронной почты.

Осталось сделать последний шаг:

npm publish

Можно указать путь к tar-архиву или каталогу. Как предупреждает Guide, доступ предоставляется ко всему содержимому каталога, если только вы не используете в файле package.json директиву .npmignore со списком файлов для игнорирования материала. Тем не менее перед публикацией модуля лучше просто удалить все, без чего можно обойтись.

После публикации — и после того, как исходный код также будет загружен в GitHub (если вы используете этот репозиторий), — модуль официально готов для использования другими разработчиками. Рекламируйте свой модуль в Твиттере, Google+, Facebook, на своем сайте и вообще повсюду, где люди смогут о нем узнать. Такая реклама не хвастовство, а распространение информации.

The post Как создать собственные модули в Node.js и опубликовать в NPM appeared first on HackerX.

Последние время WebSockets стали довольно популярный, появились очень многие приложение, игры и сайты, которые используют Веб-Сокеты. Но несмотря на это, есть проблемы с браузерами — все новые браузеры поддерживают протокол WS, но как быть с старыми браузерами? Если бы мы писали чистый код (не используя библиотеку), то для решение этой проблемы нам нужно было писать некоторые условия и костыли. Но если мы будем использовать библиотеку Socket.io, то данная проблема для нас не актуален.

Знакомство с Socket.io — Что это такое

Высшее уже сказал, что с библиотекой Socket.io у нас не будет проблем с браузерами — данная библиотека осуществляет взаимодействие тем способом, который подходит для его участников (клиент, сервер). Ниже представлен список доступных методов:

• WebSocket
• Adobe Flash Socket
• Server-Sent Events
• XHR long polling
• XHR multipart streaming
• Forever Iframe
• JSONP Polling
• ActiveX HTMLFile

Для современных браузеров, которые поддерживают протокол WebSocket, библиотека Socket.io будет использовать аналогичный метод взаимодействия. При отсутствие поддержки он автоматический выберет подходящий и лучший метод взаимодействие. Кроме этого библиотека Socket.io добавляет в стандартный функционал WebSocket новые функции, которые рассмотрены ниже.

Создание сокет-сервера на Socket.io

Давайте начнем создать простой сокет-сервер на библиотеке Socket.io, Node.js и Express framework. Для этого нам нужно создать папку для проекта, открыть терминал / командную строку, перейти в папку. После этого в папке создаем файл package.json с таким содержанием:

{
  "name": "socket",
  "version": "0.0.1",
  "description": "Мой первый проект на Socket.io",
  "dependencies": {}
}

После этого нужно установить Express фреймворк и библиотеку Socket.io.

npm install --save express
npm install --save socket.io

После установки необходимых библиотек нужно создать файл server.js, который будет сервером. Наш сервер будет состоять из нескольких строк кода.

const app  = require('express')();
const http = require('http').Server(app);
const io   = require('socket.io')(http);

app.get('/', (req, res) => {
  res.sendFile(__dirname + '/index.html');
});

io.on('connection', (socket) => {
  socket.emit("hello", "Привет из Сокет-сервера");
});

http.listen(3000, () => {
  console.log('Сервер слушает порт 3000');
});

В первых трех строках кода мы подключаем необходимые модули — Express Framework, HTTP, Socket.io. Далее устанавливаем обработчик — при запросе на главную страницу мы отправим клиенту содержимое файла index.html. После этого устанавливаем новый обработчик (9 строка кода) — если клиент подключиться к Веб-Сокет серверу, то будет вызван функция обратного вызова и в переменную socket будут данные клиента. Десятом строке мы сообщаем клиенту, что должна выполнена события с названием hello, который находится на стороне клиента и отправляем сообщения, который клиент получить в виде параметра функцию обратного вызова.

Наш сервер готов, давайте создадим клиент. Создаем в папке файл index.html с таким содержанием:

<!DOCTYPE html>
<html lang="ru">
<head>
  <meta charset="UTF-8">
  <title>Socket.io</title>
  <script src="/socket.io/socket.io.js"></script>
</head>
<body>

  <script>
    var socket = io();
    socket.on("hello", function(serverData) {
       alert(serverData);
    });
  </script>

</body>
</html>

Здесь мы подключаем библиотеку socket.io — <script src="/socket.io/socket.io.js"></script> почему у нас нет файла socket.io.js а он подключается — более подробно об этом поговорим потом. После подключение библиотеки, на стороне клиента нам будет доступна функция io(). После вызова, функции в переменную socket получить объект, который имеет несколько методов и объектов. Один из методов — это on(). С помощью этого метода мы устанавливаем событие. Первым параметром он принимает имя а вторым callback функцию. Из сервера мы можем вызвать событию с помощью метода emit().

Более подробно можно прочитать здесь — События в Node.js.

Наш Сокет-Сервер и клиент готов, можно запустить и тестировать. Вводим в терминале следующую команду:

npm start

Открываем в браузере этот адрес: http://localhost:3000. После этого, в браузере мы увидим сообщение с сервера.

У нас уже есть Сокет-Сервер, который создан с помощью Socket.io, Node.js и Express. В второй части этой статьи мы на базе этого сервера создадим чат. Весь список уроков Node.js представлен на этом странице.

The post Node.js, Socket.io и Express: Создание чата с нуля. Часть 1 appeared first on HackerX.

ORM (англ. Object-Relational Mapping, рус. объектно-реляционное отображение) — это технология программирования, который связывает базу данных с моделью объектно-ориентированных языков программирования. Он создает для СУБД виртуальный объектный интерфейс.

ORM помогает программистам избавиться от больших кусков кода, ошибок и повышает скорость разработки. То есть, мы избавляемся от обычных SQL запросов, пишем небольшие куски кодов в объектно-ориентированным стилем, а библиотека транслирует этот код в sql запросы.

Сейчас есть довольно большое количество ORM библиотек для различных языков. Например, для PHP это Propel, Doctrine и Qcodo. Для Python это SQLAlchemy, Storm. Для Java это Hibernate. Для всех популярных объектно-ориентированных языков есть по крайней мере один свой ORM.

После того, как с помощью языка JavaScript (Node.js) стало возможно программировать на сервере, и для этого языка появились ORM системы. Самый популярный из них — это Sequelize. Как понимаете, в этом уроке мы будем изучать его.

Node.js и ORM-система Sequelize — Начинаем работать

Библиотека Sequelize — это Node.js ORM система для работы с такими базами данных, как PostgreSQL, MySQL, SQLite и MSSQL. Давайте начнем работать с Sequelize. Нам нужно установить данную библиотеку. Для установки открываем терминал (командная строка) и вводим команду ниже.

npm install --save sequelize

После этого нужно установить одну из библиотек. Например, если вы хотите работать с MySQL, то нужно установить mysql2.

npm install --save pg pg-hstore // PostgreSQL
npm install --save mysql2  // MySQL
npm install --save sqlite3  // SQLite
npm install --save tedious  // MSSQL

Настройка соединения

После установки библиотек мы можем установить соединение с базой данных.

const Sequelize = require("sequelize");
const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql'|'sqlite'|'postgres'|'mssql',

  pool: {
    max: 5,
    min: 0,
    idle: 10000
  },

  // Только Для SQLite
  storage: 'path/to/database.sqlite'
});

Давайте немного подробнее рассмотрим этот код. После подключение ORM-системы Sequelize, нам в первом строке кода вернется функция / конструктор. Конструктор принимает несколько аргументов. Во второй строке кода мы вызываем конструктор (создаем новый объект с помощью оператора new), и передаем нужные аргументы / параметры.

Первые три аргументы — это данные доступа к базе данных:

• database — имя базы данных
• username — логин пользователя
• password — пароль пользователя базы данных

Последним аргументом конструктор принимает объект, где в виде key-value указаны необходимые параметры.

• host — это адрес сервера базы данных. Обычно тут нужно указать localhost, если база и проект находятся на одном сервере, если база данных на другом сервере, то там нужно будет указать IP адрес сервера.
• dialect — здесь нужно указать с каким СУБД вы работаете. Например, если вы работаете с PostgreSQL, то нужно указать postgres.
• storage — Этот ключ нужно только в том случае, если вы используете в качестве базы данных SQLite. Там нужно в виде строки указать путь к базе.

Пример кода, который указан выше, это общий пример, поэтому предлагаю рассмотреть конкретный пример. Например, давайте подключимся к базе данных MySQL.

const Sequelize = require("sequelize");
const sequelize = new Sequelize('database', 'username', 'password', {
  host: 'localhost',
  dialect: 'mysql',

  pool: {
    max: 5,
    min: 0,
    idle: 10000
  }
});

В константе (переменная) sequelize содержится экземпляр соединения и мы можем с ним работать. Sequelize имеет функцию (метод) authenticate, с помощью которого можно проверить состояние соединение.

sequelize
  .authenticate()
  .then(() => {
    console.log('Соединение установлено.');
  })
  .catch(err => {
    console.error('Ошибка соединения:', err);
  });

В этом уроке мы узнали, что такое ORM, как установить ORM-систему Sequelize, и как с Node.js подключится к серверу БД с помощью Sequelize. В следующем уроке мы продолжим знакомиться с ORM Sequelize и создадим CRUD приложения.

Полный список уроков Node.js представлен на этом странице.

The post ORM-система Sequelize для Node.js appeared first on HackerX.

Мы можем назначить объекту обработчик события с помощью метода addListener(event, callback). Метод принимает два аргумента — имя и обработчик события. Имя события — это строка, обычно в camelCase-стиле, например, connection, message, messageBegin. А второй параметър (обработчик) — ето callback функция (функция обратного вызова). Но есть и короткая версия этого метода, это для тех разработчиков, которые привыкли к удобств jQuery. Для метода addListener() существует синоним — метод on().

Пример обработки событий с помощью метода on:

server.on("connection", () => {
    console.log("connected!");
});

У метода on() есть очень полезная модификация — once(). С помощью метода once() мы можем назначить однократный обработчик события.

server.once("connection", () => {
    console.log("first connection!");
});

Этот код (события) сработает только при первом соединение с сервером.

В Node.js мы можем с одним объектом связать сколько угодно обработчиков, но по умолчанию их количество ограничено 10. Это сделано для того, чтобы предотвратить утечки памяти. Но мы имеем возможность изменить максимальное количество с помощью метода setMaxListeners(n), где n — это требуемое максимальное допустимое количество обработчиков.

Так же мы можем посмотреть все обработчики объекта, которые связаны с конкретными событиями. Это можно сделать с помощью метода listeners, который возвращает массив обработчиков.

const http = require("http");

const server = http.createServer((req, res) => {

}).listen(8080);

function serverClose(){
    server.close();
}

server.on("connection", () => {
    console.log("Connected!");
});

server.on("connection", serverClose);

console.log( server.listeners("connection") );

Результат:

[ [Function: connectionListener],
[Function],
[Function: serverClose] ]

Мы ожидали, что в консоле мы увидим два обработчиков, а мы видим три, откуда взялся первый обработчик? Всё просто, connectionListener автоматически создается методом http.createServer(), это родной обработчик объекта.

Мы можем удалить обработчик с помощью метода removeListener(event, callback).

server.removeListener("connection", () => {
    console.log("Удален!");
});

Метод emit(event, [args]) — этот метод позволяет назначенным обработчикам срабатывать, как если бы связанные событие случилось. То есть, мы можем создать обработчик события а потом с помощью этого метода вызвать обработчик.

server.on("myEventName", (userName) => {
    console.log(`Hello, ${userName}`);
});

server.emit("myEventName", "John");

Метод emit() кроме имени обработчика может принимать необязательные параметры — список аргументов обработчика.

В Node.js мы можем создать собственные событие и обработать. Это можно сделать с помощью конструктора / класса EventEmitter.

Объект EventEmitter

EventEmitter — это основной объект, который реализует работу обработчиков событий в Node.js. Любой объект, который является источником событий, наследует от класса EventEmitter. Так же все методы, о которых мы говорили, принадлежат этому классу. С помощью этого объекта мы можем создать собственной событие.

const EventEmitter = require("events").EventEmitter;

const myEventObject = new EventEmitter();

myEventObject.on("eventName", (userName) => {
    console.log(userName);
});

myEventObject.emit("eventName", "John");

The post Node.js — обработка событий. Объект EventEmitter appeared first on HackerX.

Что такое Redis

Redis — это высокопроизводительная key-value хранилище данных. Все данные хранятся в оперативной памяти. Также, по мере необходимости данные дублируются на физический носитель. После сбоев или перезагрузки сервера Redis читать данные с диска. Используя Redis, мы получаем хранилище данных, которые хранятся в оперативной памяти, и после сбоев или перезагрузки сервера мы не теряем эти данные.

Сохранение данных на физический диск можно настроить двумя способами:

1. через определенный промежуток времени он сохранял данные на диск;
2. после определенное количество атомарных изменений он сохранял данные на диск.

Redis обладает такими возможностями и механизмы, как журналирование, снимки, поддержка работы с такими данными, для каждого из которых существует свой набор команд, транзакции, неблокирующая master-slave репликация на несколько узлов, подтяжка использование нескольких БД, с возможностью атомарного переноса ключей между ними, Pipeline (отправка на выполнение набора команд и отложенное получение ответа).

Типы данных Redis

• Строки (String) — Базовый тип данных Redis. Строки в Redis бинарно-безопасны, могут использоваться так же как числа.
• Списки (List) — Классические списки строк, упорядоченные в порядке вставки, которая возможна как со стороны головы, так и со стороны хвоста списка.
• Множества (Set) — Множества строк в математическом понимании: не упорядочены, поддерживают операции вставки, проверки вхождения элемента, пересечения и разницы множеств.
• Хеш-таблицы (Hash) — Классические хеш-таблицы или ассоциативные массивы.
• Упорядоченные множества (Sorted Sets) — Упорядоченное множество отличается от обычного тем, что его элементы упорядочены по особому параметру «score».

Обычно стандартные key-value хранилищи позволяют работать только с ключами. Но Redis нарушает эти принципы. Для каждого типа содержимое у него своя логика работы и набор команд.

Redis и Node.js — Модуль Redis для Node.js

Для работы с Redis v Node.js нам нужно установить модуль redis:

npm install redis

А теперь, давайте подключаем модуль и начнем работу с ним.

// Подключаем модуль
const redis  = require("redis");
// Создаем клиента
const client = redis.createClient();

// Выбираем базу данных
client.select(0, ( ) => {
    client.on("error", (err) =>  {
        console.log("Error " + err);
    });

    // .......

    client.quit( );
});

После подключение модуля и создание redis-клиента мы выбрали базу данных — 0. Но в данном случае это лишний шаг, по умолчанию используется база 0.

После выбора базы данных можно работать с Redis — записать данные в базу, получить и удалить данные с базы.

const redis  = require("redis");
const client = redis.createClient();

client.select(0, ( ) => {
    client.on("error", (err) =>  {
        console.log("Error " + err);
    });

    // Запись данных
    client.set("string_key", "string value", redis.print);

    // Получение данных
    client.get("string_key", (err, data) => {
        if(err) console.log(err);

        console.log(data);
    });

    client.quit( );
});

С помощью метода set объекта client записать данные в виде «Ключ — Значение», а с помощью метода get мы получаем данные по ключу.

Также, мы можем удалить данные по ключу с помощью метода del:

client.del("string_key", (err) => {
    if(err) console.log(err);
});

Данный модуль поддерживает все команды Redis. Например, мы с помощью одной команды можем одновременно работать с множеством ключей и значение.

client.mset(
    "string_key_1", "string value 1",
    "string_key_2", "string value 2",
    "string_key_3", "string value 3",
    "string_key_4", "string value 4",
    (err, result) => {
        if(err) console.log(err);

        console.log(result);
    }
);

В следующем статье я покажу, как на Node.js можно создать модель для Redis.

The post Использование Redis в Node.js appeared first on HackerX.

Middleware (связующее программное обеспечение) — это программное обеспечение, который обеспечивает связь других программных компонентов. При этом под «программными компонентами» могут понимается очень разные вещи. Например, middleware можно назвать слои программного обеспечения для взаимодействий между клиентской части и базой данных, сетевых и прикладных программных компонентов.

Connect — это классический middleware framework, который содержит в себе множество инструментов, необходимых при разработке веб-приложений на Node.js. Он имеет такие инструменты, как средства для ведение логов, маршрутизация, работа с сессиями, файлами cookies, профайлер, сервер раздачи статического контента, программы для обработки http-запросов и много других связающих программ.

Использование Connect middleware фреймворка

Для установки Connect открываем терминал и выполнить следующую команду.

npm install connect

Давайте сначало сделаем что нибудь простое. Например, создадим HTTP-сервер с использованием Connect middleware.

const connect = require("connect");
const http = require("http");

const app = connect()
              .use((req, res, next) => {
                console.log('Hello 1');
                next();
              })
              .use((req, res, next) => {
                console.log('Hello 2');
                next();
              })
              .use((req, res, next) => {
                console.log('Hello 3');
                res.end('END');
              });

http.createServer(app).listen(8080);

После этого запускаем создании сервер с консоли — node index.js. Заходим в браузер и в адресной строки вводим localhost:8080. После этого в браузере мы увидим слово «END», а в консоли мы увидим следующее:
Hello 1
Hello 2
Hello 3

Давайте подробно рассмотрим написании код. В первых двух строках кода мы подключаемые модули connect и http. Потом создаем объект app — экземпляр приложения, использующего connect. Затем с помощью метода use мы связываем приложение с необходимыми «связующими программами» и со слушателем connect запросов. Связующие программы — это функции, которые на данном примере принимают три аргумента: request (запрос клиента), response (ответ сервера) и next (функция). При вызове функции next он нас выбрасывает из одной middleware в другую. Если бы мы не вызвали функцию next в первом middleware, то после выполнение первой middleware программа остановился, и мы в консоле увидели только «Hello 1».

The post Connect — middleware framework для Node.js appeared first on HackerX.

const fs = require("fs");  // Подключаем модуль fs

В этой статье мы узнаем как можно читать файлы в Node.js. В Node.js читать файлы можно двумя способами — асинхронный и синхронный.

Асинхронное чтение файла — fs.readFile( )

Метод readFile может принимать 3 аргумента. Из них второй аргумент является обязательным.

fs.readFile(файл[, опции], callback)

• файл <String> | <Buffer> | <Integer> Имя / адрес файла или файловый дескриптор
• опции <Object> | <String>
  • кодировка <String> | <Null> по умолчанию = null
  • флаг <String> по умолчанию = ‘r’
• callback <Function>

• Первый аргумент — это адрес файла, который нужно читать;
• Второй аргумент — это опции, который является обязательным. Опции можно указать в виде объекта (для указание нескольких опций) и в виде строки;
• Третий аргумент — это функция обратного вызова (callback функция). Функция вызывается после чтения файла.

Пример чтение файла асинхронно:

const fs = require("fs");

fs.readFile('./test.txt', (err, data) => {
    if (err) throw err;
    console.log(data);
});

В функцию обратного вызова передается два аргумента (err, data). Если при чтение файла возникла ошибка, то в переменную err получим объект с описанием ошибки. А аргумент data содержит содержимое файла.

Если при чтение файла ми не указали кодировку, то данные будут возвращены в виде буфера.

Пример чтение файла с указанием опции:

const fs = require("fs");

fs.readFile('./test.txt', 'utf8', (err, data) => {
    if (err) throw err;
    console.log(data);
});

Синхронное чтение файла — fs.readFileSync( )

Многие асинхронные функции в Node.js имеют синхронный вариант. И для чтение файлов в синхронном режиме есть метод readFileSync. Он может принимать 2 аргумента.

fs.readFileSync(файл[, опции])

• файл <String> | <Buffer> | <Integer> Имя / адрес файла или файловый дескриптор
• опции <Object> | <String>
  • кодировка <String> | <Null> по умолчанию = null
  • флаг <String> по умолчанию = ‘r’

• Первый аргумент — это адрес файла, который нужно читать;
• Второй аргумент — это опции, который является обязательным. Опции можно указать в виде объекта (для указание нескольких опций) и в виде строки;

Пример чтение файла синхронно:

const fs = require("fs");

let data = fs.readFileSync('./test.txt', 'utf8');
console.log(data);

The post Синхронное и асинхронное чтение файла в Node.js appeared first on HackerX.