Полезные видео о фронтенде. Подпишись на Rutube

Как использовать переменные среды в React

2 года назад·5 мин. на чтение

О различных способах доступа к переменным среды в React приложении

Если у вас нет опыта server side программирования, переменные среды могут показаться чем-то магическим. Этот недостаток знаний может поставить вас в тупик, когда вы закончите создавать приложения todo на localhost и попытаетесь создать продакшн сборку в первый раз. Если вы хотите узнать, как использовать переменные среды в ваших собственных инструментах, или глубоко погрузиться в то, как переменные среды работают в React, вы можете продолжить чтение этой статьи. Но если вы ищете быстрое решение и используете Create React App, ознакомьтесь с документацией здесь. Пользователи NextJS, ознакомьтесь с документацией здесь.

Проблема, которую мы решаем

Как объявить различные URL-адресов API для локальной разработки и для продакшн сборки.

Как решить эту проблему

Использовать переменные среды. При работе с React переменные среды — это переменные, доступные через глобальный объект process.env. Этот глобальный объект предоставляется вашей средой через NodeJS. И поскольку у нас нет NodeJS в браузере, нам понадобится webpack. В этой статье рассмотрим два способа установки и использования переменных среды для ваших React проектов с помощью webpack: с помощью скриптов npm и с помощью файла .env.

Способ 1: Использование скриптов npm для установки переменных среды

Во-первых, установите webpack и webpack-cli из npm:

npm install --save-dev webpack webpack-cli

Перейдите в файл package.json, проверьте поле scripts и найдите команды, которые запускают webpack. Вероятно, это будет выглядеть примерно так:

{
  // ...
  scripts: {
    "dev": "webpack --config webpack.config.dev.js",
    "build": "webpack --config webpack.config.build.js"
  }
}

Давайте добавим некоторые переменные окружения с флагом --env в scripts:

{
  // ...
  scripts: {
    "dev": "webpack --env.API_URL=http://localhost:8000 --config webpack.config.dev.js",
    "build": "webpack --env.API_URL=https://www.myapi.com --config webpack.config.build.js"
  }
}

Мы добавили --env.API_URL= часть в обоих скриптах. Теперь запустите команду npm run dev, перейдите к React компоненту и используйте process.env.API_URL:

const App = () => <h1>{process.env.API_URL}</h1>;

И тут проект должен сломаться.

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

const webpack = require('webpack'); // DefinePlugin это часть webpack, поэтому это require обязателен

// возвращаем функцию из config файла
// переменная `env` будет просто объектом { API_URL: 'http://localhost:8000' }
// в ней будут содержаться все переменные среды, которые мы указали в package.json

module.exports = (env) => {
  // этот объект это сама конфигурация webpack
  return {
    plugins: [
      // добавим плагин в список плагинов
      new webpack.DefinePlugin({ `process.env.API_URL`: JSON.stringify(${env.API_URL}) })
    ]
  };
};

DefinePlugin требует, чтобы вы буквально определили свои «переменные среды». Вы также можете применить .reduce к переменным среды, чтобы получить объект:

module.exports = (env) => {
  // создаем объект из переменных среды
  const envKeys = Object.keys(env).reduce((prev, next) => {
    prev[`process.env.${next}`] = JSON.stringify(env[next]);
    return prev;
  }, {});

  return {
    plugins: [
      new webpack.DefinePlugin(envKeys)
    ]
  };
};

Если вы запустите команду сейчас, все скомпилируется, и ваш process.env.API_URL будет скомпилирован в правильный URL-адрес на основе переменной среды.

Способ 2: Использование файла `.env` для установки переменных среды

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

Создадим файл `.env`

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

API_URL=http://localhost:8000

Обработка файла `.env`

Теперь нам нужен какой-то способ обработки файлов и их содержимого. Для этого мы собираемся использовать популярный npm пакет под названием dotenv. Dotenv широко используется (create-react-app использует его). Он будет получать переменные из нашего файла .env и добавлять их в глобальный process.env.

$ npm install --save-dev dotenv

Добавление переменных в проект React

