Administrerende Staten Reagere Med Unstated

0
28

Som din søknad blir mer komplekse, forvaltning av statlig kan bli kjedelig. En komponent er staten er ment å være selvstendig, som gjør deling staten på tvers av flere komponenter en hodepine. Redux er vanligvis den går til biblioteket for å administrere staten Reagere, men, avhengig av hvordan komplekse søknaden din, har du kanskje ikke trenger Redux.

Unstated er et alternativ som gir deg funksjonalitet til å styre staten på tvers av flere komponenter med en Beholder klasse og Leverandør og Abonnere komponenter. La oss se Unstated i handlingen ved å lage en enkel disken, og deretter se på en mer avansert å-gjøre-programmet.

Ved hjelp av Unstated å Lage en Teller

Koden for counter vi gjør er tilgjengelig på GitHub:

Vis Repo

Du kan legge til Unstated til din søknad med Garn:

garn legge til unstated
Beholderen

Beholderen strekker seg Unstated Beholderen klasse. Det skal bare brukes for statlig styring. Dette er hvor den første staten vil bli initialisert og kallet til å setState() som vil skje.

import { Beholderen } fra ‘unstated’

klasse CounterContainer strekker seg Container {
tilstand = {
teller: 0
}

tilvekst = () => {
dette.setState({ count: dette.staten.teller + 1 })
}

minsk = () => {
dette.setState({ count: dette.staten.teller – 1 })
}
}

eksport standard CounterContainer

Så langt har vi definert Beholderen (CounterContainer), angi start stat for å telle på null og definert metoder for å legge til og trekke til den komponenten er staten i intervaller, og reduserer.

Du lurer kanskje på hvorfor vi ikke har importert Reagere på dette punktet. Det er ikke nødvendig å importere det inn i Beholderen siden vi ikke vil være rendering JSX i det hele tatt.

Hendelser som slipper ut vil bli brukt for å ringe setState() og føre til at komponenter for å re-render. Komponentene som vil gjøre bruk av denne beholderen må du abonnere på den.

Abonner

Abonner komponent som brukes til å koble tilstanden til komponenter som trenger det. Fra her, vil vi være i stand til å ringe øke eller redusere metoder, som vil oppdatere tilstand av programmet og føre til at du abonnerer komponent for å re-gjengi med riktig antall. Disse metodene vil bli utløst ved et par knapper som inneholder hendelser lyttere til å legge til eller trekke fra å telle, henholdsvis.

import Reagere fra “reagerer’
import { Abonnere } fra ‘unstated’

import CounterContainer fra ‘./beholdere/counter’

const Counter = () => {
retur (
<Abonnere={[CounterContainer]}>
{counterContainer => (
<div>
<div>
// Den nåværende telle verdi
Antall: { counterContainer.staten.count }
</div>
// Denne knappen vil legge til telling
<- knappen for onClick={counterContainer.tilvekst}>Tilvekst</button>
// Denne knappen vil du trekke fra antall
<- knappen for onClick={counterContainer.minsk}>Minsk</button>
</div>
)}
</Abonner>
)
}

eksport-standard-Counter

Abonner komponent er gitt CounterContainer i form av en array til å prop. Dette betyr at du vil Abonnere komponent kan abonnere på mer enn én container, og alle containere er gått til å støtte av Abonnere komponent i en rekke.

Den counterContainer er en funksjon som mottar en forekomst av hver container Abonnere komponent abonnerer på.

Med det kan vi nå få tilgang til staten og metoder som er gjort tilgjengelig i beholderen.

Leverandør

Vi vil gjøre bruk av komponent Leverandør til store beholderen forekomster, og tillate barna å abonnere på det.

import Reagere, { Komponent } fra “reagerer’;
import { Leverandør } fra ‘unstated’

import Counter fra ‘./Counter’

klasse App strekker seg Komponent {
render() {
retur (
<Leverandøren>
<Counter />
</Leverandør>
);
}
}

eksport-standard-App;

Med denne Telleren komponent kan gjøre bruk av vår counterContainer.

Unstated gir deg mulighet til å gjøre bruk av all den funksjonaliteten som Reagerer er setState() gir. For eksempel, hvis vi ønsker for å øke den tidligere tilstand ved ett tre ganger med ett klikk, kan vi passere en funksjon for å setState() som dette:

