Перейти к содержимому

Как подключить api к react

  • автор:

Как упростить работу с API в React-приложениях

Привет! Меня зовут Владислав Панов, я фронтенд-разработчик в KODE. Два с половиной года назад, когда мы выбирали стек для проектов, чтобы хранить все пользовательские данные, решили использовать Redux. Он до сих пор хорошо справляется с управлением состоянием, связанным с клиентской логикой и UI, но при хранении статусов, ошибок и прочей информации о результатах выполнения запросов появляется много бойлерплейта.

Несмотря на появление Redux Toolkit от авторов Redux, который сильно упрощает жизнь, мы к нему так и не вернулись. Почему? Рассказываю в статье.

В чём заключается проблема

При использовании Redux наша архитектура становилась всё более громоздкой из-за бойлерплейта, дополнительное время уходило на ручной ввод схожего по функционалу кода. Нам приходилось вручную добавлять типизацию и информацию о запросах из Swagger’а или клиентских требований. При ручном вводе всегда высока вероятность появления ошибок из-за человеческого фактора или желания внедрить новый подход на существующей кодовой базе. Дошло до того, что на некоторых проектах вырос технический долг, возврат которого может затянуться в лучшем случае на месяцы.

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

Наш путь и выбор вариантов улучшения стека

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

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

В качестве основного инструмента для кодогенерации мы выбрали openapi-generator от OpenAPI Tools. Его просто использовать и можно гибко настраивать. Ключевая особенность — широкий выбор «шаблонов», которые позволяют создать код для множества языков и используемых в них библиотек, например:

  • javascript-flowtyped ,
  • typescript-fetch ,
  • typescript-axios .

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

Сейчас существует множество таких вариантов. Команда Redux предлагает набор инструментов Redux Toolkit с RTK Query, которые избавляют от кучи шаблонного кода. При этом всё ещё придётся, пусть в меньшем количестве, но создавать reducer’ы, middleware, а нам хотелось отойти от этого. Другой способ — useSWR, который не зависит ни от какого стейт-менеджера и целиком использует хуки для вызова запроса.

Наш выбор пал на библиотеку React Query, которая также применяет хуки для работы с API. И вот почему:

  • Гибкость в настройке и больший функционал по сравнению с useSWR, RTK Query.
  • Собственные удобные Devtools.
  • Удобство работы с бесконечными списками, пагинацией прямиком из коробки.

Таким образом у OpenAPI Generator и React Query свои зоны ответственности: OpenAPI Generator помогает нам с типизацией и избавляет от ручного написания кода для вызова запросов, а React Query — за кэширование, работу с запросами, их инвалидацию и не только. Забегая вперёд, скажу, что сейчас использование этих инструментов стало стандартом на всех наших проектах.

Переход от старых инструментов к новым

Поскольку мы перешли на новую библиотеку, нам нужно было перестроить своё мышление и писать по-другому. У инструментов, которые мы выбрали, есть свои особенности.

Из всех шаблонов для кодогенерации мы остановились на typescript-axios по двум причинам:

  • Типизация — это круто, так как мы можем всегда посмотреть в коде актуальную информацию об ответах на запросы.
  • Axios — мощная обёртка при работе с запросами, которая позволяет использовать интерсепторы (interceptors) для перехвата некоторых запросов и специальный конфиг, генерируемый шаблоном, который позволяет удобным образом проставлять заголовки, основной адрес запросов и подставлять токены или API-ключи в зависимости от параметра securitySchemes в OpenAPI-спецификации.

В отличие от Redux и связанных с ней подходов у React Query есть ряд особенностей:

  • React Query использует хуки, потому на место компонентов высшего порядка (HOC) приходят обычные функциональные компоненты.
  • По умолчанию данные отделены от любого из хранилищ ( localStorage , sessionStorage ) и остаются только в рантайме. При желании их можно удобным образом персистить в любом из удобных клиентских хранилищ.

Одним из популярных подходов по разделению ответственности является создание «умных» и «глупых» компонентов. «Глупый» компонент содержит только вёрстку и принимает значения, на основе которых понимает, что и как рендерить. «Умный» — управляет состоянием, содержит в себе необходимую бизнес-логику и передаёт форматированные данные в виде пропсов в «глупый» компонент.

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

Настраиваем кодогенерацию

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

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

Создав приложение через CRA или Vite, настроим кодогенерацию. Для этого нам необходимо установить библиотеку openapi-generator-cli :

npm install @openapitools/openapi-generator-cli -D
yarn add -D @openapitools/openapi-generator-cli

Данный CLI является nodejs-обёрткой для работы с генератором, изначально написанным на Java. Потому нам потребуется ещё установить Java (не меньше 8-й версии). Если её нет, скачайте с официального сайта.

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

Сама генерация запускается максимально просто, одной командой:

yarn openapi-generator-cli generate

После её выполнения у нас подтягивается схема от бэка по адресу в inputSpec и создаётся папка src/shared/api/axios-client , в которой будут сгенерированы типы моделей и созданы классы для вызова запросов.

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

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

const petApi = new PetApi()

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

Здесь нам и поможет React Query. Прежде чем начать работу, нужно обернуть приложение в QueryClientProvider и передать в него экземпляр queryClient . Именно queryClient будет отвечать за хранение полученных данных и позволит вручную изменять их или помечать как неактуальные.

import < QueryClient, QueryClientProvider >from '@tanstack/react-query'; import < App >from './app'; const queryClient = new QueryClient(); export const AppConnector = () => < return ( >  ); >;

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

import < PetStatusEnum >from '@shared/api/axios-client'; import < petApi >from '@shared/api/user-client'; import < useQuery >from '@tanstack/react-query'; export const useGetPetsByStatus = (status: PetStatusEnum) => < const query = useQuery(['pets'], () =>petApi.findPetsByStatus(< status >)); return query; >;

