Express js быстрый сервер. Основы Node JS & Express (III)

$ 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 & Express (III).

Разбираемся, что такое npm и для чего он нужен. Устанавливаем Express и шаблонизатор EJS. Делаем полную подготовительную работу и начинаем создавать свой собственный сайт на NodeJS.

Теперь с параметрами, которые постоянно будут меняться.

Если нам нужно создать ссылку на некое значение, после /mews/значение . Оно будет меняться. Например: 23, part или любое др значение.

App.get("/news/:id", function(req, res){ res.send("ID is - " + req.params.id); });

В зависимости от этого параметра мы можем брать данные из БД (базы данных) и выводить конкретную статью.

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

Нам нужен некий шаблонизатор .

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

Поскольку EJS является дополнительным пакетом, то нам нужно его установить.

Нажать Enter

После этого он установится в наш проект.

Он позволяет передавать данные в различные шаблоны, причем эти шаблоны будут иметь расширение.ejs .

В этих шаблонах мы сможем выводить наш html код вместе с вставленным в него js кодом (переменными, выводить циклы и многое другое).

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

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

View engine - по сути шаблонизатор.

Поскольку их существует огромное количество, а мы выбрали именно EJS, то мы должны его указать в нашем index.js файле.

Сразу после инициализации переменной app .

App.set("view-engine", "ejs");

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

На том же уровне, где index.js создадим папку views .

В ней создадим новый файл news.ejs . Это будет некий шаблон, который мы будем наполнять.

В эти шаблоны мы можем помещать самый обычный html-код.

Новости

Новостная страница.

Для этого мне не нужно использовать метод.send или.sendFile , а мне потребуется метод render() .

Метод render() берет нужный файл (шаблон) в папке views и может отобразить его в браузере. Плюс в этот шаблон он может передать некие параметры.

Расширение в методе render() можно не указывать. Далее можно передать некие параметры в сам шаблон. Поэтому мы передаем вторым параметром - объект. В нем может быть большое количество свойств и значений.

Допустим, что мы решили передать некий параметр newsId со значением req.params.id - то есть значение будет как раз сам вызываемый id .

App.get("/news/:id", function(req, res){ render("news", {newsId: req.params.id}); });

Таким образом в шаблон news будет передано значение, которое будет называться newsId со значением id .

В файл news.ejs мы можем все это принять и отобразить.

Немного изменим наш файл news.ejs . В заголовок страницы будем выводить ID.

Все можно посмотреть в документации к шаблонизатору EJS (ссылка выше).

Новостная страница c ID = <%= newsId %>

Файл /views/news.ejs

Новости

Новостная страница c ID = <%= newsId %>

Lorem ipsum dolor sit amet, consectetur adipisicing elit. Eaque numquam libero, veniam ipsum similique odit molestiae esse quia blanditiis magni debitis aliquam, pariatur nam quaerat quas nemo, facilis temporibus laboriosam.Lorem ipsum dolor sit amet, consectetur adipisicing elit. Maiores enim vitae dolore nemo quas aliquam quia corrupti rerum ipsam ad nesciunt, architecto, pariatur officiis. Maxime iste ullam quibusdam, nobis voluptas!

Файл index.js

Let express = require("express"); let app = express(); app.set("view engine", "ejs"); app.get("/", function(req, res){ res.sendFile(__dirname + "/index.html"); }); app.get("/about", function(req, res){ res.sendFile(__dirname + "/about.html"); }); app.get("/news/:id", function(req, res){ res.render("news", {newsId: req.params.id}); }); app.listen(8080);

Мы можем передавать несколько параметров. Например:

App.get("/news/:id", function(req, res){ res.render("news", {newsId: req.params.id, newParam: 535 }); });

А в файле news.ejs выведем его на страницу, например так:

<%= newParam %>

Помимо этого мы можем передавать и собственные объекты. Например, создадим объект:

App.get("/news/:id", function(req, res){ let obj = { title:"Новость", id: 4}; res.render("news", {newsId: req.params.id, newParam: 535}); });

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

Например:

App.get("/news/:id", function(req, res){ let obj = { title:"Новость", id: 4}; res.render("news", {newsId: req.params.id, newParam: 535, obj: obj }); });

