Jotai: A Primitive and Flexible State Management Library for React

Jotai is a minimalistic state management library for React applications. It offers a simple, atomic approach to managing state, allowing you to manage and update state directly within your components while keeping the architecture lean and easy to understand. Jotai is designed to be highly performant and flexible, making it a great choice for React applications of any size, from small projects to large-scale applications.

With its simple API and small bundle size, Jotai is particularly suitable for developers who prefer atomic state management without the boilerplate often associated with more complex state management libraries like Redux.

1. Core Concepts of Jotai

Jotai introduces a straightforward API with a few key concepts that make it easy to manage state in React:

1. Atoms

Atoms in Jotai represent the smallest units of state, similar to Recoil's atoms. An atom holds a single piece of state, and components can read and write the value of an atom. Atoms are globally accessible and are the foundation of Jotai's state management.

Example:

import { atom } from 'jotai';

// Create an atom for a counter state
export const counterAtom = atom(0); // The default value is 0

• atom is used to define a unit of state. The value of this atom can be read or written to in React components.

2. useAtom

The useAtom hook is the primary way to interact with atoms in Jotai. It allows components to read the value of an atom and update it. This is similar to using useState, but with the ability to share state across components.

Example:

import { useAtom } from 'jotai';
import { counterAtom } from './atoms';

const Counter = () => {
  const [counter, setCounter] = useAtom(counterAtom);

  const increment = () => setCounter(counter + 1);
  const decrement = () => setCounter(counter - 1);

  return (
    <div>
      <p>Counter: {counter}</p>
      <button onClick={increment}>Increment</button>
      <button onClick={decrement}>Decrement</button>
    </div>
  );
};

• useAtom is used to get and set the state for an atom. The first value (counter) is the current state, and the second (setCounter) is a function used to update the state.

3. Derived Atoms

Jotai allows you to create derived atoms which are dependent on other atoms or derived data. These are similar to Recoil's selectors and allow you to compute new values based on other atoms.

Example:

import { atom } from 'jotai';
import { counterAtom } from './atoms';

// Create a derived atom
export const doubleCounterAtom = atom((get) => {
  const counter = get(counterAtom); // Get the value of the counter atom
  return counter * 2; // Derive new value
});

• Derived atoms are created using a function that reads other atoms and returns a new value based on those atoms.

4. Atom Effects

Jotai also supports atom effects, which can run code in response to changes in atom values. This allows you to perform side effects like fetching data or running callbacks when state changes.

Example:

import { atom } from 'jotai';

// Create an atom for a counter state
export const counterAtom = atom(0); // The default value is 0

• This pattern enables executing side effects, like API calls or logging, whenever the state of an atom changes.

2. Benefits of Using Jotai

1. Simple and Lightweight

Jotai is designed to be minimalistic and lightweight, with a very small API surface. It doesn’t require boilerplate code like action creators or reducers, making it faster to get started with.

2. Performance

Jotai uses a reactive model, where only the components that use a particular atom will re-render when that atom changes. This results in efficient updates, especially for large applications with many components.

3. Fine-Grained Control

Jotai gives you fine-grained control over the state in your application. Atoms are independent and can be managed directly without the need for complex structures like reducers or context providers.

4. Minimal Re-Renders

Jotai optimizes re-renders by only updating components that subscribe to the specific atom that changed, rather than re-rendering the entire component tree.

5. Scalable and Flexible

Jotai’s atomic design makes it easy to scale as your application grows. You can have multiple independent atoms that represent different parts of your application’s state, which makes the architecture clean and flexible.

3. Example of Full Jotai Application

Here's an example of a small counter app using Jotai:

import { useAtom } from 'jotai';
import { counterAtom } from './atoms';

const Counter = () => {
  const [counter, setCounter] = useAtom(counterAtom);

  const increment = () => setCounter(counter + 1);
  const decrement = () => setCounter(counter - 1);

  return (
    <div>
      <p>Counter: {counter}</p>
      <button onClick={increment}>Increment</button>
      <button onClick={decrement}>Decrement</button>
    </div>
  );
};

import { atom } from 'jotai';
import { counterAtom } from './atoms';

// Create a derived atom
export const doubleCounterAtom = atom((get) => {
  const counter = get(counterAtom); // Get the value of the counter atom
  return counter * 2; // Derive new value
});

import { atom } from 'jotai';

export const counterAtom = atom(
  0, // Initial value
  (get, set, update) => {
    // Atom effect: run a side effect when the counter is updated
    console.log('Counter updated:', update);
    set(counterAtom, update); // Update the state of counterAtom
  }
);

How This Works:

• Atoms hold the state for the counter (counterAtom).
• useAtom is used inside the Counter component to both read and update the atom's value.
• setCounter updates the atom’s state when the buttons are clicked.

4. When to Use Jotai

Jotai is a great choice when:

• You need a minimalist and efficient state management solution.
• You want to manage state at the atomic level.
• You prefer a declarative and flexible API without the need for additional boilerplate.
• You are working on a project that requires high performance and fine-grained control over re-renders.

If your project is small or you want to avoid the complexities of larger state management solutions like Redux, Jotai provides a simple and powerful alternative.

5. Conclusion

Jotai is a powerful yet lightweight state management library that focuses on atomic state and minimalism. With its simple API, performance optimizations, and fine-grained control, Jotai is an excellent choice for React developers looking for a flexible, efficient state management solution.

The above is the detailed content of Jotai: A Simple and Powerful State Management Library for React. For more information, please follow other related articles on the PHP Chinese website!