Есть одна проблема. Dotenv работает только на стороне сервера. А мы хотим использовать переменные среды на стороне клиента, на фронтенде. В данном случае мы разрабатываем клиентскую часть. И dotenv нужна какая-то среда для фактического хранения переменных. Здесь поможет Webpack. Воспользуемся плагином DefinePlugin в нашей webpack конфигурации:

const webpack = require('webpack');
const dotenv = require('dotenv');

module.exports = () => {
  // dotenv вернет объект с полем parsed 
  const env = dotenv.config().parsed;
  
  // сделаем reduce, чтобы сделать объект
  const envKeys = Object.keys(env).reduce((prev, next) => {
    prev[`process.env.${next}`] = JSON.stringify(env[next]);
    return prev;
  }, {});

  return {
    plugins: [
      new webpack.DefinePlugin(envKeys)
    ]
  };
};

При необходимости проверьте параметры конфигурации dotenv в документации на github. Вызов .config() в dotenv вернет объект со всеми переменными среды, установленными в вашем файле .env через поле parsed. Теперь давайте проверим наш React код:

const App = () => <h1>{process.env.API_URL}</h1>;

И это работает! Он показывает значение переменной среды API_URL, определенной в .env. Осталась только одна проблема: нам все еще нужно определить различные API_URL для локальной разработки и продакшена.

Различные переменные среды для разных сред

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

.env (содержит все переменные среды для продакшн)
.env.development (содержит все переменные среды для локальной разработки)

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

Настройка активной среды с помощью `scripts` в `package.json`

Мы собираемся использовать scripts (как мы это делали в методе 1), чтобы установить текущую среду в нашем package.json:

{
  "scripts": {
    "dev": "webpack --env.ENVIRONMENT=development --config webpack.config.dev.js",
    "build": "webpack --env.ENVIRONMENT=production --config webpack.config.build.js"
  }
}

Так как мы определили нашу среду в нашем package.json, теперь она доступна в нашей конфигурации webpack. Следующим шагом будет переход к webpack конфигурации и дать ему использовать файл .env, принадлежащий активной среде. Как и раньше, мы используем dotenv, но теперь мы указываем пользовательский path в параметрах.

const webpack = require('webpack');
const dotenv = require('dotenv');
const fs = require('fs'); // для проверки существования файла
const path = require('path'); // для получения текущего пути

