diff --git a/src/content/learn/managing-state.md b/src/content/learn/managing-state.md
index 93bcc10fd6..40fa2ca8cb 100644
--- a/src/content/learn/managing-state.md
+++ b/src/content/learn/managing-state.md
@@ -4,27 +4,27 @@ title: Managing State
 
 <Intro>
 
-As your application grows, it helps to be more intentional about how your state is organized and how the data flows between your components. Redundant or duplicate state is a common source of bugs. In this chapter, you'll learn how to structure your state well, how to keep your state update logic maintainable, and how to share state between distant components.
+По мере роста вашего приложения полезно более осознанно подходить к организации состояния и потокам данных между компонентами. Избыточное или дублирующееся состояние — частый источник ошибок. В этой главе вы узнаете, как правильно структурировать состояние, как поддерживать логику обновления состояния в управляемом виде и как совместно использовать состояние между удалёнными компонентами.
 
 </Intro>
 
 <YouWillLearn isChapter={true}>
 
-* [How to think about UI changes as state changes](/learn/reacting-to-input-with-state)
-* [How to structure state well](/learn/choosing-the-state-structure)
-* [How to "lift state up" to share it between components](/learn/sharing-state-between-components)
-* [How to control whether the state gets preserved or reset](/learn/preserving-and-resetting-state)
-* [How to consolidate complex state logic in a function](/learn/extracting-state-logic-into-a-reducer)
-* [How to pass information without "prop drilling"](/learn/passing-data-deeply-with-context)
-* [How to scale state management as your app grows](/learn/scaling-up-with-reducer-and-context)
+* [Как думать об изменениях UI как об изменениях состояния](/learn/reacting-to-input-with-state)
+* [Как правильно структурировать состояние](/learn/choosing-the-state-structure)
+* [Как «поднимать состояние вверх» для совместного использования между компонентами](/learn/sharing-state-between-components)
+* [Как контролировать сохранение или сброс состояния](/learn/preserving-and-resetting-state)
+* [Как консолидировать сложную логику состояния в функции](/learn/extracting-state-logic-into-a-reducer)
+* [Как передавать информацию без «проп-драйлинга»](/learn/passing-data-deeply-with-context)
+* [Как масштабировать управление состоянием по мере роста приложения](/learn/scaling-up-with-reducer-and-context)
 
 </YouWillLearn>
 
-## Reacting to input with state {/*reacting-to-input-with-state*/}
+## Реакция на ввод с помощью состояния {/*reacting-to-input-with-state*/}
 
-With React, you won't modify the UI from code directly. For example, you won't write commands like "disable the button", "enable the button", "show the success message", etc. Instead, you will describe the UI you want to see for the different visual states of your component ("initial state", "typing state", "success state"), and then trigger the state changes in response to user input. This is similar to how designers think about UI.
+В React вы не будете напрямую изменять UI из кода. Например, вы не будете писать команды вроде «отключить кнопку», «включить кнопку», «показать сообщение об успехе» и т. д. Вместо этого вы опишете UI, который хотите видеть для различных визуальных состояний вашего компонента («начальное состояние», «состояние ввода», «состояние успеха»), а затем будете запускать изменения состояния в ответ на ввод пользователя. Это похоже на то, как дизайнеры думают об UI.
 
-Here is a quiz form built using React. Note how it uses the `status` state variable to determine whether to enable or disable the submit button, and whether to show the success message instead.
+Вот форма викторины, созданная с использованием React. Обратите внимание, как она использует переменную состояния `status`, чтобы определить, следует ли включать или отключать кнопку отправки, и следует ли показывать сообщение об успехе вместо этого.
 
 <Sandpack>
 
