Zustandsverwaltung ist ein entscheidender Aspekt der modernen Webentwicklung, insbesondere bei komplexen Anwendungen. Dazu gehört der Umgang mit Daten, die sich im Laufe der Zeit ändern können, und die Sicherstellung, dass diese Daten in der gesamten Anwendung konsistent dargestellt werden. Eine effektive Zustandsverwaltung führt zu vorhersehbareren und besser wartbaren Anwendungen.
Zustand ist eine kleine, schnelle und skalierbare Zustandsverwaltungslösung für React-Anwendungen. Zustand wurde von Jared Palmer und Daishi Kato entwickelt und bietet eine einfache und intuitive API, die die Zustandsverwaltung im Vergleich zu anderen Lösungen weniger umständlich macht.
Bevor wir tiefer in den Zustand eintauchen, wollen wir die verschiedenen Zustandstypen in Webanwendungen verstehen:
Zustand zeichnet sich durch die Verwaltung sowohl lokaler als auch globaler Status aus und kann in Lösungen für die Remote-Statusverwaltung integriert werden.
Um Zustand zu verwenden, installieren Sie es zunächst über npm, Yarn oder pnpm:
npm install zustand # or yarn add zustand # or pnpm add zustand
Zustand verfügt über mehrere Funktionen, die es auszeichnen:
Sehen wir uns eine grundlegende Implementierung von Zustand:
an
import { create } from 'zustand'
const useStore = create((set) => ({
bears: 0,
increasePopulation: () => set((state) => ({ bears: state.bears + 1 })),
removeAllBears: () => set({ bears: 0 }),
}))
function BearCounter() {
const bears = useStore((state) => state.bears)
return <h1>{bears} around here...</h1>
}
function Controls() {
const increasePopulation = useStore((state) => state.increasePopulation)
return <button onClick={increasePopulation}>one up</button>
}
In diesem Beispiel erstellen wir einen Shop mit einem Bärenstatus und zwei Aktionen, um ihn zu ändern. Die BearCounter- und Controls-Komponenten können dann mithilfe des useStore-Hooks auf den Status zugreifen und ihn ändern.
Vergleichen wir Zustand mit anderen beliebten Lösungen zur Zustandsverwaltung:
Vorteile des Zustands:
Nachteile:
Vorteile des Zustands:
Nachteile:
Vorteile des Zustands:
Nachteile:
Zustands Systemdesign basiert auf einigen Grundprinzipien:
This design allows Zustand to be both simple and powerful, providing excellent performance even in large applications.
Zustand makes it easy to persist state, which is crucial for many applications. Here's an example using the persist middleware:
import { create } from 'zustand'
import { persist } from 'zustand/middleware'
const useStore = create(persist(
(set, get) => ({
fishes: 0,
addAFish: () => set({ fishes: get().fishes + 1 }),
}),
{
name: 'food-storage', // unique name
getStorage: () => localStorage, // (optional) by default, 'localStorage' is used
}
))
This will automatically save the state to localStorage and rehydrate it when the app reloads.
One of Zustand's strengths is that it can be used outside of React components. This is particularly useful for integrating with other parts of your application or for testing:
const { getState, setState } = useStore
// Getting state
console.log(getState().bears)
// Setting state
setState({ bears: 10 })
// Using actions
getState().increasePopulation()
Let's look at some real-world examples of using Zustand:
import { create } from 'zustand'
const useAuthStore = create((set) => ({
user: null,
isAuthenticated: false,
login: (userData) => set({ user: userData, isAuthenticated: true }),
logout: () => set({ user: null, isAuthenticated: false }),
}))
// Usage in a component
function LoginButton() {
const { isAuthenticated, login, logout } = useAuthStore()
const handleAuth = () => {
if (isAuthenticated) {
logout()
} else {
// Simulate login
login({ id: 1, name: 'John Doe' })
}
}
return (
<button onClick={handleAuth}>
{isAuthenticated ? 'Logout' : 'Login'}
</button>
)
}
import { create } from 'zustand'
const useCartStore = create((set) => ({
items: [],
addItem: (item) => set((state) => ({ items: [...state.items, item] })),
removeItem: (itemId) => set((state) => ({
items: state.items.filter((item) => item.id !== itemId),
})),
clearCart: () => set({ items: [] }),
total: 0,
updateTotal: () => set((state) => ({
total: state.items.reduce((sum, item) => sum + item.price, 0),
})),
}))
// Usage in components
function CartSummary() {
const { items, total, removeItem } = useCartStore()
return (
<div>
{items.map((item) => (
<div key={item.id}>
{item.name} - ${item.price}
<button onClick={() => removeItem(item.id)}>Remove</button>
</div>
))}
<div>Total: ${total}</div>
</div>
)
}
import { create } from 'zustand'
import { persist } from 'zustand/middleware'
const useThemeStore = create(persist(
(set) => ({
theme: 'light',
toggleTheme: () => set((state) => ({
theme: state.theme === 'light' ? 'dark' : 'light',
})),
}),
{
name: 'theme-storage',
}
))
// Usage in a component
function ThemeToggle() {
const { theme, toggleTheme } = useThemeStore()
return (
<button onClick={toggleTheme}>
Switch to {theme === 'light' ? 'dark' : 'light'} mode
</button>
)
}
Zustand offers a refreshing approach to state management in React applications. Its simplicity, flexibility, and performance make it an excellent choice for both small and large projects. By reducing boilerplate and providing a straightforward API, Zustand allows developers to focus on building features rather than managing complex state logic.
While it may not have the extensive ecosystem of some older state management solutions, Zustand's design principles and ease of use make it a compelling option for modern React development. Its ability to work outside of React components and easy integration with persistence solutions further extend its utility.
For many React applications, Zustand strikes an excellent balance between simplicity and power, making it worth considering for your next project.
Zustand also handles asynchronous functions/code really well and without the need for any Middleware setup.
Let's talk a bit about that:
One of Zustand's strengths is its simplicity in handling asynchronous operations without the need for additional middleware or complex setups. This makes it particularly easy to work with API calls, data fetching, and other asynchronous tasks.
Zustand's approach to asynchronous code is straightforward:
Here's an example of how to implement asynchronous code in Zustand:
import { create } from 'zustand'
const useUserStore = create((set) => ({
user: null,
isLoading: false,
error: null,
fetchUser: async (userId) => {
set({ isLoading: true, error: null });
try {
const response = await fetch(`https://api.example.com/users/${userId}`);
if (!response.ok) throw new Error('Failed to fetch user');
const userData = await response.json();
set({ user: userData, isLoading: false });
} catch (error) {
set({ error: error.message, isLoading: false });
}
},
}));
// Usage in a component
function UserProfile({ userId }) {
const { user, isLoading, error, fetchUser } = useUserStore();
React.useEffect(() => {
fetchUser(userId);
}, [userId]);
if (isLoading) return <div>Loading...</div>;
if (error) return <div>Error: {error}</div>;
if (!user) return null;
return (
<div>
<h1>{user.name}</h1>
<p>Email: {user.email}</p>
</div>
);
}
In this example:
Unlike Redux, which often requires middleware like Redux Thunk or Redux Saga for handling async operations, Zustand's approach is much more straightforward. This simplicity can lead to less boilerplate and a gentler learning curve, especially for developers new to state management.
MobX and Recoil also offer ways to handle async operations, but Zustand's approach might be considered more intuitive due to its direct use of async/await syntax without additional abstractions.
Zustands Umgang mit asynchronem Code verdeutlicht seine Philosophie der Einfachheit und Flexibilität. Indem es Entwicklern ermöglicht, asynchrone Funktionen ohne spezielle Syntax oder Middleware direkt im Store zu schreiben, erleichtert Zustand die Verwaltung komplexer Zustandsoperationen und hält gleichzeitig die Codebasis sauber und lesbar.
Dieser Ansatz für asynchronen Code macht es in Kombination mit den anderen Funktionen von Zustand, wie der geringen Bundle-Größe und der einfachen Einrichtung, zu einer hervorragenden Wahl für Projekte jeder Größe, insbesondere für Projekte, die eine erhebliche asynchrone Zustandsverwaltung erfordern.
Ich hoffe, dieser „irgendwie Leitfaden“ war nützlich und aufschlussreich für alle von Ihnen, die darüber nachdenken, wie Sie Ihren globalen Bewerbungsstatus verwalten können.
Vielen Dank und viel Spaß beim Codieren.
Schauen Sie sich auf meiner Website unter https://www.ricardogesteves.com um
Folge mir @ricardogesteves
X(twitter)
Full-Stack-Entwickler | Leidenschaft für die Schaffung intuitiver und wirkungsvoller Benutzererlebnisse | Sitz in Lissabon, Portugal ?? - Ricardo GEsteves
github.com
Das obige ist der detaillierte Inhalt vonZustand, Wann, Wie und Warum. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Methode zum Festlegen des HTML-Bereichs
IIS unerwarteter Fehler 0x8ffe2740 Lösung
Implementierungsmethode der js-Sperrfunktion
Eine vollständige Liste der Betriebs- und Wartungsbefehle für Linux-Server
Verwendung zufälliger Funktionen in der C-Sprache
Wie lautet das Passwort für den Mobilfunkdienst?
So sperren Sie den Bildschirm auf oppo11
So passen Sie die Helligkeit des Computerbildschirms an
