Автор оригинала: FreeCodeCamp Community Member.
Тома Коулман
Очень смысл быстро меняющейся реагирования на лучшую практику.
Если вы новичок в реакции, вы, возможно, слышали о «компонентах более высокого порядка» и компонентами «контейнера». Если это так, вам может быть интересно, какова вся суета. Или вы, возможно, даже использовали API для библиотеки, которая обеспечивает одну, и было немного запутано к терминологии.
Как сопровождающий Apollo’s React Integration – Популярная библиотека с открытым исходным кодом, которая делает тяжелое использование компонентов высокого порядка – и автора большей части его документации, я потратил немного времени, когда я голову вокруг концепции сам.
Я надеюсь, что этот пост может помочь пролить свет на эту тему для вас.
React Re-Primer
Этот пост предполагает, что вы знакомы с реагированием – если нет там много отличного контента. Например, Sacha Greif’s 5 React Concepts Post это хорошее место для начала. Тем не менее, давайте просто пойдем через пару вещей, чтобы получить нашу историю прямо.
Приложение Reacts состоит из набора Компоненты Отказ Компонент пропускается набор входных свойств ( реквизит ) и дает какой-то HTML, который отображается на экран. Когда реквизиты компонента изменяются, он повторно отображает, и HTML может измениться.
Когда пользователь приложения взаимодействует с этим HTML, через какое-то событие (например, щелчок мыши) компонент обрабатывает его либо путем запуска A Обратный вызов опоры или изменение некоторых внутренних Государство Отказ Изменение внутреннего состояния также вызывает его и его дети для переназначения.
Это приводит к компоненту жизненный цикл В качестве компонента впервые отображается компонент, прикрепленный к DOM, принял новые реквизиты и т. Д.
Функция рендеринга компонента возвращает один или экземпляры других компонентов. Полученный Вид дерева Является ли хорошая умственная модель, чтобы иметь в виду, как компоненты приложения взаимодействуют. В целом они взаимодействуют только путем прохождения реквизит к своим детям или запуск обратных вызовов, прошедших их родителями.
Рейкт UI против состояния
Это кажется почти датированным сейчас, но было время, когда все было описано с точки зрения различия между моделями, представлениями и контроллерами (или просмотра моделями или ведущими, и т. Д.). В этой классификации задача просмотра – это оказывать и иметь дело с взаимодействием пользователя, а контроллер – это Подготовьте данные Отказ
Недавняя тенденция реагирования в направлении Функциональные стандартные компоненты Отказ Эти простейшие «чистые» компоненты только когда-либо преобразуют их реквизиты в HTML и вызовов обратных вызовов на взаимодействие пользователя:
Они функциональны, потому что вы действительно можете думать о них как о функциях. Если ваша древовидная древесина состояла из них, вы действительно говорите о одной большой функции для получения HTML, состоящей из звонков на многие меньшие.
Приятное свойство функциональных компонентов без гражданства состоит в том, что они очень легко проверить, и просто понять. Это означает, что они легче разрабатывать и быстрее для отладки.
Но вы не всегда можете уйти с этим. UI нужен государство. Например, ваше меню может потребоваться открыть, когда пользователь заведет на него (тьфу, я надеюсь, что нет!) – и способ сделать это в реакции, безусловно, с использованием состояния. Чтобы использовать состояние, вы используете классовые компоненты.
Там, где все сложные, – это проводка «глобального состояния» вашего интерфейса в дереве зрения.
Глобальное состояние
Глобальное состояние в вашем UI является государством, которое не имеет прямого и однозначности актуальности для одного компонента. Обычно он состоит из двух основных типов вещей:
1. данные В вашем приложении произошло с некоторых серверов. Обычно данные используются в нескольких местах и поэтому не уникальны для одного компонента.
2. Глобальное государство UI (как URL, и, таким образом, на каком странице смотрит пользователь).
Один из подходов к глобальному состоянию состоит в том, чтобы прикрепить его к самому высокому компоненту «root» в вашем приложении и передавать его по дереву всем компонентам, которые это нужно. Затем вы проходите все изменения в это состояние резервного копирования дерева через цепочку обратных вызовов.
Этот подход становится громоздким довольно быстро, хотя. Это означает, что корневой компонент должен понимать требования всего дерева, а также для каждого родителя каждого поддерева во всем дереве. Вот где приходит эта следующая концепция.
Контейнеры и презентационные компоненты
Эта проблема обычно решается, позволяя компонентам получать доступ к глобальному состоянию в любом месте дерева зрения (некоторое ограничение обычно называется).
В этом мире компоненты могут быть классифицированы в те, которые получают доступ к глобальному государству, а те, которые не имеют.
«Чистые» компоненты, которые не являются простыми для тестирования и понимать (особенно если они являются функциональными компонентами без гражданства). А в ближайшее время, как компонент «нечистый», это испорчено и сложнее иметь дело.
По этой причине шаблон появился для отделения каждого «нечистого» компонента в Два компоненты:
- Контейнер компонент, который делает «грязную» глобальную государственную работу
- презентационный Компонент, который не делает.
Теперь мы можем рассматривать презентационную компонент, как мы относились к нашим простым компонентам выше и изолируйте грязные, сложные работы по обработке данных в контейнере.
Контейнер
Как только вы на борту с разделением компонентов презентационного/контейнера, написание компонентов контейнера становится интересным.
Одна вещь, которую вы замечаете, это они часто не похожи на компонент вообще. Они могли бы:
- Получить и пройти один кусок глобального состояния (скажем, от redux) в их ребенка.
- Запустите один запрос доступа к данным (SALE GRAGHQL) и передайте результаты в своего ребенка.
Кроме того, если мы будем следовать хорошим разделением проблем, наши контейнеры будут только когда-либо визуализировать один дочерний компонент . Контейнер обязательно привязан к ребенку, потому что ребенок закреплен в функции рендеринга. Либо это?
Обобщая контейнеры
Для любого «типа» контейнерного компонента (например, который доступа к магазину Redux), реализация выглядит одинаково, отличается только в деталях: какой дочерний компонент они представляют, и какие точные данные они получают.
Например, в мире redux (если у нас не было React-redux ‘s Connect HOC) Контейнер может выглядеть так:
Несмотря на то, что этот контейнер не делает большую часть того, что сделает настоящий контейнер Redux, вы уже можете увидеть, что помимо реализации MapstatetoProps и конкретный MyComponent Что мы обертываем, есть много котельной, которую нам пришлось бы написать Каждый раз, когда мы пишем redux-доступа к контейнеру Отказ
Генерация контейнеров
На самом деле, может быть проще просто написать функцию, которую генерирует Компонент контейнеров на основе соответствующей информации (в этом случае дочерний компонент и MapStatetoPOOP Функция).
Это Компонент высшего порядка (HOC), который является Функция Это принимает дочерний компонент и некоторые варианты, затем создает контейнер для этого ребенка.
Это «высший порядок» так же, как «функция более высокого порядка» – функция, которая создает функцию. На самом деле вы можете подумать о комментариях Ractions в качестве функций, которые производят пользовательский интерфейс. Это особенно хорошо работает для функциональных компонентов без гражданства, но если вы всасываетесь, он работает для чистых гостевых презентационных компонентов. HOC имеет ровно функцию более высокого порядка.
Примеры HOCS.
Есть много, но некоторые заметные:
- Наиболее распространенным является, вероятно, Redux’s
соединитьФункция, которая нашаbuildreduxcontainerФункция выше – просто потертая версия. - React Router’s
ВозможностьФункция, которая просто захватывает маршрутизатор от контекста и делает его для ребенка. - React-Apollo Основной интерфейс является
graphqlHOC, который, учитывая компонент и запрос GraphQL, предоставляет результаты этого запроса ребенку. - Пересчитать Это библиотека, полная HOCS, которые делают различные небольшие задачи, которые вы можете отстраниться от ваших компонентов.
Пользовательские HOCS.
Если вы пишете новые HOCS в вашем приложении? Конечно, если у вас есть паттерны компонентов, которые могут быть обобщены.
Написание HOC так же просто, как функция, которая возвращает класс, как мы видели с нашими buildreduxcontainer функция выше. Если вы хотите прочитать больше о том, что вы можете сделать, когда вы создаете HOC, я предлагаю вам прочитать Fran Guijarro’s Чрезвычайно полный пост на предмет.
Заключение
Компоненты более высокого порядка находятся в основе кодификации разделения проблем в компонентах в Функциональный способ. Ранние версии React используемые классы и смешины для достижения повторного использования кода, но все знаки указывают на этот более функциональный подход, управляющий будущим дизайном реагирования.
Если ваши глаза обычно глазуют, когда вы слышите о методах функциональных программиров, не волнуйтесь! Команда Ract React проделала большую работу по привлечению наилучших упрощенных частей этих подходов, чтобы завести нас всех к написанию более модульных, компонентных UIS.
Если вы хотите узнать больше о создании приложений в современном, ориентированном на компонент мода, проверьте мой Серия постов на Хрома И если вам нравится эта статья, пожалуйста, рассмотрите? и делиться этим!
Оригинал: “https://www.freecodecamp.org/news/understanding-higher-order-components-6ce359d761b/”