Lab / ReactJS

Jotai: новый быстрый стор для React, пишем Wishlist и корзину

Jotai это библиотека управления состоянием для React, тоесть ещё один state manager. Jotai построен на концепции атомов (atoms). В отличие от Zustand, где мы обычно создаём store с данными и с методами, Jotai позволяет разделить состояние приложения на небольшие независимые части, которые могут взаимодействовать друг с другом.

Главное преимущество такого подхода, что компоненты обзёрвят только на необходимые им атомы. При изменении одного состояния React не приходится перерисовывать все компоненты, использующие общий store.

Разберём два примера: простой Wishlist с сохранением в LocalStorage и более сложный пример - корзина для интернет-магазина с расчётом стоимости, скидками и доставкой.

Примеры рассчитаны на React 18/19 и Jotai 3.

Установка Jotai

В существующем React-проекте устанавливаем библиотеку:

npm install jotai

Пример 1. Wishlist с сохранением в LocalStorage

Предположим, у нас есть каталог товаров. Пользователь может добавлять товары в избранное, удалять их и видеть количество сохранённых товаров в шапке сайта.

Нам нужно, чтобы состояние было доступно из разных компонентов и сохранялось после перезагрузки страницы.

Создаём атомы

src/store/wishlist.js

import { atom } from 'jotai'
import { atomWithStorage } from 'jotai/utils'

// Список избранных товаров
export const wishlistAtom = atomWithStorage('wishlist', [])

// Количество избранных товаров
export const wishlistCountAtom = atom(
  (get) => get(wishlistAtom).length
)

// Добавление и удаление товара
export const toggleWishlistAtom = atom(
  null,
  (get, set, product) => {
    const wishlist = get(wishlistAtom)

    const exists = wishlist.some(
      (item) => item.id === product.id
    )

    set(
      wishlistAtom,
      exists
        ? wishlist.filter((item) => item.id !== product.id)
        : [...wishlist, product]
    )
  }
)

Тут используются три атома с разным назначением.

wishlistAtom хранит массив товаров в LocalStorage. wishlistCountAtom вычисляет количество элементов на основании первого атома. toggleWishlistAtom отвечает за изменение состояния, добавление или удаление товара.

Обратите внимание, что у wishlistCountAtom нет собственного хранилища. Jotai автоматически пересчитывает его значение при изменении wishlistAtom.

Добавляем кнопку в карточку товара

src/components/ProductCard.jsx

import { useAtomValue, useSetAtom } from 'jotai'
import {
  wishlistAtom,
  toggleWishlistAtom
} from '../store/wishlist'

export default function ProductCard({ product }) {
  const wishlist = useAtomValue(wishlistAtom)
  const toggleWishlist = useSetAtom(toggleWishlistAtom)

  const isFavorite = wishlist.some(
    (item) => item.id === product.id
  )

  return (
    <article>
      <h3>{product.name}</h3>
      <p>{product.price} €</p>

      <button
        type="button"
        aria-pressed={isFavorite}
        onClick={() => toggleWishlist(product)}
      >
        {isFavorite ? '♥ В избранном' : '♡ В избранное'}
      </button>
    </article>
  )
}

Хук useAtomValue() позволяет только читать значение атома, а useSetAtom() — изменять его без подписки на значение.

Таким образом, логика добавления и удаления товаров полностью вынесена из компонента.

Выводим счётчик в шапке

src/components/WishlistCounter.jsx

import { useAtomValue } from 'jotai'
import { wishlistCountAtom } from '../store/wishlist'

export default function WishlistCounter() {
  const count = useAtomValue(wishlistCountAtom)

  return <a href="/wishlist">Избранное ({count})</a>
}

Счётчик обновляется автоматически при добавлении или удалении товара из любого компонента приложения.

Создаём страницу Wishlist

src/components/Wishlist.jsx

import { useAtomValue, useSetAtom } from 'jotai'
import {
  wishlistAtom,
  toggleWishlistAtom
} from '../store/wishlist'

