Zarządzanie stanem za pomocą hooków
Naucz się zarządzać danymi właściwymi dla komponentu za pomocą `useState` i innych podstawowych hooków React.
Zarządzanie stanem za pomocą hooków to bezpłatna lekcja Next.js 15 Fullstack Web Apps na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Next.js 15 Fullstack Web Apps, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Next.js 15 Fullstack Web Apps zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
Intro to Component State
In React, state refers to data that a component manages internally and that can change over time, affecting how the component renders.
Think of it as a component's memory. When state changes, React efficiently updates only the necessary parts of your user interface.
Why State Matters
State is crucial for building interactive and dynamic web applications. Without it, your UI would be static and unable to respond to user actions.
- User Input: Storing text from an input field.
- Toggles: Managing whether a menu is open or closed.
- Counters: Keeping track of a numerical value.
It makes your components 'alive'!
Meet the `useState` Hook
To add state to functional components in React, we use a special function called a Hook. The primary hook for managing local component state is useState.
Hooks are functions that let you 'hook into' React features like state and lifecycle methods from functional components.
Declaring State with `useState`
The useState hook returns an array with two items:
- The current state value.
- A function to update that state value.
We use array destructuring to get these values:
import React, { useState } from 'react';
function MyComponent() {
// Declares a state variable 'count' initialized to 0
// 'setCount' is the function to update 'count'
const [count, setCount] = useState(0);
// Declares a state variable 'name' initialized to an empty string
const [name, setName] = useState('');
return (
<div>
<p>Count: {count}</p>
<p>Name: {name}</p>
</div>
);
}Updating State: Simple Counter
To change the state, you must call the setter function (e.g., setCount). When you call this function, React will re-render your component with the new state value.
Try clicking the button to see the count change!
import React, { useState } from 'react';
function Counter() {
const [count, setCount] = useState(0);
const increment = () => {
setCount(count + 1); // Update the state
};
return (
<div>
<p>Current Count: {count}</p>
<button onClick={increment}>Increment</button>
</div>
);
}State Updates are Asynchronous
It's important to know that state updates in React are often asynchronous. This means React might batch multiple state updates for performance.
Because of this, if your new state depends on the previous state, it's safer to pass a function to the setter.
Functional State Updates
When updating state based on its previous value, provide a function to the setter. This function receives the previous state as an argument.
This pattern ensures you're always working with the most up-to-date state, preventing subtle bugs.
import React, { useState } from 'react';
function SafeCounter() {
const [count, setCount] = useState(0);
const incrementByTwo = () => {
// This ensures we always increment based on the latest count
setCount(prevCount => prevCount + 1);
setCount(prevCount => prevCount + 1);
};
return (
<div>
<p>Count: {count}</p>
<button onClick={incrementByTwo}>Add 2</button>
</div>
);
}Managing User Input
useState is perfect for controlling form input elements. When an input's value is managed by React state, it's called a controlled component.
This gives you full control over the input's value and allows for easy validation or transformation.
Controlled Input Example
Here's how you can use useState to manage the value of a text input field. The onChange event handler updates the state every time the user types.
Type something into the box!
import React, { useState } from 'react';
function InputField() {
const [text, setText] = useState('');
const handleChange = (event) => {
setText(event.target.value); // Update state with input's value
};
return (
<div>
<input type="text" value={text} onChange={handleChange} />
<p>You typed: {text}</p>
</div>
);
}Quick Check: `useState`
Which of the following statements about the useState hook in React are TRUE?
Recap: State with Hooks
You've now learned the core of state management in React using the useState hook!
- What is State? Data that changes and affects component rendering.
useState: The primary hook to add state to functional components.- Syntax:
const [value, setValue] = useState(initial); - Updating: Always use the setter function. For updates based on previous state, pass a function to the setter.
- Use Cases: Counters, toggles, managing user input, and much more!
Mastering useState is a fundamental step in building interactive React apps.
Często zadawane pytania
Czy lekcja „Zarządzanie stanem za pomocą hooków” jest bezpłatna?
Tak — pełny tekst „Zarządzanie stanem za pomocą hooków” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Next.js 15 Fullstack Web Apps, przejdź na CoddyKit PRO. Kurs Next.js 15 Fullstack Web Apps zawiera 4 lekcji w sumie.
Co nauczysz się w „Zarządzanie stanem za pomocą hooków”?
Naucz się zarządzać danymi właściwymi dla komponentu za pomocą `useState` i innych podstawowych hooków React. Ćwiczysz Next.js 15 Fullstack Web Apps z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Next.js 15 Fullstack Web Apps?
Nie wymagamy żadnego doświadczenia. Next.js 15 Fullstack Web Apps w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.
Ile czasu zajmuje lekcja „Zarządzanie stanem za pomocą hooków”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Next.js 15 Fullstack Web Apps?
Tak. Każda lekcja Next.js 15 Fullstack Web Apps zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Komponenty React i JSX
- Zarządzanie stanem za pomocą hooków
- Propsy i komunikacja między komponentami
- Renderowanie list, klucze i interfejs warunkowy