diff --git a/src/content/reference/react/forwardRef.md b/src/content/reference/react/forwardRef.md
index 5b0e679b89..da23b50b16 100644
--- a/src/content/reference/react/forwardRef.md
+++ b/src/content/reference/react/forwardRef.md
@@ -1,18 +1,17 @@
 ---
 title: forwardRef
 ---
-
 <Deprecated>
 
-In React 19, `forwardRef` is no longer necessary. Pass `ref` as a prop instead.
+В React 19 `forwardRef` больше не нужен. Вместо этого передавайте `ref` как пропс.
 
-`forwardRef` will deprecated in a future release. Learn more [here](/blog/2024/04/25/react-19#ref-as-a-prop).
+`forwardRef` будет устаревшим в будущем релизе. Узнайте больше [здесь](/blog/2024/04/25/react-19#ref-as-a-prop).
 
 </Deprecated>
 
 <Intro>
 
-`forwardRef` lets your component expose a DOM node to parent component with a [ref.](/learn/manipulating-the-dom-with-refs)
+`forwardRef` позволяет вашему компоненту предоставить DOM-узел родительскому компоненту с помощью [ref.](/learn/manipulating-the-dom-with-refs)
 
 ```js
 const SomeComponent = forwardRef(render)
@@ -24,11 +23,11 @@ const SomeComponent = forwardRef(render)
 
 ---
 
-## Reference {/*reference*/}
+## Справочник {/*reference*/}
 
 ### `forwardRef(render)` {/*forwardref*/}
 
-Call `forwardRef()` to let your component receive a ref and forward it to a child component:
+Вызовите `forwardRef()`, чтобы ваш компонент мог принимать ref и передавать его дочернему компоненту:
 
 ```js
 import { forwardRef } from 'react';
@@ -38,26 +37,26 @@ const MyInput = forwardRef(function MyInput(props, ref) {
 });
 ```
 
-[See more examples below.](#usage)
+[См. больше примеров ниже.](#usage)
 
-#### Parameters {/*parameters*/}
+#### Параметры {/*parameters*/}
 
-* `render`: The render function for your component. React calls this function with the props and `ref` that your component received from its parent. The JSX you return will be the output of your component.
+* `render`: Функция рендеринга для вашего компонента. React вызывает эту функцию с пропсами и `ref`, которые ваш компонент получил от родителя. Возвращаемый вами JSX будет результатом работы вашего компонента.
 
-#### Returns {/*returns*/}
+#### Возвращает {/*returns*/}
 
-`forwardRef` returns a React component that you can render in JSX. Unlike React components defined as plain functions, a component returned by `forwardRef` is also able to receive a `ref` prop.
+`forwardRef` возвращает React-компонент, который вы можете рендерить в JSX. В отличие от React-компонентов, определённых как обычные функции, компонент, возвращаемый `forwardRef`, также способен принимать пропс `ref`.
 
-#### Caveats {/*caveats*/}
+#### Особенности {/*caveats*/}
 
-* In Strict Mode, React will **call your render function twice** in order to [help you find accidental impurities.](/reference/react/useState#my-initializer-or-updater-function-runs-twice) This is development-only behavior and does not affect production. If your render function is pure (as it should be), this should not affect the logic of your component. The result from one of the calls will be ignored.
+* В Strict Mode React **дважды вызовет вашу функцию рендеринга**, чтобы [помочь вам найти случайные примеси.](/reference/react/useState#my-initializer-or-updater-function-runs-twice) Это поведение только для разработки и не влияет на продакшен. Если ваша функция рендеринга является чистой (как и должно быть), это не должно повлиять на логику вашего компонента. Результат одного из вызовов будет проигнорирован.
 
 
 ---
 
-### `render` function {/*render-function*/}
+### Функция `render` {/*render-function*/}
 
-`forwardRef` accepts a render function as an argument. React calls this function with `props` and `ref`:
+`forwardRef` принимает функцию рендеринга в качестве аргумента. React вызывает эту функцию с `props` и `ref`:
 
 ```js
 const MyInput = forwardRef(function MyInput(props, ref) {
@@ -70,23 +69,23 @@ const MyInput = forwardRef(function MyInput(props, ref) {
 });
 ```
 
-#### Parameters {/*render-parameters*/}
+#### Параметры {/*render-parameters*/}
 
-* `props`: The props passed by the parent component.
+* `props`: Пропсы, переданные родительским компонентом.
 
-* `ref`:  The `ref` attribute passed by the parent component. The `ref` can be an object or a function. If the parent component has not passed a ref, it will be `null`. You should either pass the `ref` you receive to another component, or pass it to [`useImperativeHandle`.](/reference/react/useImperativeHandle)
+* `ref`: Атрибут `ref`, переданный родительским компонентом. `ref` может быть объектом или функцией. Если родительский компонент не передал ref, он будет `null`. Вы должны либо передать полученный `ref` другому компоненту, либо передать его в [`useImperativeHandle`.](/reference/react/useImperativeHandle)
 
-#### Returns {/*render-returns*/}
+#### Возвращает {/*render-returns*/}
 
-`forwardRef` returns a React component that you can render in JSX. Unlike React components defined as plain functions, the component returned by `forwardRef` is able to take a `ref` prop.
+`forwardRef` возвращает React-компонент, который вы можете рендерить в JSX. В отличие от React-компонентов, определённых как обычные функции, компонент, возвращаемый `forwardRef`, способен принимать пропс `ref`.
 
 ---
 
-## Usage {/*usage*/}
+## Использование {/*usage*/}
 
-### Exposing a DOM node to the parent component {/*exposing-a-dom-node-to-the-parent-component*/}
+### Предоставление DOM-узла родительскому компоненту {/*exposing-a-dom-node-to-the-parent-component*/}
 
-By default, each component's DOM nodes are private. However, sometimes it's useful to expose a DOM node to the parent--for example, to allow focusing it. To opt in, wrap your component definition into `forwardRef()`:
+По умолчанию DOM-узлы каждого компонента являются приватными. Однако иногда бывает полезно предоставить DOM-узел родителю — например, чтобы позволить ему сфокусироваться на нём. Чтобы включить эту возможность, оберните определение вашего компонента в `forwardRef()`:
 
 ```js {3,11}
 import { forwardRef } from 'react';
@@ -102,7 +101,7 @@ const MyInput = forwardRef(function MyInput(props, ref) {
 });
 ```
 
-You will receive a <CodeStep step={1}>ref</CodeStep> as the second argument after props. Pass it to the DOM node that you want to expose:
+Вы получите <CodeStep step={1}>ref</CodeStep> как второй аргумент после пропсов. Передайте его DOM-узлу, который вы хотите предоставить:
 
 ```js {8} [[1, 3, "ref"], [1, 8, "ref", 30]]
 import { forwardRef } from 'react';
@@ -118,7 +117,7 @@ const MyInput = forwardRef(function MyInput(props, ref) {
 });
 ```
 
-This lets the parent `Form` component access the <CodeStep step={2}>`<input>` DOM node</CodeStep> exposed by `MyInput`:
+Это позволяет родительскому компоненту `Form` получить доступ к DOM-узлу `<input>`, предоставленному `MyInput`:
 
 ```js [[1, 2, "ref"], [1, 10, "ref", 41], [2, 5, "ref.current"]]
 function Form() {
@@ -139,15 +138,15 @@ function Form() {
 }
 ```
 
-This `Form` component [passes a ref](/reference/react/useRef#manipulating-the-dom-with-a-ref) to `MyInput`. The `MyInput` component *forwards* that ref to the `<input>` browser tag. As a result, the `Form` component can access that `<input>` DOM node and call [`focus()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus) on it.
+Этот компонент `Form` [передаёт ref](/reference/react/useRef#manipulating-the-dom-with-a-ref) в `MyInput`. Компонент `MyInput` *перенаправляет* этот ref в браузерный тег `<input>`. В результате компонент `Form` может получить доступ к этому DOM-узлу `<input>` и вызвать на нём [`focus()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement/focus).
 
-Keep in mind that exposing a ref to the DOM node inside your component makes it harder to change your component's internals later. You will typically expose DOM nodes from reusable low-level components like buttons or text inputs, but you won't do it for application-level components like an avatar or a comment.
+Имейте в виду, что предоставление ref к DOM-узлу внутри вашего компонента затрудняет изменение внутренних данных вашего компонента в будущем. Обычно вы будете предоставлять DOM-узлы из повторно используемых низкоуровневых компонентов, таких как кнопки или текстовые поля ввода, но не для компонентов уровня приложения, таких как аватар или комментарий.
 
-<Recipes titleText="Examples of forwarding a ref">
+<Recipes titleText="Примеры перенаправления ref">
 
-#### Focusing a text input {/*focusing-a-text-input*/}
+#### Фокусировка текстового поля ввода {/*focusing-a-text-input*/}
 
-Clicking the button will focus the input. The `Form` component defines a ref and passes it to the `MyInput` component. The `MyInput` component forwards that ref to the browser `<input>`. This lets the `Form` component focus the `<input>`.
+Нажатие на кнопку сфокусирует поле ввода. Компонент `Form` определяет ref и передаёт его компоненту `MyInput`. Компонент `MyInput` перенаправляет этот ref в браузерное поле ввода `<input>`. Это позволяет компоненту `Form` сфокусироваться на `<input>`.
 
 <Sandpack>
 
@@ -199,9 +198,9 @@ input {
 
 <Solution />
 
-#### Playing and pausing a video {/*playing-and-pausing-a-video*/}
+#### Воспроизведение и пауза видео {/*playing-and-pausing-a-video*/}
 
-Clicking the button will call [`play()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/play) and [`pause()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/pause) on a `<video>` DOM node. The `App` component defines a ref and passes it to the `MyVideoPlayer` component. The `MyVideoPlayer` component forwards that ref to the browser `<video>` node. This lets the `App` component play and pause the `<video>`.
+Нажатие на кнопку вызовет [`play()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/play) и [`pause()`](https://developer.mozilla.org/en-US/docs/Web/API/HTMLMediaElement/pause) на DOM-узле `<video>`. Компонент `App` определяет ref и передаёт его компоненту `MyVideoPlayer`. Компонент `MyVideoPlayer` перенаправляет этот ref в браузерный узел `<video>`. Это позволяет компоненту `App` воспроизводить и ставить на паузу `<video>`.
 
 <Sandpack>
 
@@ -260,9 +259,9 @@ button { margin-bottom: 10px; margin-right: 10px; }
 
 ---
 
-### Forwarding a ref through multiple components {/*forwarding-a-ref-through-multiple-components*/}
+### Перенаправление ref через несколько компонентов {/*forwarding-a-ref-through-multiple-components*/}
 
-Instead of forwarding a `ref` to a DOM node, you can forward it to your own component like `MyInput`:
+Вместо перенаправления `ref` на DOM-узел, вы можете перенаправить его на собственный компонент, такой как `MyInput`:
 
 ```js {1,5}
 const FormField = forwardRef(function FormField(props, ref) {
@@ -276,7 +275,7 @@ const FormField = forwardRef(function FormField(props, ref) {
 });
 ```
 
-If that `MyInput` component forwards a ref to its `<input>`, a ref to `FormField` will give you that `<input>`:
+Если этот компонент `MyInput` перенаправляет ref на свой `<input>`, то ref на `FormField` даст вам этот `<input>`:
 
 ```js {2,5,10}
 function Form() {
@@ -297,7 +296,7 @@ function Form() {
 }
 ```
 
-The `Form` component defines a ref and passes it to `FormField`. The `FormField` component forwards that ref to `MyInput`, which forwards it to a browser `<input>` DOM node. This is how `Form` accesses that DOM node.
+Компонент `Form` определяет ref и передаёт его `FormField`. Компонент `FormField` перенаправляет этот ref в `MyInput`, который перенаправляет его в DOM-узел браузерного `<input>`. Таким образом `Form` получает доступ к этому DOM-узлу.
 
 
 <Sandpack>
@@ -336,7 +335,7 @@ const FormField = forwardRef(function FormField({ label, isRequired }, ref) {
         ref={ref}
         label={label}
         value={value}
-        onChange={e => setValue(e.target.value)} 
+        onChange={e => setValue(e.target.value)}
       />
       {(isRequired && value === '') &&
         <i>Required</i>
@@ -375,9 +374,9 @@ input, button {
 
 ---
 
-### Exposing an imperative handle instead of a DOM node {/*exposing-an-imperative-handle-instead-of-a-dom-node*/}
+### Предоставление императивного обработчика вместо DOM-узла {/*exposing-an-imperative-handle-instead-of-a-dom-node*/}
 
-Instead of exposing an entire DOM node, you can expose a custom object, called an *imperative handle,* with a more constrained set of methods. To do this, you'd need to define a separate ref to hold the DOM node:
+Вместо предоставления всего DOM-узла, вы можете предоставить пользовательский объект, называемый *императивным обработчиком*, с более ограниченным набором методов. Для этого вам потребуется определить отдельный ref для хранения DOM-узла:
 
 ```js {2,6}
 const MyInput = forwardRef(function MyInput(props, ref) {
@@ -389,7 +388,7 @@ const MyInput = forwardRef(function MyInput(props, ref) {
 });
 ```
 
-Pass the `ref` you received to [`useImperativeHandle`](/reference/react/useImperativeHandle) and specify the value you want to expose to the `ref`:
+Передайте полученный `ref` в [`useImperativeHandle`](/reference/react/useImperativeHandle) и укажите значение, которое вы хотите предоставить для `ref`:
 
 ```js {6-15}
 import { forwardRef, useRef, useImperativeHandle } from 'react';
@@ -412,7 +411,7 @@ const MyInput = forwardRef(function MyInput(props, ref) {
 });
 ```
 
-If some component gets a ref to `MyInput`, it will only receive your `{ focus, scrollIntoView }` object instead of the DOM node. This lets you limit the information you expose about your DOM node to the minimum.
+Если какой-либо компонент получит ref на `MyInput`, он получит только ваш объект `{ focus, scrollIntoView }` вместо DOM-узла. Это позволяет вам ограничить информацию, которую вы предоставляете о вашем DOM-узле, до минимума.
 
 <Sandpack>
 
@@ -425,7 +424,7 @@ export default function Form() {
 
   function handleClick() {
     ref.current.focus();
-    // This won't work because the DOM node isn't exposed:
+    // Это не сработает, потому что DOM-узел не предоставлен:
     // ref.current.style.opacity = 0.5;
   }
 
@@ -471,25 +470,25 @@ input {
 
 </Sandpack>
 
-[Read more about using imperative handles.](/reference/react/useImperativeHandle)
+[Подробнее об использовании императивных обработчиков.](/reference/react/useImperativeHandle)
 
 <Pitfall>
 
-**Do not overuse refs.** You should only use refs for *imperative* behaviors that you can't express as props: for example, scrolling to a node, focusing a node, triggering an animation, selecting text, and so on.
+**Не злоупотребляйте refs.** Используйте refs только для *императивных* действий, которые вы не можете выразить через пропсы: например, прокрутка к узлу, фокусировка на узле, запуск анимации, выделение текста и т. д.
 
-**If you can express something as a prop, you should not use a ref.** For example, instead of exposing an imperative handle like `{ open, close }` from a `Modal` component, it is better to take `isOpen` as a prop like `<Modal isOpen={isOpen} />`. [Effects](/learn/synchronizing-with-effects) can help you expose imperative behaviors via props.
+**Если вы можете выразить что-то через пропс, вам не следует использовать ref.** Например, вместо предоставления императивного обработчика вроде `{ open, close }` из компонента `Modal`, лучше принять `isOpen` как пропс, например `<Modal isOpen={isOpen} />`. [Эффекты](/learn/synchronizing-with-effects) могут помочь вам предоставлять императивные действия через пропсы.
 
 </Pitfall>
 
 ---
 
-## Troubleshooting {/*troubleshooting*/}
+## Устранение неполадок {/*troubleshooting*/}
 
-### My component is wrapped in `forwardRef`, but the `ref` to it is always `null` {/*my-component-is-wrapped-in-forwardref-but-the-ref-to-it-is-always-null*/}
+### Мой компонент обёрнут в `forwardRef`, но `ref` на него всегда `null` {/*my-component-is-wrapped-in-forwardref-but-the-ref-to-it-is-always-null*/}
 
-This usually means that you forgot to actually use the `ref` that you received.
+Обычно это означает, что вы забыли фактически использовать полученный `ref`.
 
-For example, this component doesn't do anything with its `ref`:
+Например, этот компонент ничего не делает с `ref`:
 
 ```js {1}
 const MyInput = forwardRef(function MyInput({ label }, ref) {
@@ -502,7 +501,7 @@ const MyInput = forwardRef(function MyInput({ label }, ref) {
 });
 ```
 
-To fix it, pass the `ref` down to a DOM node or another component that can accept a ref:
+Чтобы исправить это, передайте `ref` вниз к DOM-узлу или другому компоненту, который может принять ref:
 
 ```js {1,5}
 const MyInput = forwardRef(function MyInput({ label }, ref) {
@@ -515,7 +514,7 @@ const MyInput = forwardRef(function MyInput({ label }, ref) {
 });
 ```
 
-The `ref` to `MyInput` could also be `null` if some of the logic is conditional:
+`ref` на `MyInput` также может быть `null`, если некоторая логика является условной:
 
 ```js {1,5}
 const MyInput = forwardRef(function MyInput({ label, showInput }, ref) {
@@ -528,7 +527,7 @@ const MyInput = forwardRef(function MyInput({ label, showInput }, ref) {
 });
 ```
 
-If `showInput` is `false`, then the ref won't be forwarded to any node, and a ref to `MyInput` will remain empty. This is particularly easy to miss if the condition is hidden inside another component, like `Panel` in this example:
+Если `showInput` равно `false`, то ref не будет перенаправлен ни к одному узлу, и ref на `MyInput` останется пустым. Это особенно легко упустить, если условие скрыто внутри другого компонента, как `Panel` в этом примере:
 
 ```js {5,7}
 const MyInput = forwardRef(function MyInput({ label, showInput }, ref) {
@@ -541,4 +540,4 @@ const MyInput = forwardRef(function MyInput({ label, showInput }, ref) {
     </label>
   );
 });
-```
+```
\ No newline at end of file