module.exports = (env) => {
  // получаем корневой путь (предполагаем, что webpack config лежит в корне проекта)
  const currentPath = path.join(__dirname);
  
  // путь по умолчанию (будет использован для продакшена - `.env`)
  const basePath = currentPath + '/.env';

  // склеиваем имя среды с именем файла для получения имени env файла
  const envPath = basePath + '.' + env.ENVIRONMENT;

  // проверяем существует ли env файл, если нет используем имя по умолчанию
  const finalPath = fs.existsSync(envPath) ? envPath : basePath;

  // устанавливаем параметр path в dotenv
  const fileEnv = dotenv.config({ path: finalPath }).parsed;
  
  // сделаем reduce, чтобы получить объект
  const envKeys = Object.keys(fileEnv).reduce((prev, next) => {
    prev[`process.env.${next}`] = JSON.stringify(fileEnv[next]);
    return prev;
  }, {});

  return {
    plugins: [
      new webpack.DefinePlugin(envKeys)
    ]
  };

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

Frontend React Webpack

Как передать компонент в качестве пропса в React

2 года назад·4 мин. на чтение

Существует множество способов передать компонент в качестве пропса

Существует множество способов передать компонент в качестве пропса, например, специальный проп children, и паттерн render prop. О них вы можете узнать в видео “Паттерн Render Props в ReactJS”. В случае с render props мы передаем функцию, которая возвращает компонент. В этой статье рассмотрим как передать просто компонент в качестве пропса. В этой статье мы увидим простую технику, которая позволяет писать удобные настраиваемые компоненты с помощью простых API, просто используя основные строительные блоки React - компоненты. Опытный React разработчик использует эту технику естественным образом, но новичку сложно понять этот механизм.

Переизбыток пропсов

Иногда в компонент приходится передавать огромное количество пропсов для того чтобы настроить более мелкие вложенные компоненты, из которых состоит ваш компонент. Возникает переизбыток пропсов. Давайте посмотрим на это на примере. Предположим, есть компонент Alert с Button внутри.

const Button = ({ onClick, children }) => <button onClick={onClick}>{children}</button>;

const Alert = ({ children, onAccept }) => (
  <div className="alert">
    <div className="alert-header">
      <h1>Alert!</h1>
    </div>
    <div className="alert-content">{children}</div>
    <div className="alert-footer">
      <Button onClick={onAccept}>Ok</Button>
    </div>
  </div>
);

<Alert onAccept={() => {}}>Attention!</Alert>

Что вы можете сделать, чтобы настроить внутренний Button? Если вы новичок в React вы, вероятно, думаете, что правильный способ - это передать проп.

const Alert = ({ children, acceptMessage = "Ok", onAccept }) => (
  <div className="alert">
    <div className="alert-header">
      <h1>Alert!</h1>
    </div>
    <div className="alert-content">{children}</div>
    <div className="alert-footer">
      <Button onClick={onAccept}>{acceptMessage}</Button>
    </div>
  </div>
);


<Alert acceptMessage="Understood!" onAccept={() => {}}>
  Attention!
</Alert>

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

const Confirm = ({ children, acceptMessage = "Ok", rejectMessage = "Cancel", onAccept, onReject }) => (
  <div className="confirm">
    <div className="confirm-header">
      <h1>Confirm</h1>
    </div>
    <div className="confirm-content">{children}</div>
    <div className="confirm-footer">
      <Button onClick={onAccept}>{acceptMessage}</Button>
      <Button onClick={onReject}>{rejectMessage}</Button>
    </div>
  </div>
);


<Confirm acceptMessage="Yep" rejectMessage="Nope" onAccept={() => {}} onReject={() => {}}>
  You sure?
</Confirm>

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

Улучшение. Вложенные пропсы

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

const Confirm = ({
  children,
  onAccept,
  onReject,
  acceptButton = {
    message: "Ok",
    className: "accept-btn",
  },
  rejectButton = {
    message: "Cancel",
    className: "cancel-btn",
  },
}) => (
  <div className="confirm">
    <div className="confirm-header">
      <h1>Confirm</h1>
    </div>
    <div className="confirm-content">{children}</div>
    <div className="confirm-footer">
      <Button className={acceptButton.className} onClick={onAccept}>
        {acceptButton.message}
      </Button>
      <Button className={rejectButton.className} onClick={onReject}>
        {rejectButton.message}
      </Button>
    </div>
  </div>
);

<Confirm
  acceptButton={{ message: "Yep", className: "accept-btn" }}
  rejectButton={{ message: "Nope", className: "reject-btn" }}
  onAccept={() => {}}
  onReject={() => {}}
>
  You sure?
</Confirm>

Это исправляет конфликты, но все становится сложнее. Что произойдет, если я захочу переопределить только один вложенный проп? Чтобы сделать это, нам нужно вручную объединить пропсы со значениями по умолчанию. И что произойдет, если Button также содержит Icon? Следует ли использовать пару новых пропсов (acceptButtonIcon, rejectButtonIcon)? Должны ли вы вкладывать их в существующие пропсы (acceptButton.icon)? Типы или prop types будет очень сложно читать.

Другой подход. Render props

Render props это один из способов сделать ваши компоненты действительно настраиваемыми, вместо того, чтобы добавлять массу пропсов. Давайте попробуем. Напишем три разные версии компонента Confirm, который принимает рендер пропсы.

Версия 1. По одному рендер пропсу для каждой кнопки

В первой версии в компоненте Confirm добавим по одному рендер пропсу для каждой кнопки:

const Confirm = ({
  children,
  onAccept,
  onReject,
  renderAcceptButton = onAccept => (
    <Button className="accept-btn" onClick={onAccept}>
      OK
    </Button>
  ),
  renderRejectButton = onReject => (
    <Button className="reject-btn" onClick={onReject}>
      Cancel
    </Button>
  ),
}) => (
  <div className="confirm">
    <div className="confirm-header">
      <h1>Confirm</h1>
    </div>
    <div className="confirm-content">{children}</div>
    <div className="confirm-footer">
      {renderAcceptButton(onAccept)}
      {renderRejectButton(onReject)}
    </div>
  </div>
);

<Confirm
  renderAcceptButton={onAccept => (
    <Button className="accept-btn" onClick={onAccept}>
      Yep
    </Button>
  )}
  renderRejectButton={onReject => (
    <Button className="cancel-btn" onClick={onReject}>
      Nope
    </Button>
  )}
>
  You sure?
</Confirm>

Версия 2. Один рендер проп для всех кнопок

Вторая версия - это один рендер проп для всех кнопок.

const Confirm = ({
  children,
  onAccept,
  onReject,
  renderButtons = (onAccept, onReject) => (
    <>
      <Button className="accept-btn" onClick={onAccept}>
        OK
      </Button>
      <Button className="reject-btn" onClick={onReject}>
        Cancel
      </Button>
    </>
  ),
}) => (
  <div className="confirm">
    <div className="confirm-header">
      <h1>Confirm</h1>
    </div>
    <div className="confirm-content">{children}</div>
    <div className="confirm-footer">{renderButtons(onAccept, onReject)}</div>
  </div>
);

<Confirm
  renderButtons={(onAccept, onReject) => (
    <>
      <Button className="accept-btn" onClick={onAccept}>
        Yep
      </Button>
      <Button className="cancel-btn" onClick={onReject}>
        Nope
      </Button>
    </>
  )}
>
  You sure?
</Confirm>

Версия 3. Один рендер проп для всех подкомпонентов

И, наконец, рендер проп для всего компонента:

const Confirm = ({
  children,
  onAccept,
  onReject,
  render = (onAccept, onReject, children) => (
    <div className="confirm">
      <div className="confirm-header">
        <h1>Confirm</h1>
      </div>
      <div className="confirm-content">{children}</div>
      <div className="confirm-footer">
        <Button className="accept-btn" onClick={onAccept}>
          OK
        </Button>
        <Button className="reject-btn" onClick={onReject}>
          Cancel
        </Button>
      </div>
    </div>
  ),
}) => render(onAccept, onReject, children);

<Confirm
  render={() => {
    // компонент, который появится внутри `Confirm`
  }}
>
 You sure?
</Confirm>

Последний вариант своего рода крайность. Рендер пропсы настолько мощный, насколько это возможно, но он также имеет свои нюансы. Они позволяют изменить способ рендеринга компонента, но повторно использовать «значения по умолчанию» непросто. Это зависит от того, что визуализирует ваш рендер проп. В предыдущих примерах мы видели три варианта, каждый из которых обеспечивает большую гибкость, но меньшую возможность повторного использования «значений по умолчанию». Однако этот подход может показаться излишним, когда мы просто хотим настроить текст кнопок Alert/Confirm.

Просто передать компонент

const Confirm = ({
  children,
  onAccept,
  onReject,
  acceptButton = <Button>Ok</Button>,
  rejectButton = <Button>Cancel</Button>,
}) => (
  <div className="confirm">
    <div className="confirm-header">
      <h1>Confirm</h1>
    </div>
    <div className="confirm-content">{children}</div>
    <div className="confirm-footer">
      {React.cloneElement(acceptButton, { className: "accept-btn", onClick: onAccept })}
      {React.cloneElement(rejectButton, { className: "reject-btn", onClick: onReject })}
    </div>
  </div>
);

<Confirm
  acceptButton={<Button>Yep</Button>}
  rejectButton={<Button>Nope</Button>}
  onAccept={() => {}}
  onReject={() => {}}
>
  You sure?
</Confirm>

Этот API гораздо более естественен. Это один из тех случаев, когда cloneElement является правильным инструментом. Если вам интересно, почему мы всегда передаем обработчики, когда в некоторых случаях имеет смысл просто использовать их напрямую, вы правы. В данном случае это не обязательно.

<Confirm
  acceptButton={<Button onAccept={() => {}}>Yep</Button>}
  rejectButton={<Button onReject={() => {}}>Nope</Button>}
>
  You sure?
</Confirm>

Frontend React