Данный хук мы будем импортировать в коннекторе, чтобы передать данные в UI. Результат получается весьма минималистичным и простым. Ранее написанный useGetPetsByStatus получает данные и статус по запросу, а getPetListData преобразовывает данные в удобный формат для «глупых» UI-компонентов.

import < useState >from 'react'; import < useQueryClient >from '@tanstack/react-query'; import < getPetListData, useGetPetsByStatus, >from '@entities/pet'; export const PetListWidgetConnector = () => < const < data, isLoading, isError >= useGetPetsByStatus('available'); const items = getPetListData(data?.data) ?? []; return ( isLoading= hasError= onClick= /> ); >;

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

Именно для этих целей используется хук useMutation (документация). На первый взгляд он может показаться аналогичным useQuery , но одной из его особенностей является возможность указывать колбэки, связанные с жизненным циклом мутации. Мы можем указать onError или onSuccess , чтобы показывать различные уведомления при успешном или провальном запросе.

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

import < useMutation >from '@tanstack/react-query'; import < petApi >from '@shared/api/user-client'; export const useDeletePet = () => < const queryClient = useQueryClient(); const mutation = useMutation((petId: number) =>petApi.deletePet(< petId >), < onSettled: () =>< queryClient.invalidateQueries(['pets']); >, >); return mutation; >;

Затем внутри коннектора вызовем хук, чтобы получить из него mutateAsync и вызывать запрос при нажатии на кнопку:

import < useState >from 'react'; import < useQueryClient >from '@tanstack/react-query'; import < PetList, PET_QUERY_KEYS >from '@entities/pet'; import < PetDetailsModal, useDeletePet, >from '@features/pet-details-modal'; export const PetListWidgetConnector = () => < … const queryClient = useQueryClient(); const < mutateAsync, isLoading: isFetchingDeletion >= useDeletePet(); const onDeletePet = () => < if (selectedPetId) < mutateAsync(selectedPetId); >>; … return ( <> petDetails= onClose= onDeletePet= isFetchingDeletion= />  ); >;

С кодом проекта можно ознакомиться на Гитхабе. А сам пример проекта — посмотреть по ссылке.

Наш опыт использования

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

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

Используя данные решения, мы столкнулись со следующими сложностями и нюансами:

  • Из-за React Query получается сильная привязка к UI, в который может выноситься часть логики.
  • Из-за сильной привязки к UI тяжелее тестировать логику, потому что она может быть разделена между несколькими компонентами.
  • Редактируя вручную спецификацию, опечатки или неправильные отступы можно сломать всю кодгенерацию. Потому важно использовать линтеры спецификаций вроде Spectral.

Но даже несмотря на всё это, используя кодгенерацию и React Query, нам удалось достигнуть нескольких улучшений в процессе разработки:

  • У нас появился единый источник правды по запросам и упростилось общение с бэком.
  • Мы стали меньше времени тратить на типизацию и создание обёрток для работы с запросами.
  • Образовался единый подход по работе с API.
  • Возникло чёткое отделение всего сетевого слоя приложения.

Применение в React REST API с помощью Fetch и Axios

Если вы являетесь React-разработчиком и хотите узнать, как начать использовать API в своих React-приложениях, то эта статья для вас. Мы объясним, что такое REST API и как можно создать простое приложение, которое использует REST API с помощью Fetch API и Axios.

Применить REST API в React-приложениях можно различными способами, но в этом руководстве мы рассмотрим, то, как можно применить REST API, используя два наиболее популярных метода, известных как Axios (HTTP-клиент на основе промисов) и Fetch API (встроенный в браузер веб-API). Мы подробно рассмотрим и реализуем каждый из этих методов и объясним некоторые интересные функции, которые может предложить каждый из этих методов.

API — это то, что мы можем использовать, чтобы загрузить React-приложения данными. Есть определенные операции, которые нельзя выполнить на стороне клиента, поэтому эти операции выполняются на стороне сервера. Затем мы можем использовать API-интерфейсы для использования данных на стороне клиента.

API состоят из набора данных, которые часто представлены в формате JSON с указанными конечными точками. Когда мы получаем доступ к данным из API, мы хотим получить доступ к определенным конечным точкам в этой структуре API. Также можно сказать, что API — это соглашение между двумя службами в форме запроса и ответа. Код является побочным продуктом. Он также содержит условия обмена данными.

В React доступны различные способы использования REST API в приложениях, в том числе использование встроенного JavaScript- метода fetch() и Axios, который является HTTP-клиентом на основе промисов для браузера и Node.js.

Примечание. Хорошее знание ReactJS, React Hooks, JavaScript и CSS пригодится вам, когда вы будете изучать это руководство.

Давайте начнем с изучения дополнительных сведений о REST API.

Что такое REST API

REST API — это API, который структурирован в соответствии с REST структурой для API. REST означает «передача состояния представления». Он состоит из различных правил, которым следуют разработчики при создании API.

Преимущества REST API

  1. Прост в освоении и понимании;
  2. Предоставляет разработчикам возможность организовывать сложные приложения в простые ресурсы;
  3. Внешним клиентам можно построить REST API без каких-либо сложностей;
  4. Очень легко масштабируется;
  5. REST API не зависит от языка или платформы, то есть может использоваться на любом языке или работать на любой платформе.

Пример ответа REST API

То, как структурирован REST API, зависит от продукта, для которого он был создан, но при этом должны соблюдаться правила REST.

Ниже приведен пример ответа из Github Open API . Мы будем использовать этот API в этом руководстве для создания React- приложения (чуть позже).

