react saga что это
Зачем использовать Redux Saga?
Вы когда-нибудь задумывались, почему redux saga приобрела такую популярность и постепенно становится сердцем любого корпоративного приложения. В этой статье я расскажу вам о преимуществах использования redux saga. Кроме того, эта статья предназначена для новичков, чтобы понять / решить, когда и зачем использовать redux saga.
Redux Saga как Middleware
Redux Saga — это промежуточное программное обеспечение(middleware), которое берет на себя управление вашими действиями до того, как напрямую достигнет reducers.
Pабота без redux saga:
With Redux saga as middleware:
Action(s) → Redux Saga →Reducer(s)
Redux saga действует как промежуточное middleware, которое дает разработчикам возможность аккуратно разделить любую бизнес-логику, запросы xhr (широко известные как Ajax), манипуляции с данными или любые другие операции, которые могут показаться неприемлемыми для редукторов напрямую.
Зачем использовать Sagas
Давайте посмотрим на некоторые преимущества использования Saga:
Включение redux saga в существующее приложение:
вам понадобится babel, чтобы преобразовать его в код ES5
В приведенном выше коде мы пишем наш первый метод саги, который говорит, что всякий раз, когда запускается действие с типом: FETCH_REQUESTED, оно вызывает метод выборки данных. Точно так же мы можем зарегистрировать несколько методов в первой саге, например:
Напоследок напишем, что делает метод саги
Я знаю, что многие из вас подумают, что такое call и put. Мы постараемся понять это в следующем рассказе. На данный момент было бы достаточно знать, что эффект «call» принимает первые аргументы в качестве имени функции, которая будет выполняться, например: вызвать api.fetchUser с параметром action.payload.url и оставить его в качестве параметров, а «put» можно рассматривать как псевдоним для store.dispatch (<тип: “FETCH_SUCCEEDED”, данные: данные>);
В ближайшие недели я напишу следующую статью и расскажу больше об эффектах / асинхронных редукторах / тестировании и расширенном использовании.
Надеюсь, эта статья окажется для вас полезной.
React saga что это
Приступая к работе
Альтернативно, вы можете использовать предоставленные UMD сборки напрямую в на HTML странице. Смотрите эту секцию.
Предположим, что у нас есть интерфейс для извлечения некоторых пользовательских данных с удаленного сервера при нажатии кнопки. (Для краткости, мы просто покажем код запуска экшена.)
Компонент диспатчит action в виде простого объекта в Store. Мы создадим сагу, которая слушает все USER_FETCH_REQUESTED экшены и триггерит вызовы API для извлечения пользовательских данных.
Для запуска нашей саги, мы подключим ее к Redux Store, используя redux-saga мидлвар.
Использование UMD сборки в браузере
umd версия полезна, если вы не используете Webpack или Browserify. Вы можете получить доступ к ней, непосредственно из unpkg.
Доступны следующие сборки:
Сборка примеров из исходных файлов
Ниже приведены примеры, портированые (пока) из репозиториев Redux.
Есть три примера счетчика.
Для запуска примера, просто откройте index.html в вашем браузере.
Важно: ваш браузер должен поддерживать Генераторы. Последние версии Chrome/Firefox/Edge подойдут.
Демо, использующее низкоуровневое API для демонстрации отмены задачи.
Пример Shopping Cart
real-world пример (с webpack hot reloading)
Поддержите нас при помощи ежемесячного пожертвования и помогите нам продолжать нашу деятельность. [Стать меценатом]
Стань спонсором и получи свой логотип в нашем README на Github с ссылкой на ваш сайт. [Стать спонсором]
Разбираемся в redux-saga: От генераторов действий к сагам
Любой redux разработчик расскажет вам, что одной из самых тяжелейших частей разработки приложений являются асинхронные вызовы — как вы будете обрабатывать реквесты, таймауты и другие коллбэки без усложнения redux действий(actions) и редьюсеров(reducers).
В этой статье я опишу несколько различных подходов к управлению асинхронностью в вашем приложении, начиная от простых подходов как redux-thunk, заканчивая более продвинутыми библиотеками вроде redux-saga.
Мы собираемся использовать React и Redux, поэтому будем полагать, что вы имеете хотя бы какое то представление о том как они работают.
Генераторы действий (Action creators)
Взаимодействие с API довольно частое требование в приложениях. Представьте, что нам необходимо показывать случайную картинку собаки, когда мы нажимаем на кнопку.
мы можем использовать Dog CEO API и что-то довольно простое вроде вызова fetch внутри генератора действия (action creator).
Нет ничего плохого в таком подходе. При прочих равных всегда лучше использовать более простой подход.
Однако, использование только Redux не дает нам достаточно гибкости. Ядро Redux это контейнер состояния (state container), который поддерживает только синхронные потоки данных.
На каждое действие, в хранилище (store) посылается объект, описывающий что произошло, затем вызывается редюсер (reducer) и состояние (state) сразу обновляется.
Но в случае асинхронного вызова, вам необходимо сначала дождаться ответа и затем уже, если не было ошибок, обновить состояние. А что если у вашего приложения есть некая сложная логика/workflow?
Для этого Redux использует промежуточные слои (middlewares). Промежуточный слой это кусок кода, который выполняется после отправки действия, но перед вызовом редюсера.
Промежуточные слои могут соединяться в цепочку вызовов для различной обработки действия (action), но на выходе обязательно должен быть простой объект (действие)
Для асинхронных операций, Redux предлагает использовать redux-thunk промежуточный слой.
Redux-thunk
Redux-thunk является стандартным путем выполнения асинхронных операций в Redux.
Для нашей цели, redux-thunk вводит понятие преобразователь(thunk), что является функцией, которая предоставляет отложенное выполнение, по необходимости.
Значение 3 сразу присваивается переменной x.
Однако, если у нас есть выражение наподобие
То суммирование выполняется не сразу, а только при вызове функции foo(). Это делает функцию foo преобразователем(thunk).
Redux-thunk позволяет генератору действия (action creator) отправлять функцию в дополнении к объекту, конвертируя таким образом генератор действия в преобразователь.
Ниже, мы перепишем предыдущий пример используя redux-thunk
На первый взгляд он не сильно отличается от предыдущей версии.
Преимуществом использования redux-thunk является то, что компонент не знает, что выполняется асинхронное действие.
Т.к. промежуточный слой автоматически передает функцию dispatch в функцию, которую возвращает генератор действий, то снаружи, для компонента, нет никакой разницы в вызове синхронных и асинхронных действий (и компонентам больше не нужно об этом беспокоиться)
Таким образом, с помощью механизма промежуточных слоев, мы добавили неявный слой (a layer of indirection), который дал нам больше гибкости.
Поскольку redux-thunk передает в возвращаемые функции методы dispatch и getState из хранилища (store) как параметры, то вы можете отсылать другие действия и использовать состояние (state) для реализации дополнительной логики и workflow.
Но что если у нас есть что-то более сложное, чтобы быть выраженным с помощью преобразователя (thunk), без изменения react компонента. В этом случае мы можем попробовать использовать другую библиотеку промежуточных слоев (middleware library) и получить больше контроля.
Давайте посмотрим как заменить redux-thunk на библиотеку, что может дать нам больше контроля — redux-saga.
Redux-saga
Redux-saga это библиотека нацеленная делать сайд-эффекты проще и лучше путем работы с сагами.
Саги это дизайн паттерн, который пришел из мира распределенных транзакций, где сага управляет процессами, которые необходимо выполнять транзакционным способом, сохраняя состояние выполнения и компенсируя неудачные процессы.
Чтобы узнать больше о сагах можно начать с просмотра Применения паттерна Сага от Caitie McCaffrey, ну а если вы амбициозны, то здесь Статья, которая первая описывает саги в отношении распределенных систем.
В контексте Redux, сага реализована как промежуточный слой (мы не можем использовать редюсеры потому что они должны быть чистыми функциями), который координирует и побуждает асинхронные действия (сайд-эффекты).
Redux-saga делает это с помощью ES6 генераторов
Генераторы (Generators) это функции которые могут быть остановлены и продолжены, вместо выполнения всех выражений в один проход.
Когда вы вызываете функцию-генератор, она возвращает объект-итератор. И с каждым вызовом метода итератора next() тело функции-генератора будет выполняться до следующего yield выражения и затем останавливаться.
Это делает асинхронный код проще для написания и понимания.
Для примера вместо следующего выражения:
С генераторами мы бы написали так:
Возвращаясь к redux-saga, если говорить в общем, мы имеем сагу чья работа это следить за отправленными действиями (dispatched actions).
Для координирования логики, которую мы хотим реализовать внутри саги, мы можем использовать вспомогательную функцию takeEvery для создания новой саги для выполнения операции.
Если есть несколько запросов, takeEvery стартует несколько экземпляров саги-рабочего (worker saga). Иными словами реализует конкурентность(concurrency) для вас.
Надо отметить, что сага-наблюдатель (watcher saga) является другим неявным слоем (layer of indirection), который дает больше гибкости для реализации сложной логики (но это может быть лишним для простых приложений).
Теперь мы можем реализовать fetchDogAsync() функцию (мы полагаем, что у нас есть доступ к методу dispatch)
Но redux-saga позволяет нам получить объект, который декларирует наше намерение произвести операцию, вместо результата выполнения самой операции. Иными словами, пример выше реализуется в redux-saga следующим образом:
(Прим. переводчика: автор забыл заменить самый первый вызов dispatch)
Вместо вызова асинхронного реквеста напрямую, метод call вернет только объект описывающий эту операцию и redux-saga сможет позаботиться о вызове и возвращении результатов в функцию-генератор.
Тоже самое касается и метода put. Вместо отправления действий (dispatch action) внутри функции-генератора, put возвращает объект с инструкциями для промежуточного слоя (middleware) — отправить действие.
Эти возвращаемые объекты называются Эффекты (Effects). Ниже пример эффекта возвращаемого методом call:
Работая с Эффектами, redux-saga делает саги скорее Декларативными, чем Императивными.
Декларативное программирование это стиль программирования, который пытается минимизировать или устранить сайд-эффекты, описанием что программа должна делать, вместо описания как она должна это делать.
Преимущество, которое это дает, и о чем говорят большинство людей, то что функцию, которая возвращает простой объект, гораздо проще тестировать, чем функцию, которая делает асинхронный вызов. Для тестирования, вам не нужно использовать реальное АПИ, делать фейки или мокать.
Для тестирования, вы просто итерируете функцию-генератор делая assert и сравниваете полученные значения.
Еще одно дополнительное преимущество это возможность легко объединять разные эффекты в сложный workflow.
Возвращаясь к нашему простому примеру, ниже полная реализация в redux-saga:
Когда вы нажимаете на кнопку, вот что происходит:
1. Отправляется действие FETCHED_DOG
2. Сага-наблюдатель (watcher saga) watchFetchDog получает это действие и вызывает сагу-рабочего (worker saga) fetchDogAsync.
3. Отправляется действие по отображению индикатора загрузки.
4. Происходит вызов API метода.
5. Отправляется действие по обновлению состояния (успех или провал)
Если вы считаете, что несколько неявных слоев и чуть-чуть дополнительной работы стоят этого, то redux-saga может дать вам больше контроля для обработки сайд-эффектов функциональным способом.
Заключение
Эта статья показала как реализовать асинхронные операции в Redux с помощью генераторов действий (action creators), преобразователей (thunks), и саг (sagas), идя от простого подхода к более сложному.
Redux не предписывает решение для обработки сайд-эффектов. Когда вы будете решать какому подходу следовать, вам необходимо учитывать сложность вашего приложения. Моя рекомендация — начинать с простого решения.
Также есть альтернативы redux-saga, которые стоит попробовать. Две самых популярных это redux-observable (который базируется на RxJS) и redux-logic (также базирующийся на RxJS наблюдателях, но дающий свободу писать вашу логику в других стилях).
Введение в Redux Saga
Когда использовать Redux Saga
В приложении, использующемRedux, когда вы запускаете действие, что-то меняется в состоянии приложения.
В этом случае вам может потребоваться сделать что-то, вытекающее из этого изменения состояния.
Например, вы можете захотеть:
Это все вещи, которые на самом деле не связаны с состоянием приложения или являются асинхронными, и вам нужно переместить их в место, отличное от ваших действий или редукторов (в то время как вы техническимог, это не лучший способ иметь чистую кодовую базу).
Представляем Redux Saga, промежуточное программное обеспечение Redux, которое поможет вам справиться с побочными эффектами.
Базовый пример использования Redux Saga
Чтобы не углубляться в теорию, прежде чем показывать реальный код, я кратко расскажу, как я решил проблему, с которой столкнулся при создании примера приложения.
В чате, когда пользователь пишет сообщение, я немедленно показываю это сообщение на экране, чтобы обеспечить оперативную обратную связь. Это делается черезRedux Action:
и состояние меняется через редуктор:
Вы инициализируете Redux Saga, сначала импортируя его, а затем применяясагав качестве промежуточного программного обеспечения для Redux Store:
Затем мы создаем промежуточное ПО и применяем его к нашему недавно созданному Redux Store:
Как это работает за кадром
БытьReduxПромежуточное ПО, Redux Saga может перехватывать действия Redux и внедрять свои собственные функции.
Есть несколько концепций, которые нужно усвоить, и вот основные ключевые слова, которые вы захотите вонзить в свою голову вместе:сага,генератор,промежуточное ПО,обещать,Пауза,продолжить,эффект,отправлять,действие,выполнено,решено,урожай,уступил.
Асагаэто некая «история», которая реагирует наэффектчто ваш код вызывает. Это может содержать что-то из того, о чем мы говорили раньше, например, HTTP-запрос или некоторую процедуру, которая сохраняется в кеш.
Мы создаемпромежуточное ПОсо спискомсагиto run, которых может быть один или несколько, и мы подключаем это промежуточное ПО к хранилищу Redux.
Асагаэтогенераторфункция. Когдаобещатьзапущен иуступил, промежуточное ПОприостанавливаетвсагадообещатьявляетсярешено.
Однаждыобещатьявляетсярешенопромежуточное ПОвозобновляетсясага, до следующегоурожайзаявление найдено, и вот оноприостановленныйснова, пока егообещать решает.
Внутри кода саги вы создадитепоследствияиспользуя несколько специальных вспомогательных функций, предоставляемых redux-saga упаковка. Для начала мы можем перечислить:
Когдаэффектвыполняется,сагаявляетсяприостановленодоэффектявляетсявыполнено.
Когдапромежуточное ПОвыполняет handleNewMessage сага, этоостанавливаетсяна yield takeEvery инструкция иждет(асинхронно, конечно) до тех пор, пока ADD_MESSAGE действиеотправлен. Затем он выполняет обратный вызов, исагаможетпродолжить.
Базовые помощники
Давайте познакомимся с самыми основными помощниками, которые вы можете использовать для запуска ваших эффектов:
takeEvery()
В watchMessages генератор останавливается до тех пор, пока ADD_MESSAGE боевые пожары, икаждый разон срабатывает, он вызовет postMessageToServer функция, бесконечно и одновременно (нет необходимости postMessageToServer чтобы завершить его выполнение до того, как можно будет запустить новый раз)
takeLatest()
take() отличается тем, что ждет только один раз. Когда происходит ожидаемое действие, обещание разрешается и итератор возобновляет работу, поэтому он может перейти к следующему набору инструкций.
Отправляет действие в магазин Redux. Вместо передачи в хранилище Redux или действия отправки в сагу вы можете просто использовать put() :
который возвращает простой объект, который вы можете легко проверить в своих тестах (подробнее о тестировании позже).
Если вы хотите вызвать какую-либо функцию в саге, вы можете сделать это, используя простой вызов функции, возвращающий обещание:
но это не очень хорошо с тестами. Вместо, call() позволяет обернуть этот вызов функции и вернуть объект, который можно легко проверить:
Параллельное выполнение эффектов
второй fetch() вызов не будет выполнен, пока первый не завершится успешно.
Чтобы выполнить их параллельно, оберните их в all() :
all() не будет решен, пока оба call() возвращаться.
race() отличается от all() не дожидаясь ответа всех помощников. Он просто ждет, пока один из них вернется, и все готово.
Это гонка, чтобы увидеть, кто из них финиширует первым, а потом мы забываем о других участниках.
Обычно он используется для отмены фоновой задачи, которая выполняется вечно, пока что-то не произойдет:
когда CANCEL_TASK действие, мы останавливаем другую задачу, которая в противном случае выполнялась бы вечно.
Redux-Saga
An intuitive Redux side effect manager.
Easy to manage, easy to test, and executes efficiently.
Asynchronous
ES6 generators make asynchronous flows easy to read, write, and test. Create complex side effects without getting bogged down by the details.
Composition-focused
Sagas enable numerous approaches to tackling parallel execution, task concurrency, task racing, task cancellation, and more. Keep total control over the flow of your code.
Easy To Test
Assert results at each step of a generator or for a saga as a whole. Either way, side effect testing is quick, concise, and painless, as testing should be.
Example Usage
Suppose we have a UI to fetch some user data from a remote server when a button is clicked. (For brevity, we’ll just show the action triggering code.)
The component dispatches a plain object action to the store. We’ll create a Saga that watches for all USER_FETCH_REQUESTED actions and triggers an API call to fetch the user data.
To run our Saga, we have to connect it to the Redux store using the redux-saga middleware.
Backers
Support us with a monthly donation and help us continue our activities. Become a backer
Sponsors
Become a sponsor and have your logo shown below and on Github with a link to your site. Become a sponsor