от RisingStack . Переведено с разрешения правообладателей.

В этой главе я расскажу вам о том, как вы можете запустить простой HTTP-сервер на Node.js и начать обрабатывать запросы.

Модуль http для вашего Node.js-сервера

Когда вы начинаете создавать HTTP-приложения в Node.js, встроенные модули http/https - это то, с чем вы будете взаимодействовать.

Давайте создадим ваш первый HTTP-сервер на Node.js! Нам будет нужно подключить модуль http и привязать наш сервер к порту 3000 .

// содежимое index.js
const http = require("http")
const port = 3000 const requestHandler = (request, response) => {
console.log(request.url)
response.end("Hello Node.js Server!")
} const server = http.createServer(requestHandler) server.listen(port, (err) => {
if (err) {

})

Затем запускаем этот скрипт:

$ node index.js

Что нужно здесь отметить:

• requestHandler: эта функция будет вызываться каждый раз, когда на сервер придёт запрос. Если вы откроете в своём браузере адрес localhost:3000 , два сообщения появятся в консоли: одно для / и одно для favicon.ico .
• if (err) : обработка ошибок: если порт уже занят или есть какие-то другие причины, по которым сервер не может быть запущен, мы получим уведомление об этом.

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

• express
• hapi
• koa
• restify

В этой и следующих главах мы будем использовать Express, так как именно для него вы можете найти множество модулей в NPM.

Express

Быстрый, гибкий, минималистичный веб-фреймворк для Node.js -  http://expressjs.com/

Добавление Express в ваш проект - это просто установка через NPM:

$ npm install express --save

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

const app = express()
const port = 3000 app.get(‘/’, (request, response) => {
response.send("Hello from Express!")
}) app.listen(port, (err) => {
if (err) {
return console.log("something bad happened", err)
} console.log(`server is listening on ${port}`)
})

Самое большое различие, которое вы можете здесь заметить, заключается в том, что Express по умолчанию даёт вам роутер. Вам не нужно вручную разбирать URL, чтобы решить, что делать, вместо этого вы определяете маршрутизацию приложения с помощью app.get , app.post , app.put и так далее, а они уже транслируются в соответствующие HTTP-запросы.

Одна из самых мощных концепций, которую реализует Express - это паттерн Middleware.

Middleware - промежуточный обработчик

Вы можете думать о промежуточных обработчиках как о конвейерах Unix, но для HTTP-запросов.

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

На практике вы можете сделать это следующим образом:

Const express = require("express")
const app = express() app.use((request, response, next) => {
console.log(request.headers)
next()
}) app.use((request, response, next) => {
request.chance = Math.random()
next()
}) app.get("/", (request, response) => {
response.json({
chance: request.chance
})
}) app.listen(3000)

Что следует здесь отметить:

• app.use: это то, как вы можете описать middleware. Этот метод принимает функцию с тремя параметрами, первый из которых является запросом, второй - ответом, а третий - коллбеком next . Вызов next сигнализирует Express о том, что он может переходить к следующему промежуточному обработчику.
• Первый промежуточный обработчик только логирует заголовки и мгновенно вызывает следующий.
• Второй добавляет дополнительное свойство к запросу - это одна из самых мощных функций шаблона middleware. Ваши промежуточные обработчики могут добавлять дополнительные данные к объекту запроса, который могут считывать/изменять middleware, расположенные ниже.

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

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

Const express = require(‘express’)
const app = express() app.get(‘/’, (request, response) => {
throw new Error(‘oops’)
}) app.use((err, request, response, next) => {
// логирование ошибки, пока просто console.log
console.log(err)
response.status(500).send(‘Something broke!’)
}) app.listen(3000)

Что следует здесь отметить:

• Обработчик ошибок должен быть последней функцией, добавленной с помощью app.use .
• Обработчик ошибок принимает коллбек next . Он может использоваться для объединения нескольких обработчиков ошибок.

Рендеринг HTML

Ранее мы рассмотрели, как отправлять JSON-ответы. Пришло время узнать, как отрендерить HTML простым способом. Для этого мы собираемся использовать пакет handlebars с обёрткой express-handlebars .

Сначала создадим следующую структуру каталогов:

├── index.js
└── views
├── home.hbs
└── layouts
└── main.hbs

После этого заполните index.js следующим кодом:

// index.js
const path = require("path")
const express = require("express")
const exphbs = require("express-handlebars")
const app = express() app.engine(".hbs", exphbs({
defaultLayout: "main",
extname: ".hbs",
layoutsDir: path.join(__dirname, "views/layouts")
}))
app.set("view engine", ".hbs")
app.set("views", path.join(__dirname, "views"))
app.listen(3000)

Приведенный выше код инициализирует движок handlebars и устанавливает каталог шаблонов в views/layouts . Это каталог, в котором будут храниться ваши шаблоны.

После того, как вы сделали эту настройку, вы можете поместить свой начальный html в main.hbs . Чтобы всё было проще, давайте сразу перейдём к этому:

{{{body}}}

Вы можете заметить метку {{{body}}}  - здесь будет размещен ваш контент. Давайте создадим home.hbs !

Hello {{name}}

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

App.get("/", (request, response) => {
response.render("home", {
name: "John"
})
})

Метод render принимает два параметра:

• Первый - это имя шаблона.
• Второй - данные, необходимые для рендеринга.

Как только вы сделаете запрос по этому адресу, вы получите что-то вроде этого:

Hello John

Это всего лишь верхушка айсберга. Чтобы узнать, как добавить больше шаблонов (и даже частичных), обратитесь к официальной документации express-handlebars .

Отладка Express

В некоторых случаях вам может потребоваться выяснить, что происходит с Express, когда приложение работает. Для этого вы можете передать следующую переменную окружения в Express: DEBUG=express* .

Вы должны запустить свой Node.js HTTP-сервер, используя:

$ DEBUG=express* node index.js

Резюме

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

Основы 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

Файл 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

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

Var bodyParser = require("body-parser")

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

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

2. Далее, на основе документации, мы видим, что нам нужно отслеживать именно 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 %>

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

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

Если вы хотите отправить их на почту. то в 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 . Для освоения вы должны знать основы 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 примере есть шесть простых шагов.

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

Node.js

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

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

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

mkdir myapp cd myapp

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

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

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

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

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

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

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

entry point: (index.js)

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

1. Установите 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 .

1. Запустите текстовый редактор и создайте файл с именем 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 .

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

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

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

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

В серии статей мы разберем основы создания web-сервиса на Node.js и Express.js, продемонстрируем взаимодействие с базами данных MySQL, MongoDB и Redis, покажем, как организовать авторизацию пользователей на web-сервисе c помощью логина и пароля, а также аккаунта в социальной сети с использованием модуля Passport, расскажем, как разграничить доступ к различным ресурсам web-сервиса с помощью ролей (Access Control List), а также сделаем сервис отказоустойчивым и масштабируемым.

Бандинги (Bindings) - служат связующей прослойкой между кодом, написанным на С/С++, и кодом, написанным на Javascript.

Вместо традиционной для серверов многопоточной модели - на каждое подключение выделяется один поток - Node все подключения обрабатывает в одном потоке. Этот поток называется циклом событий (именно в нем исполняется проинтерпретированный пользовательский javascript код приложения). Когда поступает запрос ввода/вывода (действие, емкое с точки зрения времени), цикл событий назначает эту задачу либо операционной системе, когда дело касается работы с сетью, либо контроллеру пула потоков, когда требуется работа с файловой системой или dns (по умолчанию используется 4 потока). Затем регулярно опрашивает о состоянии операции и по ее завершении выполняет заранее назначенное действие (запускается callback-функция или срабатывает прослушиватель событий - в этом заключается событийная ориентированность Node). Возникающие события выстраиваются в специальную очередь (Event Queue), которая определяет порядок обработки событий циклом событий. Поскольку цикл событий не ждет результата операции ввода/вывода, очередной запрос не блокируется на время выполнения операции ввода/вывода, а сама операция выполняется асинхронно по отношению к циклу событий. «Из коробки» Node не поддерживает асинхронное выполнение операций, требующих ресурсов CPU, и такие задачи блокируют цикл событий. Обойти эту проблему позволяют сторонние модули (например, webworker-threads).

Прежде, чем устанавливать nvm, желательно удалить Node.js и npm. Как это сделать описано и . Также в системе должен быть установлен C++ компилятор. Для OS X достаточно установить консольную утилиту Xcode:

Xcode-select --install

Далее удостоверьтесь, что файл ~/.bash_profile существует, иначе создайте его командой touch ~/.bash_profile . Теперь все готово для установки nvm (замените версию ниже на последнюю):

Curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.31.4/install.sh | bash

В рамках данной статьи из всех возможностей утилиты nvm мы воспользуемся только установкой последней версии Node.

Принцип нумерации версий Node.js. Стоит пояснить принцип нумерации версий Node. Каждая новая версия (v.5, v.6, …) выходит раз в полгода. Четные версии (выходят в апреле) фокусируются на стабильности и безопасности и имеют длительный период поддержки - Long Term Support plan (18 месяцев активной поддержки и год обычной). Этот статус очередная четная версия приобретает во время выхода новой нечетной версии. С обновлениями LTS версии уже не наделяются новым функционалом, а получают только исправление багов, влияющих на стабильность, обновление безопасности, некритические улучшения производительности и пополнение документации. Четные версии подходят для компаний со сложной организацией кода, для которых частое обновление обременительно. Напротив, нечетные версии (выходят в октябре) получают обновления часто. С обновлениями активно нарабатывается новый функционал, улучшаются существующие API и производительность. Такие версии поддерживаются не более восьми месяцев и носят больше характер экспериментальной площадки.

На момент написания статьи последней версией была v.6.3.1. Шестая версия получила существенные улучшения производительности, надежности, удобства работы и безопасности. Хотя v.6 пока еще не достигла LTS статуса, работать мы будет именно с ней. Для установки последней версии выполните в терминале

Nvm install node

И проверим установку

Node -v v.6.3.1

Если все правильно установилось, эта команда должна вывести версию Node.js.

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

Npm -v 3.10.3

Помимо установки модулей, npm следит за их версиями - два модуля могут быть зависимы от третьего, но использовать разные его версии. Раньше менеджер npm помещал зависимый модуль в папку модуля, который его использует. Получалась вложенная структура и зачастую в разных папках хранились одинаковые модули с одинаковыми версиями. Начиная с npm v.3, модули хранятся линейно в одной папке, и только когда возникает конфликт версий, модули помещаются вложенно.

Наш web-сервис будет создаваться на основе модуля Express.js - самого популярного web фреймворка для Node.js. Node не накладывает строгих ограничений на организацию кода, предоставляя разработчикам свободу выбора. Мы будем использовать шаблон mvc. Для генерации mvc-каркаса приложения воспользуемся пакетом express-generator , для этого в терминале выполним команду.

Npm install -g express-generator

В результате пакетный менеджер npm установит модуль express-generator . Флаг -g означает глобальную установку, т.е. запускать этот модуль в терминале мы можем из-под любого пути. Заметьте, что если бы для установки Node мы не использовали nvm, то при глобальной установке модулей приходилось бы прибегать к использованию sudo , что не является безопасным. Далее создадим mvc-каркас командой

Express ~/Documents/site/app

Директория ~/Documents/site/app будет корневой для нашего проекта (все относительные пути в статье будут вестись от корневой директории). Перейдем в созданную директорию и установим зависимости, прописанные в файле./package.json (модули устанавливаются в./node_modules)

Cd ~/Documents/site/app && npm install

И запустим приложение

Npm start

При этом npm выполнит команду, прописанную в./package.json

{ ... "scripts": { "start": "node ./bin/www" }, ... }

Теперь переходите по адресу http://localhost:3000 . Если отобразилась приветственная надпись «Welcome to Express», то поздравляем - все готово для следующего шага!

Базы данных

Наш сервис для хранения пользователей, продуктов, предзаказов и системы прав доступа будет использовать MySQL, для сессий - Redis, а для отправленных смс-кодов - MongoDB.

MySQL

Эта реляционная СУБД в представлении не нуждается. Скачаем DMG образ MySQL сервера и запустим установку. В конце установки появится диалоговое окно, сообщающее временный пароль пользователя root.

Изменим временный пароль

/usr/local/mysql/bin/mysqladmin -u root -p password Enter password: New password: Confirm new password: Warning: Since password will be sent to server in plain text, use ssl connection to ensure password safety.

Запускается и останавливается сервер через панель MySQL в системных настройках.

Работать со схемой базы данных будем в MySQL Workbench .

Redis и MongoDB

Redis является сетевым журналируемым хранилищем данных типа «ключ - значение», относится к нереляционным СУБД высокой производительности, поскольку хранит базу данных в оперативной памяти. MongoDB - нереляционная СУБД для хранения JSON объектов.

Как Redis, так и MongoDB удобно устанавливать через Homebrew - пакетный менеджер для Mac OS X. Обновим базу пакетов менеджера и установим Redis командой

Brew update && brew install redis

Запустим как сервис

Brew services start redis

MongoDB устанавливается командой

Brew install mongodb

Создадим директорию

Mkdir ~/Documents/site/data

И запустим MongoDB по этому пути

Mongod --dbpath ~/Documents/site/data

Для проверки наберите в другом окне терминала

Должно появиться следующее:

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

Файл конфигурации приложения

Создадим в корне проекта две вложенные директории и пустой файл

Mkdir -p config/development && touch ./config/development/index.js

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

// файл./config/development/index.js var config = { db: { mysql: { host: "localhost", user: "root", database: "appdb", // можете заменить "appdb" на свое название password: "yourPasswordHere" // замените это на root пароль }, // от MySQL Server mongo: "mongodb://localhost/ourProject" // можете заменить "ourProject" }, // на свое название redis: { port: 6379, host: "127.0.0.1" }, port: 3000 }; module.exports = config;

Подключим этот файл к./bin/www следующим образом

// файл./bin/www //... var config = require("../config/" + (process.env.NODE_ENV || "development")); //... //var port = normalizePort(process.env.PORT || "3000"); var port = normalizePort(process.env.PORT || config.port); //...

Это позволит нам подключать разные файлы конфигурации в зависимости от параметров запуска приложения. Например, если мы создадим конфигурационный файл./config/production/index.js , то чтобы он применился, приложение следует запускать так

NODE_ENV=production npm start

Несколько слов о require, module.exports и exports

Node.js исповедует модульный подход построения приложений, причем в качестве модуля всегда выступает отдельный файл (*.js , *.json , *.node , либо файл с javascript кодом без расширения). За подключение модулей отвечает функция require . Если модуль встроенный или находится в./node-modules (или в../node-modules и выше), то в качестве параметра функции require указывается только название модуля, например require("http") . Иначе функции require передается путь (т.е. строка, начинающаяся с "./" или "/" , или "../"), например такой "./libs/dbs.js" . Расширение модуля можно не указывать и просто писать "./libs/dbs" . В таком случае, если dbs не окажется файлом модуля, dbs воспринимается как директория, и в ней ищется файл модуля с именем index . Так мы поступили выше при подключении файла конфигурации к./bin/www . Весь алгоритм получения пути к модулю по строке описывается .

Переменная, объявленная в модуле обычным образом, не будет доступна через require - ее надо передать через module.exports или exports (является ссылкой на module.exports и используется для более короткой записи). Пример ниже поясняет ситуацию

// файл module.js var a = ; var b = ; exports.a = a; // файл uses_module.js var module = require("./module"); console.log(module.a) // console.log(module.b) // undefined

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

При первом подключении модуля функция require кэширует его и помещает в объект require.cache . При последующих подключениях того же модуля объект грузится из кэша. Такая модель реализует шаблон Singleton.

Подключение баз данных к Node.js

Установка драйверов

Для MySQL мы не будем использовать ORM - вся нагрузка ляжет на хранимые процедуры, которые будут вызываться из репозиториев соответствующих объектов. Стандартным драйвером для работы с MySQL в Node является npm модуль mysql (есть более быстрый драйвер mysql2, но он пока находится на стадии релиз-кандидата). При написании кода мы будем придерживаться стиля с использованием промисов, и поскольку модуль mysql не поддерживает такой стиль, воспользуемся модулем-оберткой mysql-promise. Перейдем к корневой директории проекта и установим его

Cd ~/Documents/site/app && npm install mysql-promise --save

Флаг --save указывает пакетному менеджеру на сохранение зависимости в файл package.json . С драйвером для Redis дела обстоят похожим образом - воспользуемся модулем-оберткой promise-redis вокруг стандартного драйвера redis.

Npm install promise-redis --save

И, наконец, установим Mongoose - ODM (Object-Document Mapper) для MongoDB

Npm install mongoose --save

Mongoose имеет собственную встроенную библиотеку mpromise, реализующую промисы. На данный момент эта библиотека считается устаревшей, и рекомендуется заменять ее на другую (мы заменим на стандартные ES6 промисы).

Инициализация баз данных

Создадим папку и файл в ней

Mkdir libs && touch ./libs/dbs.js

со следующим содержанием

// файл./libs/dbs.js var mysqlPromise = require("mysql-promise")(), mongoose = require("mongoose"), Redis = require("promise-redis")(), config = require("../config/" + (process.env.NODE_ENV || "development")); mysqlPromise.configure(config.db.mysql); var redis = Redis.createClient(config.redis.port, config.redis.host); mongoose.Promise = Promise; // function checkMySQLConnection(){ // return mysqlPromise.query("SELECT 1"); } function checkRedisReadyState() { // return new Promise((resolve,reject) => { redis.once("ready", () => {redis.removeAllListeners("error"); resolve()}); redis.once("error", e => reject(e)); }) } function init() { // return Promise.all([ checkMySQLConnection(), new Promise((resolve,reject) => {mongoose.connect(config.db.mongo, err => err ? reject(err):resolve())}), checkRedisReadyState() ]); } module.exports = { // mysql: mysqlPromise, redis: redis, init: init };

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

1. Заменяем встроенную библиотеку промисов на стандартную ES6 библиотеку.
2. Функция checkMySQLConnection() проверяет подключение к MySQL простым запросом. Важно отметить, что при конфигурировании подключения к MySQL создается пул подключений, и команда query вначале берет подключение из пула, выполняет запрос, затем освобождает подключение.
3. Функция checkRedisReadyState() проверяет готовность Redis сервера.
4. Функция init() с помощью ES6 метода Promise.all параллельно запускает проверку готовности MySQL, MongoDB и Redis. Как только одна из функций возвращает ошибку, выполнение других останавливается, и Promise.all возвращает ошибку, ловить которую будем в./bin/www методом.catch() . Если ошибка не возвращается, управление передается методу.then() .
5. И, наконец, экспортируем переменные.

Изменим файл./bin/www

// файл./bin/www // ... // Добавим зависимости var config = require("../config/" + (process.env.NODE_ENV || "development")), dbs = require("../libs/dbs"); // ... // Заменим строчку // server.listen(port); // На следующий блок dbs.init().then(() => { console.log("Соединения с базами данных установлены успешно"); server.listen(port); }).catch(err => { console.log(err); process.exit(1); }); // ...

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

На этом первая часть заканчивается. В следующей части мы займемся регистрацией и ролями пользователей.

• Перевод

Начинающему программисту разработка для 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 в реальных проектах, может быть, вы посоветуете что-нибудь полезное новичкам? А если вы только что всё это впервые попробовали – ждём ваших впечатлений.