< "login": "hacktivist123", "id": 26572907, "node_id": "MDQ6VXNlcjI2NTcyOTA3", "avatar_url": "https://avatars3.githubusercontent.com/u/26572907?v=4", "gravatar_id": "", "url": "https://api.github.com/users/hacktivist123", "html_url": "https://github.com/hacktivist123", "followers_url": "https://api.github.com/users/hacktivist123/followers", "following_url": "https://api.github.com/users/hacktivist123/following", "gists_url": "https://api.github.com/users/hacktivist123/gists", "starred_url": "https://api.github.com/users/hacktivist123/starred", "subscriptions_url": "https://api.github.com/users/hacktivist123/subscriptions", "organizations_url": "https://api.github.com/users/hacktivist123/orgs", "repos_url": "https://api.github.com/users/hacktivist123/repos", "events_url": "https://api.github.com/users/hacktivist123/events", "received_events_url": "https://api.github.com/users/hacktivist123/received_events", "type": "User", "site_admin": false, "name": "Shedrack akintayo", "company": null, "blog": "https://sheddy.xyz", "location": "Lagos, Nigeria ", "email": null, "hireable": true, "bio": "☕ Software Engineer | | Developer Advocate|| ❤ Everything JavaScript", "public_repos": 68, "public_gists": 1, "followers": 130, "following": 246, "created_at": "2017-03-21T12:55:48Z", "updated_at": "2020-05-11T13:02:57Z" >

Ответ, приведенный выше, взят из REST API Github, когда я выполняю GET-запрос к следующей конечной точке https://api.github.com/users/hacktivist123. Он возвращает все сохраненные данные о пользователе с именем hacktivist123 . С помощью этого ответа можно решить, каким образом мы будем отображать его в React- приложении.

Применение API с помощью Fetch API

API fetch() является встроенным методом JavaScript, предназначенным для получения ресурсов от сервера или конечной точки API. Он похож на XMLHttpRequest , но fetch API предоставляет более мощный и гибкий набор функций.

Он определяет такие понятия, как CORS и семантика заголовка HTTP Origin , перенося их отдельные определения в другие места.

Метод fetch() API всегда принимает обязательный аргумент, представляющий собой путь или URL-адрес ресурса, который вы хотите получить. Он возвращает промис, который указывает на ответ от запроса, независимо от того, был ли запрос успешным или нет. При желании вы также можете передать объект параметров инициализации в качестве второго аргумента.

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

Разница между Fetch API и jQuery Ajax

Fetch API отличается от jQuery Ajax тремя основными моментами:

  1. Промис, возвращаемый из запроса fetch(), не будет отклонен при возникновении ошибки HTTP, независимо от характера статуса ответа. Вместо этого запрос будет обрабатываться в обычном режиме, если код состояния ответа представляет собой код типа 400 или 500, устанавливается статус «Ok». Запрос будет отклонен только из-за сбоя в сети или если что-то мешает его завершению.
  2. fetch()не разрешает использование межсайтовых файлов cookie, то есть вы не сможете проводить межсайтовый сеанс с использованием fetch().
  3. fetch() также по умолчанию не отправляет куки, если вы не указали для параметра init значение credentials.

