Tarjima qoshish uchun havola boyicha o'tib Pull Request oching (havolaga o'tish).
Standart til uchun tarkibni ko'rsatadi.
import { scopeBind } from "effector";
scopeBind
is a method to bind a unit (an Event or Effect) to a Scope to be called later. Effector supports imperative calling of events within watchers, however, there are instances where you must explicitly bind events to the scope, such as when triggering events from within setTimeout
or setInterval
callbacks.
Methods
scopeBind(event, options?)
Formulae
scopeBind<T>(event: EventCallable<T>): (payload: T) => void
scopeBind<T>(event: EventCallable<T>, options?: {scope?: Scope, safe?: boolean}): (payload: T) => void
Arguments
event
EventCallable or Effect to be bound to the scope.options
(Object): Optional configuration.scope
(Scope): Scope to bind event to.safe
(Boolean): Flag for exception suppression if there is no scope.
Returns
(payload: T) => void
— A function with the same types as event
.
Examples
Basic Usage
We are going to call changeLocation
inside history.listen
callback so there is no way for effector to associate event with corresponding scope, and we should explicitly bind event to scope using scopeBind
.
import {createStore, createEvent, attach, scopeBind} from 'effector';
const $history = createStore(history);
const initHistory = createEvent();
const changeLocation = createEvent<string>();
const installHistoryFx = attach({
source: $history,
effect: (history) => {
const locationUpdate = scopeBind(changeLocation);
history.listen((location) => {
locationUpdate(location);
});
},
});
sample({
clock: initHistory,
target: installHistoryFx,
});
scopeBind(callback, options?)
Binds arbitrary callback to a scope to be called later. The bound version of the function retains all properties of the original, e.g., if the original function would throw when called with a certain argument, the bound version will also throw under the same circumstances.
Feature is available since effector 23.1.0
release.
To be compatible with the Fork API, callbacks must adhere to the same rules as Effect
handlers:
- Synchronous functions can be used as they are.
- Asynchronous functions must follow the rules described in “Imperative Effect calls with scope”.
Formulae
scopeBind(callback: T, options?: { scope?: Scope; safe?: boolean }): (payload: T) => void;
Arguments
callback
(Function): Any function to be bound to the scope.options
(Object): Optional configuration.scope
(Scope): Scope to bind the event to.safe
(Boolean): Flag for exception suppression if there is no scope.
Returns
(payload: T) => void
— A function with the same types as callback
.
Examples
import {createEvent, createStore, attach, scopeBind} from 'effector'
const $history = createStore(history);
const locationChanged = createEvent();
const listenToHistoryFx = attach({
source: $history,
effect: (history) => {
return history.listen(
scopeBind((location) => {
locationChanged(location);
}),
);
},
});
Ingliz tilidagi hujjatlar eng dolzarb hisoblanadi, chunki u effector guruhi tomonidan yozilgan va yangilanadi. Hujjatlarni boshqa tillarga tarjima qilish jamiyat tomonidan kuch va istaklar mavjud bo'lganda amalga oshiriladi.
Esda tutingki, tarjima qilingan maqolalar yangilanmasligi mumkin, shuning uchun eng aniq va dolzarb ma'lumot uchun hujjatlarning asl inglizcha versiyasidan foydalanishni tavsiya etamiz.