Verkställande Stat Reagera Med Obestämd

0
46

När din ansökan blir mer komplexa, hantering av staten kan bli tråkiga. En komponent staten är tänkt att vara självförsörjande, vilket gör att dela staten över flera komponenter huvudvärk. Redux brukar gå till biblioteket för att hantera tillståndet i Reagera, dock beroende på hur komplex din ansökan, behöver du kanske inte Redux.

Outtalade är ett alternativ som ger dig funktioner för att hantera statliga över flera komponenter med en Behållare klass och Leverantör och Teckna komponenter. Låt oss se Outtalade i handling genom att skapa en enkel räknare och sedan titta på en mer avancerad för att göra ansökan.

Med hjälp av Outtalad att Skapa en Räknare

Koden för counter vi gör är tillgänglig på GitHub:

Visa Reporäntan

Du kan lägga till Outtalade till din ansökan med Garn:

garn lägg till outtalade
Behållare

Behållaren sträcker sig Outtalade Behållare klass. Det ska bara användas för den statliga styrningen. Det är där den ursprungliga skick kommer att initieras och uppmaningen att setState() som kommer att hända.

import { Förpackningen } från “outtalade’

klass CounterContainer sträcker sig Container {
state = {
antal: 0
}

steg = () => {
detta.setState({ count: här.stat.count + 1 })
}

minskning = () => {
detta.setState({ count: här.stat.count – 1 })
}
}

export standard CounterContainer

Hittills har vi definierat Behållare (CounterContainer), ställ in start av staten för att räkna på antalet noll och definierade metoder för att lägga till och dra ifrån för att komponentens tillstånd i ökningar och minskningar.

Du kanske undrar varför vi inte importerade Reagera på denna punkt. Det finns ingen anledning att importera den i Behållaren eftersom vi inte kommer att vara rendering JSX alls.

Händelser utsläppskällor kommer att användas för att ringa setState() och orsaka komponenter för att åter göra. De komponenter som kommer att använda sig av denna behållare måste du abonnera på den.

Prenumerera

Prenumerera komponent som används för att koppla staten till de komponenter som behöver det. Från här, vi kommer att kunna ringa increment och decrement metoder, vilket kommer att uppdatera tillstånd av ansökan och orsaka bevakade komponent för att åter göra med rätta räknas. Dessa metoder kommer att utlösas av ett par knappar som innehåller händelser lyssnare att lägga till eller dra ifrån till antalet, respektive.

importera Reagerar från ‘reagerar’
import { Prenumerera } från “outtalade’

importera CounterContainer från”. /behållare/counter’

const Counter = () => {
avkastning (
<Prenumerera på={[CounterContainer]}>
{counterContainer => (
<div>
<div>
// Den aktuella räkna värdet
Count: { counterContainer.stat.count }
</div>
// Denna knapp för att lägga till greven
<button onClick={counterContainer.ökning}>Öka</button>
// Denna knapp kommer att subtrahera från det räknas
<button onClick={counterContainer.minska}>Minska</button>
</div>
)}
</Subscribe>
)
}

export standard-Counter

Prenumerera komponent ges CounterContainer i form av en matris till dess att prop. Detta innebär att Prenumerera komponent kan prenumerera på mer än en container, och alla de behållare som är godkänd för att stötta om det Prenumerera komponent i en array.

Den counterContainer är en funktion som tar emot en instans av varje container Prenumerera komponent prenumererar på.

Med att vi nu kan få tillgång till den statliga och metoder görs tillgängliga i behållaren.

Leverantör

Vi kommer att göra bruk av den som tillhandahåller komponent för att lagra behållaren fall och att barnen för att prenumerera på den.

importera Reagera, { Komponent } ‘reagerar’;
import { Leverantör } från “outtalade’

importera Counter från ‘./Motverka”

klass App förlänger Komponent {
render() {
avkastning (
<Leverantören>
<Counter />
</Buyer>
);
}
}

export standard App;

Med denna Disk komponent kan använda sig av vårt counterContainer.

Outtalade gör att du kan använda alla funktioner som Reagerar är setState() ger. Till exempel, om vi vill öka det tidigare tillståndet med hjälp av en tre gånger med ett klick, vi kan gå till en funktion setState (), så här:

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

