One place for hosting & domains

      приложения

      Включение рендеринга на стороне сервера для приложения React


      Введение

      Рендеринг на стороне сервера (SSR) — это популярная методика рендеринга одностраничного клиентского приложения (SPA) на сервере и последующей отправки на клиент полностью отрисованной страницы. Это позволяет использовать динамические компоненты в качестве статической разметки HTML.

      Такой подход может быть полезным для поисковой оптимизации (SEO), когда при индексации код JavaScript не обрабатывается надлежащим образом. Это также может быть полезно в ситуациях, когда загрузка большого блока JavaScript затруднена из-за медленной скорости сети.

      В этом учебном модуле мы инициализируем приложение React с помощью Create React App, а затем изменим проект, чтобы он активировал рендеринг на стороне сервера.

      После прохождения учебного модуля вы получите работающий проект с клиентским приложением React и серверным приложением Express.

      Примечание. Также Next.js позволяет использовать современный подход к созданию статических приложений React и приложений, рендеринг которых выполняется на сервере.

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

      Для данного обучающего руководства вам потребуется следующее:

      Этот учебный модуль был проверен с версиями Node v14.4.0 и npm v6.14.5.

      Шаг 1 — Создание приложения React и изменение компонента приложения

      Вначале мы используем npx для запуска нового приложения React с помощью последней версии Create React App.

      Назовем наше приложение my-ssr-app:

      • npx create-react-app@3.4.1 my-ssr-app

      Перейдем в новый каталог с помощью команды cd:

      cd my-ssr-app
      

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

      Вы должны увидеть пример приложения React в окне браузера.

      Теперь создадим компонент <Home>:

      Затем добавим следующий код в файл Home.js:

      src/Home.js

      import React from 'react';
      
      export default props => {
        return <h1>Hello {props.name}!</h1>;
      };
      

      При этом будет создан заголовок <h1> с сообщением "Hello“, адресованным имени.

      Далее мы выполним рендеринг <Home> в компоненте <App>. Откройте файл App.js:

      Затем заменим существующие строки кода новыми строками кода:

      src/App.js

      import React from 'react';
      import Home from './Home';
      
      export default () => {
        return <Home name="Sammy" />;
      };
      

      Они передают name в компонент <Home> так, что ожидаемое сообщение будет выглядеть так: "Hello Sammy!".

      В файле index.js нашего приложения мы будем использовать метод ReactDOM hydrate вместо render, чтобы указать блоку рендеринга DOM, чтобы мы восстанавливаем приложение после рендеринга на стороне сервера.

      Откроем файл index.js:

      Замените содержимое файла index.js следующим кодом:

      index.js

      import React from 'react';
      import ReactDOM from 'react-dom';
      import App from './App';
      
      ReactDOM.hydrate(<App />, document.getElementById('root'));
      

      Мы завершили настройку на стороне клиента и теперь можем перейти к настройке на стороне сервера.

      Шаг 2 — Создание сервера Express и рендеринг компонента приложения

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

      • npm install express@4.17.1

      Также можно использовать yarn:

      Создайте каталог server рядом с каталогом src нашего приложения:

      Затем создайте новый файл index.js, содержащий код сервера Express:

      Добавим необходимые элементы импорта и определим некоторые константы:

      server/index.js

      import path from 'path';
      import fs from 'fs';
      
      import React from 'react';
      import express from 'express';
      import ReactDOMServer from 'react-dom/server';
      
      import App from '../src/App';
      
      const PORT = process.env.PORT || 3006;
      const app = express();
      

      Затем добавим код сервера с обработкой ошибок:

      server/index.js

      // ...
      
      app.get('/', (req, res) => {
        const app = ReactDOMServer.renderToString(<App />);
      
        const indexFile = path.resolve('./build/index.html');
        fs.readFile(indexFile, 'utf8', (err, data) => {
          if (err) {
            console.error('Something went wrong:', err);
            return res.status(500).send('Oops, better luck next time!');
          }
      
          return res.send(
            data.replace('<div id="root"></div>', `<div id="root">${app}</div>`)
          );
        });
      });
      
      app.use(express.static('./build'));
      
      app.listen(PORT, () => {
        console.log(`Server is listening on port ${PORT}`);
      });
      

      Как видите, мы можем импортировать наш компонент <App> из клиентского приложения непосредственно с сервера.

      Здесь происходит три важные вещи:

      • Мы предписываем Express вывести содержимое каталога build в виде статичных файлов.
      • Мы будем использовать метод ReactDOMServer, renderToString, для рендеринга нашего приложения в статичную строку HTML.
      • Затем мы считываем статичный файл index.html из готового клиентского приложения, вставляем статичное содержимое нашего приложения в <div> с id "root", а затем отправляем результат в качестве ответа на запрос.

      Шаг 3 — Настройка webpack, Babel и скриптов npm

      Чтобы наш серверный код работал, нам нужно объединить его в комплект и провести транспиляцию, используя webpack и Babel. Для этого добавим в проект зависимости dev, введя следующую команду в окне терминала:

      • npm install webpack@4.42.0 webpack-cli@3.3.12 webpack-node-externals@1.7.2 @babel/core@7.10.4 babel-loader@8.1.0 @babel/preset-env@7.10.4 @babel/preset-react@7.10.4 --save-dev

      Также можно использовать yarn:

      • yarn add webpack@4.42.0 webpack-cli@3.3.12 webpack-node-externals@1.7.2 @babel/core@7.10.4 babel-loader@8.1.0 @babel/preset-env@7.10.4 @babel/preset-react@7.10.4 --dev

      Примечание. В более ранней версии этого учебного модуля мы устанавливали babel-core, babel-preset-env и babel-preset-react-app. Эти пакеты с тех пор были архивированы, и вместо них используются версии с одним репозиторием.

      Далее мы создадим файл конфигурации Babel:

      После этого добавьте готовые настройки env и react-app:

      .babelrc.json

      {
        "presets": [
          "@babel/preset-env",
          "@babel/preset-react"
        ]
      }
      

      Примечание. В более ранней версии этого учебного модуля мы использовали файл .babelrc (без расширения .json). Это был файл конфигурации Babel 6, однако для Babel 7 он больше не используется.

      Теперь мы создадим конфигурацию webpack для сервера, который использует Babel Loader для транспиляции кода. Начните с создания файла:

      Затем добавьте следующие конфигурации в файл webpack.server.js:

      webpack.server.js

      const path = require('path');
      const nodeExternals = require('webpack-node-externals');
      
      module.exports = {
        entry: './server/index.js',
      
        target: 'node',
      
        externals: [nodeExternals()],
      
        output: {
          path: path.resolve('server-build'),
          filename: 'index.js'
        },
      
        module: {
          rules: [
            {
              test: /.js$/,
              use: 'babel-loader'
            }
          ]
        }
      };
      

      С этой конфигурацией наш транспилированный серверный комплект будет выводиться в папку server-build в файле с именем called index.js.

      Обратите внимание на использование target: 'node' и externals: [nodeExternals()] из webpack-node-externals. При этом опускаются файлы из node_modules в комплекте, сервер сможет получить доступ к этим файлам напрямую.

      Это завершает установку зависимости и конфигурации webpack и Babel.

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

      Мы добавим скрипты dev:build-server, dev:start и dev в файл package.json, чтобы легко выполнять сборку и подачу нашего приложения SSR:

      package.json

      "scripts": {
        "dev:build-server": "NODE_ENV=development webpack --config webpack.server.js --mode=development -w",
        "dev:start": "nodemon ./server-build/index.js",
        "dev": "npm-run-all --parallel build dev:*",
        ...
      },
      

      Мы используем nodemon для перезапуска сервера при внесении изменений. Также мы используем npm-run-all для параллельного выполнения нескольких команд.

      Давайте установим эти пакеты, введя следующие команды в окне терминала:

      • npm install nodemon@2.0.4 npm-run-all@4.1.5 --save-dev

      Также можно использовать yarn:

      • yarn add nodemon@2.0.4 npm-run-all@4.1.5 --dev

      Так вы можете запустить следующий код для сборки приложения на стороне клиента, объединения в пакет и транспиляции кода сервера и запуска сервера на порту :3006:

      Также можно использовать yarn:

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

      Откройте в браузере адрес http://localhost:3006/ и вы увидите приложение после рендеринга на стороне сервера.

      Ранее исходный код показал следующее:

      Output

      <div id="root"></div>

      С внесенными изменениями исходный код показывает:

      Output

      <div id="root"><h1 data-reactroot="">Hello <!-- -->Sammy<!-- -->!</h1></div>

      При рендеринге на стороне сервера компонент <App> был успешно конвертирован в формат HTML.

      Заключение

      В этом учебном модуле мы инициализировали приложение React и активировали рендеринг на стороне сервера.

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

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

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

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



      Source link

      Как автоматически перезапускать приложения Node.js с помощью nodemon


      Введение

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

      nodemon — это утилита командной строки, разработанная @rem. Она заключает в оболочку ваше приложение Node, наблюдает за файловой системой и автоматически перезапускает процесс.

      Из этой статьи вы узнаете об установке и настройке nodemon.

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

      Если вы захотите следовать за этой статьей, вам потребуется следующее:

      Шаг 1 — Установка nodemon

      Вначале вам нужно будет установить nodemon на вашем компьютере. Установите утилиту в проекте глобально или локально, используя npm или Yarn:

      Глобальная установка

      Вы можете установить nodemon глобально с помощью npm:

      Или с помощью Yarn:

      Локальная установка

      Также вы можете установить nodemon локально с помощью npm. При локальной установке мы можем установить nodemon как зависимость dev с помощью --save-dev (или --dev):

      • npm install nodemon --save-dev

      Или с помощью Yarn:

      При локальной установке нужно знать, сможете ли вы использовать команду nodemon напрямую из командной строки:

      Output

      • command not found: nodemon

      Однако вы также можете использовать его как часть некоторых скриптов npm или с npx.

      На этом процесс установки nodemon завершен. Далее мы будем использовать nodemon с нашими проектами.

      Шаг 2 — Настройка образца проекта Example Express с помощью nodemon

      Мы можем использовать nodemon для запуска скрипта Node. Например, если у нас имеется настройка сервера Express в файле server.js, мы можем запустить его и наблюдать за изменениями следующим образом:

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

      Процесс перезапускается каждый раз, когда вы вносите изменение в файл с одним из отслеживаемых по умолчанию расширений (.js, .mjs, .json, .coffee или .litcoffee) в текущем каталоге или подкаталоге.

      Допустим мы записываем образец файла server.js, который выводит сообщение: Dolphin app listening on port ${port}!.

      Мы можем запустить пример с помощью nodemon:

      Мы видим следующий вывод на терминале:

      Output

      [nodemon] 1.17.3 [nodemon] to restart at any time, enter `rs` [nodemon] watching: *.* [nodemon] starting `node server.js` Dolphin app listening on port 3000!

      Пока nodemon еще работает, внесем изменение в файл server.js для вывода сообщения: Shark app listening on port ${port}!.

      Мы увидим следующий дополнительный вывод на терминале:

      Output

      [nodemon] restarting due to changes... [nodemon] starting `node server.js` Shark app listening on port 3000!

      Вывод приложения Node.js на терминале отображается, как и ожидалось. Вы можете перезапустить процесс в любое время, набрав rs и нажав ENTER.

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

      package.json

      {
        // ...
        "main": "server.js",
        // ...
      }
      

      Или скрипт start:

      package.json

      {
        // ...
        "scripts": {
          "start": "node server.js"
        },
        // ...
      }
      

      После внесения изменений в package.json вы сможете вызывать nodemon для запуска образца приложения в режиме наблюдения без его передачи в server.js.

      Шаг 3 — Использование опций

      Вы можете изменить параметры конфигурации, доступные nodemon.

      Рассмотрим несколько основных опций:

      • --exec: используйте оператор --exec, чтобы задать двоичный код для выполнения файла. Например, в сочетании с двоичным кодом ts-node оператор --exec может быть полезен для наблюдения за изменениями и запуска файлов TypeScript.
      • --ext: задает различные расширения файлов для наблюдения. Для этого оператора требуется указать разделенный запятыми список расширений файлов (например, --ext js,ts).
      • --delay: по умолчанию nodemon ожидает одну секунду для перезапуска процесса после изменения файла, однако с помощью оператора --delay вы можете указать другое время задержки. Например, nodemon --delay 3.2 для задержки 3,2 секунды.
      • --watch: используйте оператор --watch, чтобы задать несколько каталогов или файлов для наблюдения. Добавляйте один оператор --watch для каждого каталога, за которым вы хотите наблюдать. По умолчанию вы наблюдаете за текущим каталогом и его подкаталогами, а с помощью --watch вы можете сузить область наблюдения до нескольких отдельных подкаталогов или файлов.
      • --ignore: используйте оператор --ignore, чтобы игнорировать определенные файлы, шаблоны файлов или каталоги.
      • --verbose: более развернутый вывод с информацией о том, какие файлы изменились, для активации перезапуска.

      Вы можете просмотреть все доступные опции с помощью следующей команды:

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

      • наблюдение за каталогом server
      • указание файлов с расширением .ts
      • игнорирование файлов с суффиксом .test.ts
      • выполнение файла (server/server.ts) с ts-node
      • ожидание перезапуска в течение трех секунд после изменения файла
      • nodemon --watch server --ext ts --exec ts-node --ignore '*.test.ts' --delay 3 server/server.ts

      Эта команда комбинирует опции --watch, --ext, --exec, --ignore и --delay, чтобы выполнить условия для нашего сценария.

      Шаг 4 — Использование конфигураций

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

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

      nodemon.json

      {
        "watch": ["server"],
        "ext": "ts",
        "ignore": ["*.test.ts"],
        "delay": "3",
        "execMap": {
          "ts": "ts-node"
        }
      }
      

      Обратите внимание, что execMap используется вместо оператора --exec. execMap позволяет задавать двоичный код, который следует использовать для определенных расширений файлов.

      Если вы предпочитаете не добавлять в проект файл конфигурации nodemon.json, вы можете добавить эти конфигурации в файл package.json в ключ nodemonConfig:

      package.json

      {
        "name": "test-nodemon",
        "version": "1.0.0",
        "description": "",
        "nodemonConfig": {
          "watch": [
            "server"
          ],
          "ext": "ts",
          "ignore": [
            "*.test.ts"
          ],
          "delay": "3",
          "execMap": {
            "ts": "ts-node"
          }
        },
        // ...
      

      Когда вы внесете изменения в nodemon.json или package.json, вы сможете запускать nodemon с помощью желаемого скрипта:

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

      Заключение

      В этой статье мы рассмотрели использование nodemon с приложениями Node.js. Этот инструмент поможет автоматизировать процесс остановки и запуска сервера Node для просмотра изменений.

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

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





      Source link

      Использование EJS для преобразования приложения Node в шаблон


      Введение

      При быстром создании приложений Node часто бывает необходим удобный и быстрый способ преобразовать приложение в шаблон.

      Jade используется по умолчанию как механизм просмотра для Express, но синтаксис Jade может быть чрезмерно сложным для многих моделей использования. EJS — один из альтернативных вариантов, удобный в настройке и позволяющий хорошо выполнить эту работу. Давайте посмотрим, как создать простое приложение и использовать EJS, чтобы включить повторяющиеся части нашего сайта (частичные элементы) и передать данные в представления.

      Настройка демонстрационного приложения

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

      Получите код: Репозиторий git с полным кодом демонстрации можно найти на GitHub здесь.

      Структура файлов

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

      - views
      ----- partials
      ---------- footer.ejs
      ---------- head.ejs
      ---------- header.ejs
      ----- pages
      ---------- index.ejs
      ---------- about.ejs
      - package.json
      - server.js
      

      package.json будет содержать информацию нашего приложения Node и необходимые нам зависимости (express и EJS), а server.js будет содержать настройку, конфигурацию сервера Express. Здесь мы определим маршруты к нашим страницам.

      Настройка узла

      Давайте откроем файл package.json и настроим в нем наш проект.

      package.json

      {
        "name": "node-ejs",
        "main": "server.js",
        "dependencies": {
          "ejs": "^3.1.5",
          "express": "^4.17.1"
        }
      }
      

      Нам потребуются только Express и EJS. Теперь нам нужно установить зависимости, которые мы только что определили. Вперед:

      Установив все зависимости, настроим приложение для использования EJS и настроим маршруты для двух страниц, которые нам нужны: страницы индекса (полная ширина) и информационной страницы (боковая панель). Мы будем делать это в файле server.js.

      server.js

      // load the things we need
      var express = require('express');
      var app = express();
      
      // set the view engine to ejs
      app.set('view engine', 'ejs');
      
      // use res.render to load up an ejs view file
      
      // index page
      app.get("https://www.digitalocean.com/", function(req, res) {
          res.render('pages/index');
      });
      
      // about page
      app.get('/about', function(req, res) {
          res.render('pages/about');
      });
      
      app.listen(8080);
      console.log('8080 is the magic port');
      

      Здесь мы определим наше приложение и зададим для него отображение на порту 8080. Также нам нужно задать EJS как механизм просмотра для нашего приложения Express с помощью app.set('view engine', 'ejs'); Обратите внимание, как мы отправляем представление пользователю, используя res.render(). Важно отметить, что res.render() будет искать представление в папке views. Это значит, что нам нужно определить только pages/index, поскольку полный путь выглядит как views/pages/index.

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

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

      Теперь мы можем открыть наше приложение в браузере, используя адреса http://localhost:8080 и http://localhost:8080/about. Мы настроили наше приложение, и нам нужно определить файлы представления и посмотреть, как EJS работает с ними.

      Создание частичных элементов EJS

      Как и в других приложениях здесь будет много кода, используемого многократно. Мы назовем такие элементы частичными шаблонами и определим три файла, которые будут использоваться везде на нашем сайте: head.ejs, header.ejs и footer.ejs. Создадим эти файлы.

      views/partials/head.ejs

      <meta charset="UTF-8">
      <title>EJS Is Fun</title>
      
      <!-- CSS (load bootstrap from a CDN) -->
      <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/twitter-bootstrap/4.5.2/css/bootstrap.min.css">
      <style>
          body { padding-top:50px; }
      </style>
      

      views/partials/header.ejs

      <nav class="navbar navbar-expand-lg navbar-light bg-light">
        <a class="navbar-brand" href="https://www.digitalocean.com/">EJS Is Fun</a>
        <ul class="navbar-nav mr-auto">
          <li class="nav-item">
            <a class="nav-link" href="https://www.digitalocean.com/">Home</a>
          </li>
          <li class="nav-item">
            <a class="nav-link" href="http://www.digitalocean.com/about">About</a>
          </li>
        </ul>
      </nav>
      

      views/partials/footer.ejs

      <p class="text-center text-muted">© Copyright 2020 The Awesome People</p>
      

      Добавление частичных шаблонов EJS в представления

      Итак, мы определили частичные шаблоны. Теперь нужно добавить их в наши представления. Возьмем файлы index.ejs и about.ejs и используем синтаксис include для добавления частичных шаблонов.

      Синтаксис добавления частичного шаблона EJS

      Используйте <%- include('RELATIVE/PATH/TO/FILE') %>, чтобы встроить частичный шаблон EJS в другой файл.

      • Дефис <%- вместо <% предписывает EJS выполнять рендеринг необработанного кода HTML.
      • Путь к частичному шаблону является относительным по отношению к текущему файлу.

      views/pages/index.ejs

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <%- include('../partials/head'); %>
      </head>
      <body class="container">
      
      <header>
          <%- include('../partials/header'); %>
      </header>
      
      <main>
          <div class="jumbotron">
              <h1>This is great</h1>
              <p>Welcome to templating using EJS</p>
          </div>
      </main>
      
      <footer>
          <%- include('../partials/footer'); %>
      </footer>
      
      </body>
      </html>
      

      Теперь мы можем посмотреть определенное представление в браузере по адресу http://localhost:8080. node-ejs-templating-index

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

      views/pages/about.ejs

      <!DOCTYPE html>
      <html lang="en">
      <head>
          <%- include('../partials/head'); %>
      </head>
      <body class="container">
      
      <header>
          <%- include('../partials/header'); %>
      </header>
      
      <main>
      <div class="row">
          <div class="col-sm-8">
              <div class="jumbotron">
                  <h1>This is great</h1>
                  <p>Welcome to templating using EJS</p>
              </div>
          </div>
      
          <div class="col-sm-4">
              <div class="well">
                  <h3>Look I'm A Sidebar!</h3>
              </div>
          </div>
      
      </div>
      </main>
      
      <footer>
          <%- include('../partials/footer'); %>
      </footer>
      
      </body>
      </html>
      

      Если мы откроем адрес http://localhost:8080/about, мы увидим нашу информационную страницу с боковой панелью! node-ejs-templating-about

      Теперь мы можем начать использовать EJS для передачи данных из нашего приложения Node в наши представления.

      Передача данных в представления и частичные шаблоны

      Определим некоторые базовые переменные и список для передачи на главную страницу. Вернитесь в файл server.js и добавьте следующий код в маршрут app.get("https://www.digitalocean.com/").

      server.js

      // index page
      app.get("https://www.digitalocean.com/", function(req, res) {
          var mascots = [
              { name: 'Sammy', organization: "DigitalOcean", birth_year: 2012},
              { name: 'Tux', organization: "Linux", birth_year: 1996},
              { name: 'Moby Dock', organization: "Docker", birth_year: 2013}
          ];
          var tagline = "No programming concept is complete without a cute animal mascot.";
      
          res.render('pages/index', {
              mascots: mascots,
              tagline: tagline
          });
      });
      

      Мы создали список mascots и простую строку tagline. Теперь перейдем в файл index.ejs и используем их.

      Рендеринг одиночной переменной в EJS

      Чтобы отразить через эхо одну переменную, мы просто используем <%= tagline %>. Добавим этот код в наш файл index.ejs:

      views/pages/index.ejs

      ...
      <h2>Variable</h2>
      <p><%= tagline %></p>
      ...
      

      Циклический перебор данных в EJS

      Для циклического перебора данных мы будем использовать .forEach. Добавим этот код в наш файл view:

      views/pages/index.ejs

      ...
      <ul>
          <% mascots.forEach(function(mascot) { %>
              <li>
                  <strong><%= mascot.name %></strong>
                  representing <%= mascot.organization %>, born <%= mascot.birth_year %>
              </li>
          <% }); %>
      </ul>
      ...
      

      Теперь мы можем видеть в браузере новую информацию, которую мы добавили!

      node-ejs-templating-rendered

      Передача данных в частичный шаблон в EJS

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

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

      views/pages/about.ejs

      ...
      <header>
          <%- include('../partials/header', {variant:'compact'}); %>
      </header>
      ...
      

      При этом нужно с осторожностью предполагать, что переменная определена.

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

      views/partials/header.ejs

      ...
      <em>Variant: <%= typeof variant != 'undefined' ? variant : 'default' %></em>
      ...
      

      В строке выше код EJS выполняет рендеринг значения variant, если оно определено, и default, если не определено.

      Заключение

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

      Дополнительную справку по EJS можно найти в официальной документации здесь.



      Source link