@@ -108,15 +108,15 @@ function submitForm(answer) {
 
 <LearnMore path="/learn/reacting-to-input-with-state">
 
-Read **[Reacting to Input with State](/learn/reacting-to-input-with-state)** to learn how to approach interactions with a state-driven mindset.
+Прочтите **[Реакция на ввод с помощью состояния](/learn/reacting-to-input-with-state)**, чтобы узнать, как подходить к взаимодействиям с точки зрения управления состоянием.
 
 </LearnMore>
 
-## Choosing the state structure {/*choosing-the-state-structure*/}
+## Выбор структуры состояния {/*choosing-the-state-structure*/}
 
-Structuring state well can make a difference between a component that is pleasant to modify and debug, and one that is a constant source of bugs. The most important principle is that state shouldn't contain redundant or duplicated information. If there's unnecessary state, it's easy to forget to update it, and introduce bugs!
+Правильная структура состояния может иметь решающее значение между компонентом, который приятно изменять и отлаживать, и тем, который является постоянным источником ошибок. Самый важный принцип — состояние не должно содержать избыточной или дублирующейся информации. Если есть ненужное состояние, его легко забыть обновить, что приведёт к ошибкам!
 
-For example, this form has a **redundant** `fullName` state variable:
+Например, эта форма имеет **избыточную** переменную состояния `fullName`:
 
 <Sandpack>
 
@@ -169,7 +169,7 @@ label { display: block; margin-bottom: 5px; }
 
 </Sandpack>
 
-You can remove it and simplify the code by calculating `fullName` while the component is rendering:
+Вы можете удалить его и упростить код, вычисляя `fullName` во время рендеринга компонента:
 
 <Sandpack>
 
@@ -221,19 +221,19 @@ label { display: block; margin-bottom: 5px; }
 
 </Sandpack>
 
-This might seem like a small change, but many bugs in React apps are fixed this way.
+Это может показаться небольшим изменением, но многие ошибки в приложениях React исправляются таким образом.
 
 <LearnMore path="/learn/choosing-the-state-structure">
 
-Read **[Choosing the State Structure](/learn/choosing-the-state-structure)** to learn how to design the state shape to avoid bugs.
+Прочтите **[Выбор структуры состояния](/learn/choosing-the-state-structure)**, чтобы узнать, как проектировать форму состояния для предотвращения ошибок.
 
 </LearnMore>
 
-## Sharing state between components {/*sharing-state-between-components*/}
+## Совместное использование состояния между компонентами {/*sharing-state-between-components*/}
 
-Sometimes, you want the state of two components to always change together. To do it, remove state from both of them, move it to their closest common parent, and then pass it down to them via props. This is known as "lifting state up", and it's one of the most common things you will do writing React code.
+Иногда вам нужно, чтобы состояние двух компонентов всегда изменялось вместе. Для этого удалите состояние из обоих компонентов, переместите его в их ближайшего общего родителя, а затем передайте его им через пропсы. Это известно как «подъём состояния вверх» (lifting state up), и это одна из самых распространённых вещей, которые вы будете делать при написании кода React.
 
-In this example, only one panel should be active at a time. To achieve this, instead of keeping the active state inside each individual panel, the parent component holds the state and specifies the props for its children.
+В этом примере только одна панель должна быть активна одновременно. Чтобы добиться этого, вместо того чтобы хранить активное состояние внутри каждой отдельной панели, родительский компонент хранит состояние и указывает пропсы для своих дочерних компонентов.
 
 <Sandpack>
 
@@ -296,15 +296,15 @@ h3, p { margin: 5px 0px; }
 
 <LearnMore path="/learn/sharing-state-between-components">
 
-Read **[Sharing State Between Components](/learn/sharing-state-between-components)** to learn how to lift state up and keep components in sync.
+Прочтите **[Совместное использование состояния между компонентами](/learn/sharing-state-between-components)**, чтобы узнать, как поднимать состояние вверх и синхронизировать компоненты.
 
 </LearnMore>
 
-## Preserving and resetting state {/*preserving-and-resetting-state*/}
+## Сохранение и сброс состояния {/*preserving-and-resetting-state*/}
 
-When you re-render a component, React needs to decide which parts of the tree to keep (and update), and which parts to discard or re-create from scratch. In most cases, React's automatic behavior works well enough. By default, React preserves the parts of the tree that "match up" with the previously rendered component tree.
+При повторном рендеринге компонента React должен решить, какие части дерева сохранить (и обновить), а какие — отбросить или пересоздать с нуля. В большинстве случаев автоматическое поведение React работает достаточно хорошо. По умолчанию React сохраняет части дерева, которые «совпадают» с предыдущим деревом отрендеренного компонента.
 
-However, sometimes this is not what you want. In this chat app, typing a message and then switching the recipient does not reset the input. This can make the user accidentally send a message to the wrong person:
+Однако иногда это не то, чего вы хотите. В этом чат-приложении ввод сообщения, а затем переключение получателя не сбрасывает поле ввода. Это может привести к тому, что пользователь случайно отправит сообщение не тому человеку:
 
 <Sandpack>
 
@@ -399,7 +399,7 @@ textarea {
 
 </Sandpack>
 
-React lets you override the default behavior, and *force* a component to reset its state by passing it a different `key`, like `<Chat key={email} />`. This tells React that if the recipient is different, it should be considered a *different* `Chat` component that needs to be re-created from scratch with the new data (and UI like inputs). Now switching between the recipients resets the input field--even though you render the same component.
+React позволяет переопределить поведение по умолчанию и *принудительно* сбросить состояние компонента, передав ему другой `key`, например `<Chat key={email} />`. Это говорит React, что если получатель отличается, он должен считаться *другим* компонентом `Chat`, который необходимо пересоздать с нуля с новыми данными (и UI, такими как поля ввода). Теперь переключение между получателями сбрасывает поле ввода — даже если вы рендерите один и тот же компонент.
 
 <Sandpack>
 
@@ -496,13 +496,13 @@ textarea {
 
 <LearnMore path="/learn/preserving-and-resetting-state">
 
-Read **[Preserving and Resetting State](/learn/preserving-and-resetting-state)** to learn the lifetime of state and how to control it.
+Прочтите **[Сохранение и сброс состояния](/learn/preserving-and-resetting-state)**, чтобы узнать о жизненном цикле состояния и как им управлять.
 
 </LearnMore>
 
-## Extracting state logic into a reducer {/*extracting-state-logic-into-a-reducer*/}
+## Извлечение логики состояния в редьюсер {/*extracting-state-logic-into-a-reducer*/}
 
-Components with many state updates spread across many event handlers can get overwhelming. For these cases, you can consolidate all the state update logic outside your component in a single function, called "reducer". Your event handlers become concise because they only specify the user "actions". At the bottom of the file, the reducer function specifies how the state should update in response to each action!
+Компоненты с множеством обновлений состояния, распределённых по многим обработчикам событий, могут стать громоздкими. В таких случаях вы можете консолидировать всю логику обновления состояния за пределами вашего компонента в одной функции, называемой «редьюсер» (reducer). Ваши обработчики событий станут лаконичными, поскольку они будут только указывать на «действия» пользователя. В нижней части файла функция редьюсера определяет, как состояние должно обновляться в ответ на каждое действие!
 
 <Sandpack>
 
@@ -693,15 +693,15 @@ ul, li { margin: 0; padding: 0; }
 
 <LearnMore path="/learn/extracting-state-logic-into-a-reducer">
 
-Read **[Extracting State Logic into a Reducer](/learn/extracting-state-logic-into-a-reducer)** to learn how to consolidate logic in the reducer function.
+Прочтите **[Извлечение логики состояния в редьюсер](/learn/extracting-state-logic-into-a-reducer)**, чтобы узнать, как консолидировать логику в функции редьюсера.
 
 </LearnMore>
 
-## Passing data deeply with context {/*passing-data-deeply-with-context*/}
+## Передача данных вглубь с помощью контекста {/*passing-data-deeply-with-context*/}
 
-Usually, you will pass information from a parent component to a child component via props. But passing props can become inconvenient if you need to pass some prop through many components, or if many components need the same information. Context lets the parent component make some information available to any component in the tree below it—no matter how deep it is—without passing it explicitly through props.
+Обычно вы передаёте информацию из родительского компонента в дочерний через пропсы. Но передача пропсов может стать неудобной, если вам нужно передать какой-то пропс через множество компонентов или если многим компонентам нужна одна и та же информация. Контекст позволяет родительскому компоненту сделать некоторую информацию доступной для любого компонента в дереве ниже него — независимо от того, насколько глубоко он находится — без явной передачи через пропсы.
 
-Here, the `Heading` component determines its heading level by "asking" the closest `Section` for its level. Each `Section` tracks its own level by asking the parent `Section` and adding one to it. Every `Section` provides information to all components below it without passing props--it does that through context.
+Здесь компонент `Heading` определяет свой уровень заголовка, «спрашивая» ближайший `Section` о его уровне. Каждый `Section` отслеживает свой собственный уровень, спрашивая родительский `Section` и добавляя к нему единицу. Каждый `Section` предоставляет информацию всем компонентам ниже него, не передавая пропсы — он делает это через контекст.
 
 <Sandpack>
 
@@ -795,15 +795,15 @@ export const LevelContext = createContext(0);
 
 <LearnMore path="/learn/passing-data-deeply-with-context">
 
-Read **[Passing Data Deeply with Context](/learn/passing-data-deeply-with-context)** to learn about using context as an alternative to passing props.
+Прочтите **[Передача данных вглубь с помощью контекста](/learn/passing-data-deeply-with-context)**, чтобы узнать об использовании контекста как альтернативы передаче пропсов.
 
 </LearnMore>
 
-## Scaling up with reducer and context {/*scaling-up-with-reducer-and-context*/}
+## Масштабирование с помощью редьюсера и контекста {/*scaling-up-with-reducer-and-context*/}
 
-Reducers let you consolidate a component’s state update logic. Context lets you pass information deep down to other components. You can combine reducers and context together to manage state of a complex screen.
+Редьюсеры позволяют консолидировать логику обновления состояния компонента. Контекст позволяет передавать информацию глубоко другим компонентам. Вы можете объединить редьюсеры и контекст вместе для управления состоянием сложного экрана.
 
-With this approach, a parent component with complex state manages it with a reducer. Other components anywhere deep in the tree can read its state via context. They can also dispatch actions to update that state.
+С помощью этого подхода родительский компонент со сложным состоянием управляет им с помощью редьюсера. Другие компоненты, находящиеся глубоко в дереве, могут читать его состояние через контекст. Они также могут отправлять действия для обновления этого состояния.
 
 <Sandpack>
 
@@ -1006,12 +1006,12 @@ ul, li { margin: 0; padding: 0; }
 
 <LearnMore path="/learn/scaling-up-with-reducer-and-context">
 
-Read **[Scaling Up with Reducer and Context](/learn/scaling-up-with-reducer-and-context)** to learn how state management scales in a growing app.
+Прочтите **[Масштабирование с помощью редьюсера и контекста](/learn/scaling-up-with-reducer-and-context)**, чтобы узнать, как управление состоянием масштабируется в растущем приложении.
 
 </LearnMore>
 
-## What's next? {/*whats-next*/}
+## Что дальше? {/*whats-next*/}
 
-Head over to [Reacting to Input with State](/learn/reacting-to-input-with-state) to start reading this chapter page by page!
+Перейдите к [Реакция на ввод с помощью состояния](/learn/reacting-to-input-with-state), чтобы начать читать эту главу страница за страницей!
 
-Or, if you're already familiar with these topics, why not read about [Escape Hatches](/learn/escape-hatches)?
+Или, если вы уже знакомы с этими темами, почему бы не прочитать о [Лазейках](/learn/escape-hatches)?