From 72a00e32263b800caa7d6f060b5f93e05c427641 Mon Sep 17 00:00:00 2001 From: Mikhail Sakhniuk Date: Tue, 23 May 2023 23:07:29 +0400 Subject: [PATCH 1/2] Translate --- .../learn/state-a-components-memory.md | 210 +++++++++--------- 1 file changed, 106 insertions(+), 104 deletions(-) diff --git a/src/content/learn/state-a-components-memory.md b/src/content/learn/state-a-components-memory.md index 1dbaab4a9..c23dbee1f 100644 --- a/src/content/learn/state-a-components-memory.md +++ b/src/content/learn/state-a-components-memory.md @@ -1,25 +1,25 @@ --- -title: "State: A Component's Memory" +title: "Состояние: память компонента" --- -Components often need to change what's on the screen as a result of an interaction. Typing into the form should update the input field, clicking "next" on an image carousel should change which image is displayed, clicking "buy" should put a product in the shopping cart. Components need to "remember" things: the current input value, the current image, the shopping cart. In React, this kind of component-specific memory is called *state*. +Компоненты часто должны изменять то, что отображается на экране как результат взаимодействия. Ввод в форму должен обновлять поле ввода, нажатие кнопки "далее" на карусели изображений должно изменять отображаемое изображение, нажатие кнопки "купить" должно добавлять товар в корзину. Компоненты должны "запоминать": текущее значение ввода, текущее изображение, корзину. В React такой компонент-специфической памятью называется *состояние*. -* How to add a state variable with the [`useState`](/reference/react/useState) Hook -* What pair of values the `useState` Hook returns -* How to add more than one state variable -* Why state is called local +* Как добавить переменную состояния с помощью хука [`useState`](/reference/react/useState) +* Какую пару значений возвращает хук `useState` +* Как добавить более одной переменной состояния +* Почему состояние называется локальным -## When a regular variable isn’t enough {/*when-a-regular-variable-isnt-enough*/} +## Когда обычной переменной недостаточно {/*when-a-regular-variable-isnt-enough*/} -Here's a component that renders a sculpture image. Clicking the "Next" button should show the next sculpture by changing the `index` to `1`, then `2`, and so on. However, this **won't work** (you can try it!): +Вот компонент, который рендерит изображение скульптуры. При нажатии на кнопку "Next" должна отображаться следующая скульптура, изменяя `index` на `1`, затем на `2` и так далее. Однако это **не сработает** (вы можете попробовать!): @@ -151,46 +151,46 @@ button { -The `handleClick` event handler is updating a local variable, `index`. But two things prevent that change from being visible: +Обработчик событий `handleClick` обновляет локальную переменную `index`. Но две вещи мешают нам увидеть изменения: -1. **Local variables don't persist between renders.** When React renders this component a second time, it renders it from scratch—it doesn't consider any changes to the local variables. -2. **Changes to local variables won't trigger renders.** React doesn't realize it needs to render the component again with the new data. +1. **Локальные переменные не сохраняются между рендерами.** Когда React рендерит этот компонент второй раз, он рендерит его заново - не учитывая никакие изменения локальных переменных. +2. **Изменения локальных переменных не запускают повторные рендеры.** React не понимает, что нужно перерисовать компонент с новыми данными. -To update a component with new data, two things need to happen: +Чтобы обновить компонент с новыми данными, нужно сделать две вещи: -1. **Retain** the data between renders. -2. **Trigger** React to render the component with new data (re-rendering). +1. **Сохранить** данные между рендерами. +2. **Запустить** отрисовку React компонента с новыми данными (перерисовка). -The [`useState`](/reference/react/useState) Hook provides those two things: +Хук [`useState`](/reference/react/useState) обеспечивает эти две вещи: -1. A **state variable** to retain the data between renders. -2. A **state setter function** to update the variable and trigger React to render the component again. +1. **Переменная состояния** для сохранения данных между рендерами. +2. **Функция установки состояния** для обновления переменной и запуска повторного рендеринга компонента. -## Adding a state variable {/*adding-a-state-variable*/} +## Добавление переменной состояния {/*adding-a-state-variable*/} -To add a state variable, import `useState` from React at the top of the file: +Для того чтобы добавить переменную состояния, импортируйте `useState` из React в начале файла: ```js import { useState } from 'react'; ``` -Then, replace this line: +Далее, замените эту строку: ```js let index = 0; ``` -with +на эту: ```js const [index, setIndex] = useState(0); ``` -`index` is a state variable and `setIndex` is the setter function. +`index` - это переменная состояния, а `setIndex` - функция установки состояния. -> The `[` and `]` syntax here is called [array destructuring](https://javascript.info/destructuring-assignment) and it lets you read values from an array. The array returned by `useState` always has exactly two items. +> Синтакс `[` и `]` называется [деструктуризацией массива](https://javascript.info/destructuring-assignment) и позволяет читать значения из массива. Массив, возвращаемый `useState`, всегда имеет ровно два элемента. -This is how they work together in `handleClick`: +Вот как они работают вместе в `handleClick`: ```js function handleClick() { @@ -199,6 +199,7 @@ function handleClick() { ``` Now clicking the "Next" button switches the current sculpture: +Теперь нажатие кнопки "Next" переключает текущую скульптуру: @@ -331,57 +332,57 @@ button { -### Meet your first Hook {/*meet-your-first-hook*/} +### Встречай твой первый хук {/*meet-your-first-hook*/} -In React, `useState`, as well as any other function starting with "`use`", is called a Hook. +В React `useState`, а также любая другая функция, начинающаяся с "`use`", называется хуком. -*Hooks* are special functions that are only available while React is [rendering](/learn/render-and-commit#step-1-trigger-a-render) (which we'll get into in more detail on the next page). They let you "hook into" different React features. +*Хуки* — это специальные функции, доступные только во время [рендеринга](/learn/render-and-commit#step-1-trigger-a-render) React (о чем мы подробнее расскажем на следующей странице). Они позволяют вам подключаться (hook into) к различным функциям React. -State is just one of those features, but you will meet the other Hooks later. +Состояние — это только одна из функций хуков, но вы познакомитесь с другими хуками позже. -**Hooks—functions starting with `use`—can only be called at the top level of your components or [your own Hooks.](/learn/reusing-logic-with-custom-hooks)** You can't call Hooks inside conditions, loops, or other nested functions. Hooks are functions, but it's helpful to think of them as unconditional declarations about your component's needs. You "use" React features at the top of your component similar to how you "import" modules at the top of your file. +**Хуки-функции начинаются с `use` и могут быть вызваны только на верхнем уровне ваших компонентов или [в ваших собственных хуках.](/learn/reusing-logic-with-custom-hooks)** Вы не можете вызывать хуки внутри условий, циклов или других вложенных функций. Хуки — это функции, но полезно думать о них как о безусловных объявлениях о потребностях вашего компонента. Вы "используете" функции React на верхнем уровне вашего компонента, подобно тому, как вы "импортируете" модули в начале файла. -### Anatomy of `useState` {/*anatomy-of-usestate*/} +### Анатомия `useState` {/*anatomy-of-usestate*/} -When you call [`useState`](/reference/react/useState), you are telling React that you want this component to remember something: +Когда ты вызываешь [`useState`](/reference/react/useState), ты говоришь React, что ты хочешь, чтобы этот компонент запомнил что-то: ```js const [index, setIndex] = useState(0); ``` -In this case, you want React to remember `index`. +В данном случае ты хочешь, чтобы React запомнил `index`. -The convention is to name this pair like `const [something, setSomething]`. You could name it anything you like, but conventions make things easier to understand across projects. +Соглашение состоит в том, чтобы называть эту пару как `const [something, setSomething]`. Вы можете назвать это как угодно, но соглашения упрощают понимание в разных проектах. -The only argument to `useState` is the **initial value** of your state variable. In this example, the `index`'s initial value is set to `0` with `useState(0)`. +Единствеенный аргумент `useState` — это **начальное значение** вашей переменной состояния. В этом примере начальное значение `index` установлено в `0` с помощью `useState(0)`. -Every time your component renders, `useState` gives you an array containing two values: +Каждый раз при рендеринге вашего компонента `useState` дает вам массив, содержащий два значения: -1. The **state variable** (`index`) with the value you stored. -2. The **state setter function** (`setIndex`) which can update the state variable and trigger React to render the component again. +1. **Переменная состояния** (`index`) со значением, которое вы сохранили. +2. **Функция установки состояния** (`setIndex`), которая может обновить переменную состояния и заставить React снова отрендерить компонент. -Here's how that happens in action: +Вот как это происходит в действии: ```js const [index, setIndex] = useState(0); ``` -1. **Your component renders the first time.** Because you passed `0` to `useState` as the initial value for `index`, it will return `[0, setIndex]`. React remembers `0` is the latest state value. -2. **You update the state.** When a user clicks the button, it calls `setIndex(index + 1)`. `index` is `0`, so it's `setIndex(1)`. This tells React to remember `index` is `1` now and triggers another render. -3. **Your component's second render.** React still sees `useState(0)`, but because React *remembers* that you set `index` to `1`, it returns `[1, setIndex]` instead. -4. And so on! +1. **Твой компонент рендерится в первый раз.** Поскольку вы передали `0` в `useState` в качестве начального значения для `index`, он вернет `[0, setIndex]`. React запоминает, что `0` — это последнее значение состояния. +2. **Ты обновляешь состояние.** Когда пользователь нажимает кнопку, вызывается `setIndex(index + 1)`. `index` равен `0`, поэтому это `setIndex(1)`. Это говорит React запомнить, что `index` теперь равен `1` и вызвать рендеринг. +3. **Второй рендеринг твоего компонента.** React по-прежнему видит `useState(0)`, но поскольку React *запомнил*, что вы установили `index` в `1`, он возвращает `[1, setIndex]`. +4. И так далее! -## Giving a component multiple state variables {/*giving-a-component-multiple-state-variables*/} +## Предоставление компоненту несколько переменных состояния {/*giving-a-component-multiple-state-variables*/} -You can have as many state variables of as many types as you like in one component. This component has two state variables, a number `index` and a boolean `showMore` that's toggled when you click "Show details": +Ты можешь иметь столько переменных состояния разных типов, сколько захочешь в одном компоненте. Этот компонент имеет две переменные состояния: число `index` и логическое значение `showMore`, которое переключается, когда вы нажимаете "Show details": @@ -520,19 +521,19 @@ button { -It is a good idea to have multiple state variables if their state is unrelated, like `index` and `showMore` in this example. But if you find that you often change two state variables together, it might be easier to combine them into one. For example, if you have a form with many fields, it's more convenient to have a single state variable that holds an object than state variable per field. Read [Choosing the State Structure](/learn/choosing-the-state-structure) for more tips. +Это хорошая идея иметь несколько переменных состояния, если их состояние не связано, например, `index` и `showMore` в этом примере. Но если вы часто изменяете две переменные состояния вместе, может быть проще объединить их в одну. Например, если у вас есть форма с множеством полей, удобнее иметь одну переменную состояния, которая содержит объект, чем переменную состояния для каждого поля. Прочитайте [Выбор структуры состояния](/learn/choosing-the-state-structure) для получения дополнительных советов. -#### How does React know which state to return? {/*how-does-react-know-which-state-to-return*/} +#### Как React узнает, какое состояние вернуть? {/*how-does-react-know-which-state-to-return*/} -You might have noticed that the `useState` call does not receive any information about *which* state variable it refers to. There is no "identifier" that is passed to `useState`, so how does it know which of the state variables to return? Does it rely on some magic like parsing your functions? The answer is no. +Вероятно ты заметил, что вызов `useState` не получает никакой информации о том на *какое* состоянии он ссылается. Нет "идентификатора", который передается в `useState`, так что как он знает, на какую из переменных состояния ссылаться? Он полагается на какую-то магию, как разбор ваших функций? Ответ - нет. -Instead, to enable their concise syntax, Hooks **rely on a stable call order on every render of the same component.** This works well in practice because if you follow the rule above ("only call Hooks at the top level"), Hooks will always be called in the same order. Additionally, a [linter plugin](https://www.npmjs.com/package/eslint-plugin-react-hooks) catches most mistakes. +Вместо этого, чтобы обеспечить их лаконичный синтаксис, Хуки **полагаются на стабильный порядок вызова на каждой отрисовке одного и того же компонента.** Это хорошо работает на практике, потому что если вы следуете правилу выше ("вызывайте Хуки только на верхнем уровне"), Хуки всегда будут вызываться в одном и том же порядке. Кроме того, [плагин линтера](https://www.npmjs.com/package/eslint-plugin-react-hooks) позволяет обнаружить большинство ошибок. -Internally, React holds an array of state pairs for every component. It also maintains the current pair index, which is set to `0` before rendering. Each time you call `useState`, React gives you the next state pair and increments the index. You can read more about this mechanism in [React Hooks: Not Magic, Just Arrays.](https://medium.com/@ryardley/react-hooks-not-magic-just-arrays-cd4f1857236e) +Под капотом React хранит массив пар состояний для каждого компонента. Он также поддерживает текущий индекс пары, который устанавливается на `0` перед отрисовкой. Каждый раз, когда вы вызываете `useState`, React дает вам следующую пару состояний и увеличивает индекс. Вы можете прочитать больше об этом механизме в [React Hooks: Not Magic, Just Arrays.](https://medium.com/@ryardley/react-hooks-not-magic-just-arrays-cd4f1857236e) -This example **doesn't use React** but it gives you an idea of how `useState` works internally: +Этот пример **не использует React**, но он дает вам представление о том, как `useState` работает внутри: @@ -540,37 +541,37 @@ This example **doesn't use React** but it gives you an idea of how `useState` wo let componentHooks = []; let currentHookIndex = 0; -// How useState works inside React (simplified). +// Как работает useState внутри React (упрощенно). function useState(initialState) { let pair = componentHooks[currentHookIndex]; if (pair) { - // This is not the first render, - // so the state pair already exists. - // Return it and prepare for next Hook call. + // Это не первая отрисовка, + // поэтому пара состояний уже существует. + // Вернуть его и подготовиться к следующему вызову Хука. currentHookIndex++; return pair; } - // This is the first time we're rendering, - // so create a state pair and store it. + // Это первая отрисовка, + // поэтому создаем пару состояний и сохраняем ее. pair = [initialState, setState]; function setState(nextState) { - // When the user requests a state change, - // put the new value into the pair. + // Когда пользователь запрашивает изменение состояния, + // поместить новое значение в пару. pair[0] = nextState; updateDOM(); } - // Store the pair for future renders - // and prepare for the next Hook call. + // Сохраним пару для будущих отрисовок + // и подготовимся к следующему вызову Хука. componentHooks[currentHookIndex] = pair; currentHookIndex++; return pair; } function Gallery() { - // Each useState() call will get the next pair. + // Каждый вызов useState() получит следующую пару. const [index, setIndex] = useState(0); const [showMore, setShowMore] = useState(false); @@ -583,8 +584,8 @@ function Gallery() { } let sculpture = sculptureList[index]; - // This example doesn't use React, so - // return an output object instead of JSX. + // Этот пример не использует React, поэтому + // возвращаем объект вывода вместо JSX. return { onNextClick: handleNextClick, onMoreClick: handleMoreClick, @@ -598,13 +599,13 @@ function Gallery() { } function updateDOM() { - // Reset the current Hook index - // before rendering the component. + // Сбразываем текущий индекс Хука + // перед отрисовкой компонента. currentHookIndex = 0; let output = Gallery(); - // Update the DOM to match the output. - // This is the part React does for you. + // Обновляем DOM, чтобы он соответствовал выводу. + // Это то, что React делает за вас. nextButton.onclick = output.onNextClick; header.textContent = output.header; moreButton.onclick = output.onMoreClick; @@ -698,7 +699,7 @@ let sculptureList = [{ alt: 'A group of bronze hippo sculptures emerging from the sett sidewalk as if they were swimming.' }]; -// Make UI match the initial state. +// Делаем интерфейс соответствующим начальному состоянию. updateDOM(); ``` @@ -724,15 +725,15 @@ button { display: block; margin-bottom: 10px; } -You don't have to understand it to use React, but you might find this a helpful mental model. +Ты не обязан понимать это, чтобы использовать React, но тебе может быть полезна эта ментальная модель. -## State is isolated and private {/*state-is-isolated-and-private*/} +## Состояние изолировано и приватно {/*state-is-isolated-and-private*/} -State is local to a component instance on the screen. In other words, **if you render the same component twice, each copy will have completely isolated state!** Changing one of them will not affect the other. +Состояние локально для экземпляра компонента на экране. Другими словами, **если вы отрисуете один и тот же компонент дважды, каждая копия будет иметь полностью изолированное состояние!** Изменение одного из них не повлияет на другой. -In this example, the `Gallery` component from earlier is rendered twice with no changes to its logic. Try clicking the buttons inside each of the galleries. Notice that their state is independent: +В этом примере компонент `Gallery` из предыдущего примера отрисован дважды без изменений в логике. Попробуйте нажать на кнопки внутри каждой галереи. Обратите внимание, что их состояние независимо: @@ -891,21 +892,22 @@ button { -This is what makes state different from regular variables that you might declare at the top of your module. State is not tied to a particular function call or a place in the code, but it's "local" to the specific place on the screen. You rendered two `` components, so their state is stored separately. +Это то, что делает состояние отличным от обычных переменных, которые вы можете объявить в верхней части своего модуля. Состояние не привязано к конкретному вызову функции или месту в коде, но оно «локально» для конкретного места на экране. Вы отрисовали два компонента ``, поэтому их состояние хранится отдельно. -Also notice how the `Page` component doesn't "know" anything about the `Gallery` state or even whether it has any. Unlike props, **state is fully private to the component declaring it.** The parent component can't change it. This lets you add state to any component or remove it without impacting the rest of the components. +Также обратите внимание, что компонент `Page` ничего не знает о состоянии `Gallery` или даже о том, есть ли оно. В отличие от свойств, **состояние полностью приватно для компонента, объявляющего его.** Родительский компонент не может его изменить. Это позволяет вам добавлять состояние в любой компонент или удалять его без влияния на остальные компоненты. -What if you wanted both galleries to keep their states in sync? The right way to do it in React is to *remove* state from child components and add it to their closest shared parent. The next few pages will focus on organizing state of a single component, but we will return to this topic in [Sharing State Between Components.](/learn/sharing-state-between-components) +Что если вы хотите, чтобы обе галереи синхронизировали свои состояния? Правильный способ сделать это в React - *удалить* состояние из дочерних компонентов и добавить его в их ближайший общий родитель. Следующие несколько страниц будут посвящены организации состояния одного компонента, но мы вернемся к этой теме в [Sharing State Between Components.](/learn/sharing-state-between-components) -* Use a state variable when a component needs to "remember" some information between renders. -* State variables are declared by calling the `useState` Hook. +* Используйте переменную состояния, когда компоненту нужно «запомнить» некоторую информацию между рендерами. +* Переменные состония декларируются вызовом хука `useState`. * Hooks are special functions that start with `use`. They let you "hook into" React features like state. -* Hooks might remind you of imports: they need to be called unconditionally. Calling Hooks, including `useState`, is only valid at the top level of a component or another Hook. -* The `useState` Hook returns a pair of values: the current state and the function to update it. -* You can have more than one state variable. Internally, React matches them up by their order. -* State is private to the component. If you render it in two places, each copy gets its own state. +* Хуки это специальные функции, которые начинаются с `use`. Они позволяют вам подключаться к функциям React, таким как состояние. +* Хуки могут напоминать вам импорты: они должны быть вызваны безусловно. Вызов хуков, включая `useState`, допустим только на верхнем уровне компонента или другого хука. +* Вызов хука `useState` возвращает пару значений: текущее состояние и функцию для его обновления. +* Вы можете иметь более одной переменной состояния. Внутри React сопоставляет их по порядку. +* Состояние приватно для компонента. Если вы отрисуете его в двух местах, каждая копия получит свое собственное состояние. @@ -913,11 +915,11 @@ What if you wanted both galleries to keep their states in sync? The right way to -#### Complete the gallery {/*complete-the-gallery*/} +#### Завершим галерею {/*complete-the-gallery*/} -When you press "Next" on the last sculpture, the code crashes. Fix the logic to prevent the crash. You may do this by adding extra logic to event handler or by disabling the button when the action is not possible. +Когда вы нажимаете «Next» на последней скульптуре, код ломается. Исправьте логику, чтобы предотвратить сбой. Вы можете сделать это, добавив дополнительную логику в обработчик событий или отключив кнопку, когда действие невозможно. -After fixing the crash, add a "Previous" button that shows the previous sculpture. It shouldn't crash on the first sculpture. +После исправления сбоя добавьте кнопку «Предыдущая», которая показывает предыдущую скульптуру. Он не должен ломаться на первой скульптуре. @@ -1059,7 +1061,7 @@ img { width: 120px; height: 120px; } -This adds a guarding condition inside both event handlers and disables the buttons when needed: +Это добавляет условие внутри обработчиков событий и отключает кнопки при необходимости: @@ -1219,13 +1221,13 @@ img { width: 120px; height: 120px; } -Notice how `hasPrev` and `hasNext` are used *both* for the returned JSX and inside the event handlers! This handy pattern works because event handler functions ["close over"](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures) any variables declared while rendering. +Заметьте как `hasPrev` и `hasNext` используются *вместе* для возвращаемым JSX и внутри обработчиков событий! Этот удобный шаблон работает потому что функции обработчиков событий ["замыкают"](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Closures) любые переменные объявленные во время рендеринга. -#### Fix stuck form inputs {/*fix-stuck-form-inputs*/} +#### Исправьте застрявшие поля ввода {/*fix-stuck-form-inputs*/} -When you type into the input fields, nothing appears. It's like the input values are "stuck" with empty strings. The `value` of the first `` is set to always match the `firstName` variable, and the `value` for the second `` is set to always match the `lastName` variable. This is correct. Both inputs have `onChange` event handlers, which try to update the variables based on the latest user input (`e.target.value`). However, the variables don't seem to "remember" their values between re-renders. Fix this by using state variables instead. +Когда вы вводите в поля ввода, ничего не появляется. Это как будто значения ввода "застряли" с пустыми строками. `value` первого `` установлено всегда соответствовать переменной `firstName`, и `value` для второго `` установлено всегда соответствовать переменной `lastName`. Это правильно. Оба ввода имеют обработчики событий `onChange`, которые пытаются обновить переменные на основе последнего пользовательского ввода (`e.target.value`). Однако переменные не "помнят" свои значения между повторными рендерингами. Исправьте это, используя переменные состояния вместо этого. @@ -1274,7 +1276,7 @@ h1 { margin-top: 10px; } -First, import `useState` from React. Then replace `firstName` and `lastName` with state variables declared by calling `useState`. Finally, replace every `firstName = ...` assignment with `setFirstName(...)`, and do the same for `lastName`. Don't forget to update `handleReset` too so that the reset button works. +Первый шаг - импортировать `useState` из React. Затем замените `firstName` и `lastName` на переменные состояния объявленные вызовом `useState`. Наконец, замените каждое присваивание `firstName = ...` на `setFirstName(...)`, и сделайте то же самое для `lastName`. Не забудьте обновить `handleReset` так, чтобы кнопка сброса работала. @@ -1325,13 +1327,13 @@ h1 { margin-top: 10px; } -#### Fix a crash {/*fix-a-crash*/} +#### Исправьте сбой {/*fix-a-crash*/} -Here is a small form that is supposed to let the user leave some feedback. When the feedback is submitted, it's supposed to display a thank-you message. However, it crashes with an error message saying "Rendered fewer hooks than expected". Can you spot the mistake and fix it? +Здесь небольшая форма, которая должна позволить пользователю оставить отзыв. Когда отзыв отправляется, он должен отображать сообщение благодарности. Однако он выходит из строя с сообщением об ошибке, говорящим "Отрисовано меньше хуков, чем ожидалось". Можете ли вы заметить ошибку и исправить ее? -Are there any limitations on _where_ Hooks may be called? Does this component break any rules? Check if there are any comments disabling the linter checks--this is where the bugs often hide! +Существуют ли какие-либо ограничения на _где_ Хуки могут быть вызваны? Нарушает ли этот компонент какие-либо правила? Проверьте, есть ли комментарии, отключающие проверки линтера - здесь часто скрываются ошибки! @@ -1370,9 +1372,9 @@ export default function FeedbackForm() { -Hooks can only be called at the top level of the component function. Here, the first `isSent` definition follows this rule, but the `message` definition is nested in a condition. +Хуки могут быть вызваны только на верхнем уровне функции компонента. Здесь первое определение `isSent` следует этому правилу, но определение `message` вложено в условие. -Move it out of the condition to fix the issue: +Переместите его из условия, чтобы исправить проблему: @@ -1407,9 +1409,9 @@ export default function FeedbackForm() { -Remember, Hooks must be called unconditionally and always in the same order! +Запомните - Хуки должны быть вызваны безусловно и всегда в одном и том же порядке! -You could also remove the unnecessary `else` branch to reduce the nesting. However, it's still important that all calls to Hooks happen *before* the first `return`. +Вы также можете удалить ненужную ветвь `else` для уменьшения вложенности. Однако важно, чтобы все вызовы Хуков происходили *перед* первым `return`. @@ -1444,19 +1446,19 @@ export default function FeedbackForm() { -Try moving the second `useState` call after the `if` condition and notice how this breaks it again. +Попробуйте переместить второй вызов `useState` после условия `if` и обратите внимание, как это снова ломает код. -If your linter is [configured for React](/learn/editor-setup#linting), you should see a lint error when you make a mistake like this. If you don't see an error when you try the faulty code locally, you need to set up linting for your project. +Если ваш линтер [настроен для React](/learn/editor-setup#linting), вы должны увидеть сообщение линтера, когда совершите такую ошибку. Если вы не видите ошибки при тестировании неправильного кода локально, вам нужно настроить линтер для вашего проекта. -#### Remove unnecessary state {/*remove-unnecessary-state*/} +#### Удаление ненужного состояния {/*remove-unnecessary-state*/} -When the button is clicked, this example should ask for the user's name and then display an alert greeting them. You tried to use state to keep the name, but for some reason it always shows "Hello, !". +Когда нажимается кнопка, этот пример должен запросить имя пользователя, а затем отобразить приветствие. Вы пытались использовать состояние для хранения имени, но по какой-то причине он всегда показывает "Hello, !". -To fix this code, remove the unnecessary state variable. (We will discuss about [why this didn't work](/learn/state-as-a-snapshot) later.) +Для того чтобы исправить этот код, удалите ненужную переменную состояния. (Мы обсудим [почему это не работает](/learn/state-as-a-snapshot) позже.) -Can you explain why this state variable was unnecessary? +Можете ли вы объяснить, почему эта переменная состояния была ненужной? @@ -1483,7 +1485,7 @@ export default function FeedbackForm() { -Here is a fixed version that uses a regular `name` variable declared in the function that needs it: +Здесь исправленная версия, которая использует обычную переменную `name`, объявленную в функции, которая ей необходима: @@ -1506,7 +1508,7 @@ export default function FeedbackForm() { -A state variable is only necessary to keep information between re-renders of a component. Within a single event handler, a regular variable will do fine. Don't introduce state variables when a regular variable works well. +Переменная состояния необходима только для хранения информации между повторными рендерами компонента. Внутри одного обработчика событий обычная переменная будет работать нормально. Не вводите переменные состояния, когда обычная переменная работает хорошо. From 8922280f6f365367f4585de782b409169ca30831 Mon Sep 17 00:00:00 2001 From: Mikhail Sakhniuk Date: Thu, 8 Jun 2023 09:27:48 +0400 Subject: [PATCH 2/2] Add fixes to translate --- .../learn/state-a-components-memory.md | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/src/content/learn/state-a-components-memory.md b/src/content/learn/state-a-components-memory.md index c23dbee1f..91d36edaa 100644 --- a/src/content/learn/state-a-components-memory.md +++ b/src/content/learn/state-a-components-memory.md @@ -4,7 +4,7 @@ title: "Состояние: память компонента" -Компоненты часто должны изменять то, что отображается на экране как результат взаимодействия. Ввод в форму должен обновлять поле ввода, нажатие кнопки "далее" на карусели изображений должно изменять отображаемое изображение, нажатие кнопки "купить" должно добавлять товар в корзину. Компоненты должны "запоминать": текущее значение ввода, текущее изображение, корзину. В React такой компонент-специфической памятью называется *состояние*. +Компоненты часто должны изменять то, что отображается на экране как результат взаимодействия. Ввод в форму должен обновлять поле ввода, нажатие кнопки "далее" на карусели изображений должно изменять отображаемое изображение, нажатие кнопки "купить" должно добавлять товар в корзину. Компоненты должны "запоминать": текущее значение ввода, текущее изображение, корзину. В React такой компонент-специфической памятью называется *состоянием*. @@ -332,7 +332,7 @@ button { -### Встречай твой первый хук {/*meet-your-first-hook*/} +### Встречайте ваш первый хук {/*meet-your-first-hook*/} В React `useState`, а также любая другая функция, начинающаяся с "`use`", называется хуком. @@ -348,13 +348,13 @@ button { ### Анатомия `useState` {/*anatomy-of-usestate*/} -Когда ты вызываешь [`useState`](/reference/react/useState), ты говоришь React, что ты хочешь, чтобы этот компонент запомнил что-то: +Когда вы вызываете [`useState`](/reference/react/useState), вы говорите React, что вы хотите, чтобы этот компонент запомнил что-то: ```js const [index, setIndex] = useState(0); ``` -В данном случае ты хочешь, чтобы React запомнил `index`. +В данном случае вы хотите, чтобы React запомнил `index`. @@ -375,14 +375,14 @@ const [index, setIndex] = useState(0); const [index, setIndex] = useState(0); ``` -1. **Твой компонент рендерится в первый раз.** Поскольку вы передали `0` в `useState` в качестве начального значения для `index`, он вернет `[0, setIndex]`. React запоминает, что `0` — это последнее значение состояния. -2. **Ты обновляешь состояние.** Когда пользователь нажимает кнопку, вызывается `setIndex(index + 1)`. `index` равен `0`, поэтому это `setIndex(1)`. Это говорит React запомнить, что `index` теперь равен `1` и вызвать рендеринг. -3. **Второй рендеринг твоего компонента.** React по-прежнему видит `useState(0)`, но поскольку React *запомнил*, что вы установили `index` в `1`, он возвращает `[1, setIndex]`. +1. **Ваш компонент рендерится в первый раз.** Поскольку вы передали `0` в `useState` в качестве начального значения для `index`, он вернет `[0, setIndex]`. React запоминает, что `0` — это последнее значение состояния. +2. **Вы обновляете состояние.** Когда пользователь нажимает кнопку, вызывается `setIndex(index + 1)`. `index` равен `0`, поэтому это `setIndex(1)`. Это говорит React запомнить, что `index` теперь равен `1` и вызвать рендеринг. +3. **Второй рендеринг вашего компонента.** React по-прежнему видит `useState(0)`, но поскольку React *запомнил*, что вы установили `index` в `1`, он возвращает `[1, setIndex]`. 4. И так далее! ## Предоставление компоненту несколько переменных состояния {/*giving-a-component-multiple-state-variables*/} -Ты можешь иметь столько переменных состояния разных типов, сколько захочешь в одном компоненте. Этот компонент имеет две переменные состояния: число `index` и логическое значение `showMore`, которое переключается, когда вы нажимаете "Show details": +Вы можете иметь столько переменных состояния разных типов, сколько захочешь в одном компоненте. Этот компонент имеет две переменные состояния: число `index` и логическое значение `showMore`, которое переключается, когда вы нажимаете "Show details": @@ -527,7 +527,7 @@ button { #### Как React узнает, какое состояние вернуть? {/*how-does-react-know-which-state-to-return*/} -Вероятно ты заметил, что вызов `useState` не получает никакой информации о том на *какое* состоянии он ссылается. Нет "идентификатора", который передается в `useState`, так что как он знает, на какую из переменных состояния ссылаться? Он полагается на какую-то магию, как разбор ваших функций? Ответ - нет. +Вероятно вы заметили, что вызов `useState` не получает никакой информации о том на *какое* состоянии он ссылается. Нет "идентификатора", который передается в `useState`, так что как он знает, на какую из переменных состояния ссылаться? Он полагается на какую-то магию, как разбор ваших функций? Ответ - нет. Вместо этого, чтобы обеспечить их лаконичный синтаксис, Хуки **полагаются на стабильный порядок вызова на каждой отрисовке одного и того же компонента.** Это хорошо работает на практике, потому что если вы следуете правилу выше ("вызывайте Хуки только на верхнем уровне"), Хуки всегда будут вызываться в одном и том же порядке. Кроме того, [плагин линтера](https://www.npmjs.com/package/eslint-plugin-react-hooks) позволяет обнаружить большинство ошибок. @@ -725,7 +725,7 @@ button { display: block; margin-bottom: 10px; } -Ты не обязан понимать это, чтобы использовать React, но тебе может быть полезна эта ментальная модель. +Вы не обязаны понимать это, чтобы использовать React, но вам может быть полезна эта ментальная модель.