Как работает express node js. Основы Node JS & Express (III). Руководство по миграции

06.08.2023 Компьютер

Глядя на шаблон синтаксиса, если мы хотим добавить новый маршрут в приложение, то можем просто сделать что-то вроде следующего:

Router.get("/app", function(req, res) { res.render("app", { title: "Express" }); });

Это маршрут? Это контроллер?

Самое интересное что маршрут это функция, содержащая логику. Внутри маршрута находится функция res.render:

Res.render("foo", { title: "Express" });

В шаблоне представления мы видим это:

H1= title p Добро пожаловать в #{title}

Это два примера того, как мы можем вытащить данные из controller/route и вывести их в представлении. В этом примере мы выводим HTML:

Express

Добро пожаловать в Express

Всё это, кажется, вытекает из проблемы - может ли маршрут также содержать информацию контроллера? Это верно, поэтому есть движение в обществе за то, чтобы изменить имя папки с routes на controllers.

Отличный пример этого можно увидеть в примере Express MVC .

Но ради логичности в этом руководстве мы будем держаться текущих соглашений.

Ошибки 404

Ошибки уже направляют вас в Express. В файле app.js есть следующее:

/// поймать 404 и перенаправить в обработчик ошибки app.use(function(req, res, next) { var err = new Error("Не найдено"); err.status = 404; next(err); });

В папке views/ есть errors.jade.

Extends layout block content h1= message h2= error.status pre #{error.stack}

Всё просто. Если вы хотите настроить свою страницу 404, то всего-лишь редактируйте это представление.

$ npm install express

или, чтобы иметь доступ к команде express, установите глобально:

$ npm install -g express

Быстрый старт

Проще всего начать работу с Express можно выполнив команду express , которая сгенерирует приложение:

Создание приложения:

$ npm install -g express $ express /tmp/foo && cd /tmp/foo

Установка зависимостей:

$ npm install -d

Запуск сервера:

Создание сервера

Чтобы создать экземпляр express.HTTPServer , просто вызовите метод createServer() . С помощью нашего экземпляра приложения мы можем задавать маршруты, основанные на HTTP-методах, в данном примере app.get() .

var app = require("express").createServer(); app.get("/", function(req, res){ res.send("hello world"); }); app.listen(3000);

Создание HTTPS-сервера

Чтобы инициализировать express.HTTPSServer , мы совершаем те же действия, что и выше, но к тому де передаем объект опций, содержащий ключ, сертификат и другие параметры, о которых написано в документации модуля https NodeJS.

var app = require("express").createServer({ key: ... });

Конфигурирование

Express поддерживает произвольные окружения (environments), как например, production и development . Разработчики могут использовать метод configure() , чтобы добавить нужные для данного окружения функции. Когда configure() вызывается без имени окружения, он будет срабатывать в любом окружении прежде чем сработает любой configure , в котором окружение задано.

В приведенном ниже примере мы просто используем опцию dumpExceptions и в режиме разработки выдаем клиенту в ответ стек-трейс исключения. В обоих же режимах мы используем прослойку methodOverride и bodyParser . Обратите внимание на использование app.router , который сам по себе позволяет монтировать маршруты - в противном случае они монтируются при первом вызове app.get() , app.post() и т.д.

app.configure(function(){ app.use(express.methodOverride()); app.use(express.bodyParser()); app.use(app.router); }); app.configure("development", function(){ app.use(express.static(__dirname + "/public")); app.use(express.errorHandler({ dumpExceptions: true, showStack: true })); }); app.configure("production", function(){ var oneYear = 31557600000; app.use(express.static(__dirname + "/public", { maxAge: oneYear })); app.use(express.errorHandler()); });

Для окруженией со схожими настройками можно передавать несколько имен окружений:

app.configure("stage", "prod", function(){ // config });

Для внутренних и произвольных настроек в Express есть методы set(key[, val]) , enable(key) , disable(key) :

app.configure(function () { app.set("views", __dirname + "/views"); app.set("views"); // => "/absolute/path/to/views" app.enable("some feature"); // все равно что app.set("some feature", true); app.disable("some feature"); // все равно что app.set("some feature", false); app.enabled("some feature") // => false });

Чтобы задать окружение мы можем установить переменную окружения NODE_ENV . Например:

$ NODE_ENV=production node app.js

Это очень важно, потому что множество механизмов кэширования включаются только в окружении production .

Настройки

Из коробки Express поддерживает следующие настройки:

home - базовый путь приложения, который используется для res.redirect(), а также для прозрачной поддержки примонтированных приложений.
views корневая директория представлений. По умолчанию текущая_папка/views
view engine - шаблонизатор по умолчанию для представлений, вызываемых без расширения файла.
view options - объект, отражающий глобальные опции представлений
view cache - включить кэширование представлений (включается в окружении production)
case sensitive routes - включить маршруты, чувствительные к регистру
strict routing - если включено, то завершающие слэши больше не игннорируются
jsonp callback - разрешить методу res.send() прозрачную поддержку JSONP

Маршрутизация

Express использует HTTP-методы для обеспечения осмысленного, выразительного API маршрутизации. Например, мы хотим, чтобы по запросу /user/12 отображался профиль пользователя с id=12 . Для этого мы определяем привелденный ниже маршрут. Значения, связанные с именованными полями, доступны в объекте res.params .

app.get("/user/:id", function(req, res){ res.send("user " + req.params.id); });

Маршрут это просто строка, которая внутри движка компилируется в регулярное выражение. Например, когда компилируется /user/:id , то получается регулярное выражение вроде такого:

\/user\/([^\/]+)\/?

Также можно сразу передавать регулярное выражение. Но поскольку группы в регулярных выражениях не именуются, к ним можно добраться в req.params по номерам. Так первая группа попадает в req.params , вторая в req.params и т.д.

app.get(/^\/users?(?:\/(\d+)(?:\.\.(\d+))?)?/, function(req, res){ res.send(req.params); });

Теперь возьмем curl и пошлем запрос на вышеупомянутый маршрут:

$ curl http://dev:3000/user $ curl http://dev:3000/users $ curl http://dev:3000/users/1 ["1",null] $ curl http://dev:3000/users/1..15 ["1","15"]

Ниже приведены несколько примеров маршрутов и пути, которые могут им соответствовать:

"/user/:id" /user/12 "/users/:id?" /users/5 /users "/files/*" /files/jquery.js /files/javascripts/jquery.js "/file/*.*" /files/jquery.js /files/javascripts/jquery.js "/user/:id/:operation?" /user/1 /user/1/edit "/products.:format" /products.json /products.xml "/products.:format?" /products.json /products.xml /products "/user/:id.:format?" /user/12 /user/12.json

Например, мы можем послать POST-ом некоторый JSON и ответить тем же JSON-ом, используя прослойку bodyParser , который умеет парсить JSON запрос (как впрочем и другие запросы) и помещать ответ в req.body:

var express = require("express"), app = express.createServer(); app.use(express.bodyParser()); app.post("/", function(req, res) { res.send(req.body); }); app.listen(3000);

Как правило мы используем “глупое” поле (например, /user/:id), у которого нет ограничений. Но если мы, к примеру, хотим ограничить ID пользователя только числовыми символами, можно использовать /user/:id(+) . Такая конструкция не будет срабатывать, если значение поля содержит нечисловые символы.

Передача управления на другой маршрут

Вызвав третий аргумент - next() , можно передать управление на следующий маршрут. Если соответствие не найдено, управление передается назад в Connect, и прослойки продолжают вызываться в порядке, в котором они были включены с помощью use() . Так же работают несколько маршрутов, имеющих один и тот же путь. Они просто вызываются по очереди, до того момента, когда один их них ответит вместо того, чтобы вызвать next() .

app.get("/users/:id?", function(req, res, next) { var id = req.params.id; if (id) { // делаем что-то } else { next(); } }); app.get("/users", function(req, res) { // делаем что-то другое });

Метод app.all() полезен, если нужно выполнить одну и ту же логику для всех HTTP-методов. Ниже мы используем этот метод для извлечения юзера из базы данных и назначения его в req.user .

Прослойки

Прослойки фреймворка Connect можно передавать в express.createServer() точно так же, как если бы использовался обычный Connect-сервер. Например:

var express = require("express"); var app = express.createServer(express.logger(), express.bodyParser());

Так же можно использовать use() . Так удобнее добавлять прослойки внутри блоков configure() , что более прогрессивно.

app.use(express.logger({ format: ":method:url" }));

Обычно с прослойками Connect мы можем подключить Connect следующим образом:

var connect = require("connect"); app.use(connect.logger()); app.use(connect.bodyParser());

Это не совсем удобно, поэтому Express повторно экспортирует Connect-овские прослойки:

app.use(express.logger()); app.use(express.bodyParser());

Порядок прослоек имеет значение. Так, когда Connect получает запрос, выполняется первая прослойка, добавленная через createServer() или use() . Она вызывается с тремя параметрами: request , response и callback-функция, обычно называемая next . когда вызывается next() , управление передается на вторую прослойку и т.д. Это важно учитывать, так так множество прослоек зависят друг от друга. Например methodOverride() обращается к req.body.method для перегрузки HTTP-метода, а bodyParser() парсит тело запроса, чтобы заполнить req.body . Другой пример - парсинг cookies и поддержка сессий - вначале необходимо вызывать use() для cookieParser() , затем для session() .

Множество Express-приложений может иметь строчку app.use(app.router) . Это может показаться странным, но это нужно просто для того, чтобы явным образом указать прослойку, которая включает в себя все созданные нами маршруты. Эту прослойку можно включать в любом порядке, хотя по умолчанию она включается в конце. Изменяя ее позицию, можно управлять очередностью ее выполнения. Например, нам нужен обработчик ошибок, который будет срабатывать после всех других прослоек и отображать любое исключение, переданное в него с помощью next() . Или же может понадобиться понизить очередность выполнения прослойки, обслуживающей статические файлы, чтобы позволить другим маршрутам перехватывать запросы к таким файлам и, например, считать количество скачиваний и т.д. Вот как это может выглядеть:

app.use(express.logger(...)); app.use(express.bodyParser(...)); app.use(express.cookieParser(...)); app.use(express.session(...)); app.use(app.router); app.use(express.static(...)); app.use(express.errorHandler(...));

Сначала мы добавляет logger() - он будет оборачивать метод req.end() , чтобы предоставлять нам данные о скорости ответа. Потом мы парсим тело запроса (если таковое имеется), затем куки, далее сессию, чтобы req.session был уже определен, когда мы доберемся до маршрутов в app.router . Если, например, запрос GET /javascripts/jquery.js будет обрабатываться маршрутами, и мы не вызовем next() , то прослойа static() никогда не получит этот запрос. Однако, если мы определим маршрут, как показано ниже, можно будет записывать статистику, отклонять загрузки, списывать оплату за загрузки, и т.д.

var downloads = {}; app.use(app.router); app.use(express.static(__dirname + "/public")); app.get("/*", function(req, res, next) { var file = req.params; downloads = downloads || 0; downloads++; next(); });

Маршруты-прослойки

Маршруты могут использовать маршрутные прослойки путем передачи методу дополнительных коллбэков (или массивов). Это полезно, если нужно ограничить доступ либо подгружать какие-либо данные перед использованием маршрута, и т.д.

Обычно асинхронное получение данных может выглядеть примерно как показано ниже (тут мы берем параметр:id и грузим данные юзера).

app.get("/user/:id", function(req, res, next) { loadUser(req.params.id, function(err, user) { if (err) return next(err); res.send("Viewing user " + user.name); }); });

Чтобы придерживаться принципа DRY и повысить читабельность кода, можно организовать такую логику с помощью прослоек. Как можно заметить, абстрагируя логику с помощью прослоек, можно как добиться повторного использования прослоек, так и сделать код маршрута более красивым.

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

function andRestrictToSelf(req, res, next) { req.authenticatedUser.id == req.user.id ? next() : next(new Error("Unauthorized")); } app.get("/user/:id/edit", loadUser, andRestrictToSelf, function(req, res) { res.send("Editing user " + req.user.name); });

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

Часто используемые “стеки” прослоек можно передавать как массивы произвольной глубины и древовидности (они будут применяться рекурсивно):

Полный пример можно посмотреть в репозитории .

Бывают случаи, когда надо пропустить остальные прослойки маршрута в стеке, но продолжить выполнение следующих маршрутов. Для этого надо вызывать next() с аргументом route: next("route") . Если не осталось маршрутов для выполнения, Express ответит ошибкой 404 Not Found .

HTTP-методы

Мы уже неоднократно пользовались app.get() , однако Express также предоставляет прочие HTTP-методы - app.post() , app.del() и т.д.

Самый распространенный пример использования POST - это отправка формы. В примере ниже мы просто делаем HTML-форму. А потом управление будет передаваться маршруту, который мы определим в следующем примере.

По умолчанию Express не знает, что ему делать с телом запроса, поэтому мы должны добавить прослойку bodyParser() , которая будет парсить тело запроса, закодированное в application/x-www-form-urlencoded или application/json , и помещать результаты парсинга в req.body . Для этого мы должны сказать use() , как показано ниже:

app.use(express.bodyParser());

Теперь нижеприведенный маршрут будет иметь доступ к объекту req.body.user , у которого будут свойства name и email:

app.post("/", function(req, res) { console.log(req.body.user); res.redirect("back"); });

В случае использования формой таких методов как PUT, можно использовать скрытый инпут по имени _method , который позволяет изменить HTTP-метод. Чтобы этого добиться, нужно сначала задействовать прослойку methodOverride() , которая будет помещена после bodyParser() , что позволит ей использовать req.body , содержащий поля переданной формы.

app.use(express.bodyParser()); app.use(express.methodOverride());

Эти прослойки не задействованы по умолчанию, потому что Express не обязательно должен сразу обладать полным функционалом. В зависимости от нужд приложения, можно и не использовать их. И тогда методы PUT и DELETE все так же будут доступны, но уже напрямую. В то же вреям methodOverride - это отличное решение для HTML-форм. Ниже показан пример использования метода PUT:

app.put("/", function() { console.log(req.body.user); res.redirect("back"); });

Обработка ошибок

У Express есть метод app.error() , который принимает все исключения, брошенные маршрутами, или переданные в виде next(err) . Ниже пример, как обслуживать несколько страниц с использованием самодельного исключения NotFound:

Можно вызывать app.error() несколько раз, как показано ниже. Тут мы проверяем instanceof NotFound и показываем страницу 404 , или же передаем управление следующему обработчику ошибок.

Заметьте, что эти обработчики могут быть определены где угодно, поскольку они все равно будут помещены ниже обработчиков маршрутов в listen() . Это позволяет их определять внутри блоков configure() , так что можно обрабатывать исключения по-разному в зависимости от текущего окружения.

app.error(function(err, req, res, next) { if (err instanceof NotFound) { res.render("404.jade"); } else { next(err); } });

Для просто ты мы принимаем здесь, что все ошибки имеют код 500, но вы можете это изменить как угодно. Например когда Node делает операции с файловой системой, можно получить объект ошибки с полем error.code = ENOENT , что означает “не найден файл или директория”, мы можем использовать это в обработчике ошибок и показывать соответствующую страницу.

app.error(function(err, req, res) { res.render("500.jade", { error: err }); });

Также приложения могут использовать для обработки исключений Connect-овскую прослойку errorHander . Например, если нужно в окружении development показывать исключения в stderr , можно сделать так:

app.use(express.errorHandler({ dumpExceptions: true }));

Также в ходе разработки нам могут понадобиться клевые HTML-странички, показывающие переданные или брошенные исключения. В таком случае нужно установить showStack в true:

app.use(express.errorHandler({ showStack: true, dumpExceptions: true }));

Прослойка errorHandler также отвечает в JSON, если клиентом передан заголовок Accept: application/json , что полезно для разработки AJAX-приложений.

Пред-обработки параметров маршрута

Пред-обработки параметров маршрута могут существенно улучшить читабельность приложения, через явную загрузку данных и валидацию URL запроса. Например, если вы постоянно извлекаете какие-то данные для определенных запросов (например грузите пользовательские данные для /user/:id), можно сделать что-то вроде этого:

app.get("/user/:userId", function(req, res, next) { User.get(req.params.userId, function(err, user) { if (err) return next(err); res.send("user " + user.name); }); });

С пред-условиями на наши параметры запроса можно навесить callback-функции, которые бы выполняли валидацию, ограничене доступа, или даже загрузку данных из базы данных. В примере ниже мы вызываем app.param() с именем параметра, на который хотим навесить callback. Как можно заметить мы получаем аргумент id , который содержит имя поля. Таким образом мы загружаем объект пользователя и выполняем обычную обработку ошибок и простой вызов next() , чтобы передать управление на следующее пред-условие либо уже на обработчик маршрута.

app.param("userId", function(req, res, next, id) { User.get(id, function(err, user) { if (err) return next(err); if (!user) return next(new Error("failed to find user")); req.user = user; next(); }); });

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

app.get("/user/:userId", function(req, res) { res.send("user " + req.user.name); });

Рендеринг представлений

Имена файлов представлений образуются по схеме { имя } . { движок } , где { движок } - это название модуля шаблонизатора, который должен быть подключен. Например представление layout.ejs говорит системе представлений, что надо сделать require("ejs") . Чтобы интегрироваться в Express, загружаемый модуль должен экспортировать метод exports.compile(str, options) , и возвращать функцию. Чтобы изменить это поведение, можно пользоваться методом app.register() - он позволяет проассоциировать расширения файлов с определенными движками. Например можно сделать, чтобы foo.html рендерился движком ejs .

Ниже - пример, использующий Jade для рендеринга index.html . И поскольку мы не используем layout:false , отрендеренный контент представления index.jade будет передан как локальная переменная body в представление layout.jade.

app.get("/", function(req, res) { res.render("index.jade", { title: "My Site" }); });

Настройка view engine позволяет указать шаблонизатор по умолчанию. Так например при использовании Jade можно сделать так:

app.set("view engine", "jade");

что позволит нам рендерить так:

res.render("index");

А не так:

res.render("index.jade");

Когда шаблонизатор установлен через view engine , расширения файлов не нужны. Однако мы по-прежнему можем использовать сразу несколько шаблонизаторов:

res.render("another-page.ejs");

В Express также есть настройка view options , которая будет накладываться при каждом рендеринге представления. Например если вы не так часто используете лэйауты, можно написать так:

app.set("view options", { layout: false });

Что можно при необходимости потом перегрузить в вызове res.render() :

res.render("myview.ejs", { layout: true });

Когда же нужен другой лэйаут, можно также указать путь. Например, если у нас view engine установлен в jade , и файл лэйаута называется./views/mylayout.jade , можно просто передать:

res.render("page", { layout: "mylayout" });

В противном случае можно передать расширение файла:

res.render("page", { layout: "mylayout.jade" });

Пути могут быть также абсолютными:

res.render("page", { layout: __dirname + "/../../mylayout.jade" });

Хороший пример - это указание нестандартных открывающих и закрывающих тегов движка ejs :

app.set("view options", { open: "{{", close: "}}" });

Фрагменты представлений

Система представлений Express имеет встроенную поддержку фрагментов и коллекций, своего рода мини-представлений. Например, вместо того, чтобы итерировать в представлении циклом для отображения списка комментариев, можно просто использовать фрагмент collection:

partial("comment", { collection: comments });

Если другие опции или локальные переменные не нужны, то можно пропустить объект и просто передать массив данных. Пример ниже равносилен предыдущему:

partial("comment", comments);

В случае использовании коллекций мы имеем несколько “волшебных” локальных переменных:

firstInCollection - true , если это первый объект
indexInCollection - индекс объекта в коллекции
lastInCollection - true , если это последний объект
collectionLength - длина коллекции

Переданные или сгенерированные локальные переменные имеет более высокий приоритет, однако локальные переменные, переданные в родительское представление, также доступны и в дочернем. Так например, если мы рендерим представление с помощью partial("blog/post", post) и оно породит локальную переменную post , а представление, вызвавшее эту функцию, имело локальную переменную user , то user также будет виден в представлении blog/post .

Дополнительную документацию см в разделе res.partial() .

Примечание: используйте коллекции осторожно, так как рендеринг массива в 100 элементов означает рендеринг 100 представлений. Для простых коллекций лучше итерировать циклом внутри представления, а не использовать коллекции. Так нагрузка будет меньше.

Поиск представлений

Поиск представлений производится относительно родительского преставления. Например если у нас есть представление views/user/list.jade и внутри него мы вызываем фрагмент partial("edit") , система попытается загрузить представление views/user/edit.jade , тогда как partial("../messages") приведет к загрузке views/messages.jade

Система представлений также позволяет делать index-файлы. Например, мы можем вызвать res.render("users") , и это может загрузить как views/users.jade , так и views/users/index.jade .

Использовать index-файлы можно также из представления в той же директории. Так вызовом partial("users") можно обратиться к представлению../users/index вместо того чтобы вызывать partial("index") .

Шаблонизаторы

Ниже представлены несколько шаблонизаторов, часто используемых с Express:

EJS - встроенный JavaScript
CoffeeKup - шаблонизация на основе CoffeeScript
jQuery Templates для Node

Поддержка сессий

Поддержку сессий можно включить используя Connect-овскую прослойку session . Также для этого нам нужна вышележащая прослойка cookieParser , которая будет парсить куки и помещать их в req.cookies .

app.use(express.cookieParser()); app.use(express.session({ secret: "keyboard cat" }));

По умолчанию прослойка session использует Connect-овское хранилище в памяти, однако существует множество других решений. Например connect-redis поддерживает хранилище сессий в Redis . Вот как им пользоваться:

var RedisStore = require("connect-redis")(express); app.use(express.cookieParser()); app.use(express.session({ secret: "keyboard cat", store: new RedisStore }));

Теперь свойства req.session и req.sessionStore будут доступны из всех маршрутов и последующих прослоек. Свойства req.session автоматически сохраняются при ответе. Вот как можно организовать корзину:

Объект req.session также имеет методы Session.touch() , Session.destroy() , Session.regenerate() для манипуляции сессиями. Для более полной информации см. документацию Connect Session .

Руководство по миграции

Разработчики, работавшие с Express 1.x могут обращаться к руководству по миграции , чтобы научить свои приложения работать с Express 2.x, Connect 1.x, и Node 0.4.x.

Request

req.header(key[, defaultValue])

Получить заголовок запроса key (нечувствительно к регистру) с необязательным значением по умолчанию DefaultValue:

req.header("Host"); req.header("host"); req.header("Accept", "*/*");

Заголовки Referrer и Referer - особый случай, обе конструкции будут работать:

// послан заголовок "Referrer: http://google.com" req.header("Referer"); // => "http://google.com" req.header("Referrer"); // => "http://google.com"

req.accepts(type)

Проверяет передан ли заголовок Accept , и подходит ли он под данный тип.

Когда заголовок Accept отсутствует, возвращается true . В противном случае проверяется соответствие типа, а потом подтипов. Можно передавать "html" которое внутренне конвертируется в "text/html" , используя таблицу соответствия MIME.

// Accept: text/html req.accepts("html"); // => true // Accept: text/*; application/json req.accepts("html"); req.accepts("text/html"); req.accepts("text/plain"); req.accepts("application/json"); // => true req.accepts("image/png"); req.accepts("png"); // => false

req.is(type)

Проверяет входящий запрос на наличие заголовка Content-Type и соответствие заданному MIME-типу.

// Пусть Content-Type: text/html; charset=utf-8 req.is("html"); req.is("text/html"); // => true // Пусть Content-Type теперь application/json req.is("json"); req.is("application/json"); // => true req.is("html"); // => false

В Express можно регистрировать собственные коллбэки для различных проверок запроса. Например, пусть нам нужно сделать красивую проверку является ли входящий запрос изображением. Для этого можно зарегистрировать коллбэк "an image" :

app.is("an image", function(req) { return 0 == req.headers["content-type"].indexOf("image"); });

Теперь внутри обработчиков маршрутов можно использовать его, чтобы проверять Content-Type вида "image/jpeg" , "image/png" и т.д.

app.post("/image/upload", function(req, res, next) { if (req.is("an image")) { // выполняем определенные действия } else { next(); } });

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

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

req.is("image/*");

Мы также можем также проверять подтип, как показано ниже. Тут проверка вернет true в случаях "application/json" , и "text/json" .

req.is("*/json");

req.param(name[, default])

Возвращает значение параметра name или - если оно не существует - default .

Проверяет параметры маршрута (req.params), например, /user/:id

Проверяет параметры строки запроса (req.query), например, ?id=12

Проверяет urlencoded-параметры тела запроса (req.body), например, id=12

Чтобы получать urlencoded-параметры тела запроса, должен существовать объект req.body . Для этого включите прослойку bodyParser() .

req.get(field, param)

Получает параметр поля заголовка. По умолчанию - пустая строка.

req.get("content-disposition", "filename"); // => "something.png" req.get("Content-Type", "boundary"); // => "--foo-bar-baz"

req.flash(type[, msg])

Помещает всплывающее сообщение в очередь.

req.flash("info", "email sent"); req.flash("error", "email delivery failed"); req.flash("info", "email re-sent"); // => 2 req.flash("info"); // => ["email sent", "email re-sent"] req.flash("info"); // => req.flash(); // => { error: ["email delivery failed"], info: }

Всплывающие сообщения также могут использовать форматные строки. По умолчанию доступна строка "%s" :

req.flash("info", "email delivery to _%s_ from _%s_ failed.", toUser, fromUser);

req.isXMLHttpRequest

Также имеет сокращение req.xhr . Проверяет заголовок X-Requested-With на предмет того, что запрос сделан с помощью XMLHttpRequest:

req.xhr req.isXMLHttpRequest

Response

res.header(key[, val])

Получает или устанавливает заголовок ответа.

res.header("Content-Length"); // => undefined res.header("Content-Length", 123); // => 123 res.header("Content-Length"); // => 123

res.charset

Устанавливает кодировку следующих заголовков Content-Type . Например, res.send() и res.render() по умолчанию будут "utf8" , а мы можем явно задать кодировку перед тем как рендерить шаблон:

res.charset = "ISO-8859-1"; res.render("users");

или перед тем, как отвечать с помощью res.send() :

res.charset = "ISO-8859-1"; res.send(str);

или с помощью встроенного в Node res.end() :

res.charset = "ISO-8859-1"; res.header("Content-Type", "text/plain"); res.end(str);

res.contentType(type)

Устанавливает заголовок ответа Content-Type .

var filename = "path/to/image.png"; res.contentType(filename); // Content-Type теперь "image/png"

Можно задавать Content-Type и строкой:

res.contentType("application/json");

Или просто расширением файла (без ведущей точки):

res.contentType("json");

res.attachment()

Устанавливает заголовок ответа Content-Disposition в "attachment" . Опционально может быть передано имя файла.

res.attachment("path/to/my/image.png");

res.sendfile(path[, options[, callback]])

Используется в res.download() для передачи произвольного файла.

res.sendfile("path/to/my.file");

Этод метод принимает необязательный параметр callback , который вызывается в случае ошибки или успеха передачи файла. По умолчанию вызывается next(err) , однако если передан callback , то надо это делать явно, или обрабатывать ошибку.

res.sendfile(path, function(err) { if (err) { next(err); } else { console.log("transferred %s", path); } });

Также можно передавать опции вызову fs.createReadStream() . Например, чтобы изменить размер буфера:

res.sendfile(path, { bufferSize: 1024 }, function(err) { // обработка... });

res.download(file[, filename[, callback[, callback2]]])

Передать данный файл как вложение (можно задать необязательное альтернативное имя файла).

res.download(‘path/to/image.png’);

res.download(‘path/to/image.png’, ‘foo.png’);

Это эквивалентно следующему:

res.attachment(file); res.sendfile(file);

Опционально можно задать callback вторым или третьим аргументом res.sendfile() . Внутри него вы можете отвечать, как если бы заголовок еще не был передан.

res.download(path, "expenses.doc", function(err) { // обработка... });

Также можно опционально передать второй коллбэк - callback2 . В нем обрабатываются ошибки, связанные с соединением. Однако в нем не следует пытаться посылать ответ.

res.download(path, function(err) { // ошибка или завершение }, function(err) { // ошибка соединения });

res.send(body|status[, headers|status[, status]])

Метод res.send() - высокоуровневое средство ответа, позволяющее передавать объекты (для JSON-ответа), строки (для HTML-ответа), экземпляры Buffer , или целые числа, определяющие статус-код (404 , 500 и т.д.). Вот как это используется:

res.send(); // 204 res.send(new Buffer("wahoo")); res.send({ some: "json" }); res.send(""); res.send("Sorry, cant find that", 404); res.send("text", { "Content-Type": "text/plain" }, 201); res.send(404);

По умолчанию заголовок Content-Type устанавливается автоматически. Однако если он был вручную, явным образом задан в res.send() или перед этим с помощью res.header() , или с помощью res.contentType() , то автоматической установки не произойдет.

Заметьте, что в этом методе происходит завершение ответа (аналогично res.end()), поэтому, если нужно выдать множественный ответ, или поток, то нужнопользоваться res.write() .

res.json(obj[, headers|status[, status]])

Посылает JSON-ответ с необязательными заголовками и статус-кодом. Этот метод идеален для организации JSON-API, однако JSON можно посылать также с помощью res.send(obj) (что впрочем не идеально, если нужно послать только строку, закодированную в JSON, так как res.send(string) отправит HTML)

res.json(null); res.json({ user: "tj" }); res.json("караул!", 500); res.json("Ничего не найдено", 404);

res.redirect(url[, status])

Перенаправляет на заданный URL. Статус-код по умолчанию - 302 .

res.redirect("/", 301); res.redirect("/account"); res.redirect("http://google.com"); res.redirect("home"); res.redirect("back");

Express поддерживает сокращения для редиректов - по умолчанию это "back" и "home" . При этом "back" перенаправляет на URL, заданный в заголовке Referrer (или Referer), а "home" использует настройку "home" (по умолчанию "/").

res.cookie(name, val[, options])

Устанавливает значение cookie с именем name в val . Опции: httpOnly , secure , expires , и т.д. Опция path по умолчанию принимает значение, установленное в настройке "home" , обычно это "/" .

// "Запомнить меня" на 15 минут res.cookie("rememberme", "yes", { expires: new Date(Date.now() + 900000), httpOnly: true });

Свойством maxAge можно задавать expire относительно Date.now() в миллисекундах. Таким образом наш вышеупомянутый пример теперь можно переписать так:

res.cookie("rememberme", "yes", { maxAge: 900000 });

Чтобы парсить входящие куки, использйте прослойку cookieParser , которая формирует объект req.cookies:

app.use(express.cookieParser()); app.get("/", function(req, res) { // используем req.cookies.rememberme });

res.clearCookie(name[, options])

Очищаем cookie по имени name , присваивая параметру expires дату в далеком прошлом. Опции те же, что у res.cookie() , path точно так же по умолчанию равен настройке "home" .

res.clearCookie("rememberme");

res.render(view[, options[, fn]])

Рендерит представление view с заданными опциями options и необязательным коллбеком fn . Когда задана fn , ответ клиенту не происходит автоматически, в противном же случае делается ответ text/html с кодом 200 .

Передаваемые опции являются по совместительству локальными переменными представления. Например, если мы хотим передать переменую user и запретить лэйаут, мы делаем это в одном объекте:

var user = { name: "tj" }; res.render("index", { layout: false, user: user });

Также объект options служит для передачи опций. Например, если вы передаете свойство status , то оно не только становится доступно представлению, а также устанавливает статус-код ответа. Это также полезно, если шаблонизатор принимает определенные опции, например debug или compress . Ниже - пример того, как можно отрендерить страницу ошибки - тут передается status как для его отображения, так и для установки статус-кода res.statusCode .

res.render("error", { status: 500, message: "Internal Server Error" });

res.partial(view[, options])

Рендерит фрагмент с заданными опциями. Этот метод всегда доступен из представления как локальная переменная.

object - объект, передаваемый в представление
as - имя переменной, которая будет представлять объект object или каждый элемент коллекции collection , переданных в представление. По умолчанию - имя представления.
- as: "something" - добавит локальную переменную something
- as: this - будет использовать элемент коллекции как контекст представления (this)
- as: global - сольёт воедино свойства элемента колекции и локальные переменные представления
- collection - массив объектов. Имя его происходит из имени представления. Например video.html будет имметь внутри объект video.

Следующие конструкции эквивалентны друг другу и имя коллекции, переданное фрагменту, везде будет "movie" .

partial("theatre/movie.jade", { collection: movies }); partial("theatre/movie.jade", movies); partial("movie.jade", { collection: movies }); partial("movie.jade", movies); partial("movie", movies); // Внутри представления: moovie.director

Чтобы сменить имя локальной переменной с "movie" на "video" , можно использовать опцию as:

partial("movie", { collection: movies, as: "video" }); // Внутри представления: video.director

Также мы можем сделать movie значением this внутри нашего представления, чтобы вместо movie.director можно было обращаться this.director .

partial("movie", { collection: movies, as: this }); // Внутри представления: this.director

Альтернативное решение - это развернуть свойства элемента коллекции в псевдо-глобальные (на самом деле локальные) переменные, используя as: global , такой вот “синтаксический сахар”:

partial("movie", { collection: movies, as: global }); // Внутри представления: director

Такая же логика применима не только к коллекциям, но и к объекту внутри фрагментного представления:

partial("movie", { object: movie, as: this }); // Внутри представления: this.director partial("movie", { object: movie, as: global }); // Внутри представления: director partial("movie", { object: movie, as: "video" }); // Внутри представления: video.director partial("movie", { object: movie }); // movie.director

Когда второй аргумент - не-коллекция (про признаку отсутствия.length), он считается объектом. При этом имя локальной переменной для этого объекта образуется из имени представления.

var movie = new Movie("Nightmare Before Christmas", "Tim Burton") partial("movie", movie) // => Внутри представления: movie.director

Исключение из этого правила - это когда передается простой объект ("{}" или "new Object"), тогда он считается объектом с локальными переменными (прим перев.: и недоступен по имени внутри фрагментного представления). Например в следующем примере можно ожидать, что будет локальная переменная "movie" , однако поскольку это простой объект, локальные переменные уже "director" и "title" , то есть его свойства:

var movie = { title: "Nightmare Before Christmas", director: "Tim Burton" }; partial("movie", movie)

Для таких случаев, когда нужно передавать именно простой объект, просто присвойте его какому-нибудь свойству, или используйте свойства object , которое унаследует имя объекта из имени файла. Перечисленные ниже примеры эквивалентны:

partial("movie", { locals: { movie: movie } }) partial("movie", { movie: movie }) partial("movie", { object: movie })

Такой же самый API может быть использован из маршрута, чтобы можно было ответить HTML-фрагментом через AJAX или WebSockets, например можно отрендерить коллекцию пользователей напрямую из маршрута:

app.get("/users", function(req, res) { if (req.xhr) { // передаем в ответ каждого юзера из коллекции // переданной в представление "user" res.partial("user", users); } else { // отвечаем полным лэйаутом со страницей списка пользователей // шаблон которой внутри себя делает partial("user", users) // ну и добавляет какой-то интерфейс res.render("users", { users: users }); } });

res.local(name[, val])

Получить или установить заданную локальную переменную. Под локальными переменными в данном случае имеются в виду переменные, передаваемые в методы рендеринга представления, например в res.render() .

app.all("/movie/:id", function(req, res, next) { Movie.get(req.params.id, function(err, movie) { // Делает присваивание res.locals.movie = movie res.local("movie", movie); }); }); app.get("/movie/:id", function(req, res) { // локальная переменная movie уже есть // , но мы можем ее дополнить, если нужно res.render("movie", { displayReviews: true }); });

res.locals(obj)

Присвоить несколько локальных переменных с помощью данного объекта obj . Следующее эквивалентно:

res.local("foo", bar); res.local("bar", baz); res.locals({ foo: bar, bar, baz });

Server

app.set(name[, val])

Установить настройку приложение name в значение val , или получить значение настройки name , если val отсутствует:

app.set("views", __dirname + "/views"); app.set("views"); // => ...path...

Также можно добраться до настроек через appsettings:

app.settings.views // => ...path...

app.enable(name)

Устанавливает настройку name в true:

app.enable("some arbitrary setting"); app.set("some arbitrary setting"); // => true app.enabled("some arbitrary setting"); // => true

app.enabled(name)

Проверяет, равна ли true настройка name:

app.enabled("view cache"); // => false app.enable("view cache"); app.enabled("view cache"); // => true

app.disable(name)

Установить настройку name в false:

app.disable("some setting"); app.set("some setting"); // => false app.disabled("some setting"); // => false

app.disabled(name)

Проверяет, равна ли false настройка name:

app.enable("view cache"); app.disabled("view cache"); // => false app.disable("view cache"); app.disabled("view cache"); // => true

app.configure(env|function[, function])

Задает коллбэк-функцию callback для окружения env (или для всех окружений):

app.configure(function() { // выполняется для всех окружений }); app.configure("development", function() { // выполняется только для окружения "development" });

app.redirect(name, val)

Для res.redirect() мы можем определить сокращения (в области видимости приложения), как показано ниже:

app.redirect("google", "http://google.com");

Теперь в маршруте мы можем вызвать:

res.redirect("google");

Также можно делать динамические сокращения:

app.redirect("comments", function(req, res) { return "/post/" + req.params.id + "/comments"; });

Теперь можно сделать следующее и редирект динамически построится в соответствие с контекстом запроса. Если мы вызвали маршрут с помощью GET /post/12 , наш редирект будет /post/12/comments .

app.get("/post/:id", function(req, res) { res.redirect("comments"); });

В случае монтированного приложения res.redirect() будет учитывать точку монтирования приложения. Например, если блог-приложение смонтировано в /blog , следующий пример сделает редирект в /blog/posts:

res.redirect("/posts");

app.error(function)

Добавляет функцию-обработчик ошибок, которая первым параметром будет принимать все исключения, как показано ниже. Заметьте, что можно устанавливать несколько обработчиков ошибок, путем нескольких вызовов этого метода, однако метод должен вызывать next() , если он не хочет сам обрабатывать исключение:

app.error(function(err, req, res, next) { res.send(err.message, 500); });

app.helpers(obj)

Регистрирует статические помощники представлений.

app.helpers({ name: function(first, last) { return first + ", " + last }, firstName: "tj", lastName: "holowaychuk" });

Наше представление может теперь пользоваться переменными firstName и lastName и функцией name() .

<%= name(firstName, lastName) %>

Также Express предоставляет по умолчанию несколько локальных переменных:

settings - объект настроек приложения
layout(path) указать лэйаут прямо изнутри представления

Этот метод имеет псевдоним app.locals() .

app.dynamicHelpers(obj) {#app.dynamic-helpers}

Регистрирует динамические помощники представлений. Динамические помощники представлений - это просто функции, принимающие res , req и выполняемые в контексте экземпляра Server перед тем, как отрендерить любое представление. Возвращаемое значение такой функции становится локальной переменной, с которой функция ассоциирована.

app.dynamicHelpers({ session: function(req, res) { return req.session; } });

Теперь все наши представления будут иметь доступ к сессии - данные сессии будут доступны на манер session.name и т.д.:

<%= session.name %>

app.lookup

Возвращает обработчики маршрута, связанные с заданным путем path .

Допустим, есть такие маршруты:

Можно использовать функционал lookup для проверки того, какие мрашруты заданы. Это может пригодиться для фреймворков более высокого уровня, построенных на Express.

app.lookup.get("/user/:id"); // => app.lookup.get("/user/:id/:op?"); // => app.lookup.put("/user/:id"); // => app.lookup.all("/user/:id"); // => app.lookup.all("/hey"); // =>

Псевдонимом для app.lookup.HTTP_МЕТОД() является просто app.HTTP_МЕТОД() - без аргумента callback . Такое вот сокращение. Например следующее эквивалентно:

app.lookup.get("/user"); app.get("/user");

Каждая возвращенная функция дополняется полезными свойствами:

var fn = app.get("/user/:id/:op?"); fn.regexp // => /^\/user\/(?:([^\/]+?))(?:\/([^\/]+?))?\/?$/i fn.keys // => ["id", "op"] fn.path // => "/user/:id/:op?" fn.method // => "GET"

app.match

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

Допустим, есть следующие маршруты:

app.get("/user/:id", function() {}); app.put("/user/:id", function() {}); app.get("/user/:id/:op?", function() {});

Вызов match для GET вернет две функции, поскольку:op в последнем маршруте необязательный параметр.

app.match.get("/user/1"); // =>

А следующий вызов вернет только один коллбэк для /user/:id/:op? .

app.match.get("/user/23/edit"); // =>

Можно использовать и all() , если нам не важен HTTP-метод

app.match.all("/user/20"); // =>

Каждая функция снабжается следующими свойствами:

var fn = app.match.get("/user/23/edit"); fn.keys // => ["id", "op"] fn.params // => { id: "23", op: "edit" } fn.method // => "GET"

app.mounted(fn)

Назначить коллбэк fn , который вызывается, когда этот Server передается в Server.use() .

var app = express.createServer(), blog = express.createServer(); blog.mounted(function(parent) { //parent - это app // this - это blog }); app.use(blog);

app.register(ext, exports)

Ассоциирует заданные экспортируемые свойства (exports) шаблонизатора с расширением ext файла шаблона.

app.register(".html", require("jade"));

Также это может пригодиться в случае с библиотеками, имя которых не совпадает в точности с расширением файла шаблона. Живой пример - Haml.js , который устанавливается npm -ом как "hamljs" , а мы можем зарегистрировать его на шаблоны ".haml" , а не ".hamljs" , как было бы по умолчанию:

app.register(".haml", require("haml-js"));

Кроме того app.register очень помогает в случае с шаблонизаторами, API которых не соответствует спецификациям Express. В примере ниже мы ассоциируем расширение.md с рендерером markdown -файлов. Рендерить в HTML будем только первый раз - для большей производительности - и будем поддерживать подстановку переменных вида "{name}" .

app.register(".md", { compile: function(str, options) { var html = md.toHTML(str); return function(locals) { return html.replace(/\{([^}]+)\}/g, function(_, name) { return locals; }); }; } });

app.listen(])

Биндим сокет сервера app к адресу host:port . Порт по умолчанию 3000 , хост - INADDR_ANY .

app.listen(); app.listen(3000); app.listen(3000, "n.n.n.n");

Аргумент port может быть также строкой, представляющей собой путь к unix domain socket :

app.listen("/tmp/express.sock");

Теперь попробуем:

$ telnet /tmp/express.sock GET / HTTP/1.1 HTTP/1.1 200 OK Content-Type: text/plain Content-Length: 11 Hello World

Участники проекта

Основной вклад в проект внесли следующие лица:

TJ Holowaychuk (visionmedia)
Ciaran Jessup (ciaranj)
Aaron Heckmann (aheckmann)
Guillermo Rauch (guille)

Сторонние модули

Следующие модули работают с Express или построены на его основе:

обеспечивает ресурсную маршрутизацию
express-messages рендеринг всплывающих уведомлений
express-configure поддержка асинхронной конфигурации (загрузка данных из Redis, и т.д.)
express-namespace - пространства имен в маршрутах
express-expose простая публикация JS-кода в клиентскую часть приложения
express-params - расширения app.param()
express-mongoose - плагин для простого рендеринга результатов запросов Mongoose (ORM для MongoDB)

Перевод

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

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

Один из способов создания серверной части приложения заключается в применении связки из Node.js, фреймворка Express и СУБД MongoDB. Собственно говоря, сегодня я расскажу о том, как создать рабочий макет API, который может служить основой для практически любого приложения. Здесь мы реализуем основные маршруты REST, будем взаимодействовать с API по HTTP и использовать простые варианты работы с базой данных.

Для того, чтобы успешно освоить этот материал, вам надо понимать, что такое REST API, иметь представление об операциях CRUD и обладать базовыми знаниями в области JavaScript. Здесь я использую ES6, ничего особенно сложного, в основном – стрелочные функции.

Мы разработаем скелет серверной части приложения для создания заметок, похожего на Google Keep . При этом с заметками можно будет выполнять все четыре CRUD-действия, а именно – создание (create), чтение (read), обновление (update), и удаление (delete).

Предварительная подготовка

Если Node у вас пока нет, самое время его установить . После установки создайте папку и выполните в ней команду инициализации нового проекта:

Npm init
В ходе инициализации ответьте на вопросы, в частности, дайте приложению имя «notable» (или, если хотите, любое другое).

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

В качестве фреймворка мы планируем использовать Express. Системой управления базами данных будет MongoDB. Кроме того, в качестве вспомогательного средства для работы с JSON, используем пакет body-parser. Установим всё это:

Npm install --save express mongodb body-parser
Ещё, я очень рекомендую установить Nodemon как dev-зависимость. Это простой маленький пакет, который, при изменении файлов, автоматически перезапускает сервер.

Для установки этого пакета выполните команду:

Npm install --save-dev nodemon
Затем можно добавить следующий скрипт в файл package.json :

// package.json "scripts": { "dev": "nodemon server.js" },
Готовый package.json будет выглядеть примерно так:

// package.json { "name": "notable", "version": "1.0.0", "description": "", "main": "server.js", "scripts": { "dev": "nodemon server.js" }, "author": "", "license": "ISC", "dependencies": { "body-parser": "^1.15.2", "express": "^4.14.0", "mongodb": "^2.2.16" }, "devDependencies": { "nodemon": "^1.11.0" } }
Теперь создадим файл server.js и приступим к работе над API.

Сервер

Начнём с подключения зависимостей в файле server.js .

// server.js const express = require("express"); const MongoClient = require("mongodb").MongoClient; const bodyParser = require("body-parser"); const app = express();
MongoClient будем использовать для взаимодействия с базой данных. Кроме того, здесь мы инициализируем константу app , символизирующую наше приложение, экземпляром фреймворка Express. Чтобы сервер заработал, осталось лишь указать приложению на то, чтобы оно начало прослушивать HTTP-запросы.

Тут укажем порт и запустим прослушивание следующим образом:

// server.js const port = 8000; app.listen(port, () =>
Теперь, если выполнить команду npm run dev (или – node server.js , если вы не устанавливали Nodemon), в терминале должно появиться сообщение: «We are live on port 8000».

Итак, сервер работает. Но сейчас он не делает совершенно ничего полезного. Давайте с этим разберёмся.

Маршруты, ориентированные на CRUD-операции

Мы планируем создать 4 маршрута. А именно:

CREATE – создание заметок.
READ –чтение заметок.
UPDATE –обновление заметок.
DELETE –удаление заметок.

Освоив эту схему, вы сможете понять, как, с помощью Node, организовать практически любой необходимый REST-маршрут.

Для того, чтобы протестировать API, понадобится нечто, способное имитировать запросы клиентской части приложения. Решить эту задачу нам поможет отличная программа, которая называется Postman . Она позволяет выполнять простые HTTP-запросы с заданным телом и параметрами.

Установите Postman. Теперь всё готово к настройке маршрутов.

О структуре проекта

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

Наше приложение большим не назовёшь, но предлагаю сделать всё как надо, учитывая, всё же, его скромные масштабы. Создайте следующие папки: папку app , а внутри неё – routes . В папке routes создайте файлы index.js и note_routes.js . Другими словами, структура проекта будет выглядеть так: root > app > routes > index.js и note_routes.js .

Mkdir app cd app mkdir routes cd routes touch index.js touch note_routes.js
Такая структура, для маленького приложения, может показаться избыточной, но она окажется очень кстати в более крупной системе, построенной на базе нашего примера. К тому же, любые проекты лучше всего начинать, используя лучшие из существующих наработок.

Создание заметок: маршрут CREATE

Начнём с маршрута CREATE. Для этого ответим на вопрос: «Как создать заметку?».
Прежде чем приступить к созданию заметок, нам понадобится расширить инфраструктуру приложения. В Express маршруты оборачивают в функцию, которая принимает экземпляр Express и базу данных как аргументы.

Выглядеть это может так:

// routes/note_routes.js module.exports = function(app, db) { };
Теперь можно экспортировать эту функцию через index.js :

// routes/index.js const noteRoutes = require("./note_routes"); module.exports = function(app, db) { noteRoutes(app, db); // Тут, позже, будут и другие обработчики маршрутов };
Импортируем то, что получилось, в server.js :

// server.js const express = require("express"); const MongoClient = require("mongodb").MongoClient; const bodyParser = require("body-parser"); const app = express(); const port = 8000; require("./app/routes")(app, {}); app.listen(port, () => { console.log("We are live on " + port); });
Обратите внимание на то, что так как базу данных мы пока не настроили, вторым аргументом передаётся пустой объект.

Теперь создаём маршрут CREATE. Синтаксис здесь довольно простой:

Module.exports = function(app, db) { app.post("/notes", (req, res) => { // Здесь будем создавать заметку. res.send("Hello") }); };
Когда приложение получает POST-запрос по пути ‘/notes’, оно исполнит код внутри функции обратного вызова, передав ей объект запроса (который содержит параметры запроса или JSON-данные) и объект ответа (который, понятно, используется для ответа).

То, что у нас получилось, уже можно протестировать. Отправим, с помощью Postman, POST-запрос по адресу localhost:8000/notes .

В ответ на запрос должно прийти «Hello»

Отлично. Первый маршрут создан. Следующий шаг – добавление к запросу параметров, обработка их в API, и, наконец – сохранение заметки в базе данных.

Параметры запроса

В Postman перейдите на вкладку Body и добавьте несколько пар ключ-значение, выбрав радиокнопку x-www-form-urlencoded . А именно, первым ключом будет title , его значение – My Note Title . Второй ключ – body , его значение – What a great note .

Это добавит к запросу закодированные данные, которые можно будет обработать в API.

Заголовок моей заметки, да и она сама – очень просты, а вы тут можете проявить фантазию

В файле note_route.js , просто выведем тело заметки в консоль.

// note_routes.js module.exports = function(app, db) { app.post("/notes", (req, res) => { console.log(req.body) res.send("Hello") }); };
Попробуйте отправить запрос с помощью Postman, и вы увидите… undefined .

К сожалению, Express не может самостоятельно обрабатывать формы в URL-кодировке. Тут нам на помощь придёт ранее установленный пакет body-parser.

// server.js const express = require("express"); const MongoClient = require("mongodb").MongoClient; const bodyParser = require("body-parser"); const app = express(); const port = 8000; app.use(bodyParser.urlencoded({ extended: true })); require("./app/routes")(app, {}); app.listen(port, () => { console.log("We are live on " + port); });
Теперь, после выполнения POST-запроса, его тело можно будет увидеть в терминале в виде объекта.

{ title: "My Note Title", body: "What a great note." }
Чтобы первый маршрут полностью заработал, осталось лишь настроить базу данных и добавить в неё заметку.

Для быстрого создания и настройки базы данных воспользуемся сервисом mLab . Работать с ним легко, для маленьких объёмов информации он бесплатен.

Создайте учётную запись на сайте mLab и разверните новую базу данных MongoDB. Для этого нажмите на кнопку Create New в разделе MongoDB Deployments , в появившемся окне, в разделе Plan , выберите Single-node . В списке Standard Line , выберите Sandbox и дайте базе данных имя. Далее, в окне управления базой, перейдите на вкладку Users и добавьте пользователя базы данных, задав имя и пароль.

Новый пользователь базы данных

Скопируйте с той же страницы второй URL – строку подключения к базе данных.

URL для подключения к базе данных

В корень проекта добавьте директорию config , создайте в ней файл db.js .

Mkdir config cd config touch db.js
В файл db.js добавьте следующее:

Module.exports = { url: здесь будет ваш URL };
Не забудьте добавить в URL имя пользователя и пароль (не те, что от учётной записи в mLab, а те, что создавали для базы данных). Если вы размещаете проект на Github, не забудьте включить в него файл .gitignore (вроде этого). Так вы не сделаете всеобщим достоянием имя и пароль для работы с базой.

Теперь, в server.js , можно использовать MongoClient для подключения к базе данных и обернуть в функцию, которая передаётся ему при создании, настройки приложения:

// server.js const express = require("express"); const MongoClient = require("mongodb").MongoClient; const bodyParser = require("body-parser"); const db = require("./config/db"); const app = express(); const port = 8000; app.use(bodyParser.urlencoded({ extended: true })); MongoClient.connect(db.url, (err, database) => { if (err) return console.log(err) require("./app/routes")(app, database); app.listen(port, () => { console.log("We are live on " + port); }); })
На этом подготовка инфраструктуры закончена. С этого момента будем заниматься исключительно путями.

Добавление записей в базу данных

MongoDB хранит данные в коллекциях (collections), которые полностью оправдывают своё название. В нашем случае заметки будут храниться в коллекции, которая, как несложно догадаться, будет называться notes .

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

Db.collection("notes")
Создание заметки в базе равносильно вызову команды insert для коллекции notes:

Const note = { text: req.body.body, title: req.body.title} db.collection("notes").insert(note, (err, results) => { }
После успешного завершения команды (или после того, как она, по какой-нибудь причине, не сможет выполниться), нужно либо отправить в ответ только что созданный объект заметки, либо – сообщение об ошибке. Вот код note_routes.js , дополненный с учётом этих рассуждений:

// note_routes.js module.exports = function(app, db) { app.post("/notes", (req, res) => { const note = { text: req.body.body, title: req.body.title }; db.collection("notes").insert(note, (err, result) =>
Испытайте то, что получилось. Отправьте из Postman POST-запрос (с флагом x-www-form-urlencoded ), задав на вкладке Body значения полей title и body .

Ответ должен выглядеть примерно так:

Успешное добавление записи в базу

Чтение заметок: маршрут READ

Инфраструктура, которую мы подготовили выше, подходит для всех маршрутов, поэтому теперь дело пойдёт быстрее.

Итак, мы собираемся запросить только что созданную заметку, пройдя по пути localhost:8000/notes/{id заметки} . В нашем случае путь будет выглядеть так: localhost:8000/notes/585182bd42ac5b07a9755ea3 .

Если ID одной из уже созданных заметок у вас нет, можете заглянуть в базу на mLab и найти его там, или создать новую заметку и скопировать её идентификатор.

Вот как это выглядит в note_route.js :

// note_routes.js module.exports = function(app, db) { app.get("/notes/:id", (req, res) => { }); app.post("/notes", (req, res) => { const note = { text: req.body.body, title: req.body.title }; db.collection("notes").insert(note, (err, result) => { if (err) { res.send({ "error": "An error has occurred" }); } else { res.send(result.ops); } }); }); };
Так же, как и раньше, мы собираемся вызвать некую команду для коллекции базы данных заметок. Применим для этого метод findOne .

// note_routes.js module.exports = function(app, db) { app.get("/notes/:id", (req, res) => { const details = { "_id": <ТУТ БУДЕТ ID> }; db.collection("notes").findOne(details, (err, item) => { if (err) { res.send({"error":"An error has occurred"}); } else { res.send(item); } }); }); app.post("/notes", (req, res) => { const note = { text: req.body.body, title: req.body.title }; db.collection("notes").insert(note, (err, result) => { if (err) { res.send({ "error": "An error has occurred" }); } else { res.send(result.ops); } }); }); };
Идентификатор из параметров URL можно вытащить с помощью конструкции req.params.id . Однако если просто вставить строку вместо <<>> из кода выше, работать это не будет.

MongoDB требуется ID не в виде строки, а в виде специального объекта. Он называется ObjectID .

Вот что, после небольших изменений, у нас получилось:

// note_routes.js var ObjectID = require("mongodb").ObjectID; module.exports = function(app, db) { app.get("/notes/:id", (req, res) => { const id = req.params.id; const details = { "_id": new ObjectID(id) }; db.collection("notes").findOne(details, (err, item) => { if (err) { res.send({"error":"An error has occurred"}); } else { res.send(item); } }); }); app.post("/notes", (req, res) => { const note = { text: req.body.body, title: req.body.title }; db.collection("notes").insert(note, (err, result) => { if (err) { res.send({ "error": "An error has occurred" }); } else { res.send(result.ops); } }); }); };
Испытайте это с одним из идентификаторов заметок, имеющихся в базе данных. Ответ в Postman должен выглядеть так:

Успешный запрос заметки из базы

Удаление заметок: маршрут DELETE

Удаление объектов – это практически то же самое, что их поиск в базе. Только вместо функции findOne используется функция remove . Вот полный код соответствующего пути. Здесь выделено то, что отличается от кода уже существующего метода, обрабатывающего запрос GET.

// note_routes.js // ... app.delete("/notes/:id", (req, res) => { const id = req.params.id; const details = { "_id": new ObjectID(id) }; db.collection("notes").remove(details, (err, item) => { if (err) { res.send({"error":"An error has occurred"}); } else { res.send("Note " + id + " deleted!"); } }); }); // ...

Обновление заметок: маршрут UPDATE

А вот и последний маршрут. Обработка запроса PUT – это, по сути, гибрид операций READ и CREATE. Сначала надо найти объект, потом – обновить его в соответствии с поступившими в запросе данными. Сейчас, если вы, испытывая предыдущий фрагмент кода, удалили свою единственную заметку, создайте ещё одну.

Вот код маршрута обновления заметок:

// note_routes.js // ... app.put ("/notes/:id", (req, res) => { const id = req.params.id; const details = { "_id": new ObjectID(id) }; const note = { text: req.body.body, title: req.body.title }; db.collection("notes").update(details, note, (err, result) => { if (err) { res.send({"error":"An error has occurred"}); } else { res.send(note); } }); }); // ...
Теперь любую заметку можно редактировать. Вот, как это выглядит:

Успешное обновление заметки

Обратите внимание на недостаток нашего примера. Если в PUT-запросе не будет тела или заголовка заметки, соответствующие поля в базе будут просто очищены.

Я не нагружал пример дополнительными проверками. Если хотите, можете сами доработать операцию обновления заметок, внося в базу новые данные только в том случае, если запрос сформирован верно.

Итоги

Теперь у вас есть рабочее Node API, которое поддерживает четыре основные операции CRUD. Серверная часть приложения умеет, реагируя на HTTP-запросы клиента, создавать в базе данных заметки, находить их, удалять и редактировать.

Основная цель моего рассказа – познакомить всех желающих со связкой Node + Express + MongoDB и с методикой разработки серверных приложений. Конечно, если сегодня состоялось ваше первое знакомство с этими инструментами, для того, чтобы во всё лучше вникнуть, вам понадобится почитать документацию. Однако, понимание происходящего позволит вам быстро восполнить пробелы в знаниях и приступить к работе над собственными проектами, использовав, в качестве отправной точки, приложение, которым мы с вами тут занимались.

Если у вас есть опыт работы с Node.js, Express и MongoDB в реальных проектах, может быть, вы посоветуете что-нибудь полезное новичкам? А если вы только что всё это впервые попробовали – ждём ваших впечатлений.

Express представляет собой популярный веб-фреймворк, написанный на JavaScript и работающий внутри среды исполнения node.js. Этот модуль освещает некоторые ключевые преимущества этого фреймворка, установку среды разработки и выполнение основных задач веб-разработки и развертывания.

Предварительные требования

Перед началом этого модуля вам необходимо представлять, что из себя представляет серверное программирование и веб-фреймворки, желательно из прочтения статей другого модуля Server-side website programming first steps . Знакомство с основными концепциями программирования и языком программирования JavaScript будет очень полезным, но оно не является обязательным для понимания базовых понятий этого модуля.

Заметка : Этот веб-сайт содержит множество источников для изучения JavaScript в контексте разработки на стороне клиента : JavaScript , JavaScript Guide , JavaScript Basics , JavaScript (изучение). Ключевые особенности и коцепции языка JavaScript остаются сходными и для серверной разработки на Node.js и используемый материал достаточно релевантен. Node.js предоставляет additional APIs для обеспечения функционала, который полезен для "безбраузерной" разработки, т.е. для создания HTTP-сервера и доступа к файловой системе, но не поддерживает JavaScript APIs для работы с браузером и DOM.

Это руководство обеспечит вас некоторой информацией о работе с Node.js и Express, но также существуют и другие многочисленные отличные ресурсы в Интернете и книгах - некоторые из них доступны из тем How do I get started with Node.js (StackOverflow) и (Quora).

Руководства

Введение в Express/Node В первой статье об Express мы ответим на вопросы "Что такое Node?" и "Что такое Express?" и дадим вам представление о том, что делает веб-фреймворк Express особенным. Мы расскажем об основных функциях и покажем вам некоторые из основных строительных блоков приложений Express (хотя на данный момент у вас еще нет среды разработки, в которой можно ее протестировать) . Настройка среды разработки Node (Express)

Теперь, когда вы знаете, что такое Express, мы покажем вам, как настроить и протестировать среду разработки Node/Express в Windows, Linux (Ubuntu) и Mac OS X. Независимо от того, какую популярную операционную систему вы используете, эта статья даст вам то, что вам нужно, чтобы начать разработку приложений Express.

Учебник Express: сайт LocalLibrary

Первая статья в нашей серии практических уроков объясняет, что вы будете изучать, и предоставит обзор веб-сайта «локальной библиотеки», над которым мы будем работать и развивать в последующих статьях.

Учебник Express часть 2: Создание скелета веб-сайта

В этой статье показано, как вы можете создать «скелет» веб-сайта, который затем можно будет заполнить с помощью маршрутов сайта, шаблонов/представлений и баз данных.

Учебник Express часть 3: Использование базы данных (с помощью Mongoose) В этой статье кратко представлены базы данных для Node/Express. Затем показывается, как мы можем использовать Mongoose для обеспечения доступа к баз данных для сайта LocalLibrary . В уроке объясняется, как объявляются объектная схема и модели, основные типы полей и базовая валидация. Также кратко показаны некоторые из основных способов доступа к данным модели. Учебник Express часть 4: Маршруты и контроллеры В этом уроке мы создадим маршруты (код обработки URL) с "фиктивным" обработчиком функций для всех конечных точек ресурсов, которые нам в конечном итоге понадобятся для сайта LocalLibrary . По завершении мы будем иметь модульную структуру нашего кода обработки маршрута, который мы можем расширить с помощью функций реального обработчика в следующих статьях. Мы также будем очень хорошо понимать, как создавать модульные маршруты, используя Express. Учебник Express часть 5: Отображение данных библиотеки Теперь мы готовы добавить страницы, на которых будут отображаться книги веб-сайта LocalLibrary и другие данные. Страницы будут включать главную страницу, которая показывает сколько записей определенного типа мы имеем и отдельную страницу для детального просмотра записи. По пути мы получим практический опыт в получении записей из баз данных и использовании шаблонов. Учебник Express часть 6: Работы с формами В этой части мы покажем вам, как работать с HTML формами в Express, используя Pug, и в частности, как создавать, обновлять и удалять документы из базы данных. Учебник Express часть 7: Выкладка в production Теперь когда вы создали восхитительный сайт LocalLibrary , вы захотите установить его на общедоступном сервере, чтобы он мог дать доступ персоналу библиотеки и пользователям в Интернет. В этой статье представлен обзор того, как вы можете найти хост для развертывания вашего сайта и что вам нужно сделать, чтобы подготовить ваш сайт к публикации. Установка LocalLibrary на PWS/Cloud Foundry В этой статье представлена практическая демонстрация того, как установить LocalLibrary на облаке Pivotal Web Services PaaS - это полнофункциональная альтернатива с открытым исходным кодом для Heroku, облачного сервиса PaaS используемого в части 7 этого учебника, представленного выше. PWS/Cloud Foundry опредленно стоит попробовать, если вы ищете альтернативу Heroku (или другому PaaS облачному сервису), или просто хотите попробовать что-то другое.

Как видно из заголовка, речь в нашей статье пойдет о выборе одного из трех фреймворков для Node.js: Express , Koa и Sails .

В конце статьи мы поделимся с вами выбором компании и объясним, почему выбранному нами фреймворку стоит уделить особое внимание.

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

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

А сейчас давайте перенесемся в 2009г. , когда двухлетние эксперименты Райана Даля по созданию серверных веб-компонентов увенчались успехом и появилась принципиально новая технология.

Node.js – событийно-ориентированная платформа, применяемая для создания веб-приложений, которая обеспечивает возможность использовать JavaScript на стороне сервера.

Так как до появления Node.js язык JavaScript использовался только на стороне клиента, появление такой платформы было встречено разработчиками с энтузиазмом. По сути, это открывало новые возможности для создания приложений с высокой производительностью и масштабируемостью.

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

Чтобы убедиться в этом, достаточно отследить периодичность выхода обновлений и объем вносимых изменений .

Сообщество Node.js растет и развивается. Регулярно генерируются новые идеи, а в результате появляются новые инструменты и библиотеки.

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

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

MVC (англ. Model-View-Controller) – шаблон проектирования, включающий в себя три компонента: Модель, Представление и Контроллер. Изменение всех трех компонентов может производиться независимо друг от друга. При этом модель предоставляет данные и правила управляющей логики, представление отвечает за отображение данных на пользовательском интерфейсе, а контроллер обеспечивает взаимодействие между моделью и представлением.

Для сравнения в рамках этой статьи м ы выбрали:

Express, как самый гибкий, простой и быстрый фреймворк
Koa , как версию Express нового поколения, созданную той же командой разработчиков
Sails , как созданный для быстрой разработки приложений на принципах Ruby on Rails и Express .

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

Но при этом все три варианта обладают определенными характеристиками и особенностями, обеспечивающими преимущество в той или иной конкретной ситу ации.

EXPRESS.JS

Начнем описание с самого простого фреймворка, используемого на платформе Node.js.

Express используется для разработки приложений достаточно давно и благодаря своей стабильности прочно занимает позицию одного из самых

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

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

Основная особенность этого фреймворка заключается в том, что для Express характерен небольшой объем базового функционала . Все остальные нужные вам функции нужно будет добирать за счет внешних модулей. По сути, Express в чистом виде – это сервер и у него может не быть ни одного модуля.

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

При этом немаловажно, что выбор модулей для Express не связан ни с какими ограничениями: ни с количественными, ни с функциональными.

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

С одной стороны, не может не радовать тот факт, что отсутствие готовых универсальных решений фактически означает, что каждое создаваемое приложение будет уникальным.

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

ПЛЮСЫ:

✓ простота

✓ гибкость

✓ хорошая масштабируемость

✓ развитое сообщество

✓ подробная документация

✓ широкий выбор подключаемых модулей

МИНУСЫ:

✗ большой объем ручной работы

✗ используется устаревший подход callbacks функций

KOA.JS

Koa был создан командой разработчиков, как вариант фреймворка Express в новом поколении . Такая улучшенная версия разрабатывалась для создания веб-приложений и API с повышенной производительностью. Соответственно, создатели стремились учесть все недостатки предшественника и сделать его более современным и удобным в использовании.

Посмотрим, насколько это удалось.

Koa обладает практически таким же функционалом и превосходит Express по легкости.

Характерной особенностью Koa является использование генераторов ES6.

Генераторы – тип функций, которые могут быть запущены, остановлены и возобновлены независимо от того, на каком этапе выполнения они находятся, и при этом сохраняют свой контент.

Применение генераторов ES6 в Koa позволяет исключить обратные вызовы (англ. callbacks ), уменьшает для разработчиков объем работы с кодом и снижает вероятность ошибок .

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

Если говорить о недостатках, они, в основном, связаны с относительной молодостью Koa (появился в 2013 г. ). Фреймворк не пользуется поддержкой такого обширного сообщества, как Express , и еще не успел продемонстрировать все свои возможности.

ПЛЮСЫ:

✓ легкий

✓ гибкий

✓ быстрый

✓ генераторы ES6

✓ лучшая кастомизация

МИНУСЫ:

✗ недостаточная поддержка сообщества

SAILS.JS

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

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

С одной стороны, от разработчика требуется минимальное количество усилий, так как для создания приложения используется собственный функционал фреймворка. Нет необходимости вникать в тонкости процесса – можно просто взять готовое проверенное решение.

С другой стороны, разработка приложения будет ограничена рамками имеющихся в наличии средств фреймворка, так как внешних модулей для Sails гораздо меньше, чем для Express или Koa .

Отличительной особенностью фреймворка является встроенная технология программирования Waterline ORM (англ. Object-Relational Mapping) , которая используется для обеспечения связи с различными базами данных.

Наличие такого компонента можно было бы отнести к преимуществам, но в процессе работы вы можете столкнуться с определенными ограничениями. Например, Waterline не поддерживает транзакции, новые фичи и исправления ошибок вносятся несвоевременно.

В целом, более медленное развитие до недавнего времени было характерно для всего сообщества Sails , особенно по сравнению с другими, поддерживающими описанные выше Express и Koa . Но следует отметить, что на данный момент сообщество Sails все же начало набирать обороты и развиваться более активно.

ПЛЮСЫ:

✓ богатый функционал

✓ поддержка Socket.io

✓ документация в одном месте

✓ легче найти специалиста с опытом работы на Sails

МИНУСЫ:

✗ тяжелый

✗ медленный

✗ ограничения Waterline

✗ недостаточно подробная документация

Мы описали основные свойства, характерные для трех фреймворков, которых вполне достаточно для составления о них объективного впечатления.

Если у вас остались вопросы, свяжитесь с нами прямо сейчас!

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

Попробуем сделать общий вывод из того, что мы уже знаем о трех рассматриваемых фреймворках. Определим для каких проектов, в целом, лучше подходит каждый из них:

Express.js подходит для:

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

Sails.js подходит для:

быстрого старта проекта;
быстрых стартапов, которые не предполагают расширения в будущем;
приложений реального времени, где требуется моментальная реакция;
начинающих Node.js программистов;
приложений, не требующих долгосрочной поддержки.

Справедливости ради отметим, что приложения реального времени можно создавать и при помощи Express. Однако при разработке такого приложения с использованием Sails на создание и настройку уйдет гораздо меньше времени и сил.

Koa.js подходит для:

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

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

Мы выбираем Koа, потому что:

Как и Express, Koa не ограничивает разработчика в использовании встроенных модулей, а дает возможность выбрать из множества именно тот, который подходит лучше всего для конкретного проекта;
Koa вобрал в себя достоинства проверенного и широко-используемого фреймворка Express;
у создателей Koa была возможность проанализировать сложности, с которыми столкнулись разработчики, использовавшие Express;
при создании Koa были учтены недостатки его предшественника;
Koa основан на новых стандартах и соответствует современным тенденциям;
Koa подходит для разработки самых разнообразных приложений любого объема, с любой степенью кастомизации и с любыми требованиями к поддержке;

… и самый главный аргумент – это собственный положительный опыт специалистов , приобретенный во время работы с этим фреймворком.

В любом случае, подойдите к решению с рациональной точки зрения и отдайте предпочтение тому фреймворку, который оснащен в соответствии с вашими конкретными требованиями.

Мы всегда готовы поддержать ваш выбор и помочь вам реализовать любой проект. Не откладывайте на завтра и прямо сейчас!