incrementBy3 = () => {
dette.setState((prevState) => ({ count: prevState.teller + 1 }))
dette.setState((prevState) => ({ count: prevState.teller + 1 }))
dette.setState((prevState) => ({ count: prevState.teller + 1 }))
}

Ideen er at setState() fungerer fortsatt som den gjør, men denne gangen med evnen til å holde staten som finnes i en Beholder klasse. Det blir lett for å spre staten å bare komponentene som trenger det.

La oss Gjøre en til Å-Gjøre-Program!

Dette er en litt mer avansert bruk av Unstated. To komponentene vil abonnere på beholderen, som vil administrere alle av staten, og metoder for å oppdatere tilstand. Igjen, den koden er tilgjengelig på Github:

Vis Repo

Beholderen vil se ut som dette:

import { Beholderen } fra ‘unstated’

klasse TodoContainer strekker seg Container {
tilstand = {
todos: [
‘Rote rundt med unstated’,
‘Start dans klasse’
],
todo:”
};

handleDeleteTodo = (gjøremål) => {
dette.setState({
todos: dette.staten.todos.filteret(c => c !== todo)
})
}

handleInputChange = (event) => {
const todo = event.målet.verdi
dette.setState({ todo });
};

handleAddTodo = (event) => {
event.preventDefault()
dette.setState(({todos}) => ({
todos: todos.concat(denne.staten.todo)
}))
dette.setState({ todo: “});
}

}

eksport standard TodoContainer

Beholderen har en innledende todos staten som en tabell med to elementer i det. For å legge til gjøremål, har vi en todo staten satt til en tom streng.

Vi kommer til å trenge en CreateTodo komponent som vil abonnere på beholderen. Hver gang en verdi som er lagt inn, onChange-hendelsen vil utløse deretter ild handleInputChange () – metoden vi har i beholderen. Klikke på send-knappen vil utløse handleAddTodo(). Den handleDeleteTodo () – metoden får en til å-gjøre, og filtrerer ut de gjøremål som samsvarer med den sendes.

import Reagere fra “reagerer’
import { Abonnere } fra ‘unstated’

import TodoContainer fra ‘./beholdere/todoContainer’

const CreateTodo = () => {
retur (
<div>
<Abonnere={[TodoContainer]}>
{todos =>
<div>
<form onSubmit={todos.handleAddTodo}>
<input
type=”text”
value={todos.staten.todo}
onChange={todos.handleInputChange}
/>
<- knappen>Send</button>
</form>
</div>
}
</Abonner>
</div>
);
}

eksport standard CreateTodo

Når en ny to-do er lagt til, todos staten gjort tilgjengelig i beholderen er oppdatert. Listen over todos er trukket fra beholderen til Todos komponent, ved å abonnere komponenten til beholderen.

import Reagere fra “reagerer’;
import { Abonnere } fra ‘unstated’;

import TodoContainer fra ‘./beholdere/todoContainer’

const Todos = () => (
<ul>
<Abonnere={[TodoContainer]}>
{todos =>
todos.staten.todos.kart(todo => (
<li key={todo}>
{todo} < – knappen for onClick={() => todos.handleDeleteTodo(gjøremål)}>X</button>
</li>
))
}
</Abonner>
</ul>
);

eksport standard Todos

Denne komponenten looper gjennom utvalget av gjøremål tilgjengelig i beholderen, og gjør dem i en liste.

Til slutt, vi må bryte komponenter som abonnerer på beholderen i en leverandør som vi gjorde i tilfelle av telleren. Dette gjør vi i vår App.js filen akkurat som vi gjorde i telleren eksempel:

import Reagere, { Komponent } fra “reagerer’;
import { Leverandør } fra ‘unstated’

import CreateTodo fra ‘./CreateTodo’
import Todos fra ‘./Todos’

klasse App strekker seg Komponent {
render() {
retur (
<Leverandøren>
<CreateTodo />
<Todos />
</Leverandør>
);
}
}

eksport-standard-App;

Innpakning Opp

Det er forskjellige måter å styre staten i Reagerer avhengig av kompleksiteten av din søknad og Unstated er en hendig bibliotek som kan gjøre det enklere. Det er verdt gjentok det punktet at Redux, mens awesome, er ikke alltid det beste verktøyet for jobben, selv om vi ofte ta tak i for det i disse typer saker. Forhåpentligvis har du nå føler at du har et nytt verktøy i beltet.