export default function Wishlist() {
  const wishlist = useAtomValue(wishlistAtom)
  const toggleWishlist = useSetAtom(toggleWishlistAtom)

  if (!wishlist.length) {
    return <p>Ваш список избранного пуст.</p>
  }

  return (
    <section>
      <h1>Избранное</h1>

      {wishlist.map((product) => (
        <article key={product.id}>
          <h3>{product.name}</h3>
          <p>{product.price} €</p>

          <button onClick={() => toggleWishlist(product)}>
            Удалить
          </button>
        </article>
      ))}
    </section>
  )
}

Мы получили общее состояние для каталога, шапки и страницы избранного. Нам не пришлось создавать Context, передавать props через промежуточные компоненты или вручную синхронизировать LocalStorage.

Для авторизованных пользователей Wishlist обычно синхронизируют с сервером. Но для гостевого списка такой реализации вполне достаточно.

Пример 2. Корзина с промокодами и расчётом доставки

Теперь усложним задачу. Создадим корзину интернет-магазина со следующей логикой:

Главная идея — хранить только исходные данные, а все вычисляемые значения получать через зависимые атомы.

Создаём хранилище корзины

src/store/cart.js

import { atom } from 'jotai'
import { atomWithStorage } from 'jotai/utils'

// Исходные данные
export const cartAtom = atomWithStorage('cart', [])
export const promoAtom = atom('')
export const deliveryAtom = atom('courier')

// Количество товаров
export const cartCountAtom = atom((get) =>
  get(cartAtom).reduce((sum, item) => sum + item.quantity, 0)
)

// Стоимость товаров
export const subtotalAtom = atom((get) =>
  get(cartAtom).reduce(
    (sum, item) => sum + item.price * item.quantity,
    0
  )
)

// Скидка
export const discountAtom = atom((get) => {
  const promo = get(promoAtom).trim().toUpperCase()
  const subtotal = get(subtotalAtom)

  return promo === 'SAVE10' ? subtotal * 0.1 : 0
})

// Стоимость доставки
export const shippingAtom = atom((get) => {
  const delivery = get(deliveryAtom)
  const amount = get(subtotalAtom) - get(discountAtom)

  if (delivery === 'pickup' || amount >= 100 || amount === 0) {
    return 0
  }

  return 7.9
})

// Итоговая стоимость заказа
export const totalAtom = atom((get) =>
  get(subtotalAtom) - get(discountAtom) + get(shippingAtom)
)

// Добавить товар
export const addToCartAtom = atom(null, (get, set, product) => {
  set(cartAtom, (items) => {
    const exists = items.some((item) => item.id === product.id)

    if (exists) {
      return items.map((item) =>
        item.id === product.id
          ? { ...item, quantity: item.quantity + 1 }
          : item
      )
    }

    return [...items, { ...product, quantity: 1 }]
  })
})

// Изменить количество
export const changeQuantityAtom = atom(
  null,
  (get, set, { id, delta }) => {
    set(cartAtom, (items) =>
      items
        .map((item) =>
          item.id === id
            ? { ...item, quantity: item.quantity + delta }
            : item
        )
        .filter((item) => item.quantity > 0)
    )
  }
)

Обратите внимание на totalAtom. Он зависит от трёх других атомов, а те, в свою очередь, зависят от исходных данных корзины, промокода и способа доставки.

При любом изменении Jotai самостоятельно пересчитает необходимые значения. Нам не нужно создавать дополнительные useEffect или хранить отдельно каждый результат вычислений.

Компонент добавления товара

src/components/AddToCart.jsx

import { useSetAtom } from 'jotai'
import { addToCartAtom } from '../store/cart'

export default function AddToCart({ product }) {
  const addToCart = useSetAtom(addToCartAtom)

  return (
    <button onClick={() => addToCart(product)}>
      Добавить в корзину
    </button>
  )
}

Использование в карточке товара:

<AddToCart
  product={{
    id: 123,
    name: 'Parfum No. 1',
    price: 85
  }}
/>