Title = <%= obj.title %>

ID = <%= obj.id %>

<%= newParam %>

Передача в шаблон массива.

Создадим массив данных и выведем его с помощью цикла.

App.get("/news/:id", function(req, res){ let obj = { title:"Новость", id: 4, paragraphs:["Параграф", "Обычный текст", "Числа: 3, 7, 24", 476] }; res.render("news", {newsId: req.params.id, newParam: 535, obj: obj}); });

Теперь в самом шаблоне мы просто выведем этот массив циклом:

<% obj.paragraphs.forEach(function(item) { %>

<%= item %>

Статические файлы и промежуточное ПО.

Файлы, которые можно включить в другие файлы.

Сейчас у нас есть один шаблон - news.ejs , а представьте. что их много. Десятки. И вам потребуется внести изменения в какую-то часть кода, который встречается во всех этих файлах. Придется вносить множество изменений.

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

В папке шаблонов views создадим папку blocks , а в ней файл hrader.ejs .

Файл hrader.ejs

На главную
Про нас
Новости

Теперь нам нужно этот файл подключить во всех шаблонах. Идем в файл news и сразу после открывающего тега body записываем:

<% include blocks/header.ejs %>

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

Статические файлы.

Создадим новую папку на уровне index.js с названием public . В ней будут находиться все статические файлы. Это css-файлы, картинки, документы и пр. Все те файлы. которые будут вызываться с различных страниц нашего сайта.

В этой папке создадим еще одну папку - css и уже в ней создадим файл style.css .

В него перенесем весь код стилей из файла index.ejs

В файлах.ejs подключаем стили:

Если теперь проверить, то ничего не произойдет. Стили не подключатся.

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

В файле index.js вверху, сразу за app.set , мы должны написать:

App.use("/public",);

И теперь, если мы где то будем использовать ссылку начинающуюся с /public сам NodeJS и Express будет понимать, что мы используем статические файлы и будет подключать все верно.

Вторым - где мы их ищем express.static("public") т. есть в папке /public .

Если обобщить, то в коде app.use("/public", express.static("public")); мы отслеживаем ту ссылку, которую прописываем в

Если бы у на было бы вот так:

То и в этом коде было бы:

App.use("/assets", express.static("public"));

В данном случае public указывает на папку!

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

App.use("/assets ", express.static("public "));

Для того, чтобы не путаться, обычно, делают ссылку и папку одного имени. Чаще всего это именно public .

Промежуточное ПО - это то, что мы делаем до того пока отправим какие-то данные на страницу (сервер).

В данном случае это и есть наше промежуточное ПО.

Создание HTML-формы и получение данных

Первое, что мы сделаем это добавим саму форму на наш сайт.

Открываем файл about.ejs и сюда мы будем добавлять форму используя технологию bootstrap.

В окно поиска вводим Forms и на найденной странице копируем первую форму сверху.

Сохраним и запустим.

POST -запрос.

Так так мы будем выполнять POST -запрос, то нам необходимо добавить в форму несколько атрибутов.

Method="post" - т.к POST -запрос

И action="" - это то куда нужно перенаправить пользователя после того,как он нажмет "Отправить". В нашем случае это:

Все остальное нам нужно сделать в файле index.js

Первым делом нам необходимо скачать пакет, который называется body-parser .

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

Для установки, в папке проекта в КС пишем.

npm install body-parser

Нажимаем - Enter .

Пакет устанавливается.

После установки стоит следовать простой инструкции.

Перейдем на сайте в раздел Examples и найдем там раздел Express route-specific

Подключаем нужные для нас модули.

Var bodyParser = require("body-parser")

Var urlencodedParser = bodyParser.urlencoded({ extended: false })

То есть тот парсер, который позволит нам брать данные из POST -запроса и работать с ними как нам будет нужно.

Далее, на основе документации, мы видим, что нам нужно отслеживать именно POST -запрос и передавать в него некое промежуточное ПО (urlencodedParser). Ранее мы уже отслеживали GET- запросы.

Данные полученные из формы мы выведем в консоль.

Console.log(req.body);

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

If (!req.body) return res.sendStatus(400)

В самой форму нужно указать для полей атрибут name . Это будут названия свойств, а значение - это то, что введет пользователь.

О нас. <% include blocks/header.ejs %>

Заголовок второго уровня.

На главную

третьего уровня заглавие.

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

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

Email address We"ll never share your email with anyone else.

Password

Check me out

Let express = require("express"); var bodyParser = require("body-parser"); let app = express(); var urlencodedParser = bodyParser.urlencoded({ extended: false }); app.set("view engine", "ejs"); app.use("/public", express.static("public")); app.get("/", function(req, res){ res.render("index"); }); app.get("/about", function(req, res){ res.render("about"); }); app.post("/about", urlencodedParser, function(req, res){ if (!req.body) return res.sendStatus(400); console.log(req.body); res.render("about"); }); app.get("/news", function(req, res) { res.render("news-common",{newParam1:"Param-1"}); }); app.get("/news/:id", function(req, res){ let obj = { title:"Новость", id: 4, paragraphs:["Параграф", "Обычный текст", "Числа: 3, 7, 24", 476]}; res.render("news", {newsId: req.params.id, newParam: 535, obj: obj}); }); app.listen(8080);

Введем данные и нажмем отправить. В консоли мы увидим вывод этих данных (свойство - значение).

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

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

Изменим немного код в файле index.js

App.post("/about", urlencodedParser, function(req, res){ if (!req.body) return res.sendStatus(400); console.log(req.body); res.render("about-success", {data: req.body} ); });

Таким образом мы будем выводить страницу about-success.ejs и мы ее сейчас создадим в папке views . Вторым параметром мы передадим данные формы в виде объекта. - {data: req.body}

О нас. <% include blocks/header.ejs %>

Hello, It is my first page on Node.js

Заголовок второго уровня.

На главную

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

Спасибо

Email: <%= data.email %>
Pass: <%= data.pass %>
isCheck: <%= data.check %>

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

Кроме этого было бы удобно отправлять эти данные на почту или сохранять в БД (базу данных).

Если вы хотите отправить их на почту. то в npm есть еще один пакет - Nodemailer . Этот пакет позволяет отправлять данные непосредственно на почту. Использовать его просто. И с помощью него вы можете получать по почте все данные формы, заполненной пользователем.

NodeJS предоставляет нам множество дополнительных пакетов. Например Express мы использовали для того, чтобы проще отслеживать ссылки и использовать шаблонизаторы. Body-parseer для того, чтобы принимать данные полученные из формы. Nodemailer - для отправки данных на почту.

Как получать данные из URL-строки.

Иногда нужно получить такой тип данных из адресной строки:

http://localhost:8080/news/12?filter-id&city=london

Разберем, как получить эти данные на примере вот этого кода из файла index.js:

App.get("/news/:id", function(req, res){ let obj = { title:"Новость", id: 4, paragraphs:["Параграф", "Обычный текст", "Числа: 3, 7, 24", 476]}; res.render("news", {newsId: req.params.id, newParam: 535, obj: obj}); });

Просто выведем эти данные в консоль:

App.get("/news/:id", function(req, res){ let obj = { title:"Новость", id: 4, paragraphs:["Параграф", "Обычный текст", "Числа: 3, 7, 24", 476]}; console.log(req.query); res.render("news", {newsId: req.params.id, newParam: 535, obj: obj}); });

В консоли мы увидим

{ filter: "id", city: "london" }

Это может быть иногда полезно.

Как видно из заголовка, речь в нашей статье пойдет о выборе одного из трех фреймворков для 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 подходит для разработки самых разнообразных приложений любого объема, с любой степенью кастомизации и с любыми требованиями к поддержке;

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

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

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

Эта статья предназначена для начинающих разработчиков и всех, кто заинтересован в работе с Node js Express . Для освоения вы должны знать основы JavaScript :

Что такое Node.js?

Node.js — это асинхронная среда выполнения JavaScript , основанная на движке JavaScript V8 от Chrome . Она предназначена для создания масштабируемых сетевых приложений.

Node.js позволяет писать JavaScript-код на стороне сервера. Теперь вы можете задуматься, каким образом? JavaScript — это язык, который работает в браузере. Браузер принимает код JavaScript и компилирует его в команды. Создатель Node.js взял движок Chrome и построил среду выполнения (runtime ), чтобы он работал на сервере. Это среда, в которой язык может интерпретироваться. Итак, что у нас есть сейчас? Способ записи JavaScript в бэкэнде.

Что касается определения, вам может быть интересно, что означает термин «асинхронный » в данном контексте. JavaScript однопоточный язык. Поэтому вы не хотите, чтобы события прерывали основной поток выполнения. Это означает обработку событий без прерывания основного потока.

Node.js основан на этом неблокирующем исполнении, что делает его одним из самых быстрых инструментов для создания веб-приложений. В следующем примере «Hello World » многие соединения могут обрабатываться одновременно. При каждом соединении запускается обратный вызов.

В этом Node js Express примере есть шесть простых шагов.

Установите Node.js для своей платформы (MacOS, Windows или Linux )

Node.js

Node.js® — это среда выполнения JavaScript , встроенная в механизм JavaScript V8 для Chrome . Node.js использует управляемые события, неблокирующий ввод-вывод…

Первый шаг состоит в том, чтобы получить экземпляр JavaScript на вашем локальном компьютере. Вбейте nodejs.org в адресной строке браузера или кликните по ссылке , и готово. Стартовое окно должно сразу дать вам то, что вы хотите. Когда я запускаю на своем компьютере Ubuntu , отображается соответствующая версия Node.js для моей операционной системы. Загрузите и установите его. Это предоставим вам инструменты, необходимые для запуска сервера на локальном компьютере:

Откройте командную строку и введите

mkdir myapp cd myapp

Эти команды Node js Express Post универсальны для любой операционной системы. Первая создаст новый каталог внутри каталога, в котором вы сейчас находитесь, mkdir = «make directory» . Последний изменится на этот вновь созданный каталог, cd = «change directory» .

Запустите свой проект и привяжите его к npm

После создания каталога с именем myapp нужно будет запустить проект и связать его с npm .

Npm является сокращением от node package manager (диспетчер пакетов Node ). Это то место, где находятся все пакеты Node . Их можно рассматривать как пакеты кода, модули, которые выполняют определенную функцию. Мы используем интерфейс прикладных программ, API , предоставляемый этими модулями.

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

Она создает файл package.json в папке myapp . Файл содержит ссылки на все пакеты npm, которые загружены в проект.

Команда предложит вам ввести несколько вариантов действий. Можно ввести свой путь через все из них за исключением этого:

entry point: (index.js)

Вы захотите изменить это на:

Установите Express в каталог myapp

Express — это минимальная и гибкая инфраструктура веб-приложений Node.js , которая обеспечивает надежный набор функций для интернета.

Находясь в каталоге myapp , запустите:

npm install express --save

Команда установки продолжит поиск пакета Node js Express files , который необходимо установить. Установите его в свой проект.

Теперь папка node_modules создается в корне вашего проекта. Добавление -save позволяет сохранять пакет в список зависимостей, расположенный в package.json , в каталоге myapp .

Express предоставляет набор инструментов для создания и запуска веб-приложения. Express стал настолько популярен, что теперь он является стандартом в подавляющем большинстве приложений Node.js . Я настоятельно рекомендую использовать Express .

Запустите текстовый редактор и создайте файл с именем app.js

После установки Express Node добавьте в созданный файл, приведенный ниже код:

var express = require("express"); var app = express(); app.get("/", function (req, res) { res.send("Hello World!"); }); app.listen(3000, function () { console.log("Example app listening on port 3000!"); });

Здесь нужно будет использовать пакет, который был недавно установлен. Первая строка объявляет переменную, которая будет содержать модуль express, находящийся в папке node_modules .

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

Метод прослушивания запускает сервер и прослушивает порт 3000 для соединений. Он отвечает «Hello World! » для запросов GET к корневому URL (/) . Для любого другого пути он ответит 404 Not Found .

Запустите приложение

Введите команду:

После выполнения команды введите в браузере http: // localhost: 3000 / , чтобы увидеть результат. Вы также должны увидеть «Example app listening on port 3000 ».

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

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, то всего-лишь редактируйте это представление.