Tanken är att setState() fortfarande fungerar som det gör, men denna gång med förmågan att hålla staten som är innesluten i en Behållare klass. Det blir lätt att sprida staten att endast de komponenter som behöver det.

Låt oss göra en Att Göra Ansökan!

Detta är en något mer avancerad användning av Outtalade. Två komponenter kommer att prenumerera på behållaren, som kommer att hantera alla av staten, och de metoder för uppdatering av staten. Igen, koden finns tillgänglig på Github:

Visa Reporäntan

Containern kommer att se ut så här:

import { Förpackningen } från “outtalade’

klass TodoContainer sträcker sig Container {
state = {
todos: [
“Röra runt med outtalade’,
‘Start-dans-klass
],
todo:”
};

handleDeleteTodo = (todo) => {
detta.setState({
todos: här.stat.todos.filter(k => k !== todo -)
})
}

handleInputChange = (event) => {
const todo = evenemanget.- målet.värde
detta.setState({ att göra });
};

handleAddTodo = (event) => {
händelsen.preventDefault()
detta.setState(({todos}) => ({
todos: todos.concat(det här.stat.todo -)
}))
detta.setState({ todo: “});
}

}

export standard TodoContainer

Behållaren har en inledande todos staten, som är en array med två poster i det. Att lägga till att-göra-objekt, vi har en todo staten ställa till en tom sträng.

Vi kommer att behöva en CreateTodo komponent som kommer att prenumerera på behållaren. Varje gång ett värde matas in onChange-händelse utlöser då brand handleInputChange() metod vi har i behållaren. Att klicka på skicka-knappen kommer att utlösa handleAddTodo(). Den handleDeleteTodo () – metoden får en att-göra-och filtrerar bort att göra som stämmer överens med den som skickas till den.

importera Reagerar från ‘reagerar’
import { Prenumerera } från “outtalade’

importera TodoContainer från”. /behållare/todoContainer’

const CreateTodo = () => {
avkastning (
<div>
<Prenumerera på={[TodoContainer]}>
{todos =>
<div>
<formen onSubmit={todos.handleAddTodo}>
<ingång
type=”text”
värde={todos.stat.todo}
onChange={todos.handleInputChange}
/>
<knappen>Skicka</button>
</form>
</div>
}
</Subscribe>
</div>
);
}

export standard CreateTodo

När en ny att-göra-är lagt, de todos staten gjort tillgängliga i behållaren är uppdaterad. Listan över todos dras från behållaren till Todos komponent, genom att prenumerera komponent i behållaren.

importera Reagerar från ‘reagerar’;
import { Prenumerera } från “outtalade’;

importera TodoContainer från”. /behållare/todoContainer’

const Todos = () => (
<ul>
<Prenumerera på={[TodoContainer]}>
{todos =>
todos.stat.todos.karta(todo => (
<li key={att göra}>
{att göra} <button onClick={() => todos.handleDeleteTodo(todo)}>X</button>
</li>
))
}
</Subscribe>
</ul>
);

export standard Todos

Denna komponent loopar igenom den samling av uppgifter som finns i behållaren och gör dem i en lista.

Slutligen, vi måste slå de komponenter som prenumererar till behållaren på en leverantör som vi gjorde när det gäller räknaren. Detta gör vi i vår App.js fil precis som vi gjorde i counter-exempel:

importera Reagera, { Komponent } ‘reagerar’;
import { Leverantör } från “outtalade’

importera CreateTodo från”. /CreateTodo’
importera Todos från”. /Todos’

klass App förlänger Komponent {
render() {
avkastning (
<Leverantören>
<CreateTodo />
<Todos />
</Buyer>
);
}
}

export standard App;

Att Linda Upp

Det finns olika sätt att hantera stat Reagerar beroende på komplexiteten i din ansökan och Outtalade är en praktisk bibliotek som kan göra det lättare. Det är värt att upprepa punkt som Redux, medan awesome, är inte alltid det bästa verktyget för jobbet, även om vi ofta ta för att det i dessa typer av fall. Förhoppningsvis har du nu känner att du har ett nytt verktyg i bältet.