Создаём компонент корзины

src/components/Cart.jsx

import { useAtom, useAtomValue, useSetAtom } from 'jotai'

import {
  cartAtom,
  cartCountAtom,
  promoAtom,
  deliveryAtom,
  subtotalAtom,
  discountAtom,
  shippingAtom,
  totalAtom,
  changeQuantityAtom
} from '../store/cart'

const formatPrice = (value) =>
  new Intl.NumberFormat('ru-RU', {
    style: 'currency',
    currency: 'EUR'
  }).format(value)

export default function Cart() {
  const items = useAtomValue(cartAtom)
  const count = useAtomValue(cartCountAtom)
  const subtotal = useAtomValue(subtotalAtom)
  const discount = useAtomValue(discountAtom)
  const shipping = useAtomValue(shippingAtom)
  const total = useAtomValue(totalAtom)

  const [promo, setPromo] = useAtom(promoAtom)
  const [delivery, setDelivery] = useAtom(deliveryAtom)

  const changeQuantity = useSetAtom(changeQuantityAtom)

  return (
    <section>
      <h2>Корзина ({count})</h2>

      {items.map((item) => (
        <article key={item.id}>
          <h3>{item.name}</h3>
          <p>{formatPrice(item.price)}</p>

          <button
            onClick={() => changeQuantity({
              id: item.id,
              delta: -1
            })}
          >
            −
          </button>

          <span>{item.quantity}</span>

          <button
            onClick={() => changeQuantity({
              id: item.id,
              delta: 1
            })}
          >
            +
          </button>
        </article>
      ))}

      <h3>Промокод</h3>

      <input
        value={promo}
        onChange={(e) => setPromo(e.target.value)}
        placeholder="Введите промокод"
      />

      <h3>Доставка</h3>

      <select
        value={delivery}
        onChange={(e) => setDelivery(e.target.value)}
      >
        <option value="courier">Курьер</option>
        <option value="pickup">Самовывоз</option>
      </select>

      <hr />

      <p>Товары: {formatPrice(subtotal)}</p>
      <p>Скидка: {formatPrice(discount)}</p>
      <p>Доставка: {formatPrice(shipping)}</p>

      <h2>Итого: {formatPrice(total)}</h2>
    </section>
  )
}

Проверим работу на конкретном примере. Добавим два товара общей стоимостью 120 € и применим промокод SAVE10.

Интерактивная демонстрация расчётов по логике примера.

Измените количество товара, промокод или способ доставки. Итоговая сумма пересчитается автоматически. В React-приложении эту реактивность обеспечивает Jotai.

Как работают зависимости атомов

Зависимости вычисляются через get(). Пунктирные линии показывают зависимости расчёта доставки.

Если изменяется cartAtom, Jotai обновляет стоимость товаров, затем зависимые скидку, доставку и итоговую сумму. При изменении promoAtom пересчитываются скидка, доставка и итог, но само содержимое корзины остаётся прежним.

Именно здесь становится заметно преимущество атомарного подхода. Каждый атом отвечает за свою часть состояния, а зависимости между ними описываются обычными JavaScript-функциями.

Что важно учитывать

В примере корзины все расчёты выполняются на клиенте. Для реального интернет-магазина сервер должен повторно проверять цены, промокоды и стоимость доставки перед оплатой. Денежные значения в production лучше хранить в минимальных единицах валюты, например в евроцентах.

Ещё один нюанс касается SSR: при использовании atomWithStorage сервер не имеет доступа к LocalStorage. Для Next.js стоит учитывать гидратацию и выводить зависящий от сохранённых данных интерфейс после инициализации на клиенте.

Выводы

Jotai особенно удобен, когда приложение содержит много небольших взаимосвязанных состояний: корзина, избранное, фильтры каталога, параметры интерфейса, многошаговые формы и различные вычисляемые значения.

Для простых случаев разница с Zustand будет небольшой. Но по мере усложнения приложения возможность создавать независимые атомы и связывать их между собой позволяет избежать большого монолитного store.