Параметры для Fetch API

  • resource
    Путь к ресурсу, который вы хотите получить, это может быть либо прямая ссылка на путь к ресурсу, либо объект запроса.
  • init
    Объект, содержащий любые пользовательские настройки или учетные данные, которые вы хотите предоставить для запроса fetch(). Ниже приведены некоторые из возможных параметров, которые могут содержаться в объекте init:
    • method
      для указания метода HTTP-запроса, например, GET, POST и т. д.
    • headers
      для указания любых заголовков, которые вы хотели бы добавить к запросу, обычно содержится в объекте или литерале объекта.
    • body
      для определения тела, которое вы хотите добавить к запросу: это может быть объект Blob, BufferSource, FormData, URLSearchParams, USVString, или
    • mode
      для задания режима, который необходимо использовать для запроса, например, cors, no-cors или same-origin.
    • credentials
      необходим для указания учетных данных запроса, которые вы хотите использовать для запроса, этот параметр должен быть предоставлен, если вы используете автоматическую отправку файлов cookie для текущего домена.

    Базовый синтаксис для использования Fetch API

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

    fetch('https://api.github.com/users/hacktivist123/repos') .then(response => response.json()) .then(data => console.log(data));

    В приведенном выше коде мы извлекаем данные из URL-адреса, который возвращает данные в формате JSON, а затем выводим их в консоль. Простейшая форма использования fetch() часто принимает только один аргумент — путь к ресурсу, который вы хотите получить, и затем возвращает промис, содержащий ответ на запрос на выборку. Этот ответ является объектом.

    Ответ — это обычный HTTP-ответ, а не фактический JSON. Другими словами, чтобы получить содержимое тела JSON из ответа, нам нужно изменить ответ на фактический JSON, используя в ответе метод json().

    Использование Fetch API в приложениях React

    Использование Fetch API в React-приложениях — это стандартный способ, которым мы использовали бы Fetch API в JavaScript, синтаксис не изменится. Единственная проблема — решить, где выполнить запрос на выборку в React- приложении. Большинство запросов на выборку или HTTP-запросы любого рода обычно выполняются в React Component.

    Запрос может быть выполнен либо внутри метода жизненного цикла , если компонент является компонентом класса, либо внутри хука React useEffect(), если компонент является функциональным компонентом.

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

    import React from 'react'; class myComponent extends React.Component < componentDidMount() < const apiUrl = 'https://api.github.com/users/hacktivist123/repos'; fetch(apiUrl) .then((response) =>response.json()) .then((data) => console.log('This is your data', data)); > render() < return 

    my Component has Mounted, Check the browser 'console'

    ; > > export default myComponent;

    В приведенном выше коде мы создаем очень простой компонент класса, который после завершения монтирования компонента React выполняет запрос на выборку, выводящий окончательные данные из запроса на выборку по URL-адресу API в консоль браузера.

    Метод fetch() принимает путь к ресурсу, который мы хотим извлечь, он присваивается переменной с именем apiUrl. После завершения запроса на выборку возвращается промис, содержащий объект ответа. Затем мы извлекаем из ответа содержимое тела JSON, используя метод json(), и, наконец, выводим окончательные данные из промиса в консоль.

    Давайте применим REST API с помощью метода Fetch

    В этом разделе мы создадим простое React- приложение, которое использует внешний API, при этом мы будем применять метод Fetch для использования API.

    Простое приложение будет отображать все репозитории, которые принадлежат конкретному пользователю, и их описание. В этом руководстве я буду использовать свое имя пользователя GitHub, вы также можете использовать свое, если захотите.

    Первое, что нам нужно сделать, это сгенерировать React-приложение с помощью create-react-app:

    npx create-react-app myRepos

    Эта команда загрузит новое React-приложение. Когда новое приложение будет создано, остается только запустить приведенную ниже команду и начать создание кода:

    npm start

    Если все было сделано правильно, мы должны увидеть это в окне браузера, когда перейдем по адресу localhost:3000 после выполнения приведенной выше команды.

    Давайте применим REST API с помощью метода Fetch

    В папке src создайте новую папку с именем component. Эта папка будет содержать все компоненты React. В новой папке создайте два файла с именами List.js и withListLoading.js . Эти два файла будут содержать компоненты, которые будут необходимы в нашем приложении.

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

    Давайте вставим приведенный ниже код в файл List.js, который мы создали внутри папки components:

      Available Public Repositories

      < return ( className='list'>); >)>

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

    Теперь позвольте мне объяснить код по частям.

    const < repos >= props;

    Мы инициализируем свойство для компонента, который называется repos.

    if (repos.length === 0 || !repos) return 

    No repos, sorry

    ;

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

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

    export default List;

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

    В файл withListLoading.js, который мы создали в папке components, давайте вставим следующий код:

    import React from 'react'; function WithListLoading(Component) < return function WihLoadingComponent(< isLoading, . props >) < if (!isLoading) return />; return ( 

    >> Hold on, fetching data may take some time :)

    ); >; > export default WithListLoading;

    Приведенный выше код является компонентом React высшего порядка, который принимает другой компонент, а затем возвращает некоторую логику. В данном случае наш компонент высшего порядка будет ожидать проверки, является ли текущее состояние isLoadingкомпонента, который он принимает, true или false. Если текущее состояние isLoadingравно true, в нем будет отображаться сообщение Hold on, fetching data may take some time �� . Сразу же после изменения состояния isLoading на false он отобразит компонент, который принял. В нашем случае это компонент List .

    Давайте вставим приведенный ниже код в файл App.js, доступный внутри папки src .

    import React, < useEffect, useState >from 'react'; import './App.css'; import List from './components/List'; import withListLoading from './components/withListLoading'; function App() < const ListLoading = withListLoading(List); const [appState, setAppState] = useState(< loading: false, repos: null, >); useEffect(() => < setAppState(< loading: true >); const apiUrl = `https://api.github.com/users/hacktivist123/repos`; fetch(apiUrl) .then((res) => res.json()) .then((repos) => < setAppState(< loading: false, repos: repos >); >); >, [setAppState]); return ( 

    My Repositories

    repos= />
    Built with by Shedrack Akintayo
    ); > export default App;

    Файл App.js является функциональным компонентом, который использует React Hooks для обработки состояния, а также побочных эффектов.

    Позвольте мне объяснить приведенный выше код.

    import React, < useEffect, useState >from 'react'; import './App.css'; import List from './components/List'; import withListLoading from './components/withListLoading';

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

    const ListLoading = withListLoading(List); const [appState, setAppState] = useState(< loading: false, repos: null, >);

    Здесь мы создаем новый компонент с именем ListLoading и назначаем withListLoadingкомпонентом высшего порядка, обернутым вокруг компонента списка. Затем мы создаем значения состояния loading и repos и используем React Hook useState().

    useEffect(() => < setAppState(< loading: true >); const user = `https://api.github.com/users/hacktivist123/repos`; fetch(user) .then((res) => res.json()) .then((repos) => < setAppState(< loading: false, repos: repos >); >); >, [setAppState]);

    Здесь мы инициализируем React Hook useEffect(). В хуке useEffect() мы устанавливаем для начального состояния загрузки значение true, пока это так, наш компонент более высокого порядка будет отображать сообщение. Затем мы создаем глобальную переменную с именем user и назначаем ей URL API, из которого будем получать данные репозиториев.

    Затем мы выполняем базовый запрос fetch(), как мы уже рассмотрели выше, а затем, после того как запрос выполнен, мы устанавливаем для состояния загрузки приложения значение false и заполняем состояние репозитория данными, которые получили из запроса.

    return ( 

    My Repositories

    repos= />
    ); > export default App;

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

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

    Давайте применим REST API с помощью метода Fetch - 2

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

    Теперь давайте немного стилизуем наш проект. Скопируйте и вставьте приведенный ниже код в файл App.css .

    @import url(‘https://fonts.googleapis.com/css2?family=Amiri&display=swap’); :root < --basic-color: #23cc71; >.App < box-sizing: border-box; display: flex; justify-content: center; align-items: center; flex-direction: column; font-family: 'Amiri', serif; overflow: hidden; >.container < display: flex; flex-direction: row; >.container h1 < font-size: 60px; text-align: center; color: var(--basic-color); >.repo-container < width: 50%; height: 700px; margin: 50px; box-shadow: 0 2px 10px rgba(0, 0, 0, 0.3); overflow: scroll; >@media screen and (max-width: 600px) < .repo-container < width: 100%; margin: 0; box-shadow: none; >> .repo-text < font-weight: 600; >.repo-description < font-weight: 600; font-style: bold; color: var(--basic-color); >.list-head < text-align: center; font-weight: 800; text-transform: uppercase; >.footer < font-size: 15px; font-weight: 600; >.list

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

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

    Теперь приложение выглядит намного лучше.

    Вот как мы можем использовать Fetch API для применения REST API. В следующем разделе мы рассмотрим Axios и то, как мы можем использовать его для применения того же API в том же приложении.

    Применение API с помощью Axios

    Axios — это простой в использовании HTTP-клиент для браузера и node.js на основе промисов. Поскольку Axios основан на промисах, мы можем воспользоваться асинхронностью и ожидать более читабельного и асинхронного кода. С помощью Axios мы получаем возможность перехватывать и отменять запросы, а также у нас появится встроенная функция, которая обеспечивает защиту от подделки межсайтовых запросов на стороне клиента.

    Функции Axios

    • Перехват запросов и ответов.
    • Упрощенная обработка ошибок.
    • Защита от
    • Поддержка процесса загрузки.
    • Задержка ответа.
    • Возможность отмены запросов.
    • Поддержка устаревших браузеров.
    • Автоматическое преобразование данных JSON.

    Выполнение запросов с помощью Axios

    Выполнить HTTP-запросы с помощью Axios довольно просто. Приведенный ниже код демонстрирует выполнение HTTP-запроса.

    // Выполняем GET-запрос axios(< method: 'get', url: 'https://api.github.com/users/hacktivist123', >); // Выполняем Post-запрос axios( < method: 'post', url: '/login', data: < firstName: 'shedrack', lastName: 'akintayo' >>);

    Приведенный выше код демонстрирует основные способы выполнения HTTP-запросов GET и POST с помощью Axios.

    Axios также предоставляет набор сокращенных методов для выполнения различных HTTP-запросов:

    • request(config);
    • get(url[, config]);
    • delete(url[, config]);
    • head(url[, config]);
    • options(url[, config]);
    • post(url[, data[, config]]);
    • put(url[, data[, config]]);
    • patch(url[, data[, config]]).

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

    // Выполняем GET-запрос с помощью сокращенного метода axios.get('https://api.github.com/users/hacktivist123'); // Выполняем Post-запрос с помощью сокращенного метода axios.post('/signup', < firstName: 'shedrack', lastName: 'akintayo' >);

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

    Выполнение нескольких запросов с помощью Axios

    Axios предоставляет разработчикам возможность создавать и обрабатывать одновременные HTTP-запросы с использованием метода axios.all(). Этот метод принимает массив аргументов и возвращает один объект промиса, который разрешается только после разрешения всех аргументов, переданных в массиве.

    Например, мы можем выполнить несколько запросов к API GitHub, используя метод axios.all(), приведенный ниже:

    axios.all([ axios.get('https://api.github.com/users/hacktivist123'), axios.get('https://api.github.com/users/adenekan41') ]) .then(response => < console.log('Date created: ', response[0].data.created_at); console.log('Date created: ', response[1].data.created_at); >);

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

    Давайте применим REST API с клиентом Axios

    В этом разделе мы заменим в нашем существующем React-приложении метод fetch() на Axios. Все, что нам нужно сделать, это установить Axios, а затем использовать его в файле App.js для отправки HTTP-запроса к API GitHub.

    Теперь давайте установим Axios в нашем React-приложении, выполнив одно из следующих действий:

    npm install axios
    yarn add axios

    После завершения установки мы должны будет импортировать axios в App.js. В файле App.js мы добавим в самое начало следующую строку:

    import axios from 'axios'

    После добавления этой строки кода в файл App.js все, что нам нужно будет сделать, это внутри useEffect() прописать следующий код:

    useEffect(() => < setAppState(< loading: true >); const apiUrl = 'https://api.github.com/users/hacktivist123/repos'; axios.get(apiUrl).then((repos) => < const allRepos = repos.data; setAppState(< loading: false, repos: allRepos >); >); >, [setAppState]);

    Возможно, вы заметили, что теперь мы заменили fetch API на сокращенный метод Axios axios.get, чтобы выполнить get-запрос к API.

    axios.get(apiUrl).then((repos) => < const allRepos = repos.data; setAppState(< loading: false, repos: allRepos >); >);

    В этом блоке кода мы выполняем запрос GET, затем возвращаем промис, содержащий данные репозиториев, и присваиваем данные глобальной переменной с именем allRepos. Затем мы устанавливаем для текущего состояния загрузки значение false и также передаем данные из запроса в переменную состояния repos.

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

    Давайте применим REST API с клиентом Axios

    Вот как мы можем использовать клиент Axios для применения REST API.

    Fetch или Axios

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

    1. Базовый синтаксис
      Fetch и Axios имеют очень простые синтаксисы для выполнения запросов. Но Axios имеет преимущество, потому что он автоматически конвертирует ответ в JSON, поэтому при использовании Axios мы пропускаем этап преобразования ответа в JSON, в отличие от Fetch(). Наконец, сокращенные методы Axios позволяют упростить определенные HTTP-запросы.
    2. Совместимость с браузерами
      Одна из многих причин, по которой разработчики предпочитают Axios, а не Fetch, заключается в том, что Axios поддерживается во всех основных браузерах и их версиях, в отличие от Fetch, который поддерживается только в Chrome 42+, Firefox 39+, Edge 14+ и Safari 10.1+.
    3. Обработка времени ожидания ответа
      Задать время ожидания ответов в Axios очень просто, для этого нужно задать параметр timeout внутри объекта запроса. Но в Fetch это сложнее сделать. Fetch предоставляет аналогичную функцию с помощью интерфейса AbortController(), но его реализация требует большего количества времени и может привести к путанице.
    4. Перехват HTTP-запросов
      Axios позволяет разработчикам перехватывать HTTP-запросы. HTTP-перехватчики необходимы, когда нам нужно изменить HTTP-запросы от приложения к серверу. Перехватчики дают нам возможность делать это без необходимости писать дополнительный код.
    5. Одновременное выполнение нескольких запросов
      Axios позволяет выполнять несколько HTTP-запросов с использованием метода all()(мы рассказали об этом выше). fetch() предоставляет ту же функцию с использованием метода promise.all(), мы можем выполнить несколько fetch() запросов.

    Заключение

    И Axios, и fetch() — это отличные способы применения API, но я советую использовать fetch() при создании относительно небольших приложений и Axios при создании больших приложений по причинам масштабируемости. Надеюсь, вам понравилось работать с этим руководством, вы всегда можете прочитать больше о применении REST API с помощью Fetch или Axios в источниках по ссылкам ниже. Если у вас есть какие-либо вопросы, вы можете задать их в комментариях к этой статье.

    • Репозиторий для этой статьи доступен на Github .

    Дополнительные ресурсы

    • « Структура REST API »
    • « CORS »
    • « HTTP-заголовки »
    • « Fetch API »,

    Подключение API с JavaScript на react-app

    У меня есть проект на create-react-app. Есть несколько страниц которые находятся в папке /src/components/ . На странице Donate.jsx нужно использовать API(виджет) от trademc(хочу сделать донат для игрового сервера).

     TrademcAPI.GetBuyForm(< Shop: "186970", Title: "Поддержать наш сервер!", Nickname: "Введите ваш никнейм", Item: "Выберите товар", Coupon: "Введите купон, если есть", Button: "Продолжить", Success_URL: "https://trademc.org", Pending_URL: "https://trademc.org", Fail_URL: "https://trademc.org", PastPlaceID: "trademc-buyform", >); 

    Незнаю как подключить JavaScript на эту страницу, вставить не работает. Пробовал подключить через /public/index.html , работает только тогда когда обновляешь страницу /donate в браузере. А так оно ищет на главной странице и когда переходишь на другую страницу оно не ищет этот div.

             SoupMine     

    Работает только после перезагрузки страницы в браузере

    Пробовал так, но не работает. Пустота даже Navbar не видно. (без /* global GetBuyForm / говорит no undef. ): / global GetBuyForm */

    function Donate() < GetBuyForm(< Shop: "186970", Title: "Поддержать наш сервер!", Nickname: "Введите ваш никнейм", Item: "Выберите товар", Coupon: "Введите купон, если есть", Button: "Продолжить", Success_URL: "https://trademc.org", Pending_URL: "https://trademc.org", Fail_URL: "https://trademc.org", PastPlaceID: "trademc-buyform", >); return export default Donate; 

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

    Руководство: Использование connect API

    На данный момент мы рекомендуем использовать React-Redux хуки. Как бы то ни было, connect по-прежнему работает.

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

    Мы работаем над новым вводным туториалом про API хуков. А пока предлагаем прочитать Redux Fundamentals, Part 5: UI and React для руководства по хукам.

    Чтобы увидеть как используется React Redux на практике, мы шаг за шагом разберём пример приложения со списком дел.

    Пример приложения со списком дел​

    Переместиться

    • �� Просто покажите мне код
    • �� Внедрение хранилища
    • ✌️ Соединение с компонентами

    React компоненты для UI

    Мы реализуем React компоненты интерфейса следующим образом:

    • TodoApp — начальный компоненты нашего приложения. Он отрисовывает заголовок и компоненты: AddTodo , TodoList , VisibilityFilters .
    • AddTodo — компонент, позволяющий пользователю создать задачу и добавить её к списку дел через кнопку “Add Todo”:
      • Компонент использует «контроллируемый» input, который обновляет своё состояние при вызове события onChange .
      • Когда пользователь нажимает на кнопку “Add Todo”, отправляется действие (которые мы предоставим с помощью React Redux) для добавления задачи в хранилище.
      • При активации фильтра VisibilityFilters отрисовывается отфильтрованный список задач.
      • Отображает содержимое задачи и показывает её статус. Завершённая задача будет вычеркнута.
      • В нём отправляет действие при изменении статуса через событие onClick .
      • Компонент принимает свойство activeFilter от его родителя, указывающее выбранный пользователем фильтр. Активный фильтр выделяется подчеркиванием.
      • Компонент отправляет действие setFilter при выборе фильтра.

      Redux хранилище(store)

      Redux-часть приложения была настроена с использованием шаблона, рекомендованного в документации Redux:

      • Хранилище(store)
        • todos : нормализованный редюсер(reducer) задач. Он содержит в себе byIds — выборку из задач и allIds , содержащий список из id всех задач.
        • visibilityFilters : строка all , completed или incomplete .
        • addTodo создаёт действие для добавления задачи. Он принимает строку content и возвращает действие ADD_TODO с переменной payload , содержащей самоувеличивающийся id и content
        • toggleTodo создаёт действие для переключения статуса задачи. Принимает номер задачи id и возвращает действие TOGGLE_TODO с payload , содержащей только её id
        • setFilter создаёт действие для установки состояния активного фильтра. Принимает строку filter и возвращает действие SET_FILTER с payload , содержащей сам фильтр filter
        • todos редюсер
          • Добавляет id к своему полю allIds и устанавливает задачу в своем поле byIds после получения действия ADD_TODO .
          • Переключает состояние поля completed для задачи, получая действие TOGGLE_TODO
          • Мы используем файл actionTypes.js , который хранит константы для типов действий, чтобы их переиспользовать
          • getTodoList возвращает список allIds из хранилища todos
          • getTodoById находит задачу в хранилище по id
          • getTodos немножко более сложный. Он принимает в себя id из allIds , ищет каждую задачу из byIds и возвращает массив из задач
          • getTodosByVisibilityFilter фильтрует задачи согласно выбранному фильтру

          Вы можете посмотреть код на CodeSandbox, там есть UI компоненты и описанное выше, но ещё не подключенное Redux хранилище(store).

          Теперь мы покажем, как подключить хранилище(store) к приложению, используя React Redux.

          Внедрение хранилища(store)​

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

          // index.js import React from 'react' import ReactDOM from 'react-dom' import TodoApp from './TodoApp'  import  Provider > from 'react-redux' import store from './redux/store'  // React 18 const root = ReactDOM.createRoot(document.getElementById('root')) root.render( Provider store=store>> TodoApp /> Provider> ) 

          Обратите внимание, сейчас обёрнут в , куда мы через пропсы передаём store .

          Привязываем компоненты​

          React Redux предоставляет функцию connect для чтения из Redux хранилища (и повторного чтения при обновлении хранилища).

          Функция connect принимает 2 не обязательных аргумента:

          • mapStateToProps : вызывается каждый раз, когда состояние хранилища(store) изменяется. Он получает всё содержимое хранилища(store) и возвращает объект с данными для этого компонента.
          • mapDispatchToProps : этот параметр может быть объектом или функцией.
            • Если это функция, она вызывается единожды при создании компонента. В аргументах она получает dispatch и должна возвращать объект с функциями, использующими dispatch для отправки действий в хранилище(store).
            • Если это объект, он должен содержать Создателей Действий, где каждый Создатель Действия будет превращен во вспомогательную функцию, которая автоматически отправляет своё действие при вызове. Обратите внимание: мы рекомендуем использовать форму “object shorthand”.

            Обычно connect вызывается так:

            const mapStateToProps = (state, ownProps) => (  // . вычисляемые данные из состояния и, опционально, ownProps >)  const mapDispatchToProps =   // . обычно это объект, полный Создателей Действий >  // `connect` возвращает функцию, которая принимает компонент для обёртки: const connectToStore = connect(mapStateToProps, mapDispatchToProps) // Эта функция принимает наш компонент и возвращает подключенный к Redux хранилищу(store) компонент-обёртку: const ConnectedComponent = connectToStore(Component)  // Обычно мы делаем и то, и другое за один шаг, например: connect(mapStateToProps, mapDispatchToProps)(Component) 

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

            Наш Cоздатель Действия addTodo выглядит так:

            // redux/actions.js import  ADD_TODO > from './actionTypes'  let nextTodoId = 0 export const addTodo = (content) => (  type: ADD_TODO, payload:   id: ++nextTodoId,  content, >, >)  // . другие действий 

            При передаче его в connect , наш компонент получит в пропсах функцию и при её вызове автоматически отправит действие в хранилище(store).

            // components/AddTodo.js  // . другие import import  connect > from 'react-redux' import  addTodo > from '../redux/actions'  class AddTodo extends React.Component   // . реализация компонента >  export default connect(null,  addTodo >)(AddTodo) 

            Обратите внимание, что обёрнут в родительский компонент . Тем временем, теперь получит 1 пропс: функцию addTodo для отправки действия ADD_TODO .

            Нам также потребуется реализовать функцию handleAddTodo , которая вызовет действие addTodo и сбросит значение input

            // components/AddTodo.js  import React from 'react' import  connect > from 'react-redux' import  addTodo > from '../redux/actions'  class AddTodo extends React.Component   // .  handleAddTodo = () =>   // Отправляет действие для добавления задачи this.props.addTodo(this.state.input)  // Приводит в изначальное состояние this.setState( input: '' >) >  render()   return ( div> input onChange=(e) => this.updateInput(e.target.value)> value=this.state.input> /> button className="add-todo" onClick=this.handleAddTodo>>  Add Todo button> div> ) > >  export default connect(null,  addTodo >)(AddTodo) 

            Теперь наш связан с хранилищем(store). При добавлении задачи компонент отправит действие для изменения хранилища(store). Пока что мы не видим этого в приложении, потому что остальные компоненты ещё не подключены. Если у вас установлено Redux DevTools Extension, вы сможете увидеть отправленное действие:

            Вы также увидите изменение хранилища(store):

            Компонент ответственен за отрисовку списка задач. Следовательно, он будет читать данные задач из хранилища. Мы реализуем это, вызывая connect с параметром mapStateToProps — функцией, описывающей часть данных, которая нам нужна из хранилища(store).

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

            // components/TodoList.js  // . другие import import  connect > from "react-redux";  const TodoList = // . реализация UI компонента  const mapStateToProps = state =>   const  byIds, allIds > = state.todos || >; const todos =  allIds && allIds.length ? allIds.map(id => (byIds ?  . byIds[id], id > : null)) : null; return  todos >; >;  export default connect(mapStateToProps)(TodoList); 

            К счастью, для этого у нас уже есть селектор getTodos . Мы можем просто импортировать его и использовать здесь.

            // redux/selectors.js  export const getTodosState = (store) => store.todos  export const getTodoList = (store) => getTodosState(store) ? getTodosState(store).allIds : []  export const getTodoById = (store, id) => getTodosState(store) ?  . getTodosState(store).byIds[id], id > : >  export const getTodos = (store) => getTodoList(store).map((id) => getTodoById(store, id)) 
            // components/TodoList.js  // . other imports import  connect > from "react-redux"; import  getTodos > from "../redux/selectors";  const TodoList = // . реализация UI компонента  export default connect(state => ( todos: getTodos(state) >))(TodoList); 

            Мы рекомендуем инкапсулировать сложные вычисления или поиск в функции селекторы. Кроме того, вы можете дополнительно оптимизировать производительность, используя Reselect для написания мемоизированных(“memoized”) селекторов, которые пропустят необязательную работу. (Посмотрите страницу документации Redux: Вычисление производных данных и запись из блога Идиоматический Redux: использование Reselect селекторов для инкапсуляции и производительности для получения информации о том, как и зачем использовать селекторы.)

            Теперь, когда наш компонент подключен к хранилищу(store), он получит список задач и передаст каждую задачу в компонент . в свою очередь отобразит их на экране. Теперь попытаемся добавить задачу. Она должна появиться в нашем списке задач!

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

            Распространенные способы вызова connect ​

            В зависимости от типа компонента, с которым вы работаете, существуют различные способы вызова connect , наиболее распространённые из них представлены в таблице:

            Не подписываются на хранилище(store) Подписываются на хранилище(store)
            Не включают Создателей Действий connect()(Component) connect(mapStateToProps)(Component)
            Включают Создателей Действий connect(null, mapDispatchToProps)(Component) connect(mapStateToProps, mapDispatchToProps)(Component)
            Компонент, не подписанный на хранилище(store) и без Создателей Действий​

            Если вы вызовете connect без аргументов, ваш компонент:

            • не перерисовывается при изменении хранилища(store)
            • получит props.dispatch , который вы можете использовать для отправки действий
            // . Реализация компонента Component export default connect()(Component) // Компонент получит `dispatch` (Прямо как наш !) 
            Компонент, подписанный на хранилище(store), но без Создателей Действий​

            Если вы вызываете connect только с mapStateToProps , ваш компонент:

            • подписывается на значения из извлечённые mapStateToProps из хранилища(store) и будет перерисовываться только при изменении этих значений
            • получит props.dispatch , который вы можете использовать для отправки действий
            // . Реализация компонента Component const mapStateToProps = (state) => state.partOfState export default connect(mapStateToProps)(Component) 
            Компонент, не подписанный на хранилище(store), но включающий Создателей Действий​

            Если вы вызываете connect только с mapDispatchToProps , ваш компонент:

            • не перерисовывается при изменении хранилища(store)
            • получит как пропс каждый из Создателей Действий, который вы включите в mapDispatchToProps и при вызове автоматически отправит действия.
            import  addTodo > from './actionCreators' // . Реализация компонента Component export default connect(null,  addTodo >)(Component) 
            Компонент, подписанный на хранилище(store) и включающий Создателей Действий​

            Если вы вызываете connect , передавая оба mapStateToProps и mapDispatchToProps , ваш компонент:

            • подписывается на значения из извлечённые mapStateToProps из хранилища(store) и будет перерисовываться только когда эти значения меняются
            • получит как пропс каждый из Создателей Действий, который вы включите в mapDispatchToProps и при вызове автоматически отправит действия.
            import * as actionCreators from './actionCreators' // . Реализация компонента Component const mapStateToProps = (state) => state.partOfState export default connect(mapStateToProps, actionCreators)(Component) 

            Эти 4 случая покрывают основные пути использования connect . Чтобы узнать больше о connect , прочитайте описание API, которое объяснит это более подробно.

            Теперь, давайте подключим остальную часть приложения .

            Как нам следует реализовать взаимодействие с переключением статуса задач? Внимательный читатель уже может дать ответ. Если вы настроили своё окружение и дошли до этого момента, самое время оставить статью в стороне и реализовать эту функцию самостоятельно. Не будет ничего удивительного в том, как мы подключим компонент , чтобы он отправлял toggleTodo :

            // components/Todo.js  // . другие import import  connect > from "react-redux"; import  toggleTodo > from "../redux/actions";  const Todo = // . реализация компонента  export default connect( null,  toggleTodo > )(Todo); 

            Теперь можно изменить статус задачи. Мы почти закончили!

            Наконец, давайте реализуем VisibilityFilters

            Компонент должен доставать из хранилища(store) активный фильтр и отправлять действия в хранилище(store). Следовательно, нам нужно реализовать оба mapStateToProps и mapDispatchToProps . mapStateToProps может просто получать состояние visibilityFilter . И mapDispatchToProps будет содержать в себе Создатель Действия setFilter .

            // components/VisibilityFilters.js  // . другие import import  connect > from "react-redux"; import  setFilter > from "../redux/actions";  const VisibilityFilters = // . Реализация компонента  const mapStateToProps = state =>   return  activeFilter: state.visibilityFilter >; >; export default connect(  mapStateToProps,  setFilter > )(VisibilityFilters); 

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

            // redux/selectors.js  // . другие селекторы export const getTodosByVisibilityFilter = (store, visibilityFilter) =>   const allTodos = getTodos(store) switch (visibilityFilter)   case VISIBILITY_FILTERS.COMPLETED: return allTodos.filter((todo) => todo.completed) case VISIBILITY_FILTERS.INCOMPLETE: return allTodos.filter((todo) => !todo.completed) case VISIBILITY_FILTERS.ALL: default: return allTodos > > 

            И подключаем к хранилищу(store) с помощью селектора:

            // components/TodoList.js  // .  const mapStateToProps = (state) =>   const  visibilityFilter > = state const todos = getTodosByVisibilityFilter(state, visibilityFilter) return  todos > >  export default connect(mapStateToProps)(TodoList) 

            Теперь мы закончили очень простой пример приложения списка задач с React Redux. Все наши компоненты подключены! Разве это не прекрасно? ����

            Ссылки​

            • Использование Redux с React
            • Использование связки React Redux
            • Подробно о компонентах высшего порядка
            • Вычисление производных данных
            • Идиоматический Redux: Используем селекторы Reselect для инкапсуляции и производительности

            Помощь​

            • Reactiflux Redux канал
            • StackOverflow
            • GitHub Issues

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *