docs: translate experimental_taintObjectReference.md to Русский

Author: translate-react-bot[bot]

src/content/reference/react/experimental_taintObjectReference.md

@@ -1,107 +1,107 @@
+```html
 ---
 title: experimental_taintObjectReference
 version: experimental
 ---
 
 <Experimental>
 
-**This API is experimental and is not available in a stable version of React yet.**
+**Этот API является экспериментальным и еще не доступен в стабильной версии React.**
 
-You can try it by upgrading React packages to the most recent experimental version:
+Вы можете попробовать его, обновив пакеты React до последней экспериментальной версии:
 
 - `react@experimental`
 - `react-dom@experimental`
 - `eslint-plugin-react-hooks@experimental`
 
-Experimental versions of React may contain bugs. Don't use them in production.
+Экспериментальные версии React могут содержать ошибки. Не используйте их в продакшене.
 
-This API is only available inside React Server Components.
+Этот API доступен только внутри React Server Components.
 
 </Experimental>
 
-
 <Intro>
 
-`taintObjectReference` lets you prevent a specific object instance from being passed to a Client Component like a `user` object.
+`taintObjectReference` позволяет предотвратить передачу конкретного экземпляра объекта в Client Component, например объекта `user`.
 
 ```js
 experimental_taintObjectReference(message, object);
 ```
 
-To prevent passing a key, hash or token, see [`taintUniqueValue`](/reference/react/experimental_taintUniqueValue).
+Чтобы предотвратить передачу ключа, хэша или токена, см. [`taintUniqueValue`](/reference/react/experimental_taintUniqueValue).
 
 </Intro>
 
 <InlineToc />
 
 ---
 
-## Reference {/*reference*/}
+## Справочник {/*reference*/}
 
 ### `taintObjectReference(message, object)` {/*taintobjectreference*/}
 
-Call `taintObjectReference` with an object to register it with React as something that should not be allowed to be passed to the Client as is:
+Вызовите `taintObjectReference` с объектом, чтобы зарегистрировать его в React как нечто, что не должно быть передано Клиенту в неизменном виде:
 
 ```js
 import {experimental_taintObjectReference} from 'react';
 
 experimental_taintObjectReference(
-  'Do not pass ALL environment variables to the client.',
+  'Не передавайте ВСЕ переменные окружения клиенту.',
   process.env
 );
 ```
 
-[See more examples below.](#usage)
+[См. больше примеров ниже.](#usage)
 
-#### Parameters {/*parameters*/}
+#### Параметры {/*parameters*/}
 
-* `message`: The message you want to display if the object gets passed to a Client Component. This message will be displayed as a part of the Error that will be thrown if the object gets passed to a Client Component.
+* `message`: Сообщение, которое вы хотите отобразить, если объект будет передан в Client Component. Это сообщение будет отображаться как часть ошибки, которая будет выброшена, если объект будет передан в Client Component.
 
-* `object`: The object to be tainted. Functions and class instances can be passed to `taintObjectReference` as `object`. Functions and classes are already blocked from being passed to Client Components but the React's default error message will be replaced by what you defined in `message`. When a specific instance of a Typed Array is passed to `taintObjectReference` as `object`, any other copies of the Typed Array will not be tainted.
+* `object`: Объект, который нужно пометить. Функции и экземпляры классов могут быть переданы в `taintObjectReference` как `object`. Функции и классы уже заблокированы для передачи в Client Components, но стандартное сообщение об ошибке React будет заменено тем, что вы определили в `message`. Когда конкретный экземпляр Typed Array передается в `taintObjectReference` как `object`, любые другие копии этого Typed Array не будут помечены.
 
-#### Returns {/*returns*/}
+#### Возвращает {/*returns*/}
 
-`experimental_taintObjectReference` returns `undefined`.
+`experimental_taintObjectReference` возвращает `undefined`.
 
-#### Caveats {/*caveats*/}
+#### Ограничения {/*caveats*/}
 
-- Recreating or cloning a tainted object creates a new untainted object which may contain sensitive data. For example, if you have a tainted `user` object, `const userInfo = {name: user.name, ssn: user.ssn}` or `{...user}` will create new objects which are not tainted. `taintObjectReference` only protects against simple mistakes when the object is passed through to a Client Component unchanged.
+- Воссоздание или клонирование помеченного объекта создает новый непомеченный объект, который может содержать конфиденциальные данные. Например, если у вас есть помеченный объект `user`, `const userInfo = {name: user.name, ssn: user.ssn}` или `{...user}` создадут новые объекты, которые не помечены. `taintObjectReference` защищает только от простых ошибок, когда объект передается в Client Component без изменений.
 
 <Pitfall>
 
-**Do not rely on just tainting for security.** Tainting an object doesn't prevent leaking of every possible derived value. For example, the clone of a tainted object will create a new untainted object. Using data from a tainted object (e.g. `{secret: taintedObj.secret}`) will create a new value or object that is not tainted. Tainting is a layer of protection; a secure app will have multiple layers of protection, well designed APIs, and isolation patterns.
+**Не полагайтесь только на пометку для обеспечения безопасности.** Пометка объекта не предотвращает утечку всех возможных производных значений. Например, клон помеченного объекта создаст новый непомеченный объект. Использование данных из помеченного объекта (например, `{secret: taintedObj.secret}`) создаст новое значение или объект, который не помечен. Пометка — это уровень защиты; безопасное приложение будет иметь несколько уровней защиты, хорошо спроектированные API и паттерны изоляции.
 
 </Pitfall>
 
 ---
 
-## Usage {/*usage*/}
+## Использование {/*usage*/}
 
-### Prevent user data from unintentionally reaching the client {/*prevent-user-data-from-unintentionally-reaching-the-client*/}
+### Предотвращение непреднамеренной передачи пользовательских данных клиенту {/*prevent-user-data-from-unintentionally-reaching-the-client*/}
 
-A Client Component should never accept objects that carry sensitive data. Ideally, the data fetching functions should not expose data that the current user should not have access to. Sometimes mistakes happen during refactoring. To protect against these mistakes happening down the line we can "taint" the user object in our data API.
+Client Component никогда не должен принимать объекты, содержащие конфиденциальные данные. В идеале, функции получения данных не должны раскрывать данные, к которым текущий пользователь не должен иметь доступа. Иногда ошибки случаются во время рефакторинга. Чтобы защититься от таких ошибок в будущем, мы можем "пометить" объект пользователя в нашем API данных.
 
 ```js
 import {experimental_taintObjectReference} from 'react';
 
 export async function getUser(id) {
   const user = await db`SELECT * FROM users WHERE id = ${id}`;
   experimental_taintObjectReference(
-    'Do not pass the entire user object to the client. ' +
-      'Instead, pick off the specific properties you need for this use case.',
+    'Не передавайте весь объект пользователя клиенту. ' +
+      'Вместо этого выбирайте конкретные свойства, которые вам нужны для данного случая использования.',
     user,
   );
   return user;
 }
 ```
 
-Now whenever anyone tries to pass this object to a Client Component, an error will be thrown with the passed in error message instead.
+Теперь, когда кто-либо попытается передать этот объект в Client Component, будет выброшена ошибка с переданным сообщением об ошибке.
 
 <DeepDive>
 
-#### Protecting against leaks in data fetching {/*protecting-against-leaks-in-data-fetching*/}
+#### Защита от утечек при получении данных {/*protecting-against-leaks-in-data-fetching*/}
 
-If you're running a Server Components environment that has access to sensitive data, you have to be careful not to pass objects straight through:
+Если вы работаете в среде Server Components, имеющей доступ к конфиденциальным данным, вы должны быть осторожны, чтобы не передавать объекты напрямую:
 
 ```js
 // api.js
@@ -117,7 +117,7 @@ import { InfoCard } from 'components.js';
 
 export async function Profile(props) {
   const user = await getUser(props.userId);
-  // DO NOT DO THIS
+  // НЕ ДЕЛАЙТЕ ЭТОГО
   return <InfoCard user={user} />;
 }
 ```
@@ -131,8 +131,7 @@ export async function InfoCard({ user }) {
 }
 ```
 
-Ideally, the `getUser` should not expose data that the current user should not have access to. To prevent passing the `user` object to a Client Component down the line we can "taint" the user object:
-
+В идеале, `getUser` не должен раскрывать данные, к которым текущий пользователь не должен иметь доступа. Чтобы предотвратить передачу объекта `user` в Client Component в дальнейшем, мы можем "пометить" объект пользователя:
 
 ```js
 // api.js
@@ -141,14 +140,15 @@ import {experimental_taintObjectReference} from 'react';
 export async function getUser(id) {
   const user = await db`SELECT * FROM users WHERE id = ${id}`;
   experimental_taintObjectReference(
-    'Do not pass the entire user object to the client. ' +
-      'Instead, pick off the specific properties you need for this use case.',
+    'Не передавайте весь объект пользователя клиенту. ' +
+      'Вместо этого выбирайте конкретные свойства, которые вам нужны для данного случая использования.',
     user,
   );
   return user;
 }
 ```
 
-Now if anyone tries to pass the `user` object to a Client Component, an error will be thrown with the passed in error message.
+Теперь, если кто-либо попытается передать объект `user` в Client Component, будет выброшена ошибка с переданным сообщением.
 
 </DeepDive>
+```