From 81e81a54b091f2aa97e57c661675d4fe262f027a Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Thu, 21 Feb 2019 00:20:25 +1300
Subject: [PATCH 01/31] Translate "Forms"

---
 content/docs/forms.md | 123 +++++++++++++++++++++---------------------
 1 file changed, 62 insertions(+), 61 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 1a8b599d5..fa9022a1e 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -9,27 +9,27 @@ redirect_from:
   - "docs/forms-zh-CN.html"
 ---
 
-HTML form elements work a little bit differently from other DOM elements in React, because form elements naturally keep some internal state. For example, this form in plain HTML accepts a single name:
+В React, HTML элементы формы работают несколько иначе чем другие DOM элементы, так как естественным образом хранят свое внутреннее состояние. К примеру, в HTML форму ниже можно ввести имя:
 
 ```html
 <form>
   <label>
-    Name:
+    Имя:
     <input type="text" name="name" />
   </label>
-  <input type="submit" value="Submit" />
+  <input type="submit" value="Отправить" />
 </form>
 ```
 
-This form has the default HTML form behavior of browsing to a new page when the user submits the form. If you want this behavior in React, it just works. But in most cases, it's convenient to have a JavaScript function that handles the submission of the form and has access to the data that the user entered into the form. The standard way to achieve this is with a technique called "controlled components".
+При отправке пользователем, поведением по умолчанию такой HTML формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием "контролируемые компоненты".
 
-## Controlled Components {#controlled-components}
+## Контролируемые компоненты {#controlled-components}
 
-In HTML, form elements such as `<input>`, `<textarea>`, and `<select>` typically maintain their own state and update it based on user input. In React, mutable state is typically kept in the state property of components, and only updated with [`setState()`](/docs/react-component.html#setstate).
+Такие HTML элементы формы, как `<input>`, `<textarea>`, and `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React, мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
 
-We can combine the two by making the React state be the "single source of truth". Then the React component that renders a form also controls what happens in that form on subsequent user input. An input form element whose value is controlled by React in this way is called a "controlled component".
+Мы можем скомбинировать оба подхода и сделать состояние React компонента "единственным источником правды". Тогда React компонент будет рендерить форму и контролировать её поведение в ответ на пользовательский ввод. Значение элемента формы input в этом случае будет контролироваться React, а сам элемент будет называться "контролируемый компонент".
 
-For example, if we want to make the previous example log the name when it is submitted, we can write the form as a controlled component:
+Допустим, требуется, чтобы предыдущий пример при отправке выводил в лог имя. Тогда можно написать форму в виде контролируемого компонента:
 
 ```javascript{4,10-12,24}
 class NameForm extends React.Component {
@@ -46,7 +46,7 @@ class NameForm extends React.Component {
   }
 
   handleSubmit(event) {
-    alert('A name was submitted: ' + this.state.value);
+    alert('Отправленное имя: ' + this.state.value);
     event.preventDefault();
   }
 
@@ -54,21 +54,21 @@ class NameForm extends React.Component {
     return (
       <form onSubmit={this.handleSubmit}>
         <label>
-          Name:
+          Имя:
           <input type="text" value={this.state.value} onChange={this.handleChange} />
         </label>
-        <input type="submit" value="Submit" />
+        <input type="submit" value="Отправить" />
       </form>
     );
   }
 }
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/VmmPgp?editors=0010)
+[**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/VmmPgp?editors=0010)
 
-Since the `value` attribute is set on our form element, the displayed value will always be `this.state.value`, making the React state the source of truth. Since `handleChange` runs on every keystroke to update the React state, the displayed value will update as the user types.
+ На элементе формы input установлен аттрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React компонента "источником правды". А, так как `handleChange` вызывается на каждое нажатие клавиши и обновляет состояние React компонента, отображаемое значение будет обновляться по мере того как пользователь печатает.
 
-With a controlled component, every state mutation will have an associated handler function. This makes it straightforward to modify or validate user input. For example, if we wanted to enforce that names are written with all uppercase letters, we could write `handleChange` as:
+В контролируемом компоненте каждая мутация состояния будет иметь связанную с ней функцию-обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать `handleChange` в таком виде:
 
 ```javascript{2}
 handleChange(event) {
@@ -76,24 +76,24 @@ handleChange(event) {
 }
 ```
 
-## The textarea Tag {#the-textarea-tag}
+## Тэг textarea {#the-textarea-tag}
 
-In HTML, a `<textarea>` element defines its text by its children:
+В HTML, элемент `<textarea>` в качестве текста отображает дочерний элемент:
 
 ```html
 <textarea>
-  Hello there, this is some text in a text area
+  Доброго здоровья, тут просто немного текста внутри тега textarea
 </textarea>
 ```
 
-In React, a `<textarea>` uses a `value` attribute instead. This way, a form using a `<textarea>` can be written very similarly to a form that uses a single-line input:
+В React, `<textarea>` использует аттрибут `value`. Таким образом, форму с `<textarea>` можно написать почти тем же способом что и форму с однострочным `<input>`: 
 
 ```javascript{4-6,12-14,26}
 class EssayForm extends React.Component {
   constructor(props) {
     super(props);
     this.state = {
-      value: 'Please write an essay about your favorite DOM element.'
+      value: 'Будьте любезны, напишите сочинение о вашем любимом DOM элементе.'
     };
 
     this.handleChange = this.handleChange.bind(this);
@@ -105,7 +105,7 @@ class EssayForm extends React.Component {
   }
 
   handleSubmit(event) {
-    alert('An essay was submitted: ' + this.state.value);
+    alert('Сочинение отправлено: ' + this.state.value);
     event.preventDefault();
   }
 
@@ -113,32 +113,32 @@ class EssayForm extends React.Component {
     return (
       <form onSubmit={this.handleSubmit}>
         <label>
-          Essay:
+          Сочинение:
           <textarea value={this.state.value} onChange={this.handleChange} />
         </label>
-        <input type="submit" value="Submit" />
+        <input type="submit" value="Отправить" />
       </form>
     );
   }
 }
 ```
 
-Notice that `this.state.value` is initialized in the constructor, so that the text area starts off with some text in it.
+Заметьте, что `this.state.value` инициализировано в конструкторе, так что текстовая область отображается уже с текстом. 
 
-## The select Tag {#the-select-tag}
+## Тэг select {#the-select-tag}
 
-In HTML, `<select>` creates a drop-down list. For example, this HTML creates a drop-down list of flavors:
+В HTML, `<select>` создаёт выпадающий список. В примере ниже HTML создаёт выпадающий список вкусов:
 
 ```html
 <select>
-  <option value="grapefruit">Grapefruit</option>
-  <option value="lime">Lime</option>
-  <option selected value="coconut">Coconut</option>
-  <option value="mango">Mango</option>
+  <option value="grapefruit">Грейпфрут</option>
+  <option value="lime">Лайм</option>
+  <option selected value="coconut">Кокос</option>
+  <option value="mango">Манго</option>
 </select>
 ```
 
-Note that the Coconut option is initially selected, because of the `selected` attribute. React, instead of using this `selected` attribute, uses a `value` attribute on the root `select` tag. This is more convenient in a controlled component because you only need to update it in one place. For example:
+Опция "Кокос" выбрана по умолчанию из за установленного атрибута `selected`. React вместо этого атрибута использует `value` на корневом теге `select`. Это удобно в контролируемом компоненте потому что обновлять значение нужно только в одном месте (`state`). Пример:
 
 ```javascript{4,10-12,24}
 class FlavorForm extends React.Component {
@@ -155,7 +155,7 @@ class FlavorForm extends React.Component {
   }
 
   handleSubmit(event) {
-    alert('Your favorite flavor is: ' + this.state.value);
+    alert('Ваш любимый вкус: ' + this.state.value);
     event.preventDefault();
   }
 
@@ -163,48 +163,49 @@ class FlavorForm extends React.Component {
     return (
       <form onSubmit={this.handleSubmit}>
         <label>
-          Pick your favorite flavor:
+          Выберите ваш любимый вкус:
           <select value={this.state.value} onChange={this.handleChange}>
-            <option value="grapefruit">Grapefruit</option>
-            <option value="lime">Lime</option>
-            <option value="coconut">Coconut</option>
-            <option value="mango">Mango</option>
+            <option value="grapefruit">Грейпфрут</option>
+            <option value="lime">Лайм</option>
+            <option value="coconut">Кокос</option>
+            <option value="mango">Манго</option>
           </select>
         </label>
-        <input type="submit" value="Submit" />
+        <input type="submit" value="Отправить" />
       </form>
     );
   }
 }
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/JbbEzX?editors=0010)
+[**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/JbbEzX?editors=0010)
 
-Overall, this makes it so that `<input type="text">`, `<textarea>`, and `<select>` all work very similarly - they all accept a `value` attribute that you can use to implement a controlled component.
+Подводя итог, `<input type="text">`, `<textarea>`, и `<select>` работают очень похоже. Все они принимают атрибут `value`, который можно использовать, чтобы реализовать контролируемый компонент.
 
-> Note
+> Примечание
 >
-> You can pass an array into the `value` attribute, allowing you to select multiple options in a `select` tag:
+> Вы можете передать массив внутрь атрибута `value`, что позволит выбрать несколько опций в теге `select`:
 >
 >```js
-><select multiple={true} value={['B', 'C']}>
+><select multiple={true} value={['Б', 'В']}>
 >```
 
+## Загрузка файла {#the-file-input-tag}
 ## The file input Tag {#the-file-input-tag}
 
-In HTML, an `<input type="file">` lets the user choose one or more files from their device storage to be uploaded to a server or manipulated by JavaScript via the [File API](https://developer.mozilla.org/en-US/docs/Web/API/File/Using_files_from_web_applications).
+В HTML, `<input type="file">` позволяет пользователю выбрать один или несколько файлов для загрузки с устройства на сервер или работать с ними на JavaScript с помощью [File API](https://developer.mozilla.org/en-US/docs/Web/API/File/Using_files_from_web_applications). 
 
 ```html
 <input type="file" />
 ```
 
-Because its value is read-only, it is an **uncontrolled** component in React. It is discussed together with other uncontrolled components [later in the documentation](/docs/uncontrolled-components.html#the-file-input-tag).
+Так как значение такого элемента доступно только для чтения, это **неконтролируемый** React компонент. Этот случай описан вместе с другими неконтролируемыми компонентами [далее в документации](/docs/uncontrolled-components.html#the-file-input-tag).
 
-## Handling Multiple Inputs {#handling-multiple-inputs}
+## Обработка нескольких input {#handling-multiple-inputs}
 
-When you need to handle multiple controlled `input` elements, you can add a `name` attribute to each element and let the handler function choose what to do based on the value of `event.target.name`.
+Когда вы имеете дело с несколькими контролируемыми элементами `input`, вы можете добавить каждому из них аттрибут `name`, что позволит функции-обработчику решать, что делать, основываясь на значении `event.target.name`.
 
-For example:
+Пример:
 
 ```javascript{15,18,28,37}
 class Reservation extends React.Component {
@@ -232,7 +233,7 @@ class Reservation extends React.Component {
     return (
       <form>
         <label>
-          Is going:
+          Пойду:
           <input
             name="isGoing"
             type="checkbox"
@@ -241,7 +242,7 @@ class Reservation extends React.Component {
         </label>
         <br />
         <label>
-          Number of guests:
+          Количество гостей:
           <input
             name="numberOfGuests"
             type="number"
@@ -254,9 +255,9 @@ class Reservation extends React.Component {
 }
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/wgedvV?editors=0010)
+[**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/wgedvV?editors=0010)
 
-Note how we used the ES6 [computed property name](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names) syntax to update the state key corresponding to the given input name:
+Обратите внимание на использование синтаксиса ES6 [вычисляемые имена](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names) чтобы обновить значение в `state` через ключ, который соответствует атрибуту name элемента input:
 
 ```js{2}
 this.setState({
@@ -264,7 +265,7 @@ this.setState({
 });
 ```
 
-It is equivalent to this ES5 code:
+Идентичный ES5 код:
 
 ```js{2}
 var partialState = {};
@@ -272,16 +273,16 @@ partialState[name] = value;
 this.setState(partialState);
 ```
 
-Also, since `setState()` automatically [merges a partial state into the current state](/docs/state-and-lifecycle.html#state-updates-are-merged), we only needed to call it with the changed parts.
+Кроме того, `setState()` автоматически производит [слияние части состояния с текущим состоянием](/docs/state-and-lifecycle.html#state-updates-are-merged), то есть можно вызывать этот метод только для изменяемых в данный момент частей `state`.
 
-## Controlled Input Null Value {#controlled-input-null-value}
+## Значение null контролируемого компонента {#controlled-input-null-value}
 
-Specifying the value prop on a [controlled component](/docs/forms.html#controlled-components) prevents the user from changing the input unless you desire so. If you've specified a `value` but the input is still editable, you may have accidentally set `value` to `undefined` or `null`.
+Передача пропа value [контролируемому компоненту](/docs/forms.html#controlled-components) позволит вам не дать пользователю изменить значение input без вашего желания. Если значение `value` передано но input остается редактируемым, возможно, значение `value` случайно было установлено в `undefined` или `null`.
 
-The following code demonstrates this. (The input is locked at first but becomes editable after a short delay.)
+Код ниже это демонстрирует. (Сперва заблокированный для ввода, Input, после небольшой задержки, становится редактируемым.)
 
 ```javascript
-ReactDOM.render(<input value="hi" />, mountNode);
+ReactDOM.render(<input value="Привет" />, mountNode);
 
 setTimeout(function() {
   ReactDOM.render(<input value={null} />, mountNode);
@@ -289,10 +290,10 @@ setTimeout(function() {
 
 ```
 
-## Alternatives to Controlled Components {#alternatives-to-controlled-components}
+## Альтернативы контролируемым компонентам {#alternatives-to-controlled-components}
 
-It can sometimes be tedious to use controlled components, because you need to write an event handler for every way your data can change and pipe all of the input state through a React component. This can become particularly annoying when you are converting a preexisting codebase to React, or integrating a React application with a non-React library. In these situations, you might want to check out [uncontrolled components](/docs/uncontrolled-components.html), an alternative technique for implementing input forms.
+Использование контролируемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React компонент. Это может особенно раздражать при переносе существующей кодовой базы в React, или когда идёт работа над интеграцией React приложения с не-React библиотекой. В такой ситуации могут пригодиться [uncontrolled components](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
 
-## Fully-Fledged Solutions {#fully-fledged-solutions}
+## Полноценные решения {#fully-fledged-solutions}
 
-If you're looking for a complete solution including validation, keeping track of the visited fields, and handling form submission, [Formik](https://jaredpalmer.com/formik) is one of the popular choices. However, it is built on the same principles of controlled components and managing state — so don't neglect to learn them.
+При поиске полноценного решения с валидацией, запоминанием посещённых полей и обработкой отправки формы, [Formik](https://jaredpalmer.com/formik) будет одной из популярных опций. Как бы то ни было, эта библиотека построена на тех же принципах контролируемых компонентов и управления состоянием, так что не пренебрегайте их изучением.

From 97834d570e58d6ebdcea1552da0451fccf0ec91d Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Thu, 21 Feb 2019 00:37:31 +1300
Subject: [PATCH 02/31] Translate "Forms": self review chages

---
 content/docs/forms.md | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index fa9022a1e..49ee00f40 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -27,7 +27,7 @@ redirect_from:
 
 Такие HTML элементы формы, как `<input>`, `<textarea>`, and `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React, мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
 
-Мы можем скомбинировать оба подхода и сделать состояние React компонента "единственным источником правды". Тогда React компонент будет рендерить форму и контролировать её поведение в ответ на пользовательский ввод. Значение элемента формы input в этом случае будет контролироваться React, а сам элемент будет называться "контролируемый компонент".
+Мы можем скомбинировать оба подхода и сделать состояние React компонента "единственным источником правды". Тогда React компонент будет рендерить форму и контролировать её поведение в ответ на пользовательский ввод. Значение элемента формы input в этом случае будет контролировать React, а сам элемент будет называться "контролируемый компонент".
 
 Допустим, требуется, чтобы предыдущий пример при отправке выводил в лог имя. Тогда можно написать форму в виде контролируемого компонента:
 
@@ -68,7 +68,7 @@ class NameForm extends React.Component {
 
  На элементе формы input установлен аттрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React компонента "источником правды". А, так как `handleChange` вызывается на каждое нажатие клавиши и обновляет состояние React компонента, отображаемое значение будет обновляться по мере того как пользователь печатает.
 
-В контролируемом компоненте каждая мутация состояния будет иметь связанную с ней функцию-обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать `handleChange` в таком виде:
+В контролируемом компоненте каждая мутация состояния будет иметь связанную с ней функцию—обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать `handleChange` в таком виде:
 
 ```javascript{2}
 handleChange(event) {
@@ -203,7 +203,7 @@ class FlavorForm extends React.Component {
 
 ## Обработка нескольких input {#handling-multiple-inputs}
 
-Когда вы имеете дело с несколькими контролируемыми элементами `input`, вы можете добавить каждому из них аттрибут `name`, что позволит функции-обработчику решать, что делать, основываясь на значении `event.target.name`.
+Когда вы имеете дело с несколькими контролируемыми элементами `input`, вы можете добавить каждому из них аттрибут `name`, что позволит функции—обработчику решать, что делать, основываясь на значении `event.target.name`.
 
 Пример:
 
@@ -257,7 +257,7 @@ class Reservation extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/wgedvV?editors=0010)
 
-Обратите внимание на использование синтаксиса ES6 [вычисляемые имена](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names) чтобы обновить значение в `state` через ключ, который соответствует атрибуту name элемента input:
+Обратите внимание, мы используем синтаксиса ES6 [вычисляемые имена](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names), чтобы обновить значение в `state` через ключ, который соответствует атрибуту name элемента input:
 
 ```js{2}
 this.setState({
@@ -292,8 +292,8 @@ setTimeout(function() {
 
 ## Альтернативы контролируемым компонентам {#alternatives-to-controlled-components}
 
-Использование контролируемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React компонент. Это может особенно раздражать при переносе существующей кодовой базы в React, или когда идёт работа над интеграцией React приложения с не-React библиотекой. В такой ситуации могут пригодиться [uncontrolled components](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
+Использование контролируемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React компонент. Это может особенно раздражать если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с не—React библиотекой. В такой ситуации могут пригодиться [uncontrolled components](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
 
 ## Полноценные решения {#fully-fledged-solutions}
 
-При поиске полноценного решения с валидацией, запоминанием посещённых полей и обработкой отправки формы, [Formik](https://jaredpalmer.com/formik) будет одной из популярных опций. Как бы то ни было, эта библиотека построена на тех же принципах контролируемых компонентов и управления состоянием, так что не пренебрегайте их изучением.
+При поиске полноценного решения, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, [Formik](https://jaredpalmer.com/formik) будет одной из популярных опций. Как бы то ни было, эта библиотека построена на тех же принципах контролируемых компонентов и управления состоянием, так что не пренебрегайте их изучением.

From 2c59f2944131e121641a62e3018f95484de50ac1 Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Thu, 21 Feb 2019 00:49:49 +1300
Subject: [PATCH 03/31] =?UTF-8?q?Translate=20"Forms":=20=D0=BA=D0=BE=D0=BD?=
 =?UTF-8?q?=D1=82=D1=80=D0=BE=D0=BB=D0=B8=D1=80=D1=83=D0=B5=D0=BC=D1=8B?=
 =?UTF-8?q?=D0=B9=20->=20=D1=83=D0=BF=D1=80=D0=B0=D0=B2=D0=BB=D1=8F=D0=B5?=
 =?UTF-8?q?=D0=BC=D1=8B=D0=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/docs/forms.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 49ee00f40..501021116 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -21,15 +21,15 @@ redirect_from:
 </form>
 ```
 
-При отправке пользователем, поведением по умолчанию такой HTML формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием "контролируемые компоненты".
+При отправке пользователем, поведением по умолчанию такой HTML формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием "управляемые компоненты".
 
-## Контролируемые компоненты {#controlled-components}
+## Управляемые компоненты {#controlled-components}
 
 Такие HTML элементы формы, как `<input>`, `<textarea>`, and `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React, мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
 
-Мы можем скомбинировать оба подхода и сделать состояние React компонента "единственным источником правды". Тогда React компонент будет рендерить форму и контролировать её поведение в ответ на пользовательский ввод. Значение элемента формы input в этом случае будет контролировать React, а сам элемент будет называться "контролируемый компонент".
+Мы можем скомбинировать оба подхода и сделать состояние React компонента "единственным источником правды". Тогда React компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться "управляемый компонент".
 
-Допустим, требуется, чтобы предыдущий пример при отправке выводил в лог имя. Тогда можно написать форму в виде контролируемого компонента:
+Допустим, требуется, чтобы предыдущий пример при отправке выводил в лог имя. Тогда можно написать форму в виде управляемого компонента:
 
 ```javascript{4,10-12,24}
 class NameForm extends React.Component {
@@ -68,7 +68,7 @@ class NameForm extends React.Component {
 
  На элементе формы input установлен аттрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React компонента "источником правды". А, так как `handleChange` вызывается на каждое нажатие клавиши и обновляет состояние React компонента, отображаемое значение будет обновляться по мере того как пользователь печатает.
 
-В контролируемом компоненте каждая мутация состояния будет иметь связанную с ней функцию—обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать `handleChange` в таком виде:
+В управляемом компоненте каждая мутация состояния будет иметь связанную с ней функцию—обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать `handleChange` в таком виде:
 
 ```javascript{2}
 handleChange(event) {
@@ -138,7 +138,7 @@ class EssayForm extends React.Component {
 </select>
 ```
 
-Опция "Кокос" выбрана по умолчанию из за установленного атрибута `selected`. React вместо этого атрибута использует `value` на корневом теге `select`. Это удобно в контролируемом компоненте потому что обновлять значение нужно только в одном месте (`state`). Пример:
+Опция "Кокос" выбрана по умолчанию из за установленного атрибута `selected`. React вместо этого атрибута использует `value` на корневом теге `select`. Это удобно в управляемом компоненте потому что обновлять значение нужно только в одном месте (`state`). Пример:
 
 ```javascript{4,10-12,24}
 class FlavorForm extends React.Component {
@@ -180,7 +180,7 @@ class FlavorForm extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/JbbEzX?editors=0010)
 
-Подводя итог, `<input type="text">`, `<textarea>`, и `<select>` работают очень похоже. Все они принимают атрибут `value`, который можно использовать, чтобы реализовать контролируемый компонент.
+Подводя итог, `<input type="text">`, `<textarea>`, и `<select>` работают очень похоже. Все они принимают атрибут `value`, который можно использовать, чтобы реализовать управляемый компонент.
 
 > Примечание
 >
@@ -199,11 +199,11 @@ class FlavorForm extends React.Component {
 <input type="file" />
 ```
 
-Так как значение такого элемента доступно только для чтения, это **неконтролируемый** React компонент. Этот случай описан вместе с другими неконтролируемыми компонентами [далее в документации](/docs/uncontrolled-components.html#the-file-input-tag).
+Так как значение такого элемента доступно только для чтения, это **неуправляемый** React компонент. Этот случай описан вместе с другими неуправляемыми компонентами [далее в документации](/docs/uncontrolled-components.html#the-file-input-tag).
 
 ## Обработка нескольких input {#handling-multiple-inputs}
 
-Когда вы имеете дело с несколькими контролируемыми элементами `input`, вы можете добавить каждому из них аттрибут `name`, что позволит функции—обработчику решать, что делать, основываясь на значении `event.target.name`.
+Когда вы имеете дело с несколькими управляемыми элементами `input`, вы можете добавить каждому из них аттрибут `name`, что позволит функции—обработчику решать, что делать, основываясь на значении `event.target.name`.
 
 Пример:
 
@@ -275,9 +275,9 @@ this.setState(partialState);
 
 Кроме того, `setState()` автоматически производит [слияние части состояния с текущим состоянием](/docs/state-and-lifecycle.html#state-updates-are-merged), то есть можно вызывать этот метод только для изменяемых в данный момент частей `state`.
 
-## Значение null контролируемого компонента {#controlled-input-null-value}
+## Значение null управляемого компонента {#controlled-input-null-value}
 
-Передача пропа value [контролируемому компоненту](/docs/forms.html#controlled-components) позволит вам не дать пользователю изменить значение input без вашего желания. Если значение `value` передано но input остается редактируемым, возможно, значение `value` случайно было установлено в `undefined` или `null`.
+Передача пропа value [управляемому компоненту](/docs/forms.html#controlled-components) позволит вам не дать пользователю изменить значение input без вашего желания. Если значение `value` передано но input остается редактируемым, возможно, значение `value` случайно было установлено в `undefined` или `null`.
 
 Код ниже это демонстрирует. (Сперва заблокированный для ввода, Input, после небольшой задержки, становится редактируемым.)
 
@@ -290,10 +290,10 @@ setTimeout(function() {
 
 ```
 
-## Альтернативы контролируемым компонентам {#alternatives-to-controlled-components}
+## Альтернативы управляемым компонентам {#alternatives-to-controlled-components}
 
-Использование контролируемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React компонент. Это может особенно раздражать если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с не—React библиотекой. В такой ситуации могут пригодиться [uncontrolled components](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
+Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React компонент. Это может особенно раздражать если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с не—React библиотекой. В такой ситуации могут пригодиться [uncontrolled components](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
 
 ## Полноценные решения {#fully-fledged-solutions}
 
-При поиске полноценного решения, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, [Formik](https://jaredpalmer.com/formik) будет одной из популярных опций. Как бы то ни было, эта библиотека построена на тех же принципах контролируемых компонентов и управления состоянием, так что не пренебрегайте их изучением.
+При поиске полноценного решения, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, [Formik](https://jaredpalmer.com/formik) будет одной из популярных опций. Как бы то ни было, эта библиотека построена на принципах управляемых компонентов и управления состоянием, так что не пренебрегайте их изучением.

From 0ad9f1150731c5f6caf6abf9385e498ebea7e30b Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Thu, 21 Feb 2019 00:57:07 +1300
Subject: [PATCH 04/31] Translate "Forms": punctuation and rephrasing

---
 content/docs/forms.md | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 501021116..59d2f516e 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -9,7 +9,7 @@ redirect_from:
   - "docs/forms-zh-CN.html"
 ---
 
-В React, HTML элементы формы работают несколько иначе чем другие DOM элементы, так как естественным образом хранят свое внутреннее состояние. К примеру, в HTML форму ниже можно ввести имя:
+В React, HTML элементы формы работают несколько иначе, чем другие DOM элементы, так как естественным образом хранят свое внутреннее состояние. К примеру, в HTML форму ниже можно ввести имя:
 
 ```html
 <form>
@@ -21,7 +21,7 @@ redirect_from:
 </form>
 ```
 
-При отправке пользователем, поведением по умолчанию такой HTML формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием "управляемые компоненты".
+При отправке пользователем, поведением по умолчанию для такой HTML формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием "управляемые компоненты".
 
 ## Управляемые компоненты {#controlled-components}
 
@@ -138,7 +138,7 @@ class EssayForm extends React.Component {
 </select>
 ```
 
-Опция "Кокос" выбрана по умолчанию из за установленного атрибута `selected`. React вместо этого атрибута использует `value` на корневом теге `select`. Это удобно в управляемом компоненте потому что обновлять значение нужно только в одном месте (`state`). Пример:
+Опция "Кокос" выбрана по умолчанию из за установленного атрибута `selected`. React вместо этого атрибута использует `value` в корневом теге `select`. Это удобно в управляемом компоненте потому что обновлять значение нужно только в одном месте (`state`). Пример:
 
 ```javascript{4,10-12,24}
 class FlavorForm extends React.Component {
@@ -279,7 +279,7 @@ this.setState(partialState);
 
 Передача пропа value [управляемому компоненту](/docs/forms.html#controlled-components) позволит вам не дать пользователю изменить значение input без вашего желания. Если значение `value` передано но input остается редактируемым, возможно, значение `value` случайно было установлено в `undefined` или `null`.
 
-Код ниже это демонстрирует. (Сперва заблокированный для ввода, Input, после небольшой задержки, становится редактируемым.)
+Код ниже это демонстрирует. (после небольшой задержки, сперва заблокированный для ввода input становится редактируемым.)
 
 ```javascript
 ReactDOM.render(<input value="Привет" />, mountNode);

From e8275a8a3b9cf600391c297dd5d5233037865e68 Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Thu, 21 Feb 2019 22:52:53 +1300
Subject: [PATCH 05/31] Translate "Forms": Review changes

---
 content/docs/forms.md | 32 ++++++++++++++++----------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 59d2f516e..cbe403e30 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -9,7 +9,7 @@ redirect_from:
   - "docs/forms-zh-CN.html"
 ---
 
-В React, HTML элементы формы работают несколько иначе, чем другие DOM элементы, так как естественным образом хранят свое внутреннее состояние. К примеру, в HTML форму ниже можно ввести имя:
+В React HTML элементы формы ведут себя несколько отлично от остальных DOM-элементов, так как у элементов формы изначально есть внутреннее состояние. К примеру, в HTML форму ниже можно ввести имя:
 
 ```html
 <form>
@@ -25,9 +25,9 @@ redirect_from:
 
 ## Управляемые компоненты {#controlled-components}
 
-Такие HTML элементы формы, как `<input>`, `<textarea>`, and `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React, мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
+В HTML элементы формы, такие как `<input>`, `<textarea>` и `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
 
-Мы можем скомбинировать оба подхода и сделать состояние React компонента "единственным источником правды". Тогда React компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться "управляемый компонент".
+Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться "управляемый компонент".
 
 Допустим, требуется, чтобы предыдущий пример при отправке выводил в лог имя. Тогда можно написать форму в виде управляемого компонента:
 
@@ -66,9 +66,9 @@ class NameForm extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/VmmPgp?editors=0010)
 
- На элементе формы input установлен аттрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React компонента "источником правды". А, так как `handleChange` вызывается на каждое нажатие клавиши и обновляет состояние React компонента, отображаемое значение будет обновляться по мере того как пользователь печатает.
+ На элементе формы input установлен атрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React-компонента "источником правды". А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, отображаемое значение будет обновляться по мере того как пользователь печатает.
 
-В управляемом компоненте каждая мутация состояния будет иметь связанную с ней функцию—обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать `handleChange` в таком виде:
+В управляемом компоненте с каждой мутацией состояния связана функция-обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать такой `handleChange`:
 
 ```javascript{2}
 handleChange(event) {
@@ -78,7 +78,7 @@ handleChange(event) {
 
 ## Тэг textarea {#the-textarea-tag}
 
-В HTML, элемент `<textarea>` в качестве текста отображает дочерний элемент:
+HTML-элемент `<textarea>` в качестве текста отображает дочерний элемент:
 
 ```html
 <textarea>
@@ -86,14 +86,14 @@ handleChange(event) {
 </textarea>
 ```
 
-В React, `<textarea>` использует аттрибут `value`. Таким образом, форму с `<textarea>` можно написать почти тем же способом что и форму с однострочным `<input>`: 
+В React `<textarea>` использует атрибут `value`. Таким образом, форму с `<textarea>` можно написать почти тем же способом что и форму с однострочным `<input>`: 
 
 ```javascript{4-6,12-14,26}
 class EssayForm extends React.Component {
   constructor(props) {
     super(props);
     this.state = {
-      value: 'Будьте любезны, напишите сочинение о вашем любимом DOM элементе.'
+      value: 'Будьте любезны, напишите сочинение о вашем любимом DOM-элементе.'
     };
 
     this.handleChange = this.handleChange.bind(this);
@@ -123,11 +123,11 @@ class EssayForm extends React.Component {
 }
 ```
 
-Заметьте, что `this.state.value` инициализировано в конструкторе, так что текстовая область отображается уже с текстом. 
+Обратите внимание, что `this.state.value` инициализировано в конструкторе, так что в текстовой области изначально есть текст.
 
 ## Тэг select {#the-select-tag}
 
-В HTML, `<select>` создаёт выпадающий список. В примере ниже HTML создаёт выпадающий список вкусов:
+В HTML `<select>` создаёт выпадающий список. HTML-код в этом примере создаёт выпадающий список вкусов:
 
 ```html
 <select>
@@ -138,7 +138,7 @@ class EssayForm extends React.Component {
 </select>
 ```
 
-Опция "Кокос" выбрана по умолчанию из за установленного атрибута `selected`. React вместо этого атрибута использует `value` в корневом теге `select`. Это удобно в управляемом компоненте потому что обновлять значение нужно только в одном месте (`state`). Пример:
+Опция "Кокос" выбрана по умолчанию из-за установленного атрибута `selected`. React вместо этого атрибута использует `value` в корневом теге `select`. В управляемом компоненте так удобнее, потому что обновлять значение нужно только в одном месте (`state`). Пример:
 
 ```javascript{4,10-12,24}
 class FlavorForm extends React.Component {
@@ -193,17 +193,17 @@ class FlavorForm extends React.Component {
 ## Загрузка файла {#the-file-input-tag}
 ## The file input Tag {#the-file-input-tag}
 
-В HTML, `<input type="file">` позволяет пользователю выбрать один или несколько файлов для загрузки с устройства на сервер или работать с ними на JavaScript с помощью [File API](https://developer.mozilla.org/en-US/docs/Web/API/File/Using_files_from_web_applications). 
+В HTML `<input type="file">` позволяет пользователю выбрать один или несколько файлов для загрузки с устройства на сервер или обработки с помощью [File API](https://developer.mozilla.org/en-US/docs/Web/API/File/Using_files_from_web_applications) JavaScript. 
 
 ```html
 <input type="file" />
 ```
 
-Так как значение такого элемента доступно только для чтения, это **неуправляемый** React компонент. Этот случай описан вместе с другими неуправляемыми компонентами [далее в документации](/docs/uncontrolled-components.html#the-file-input-tag).
+Так как значение такого элемента доступно только для чтения, это **неуправляемый** React-компонент. Мы расскажем про этот и другие неуправляемые компоненты [далее в документации](/docs/uncontrolled-components.html#the-file-input-tag).
 
 ## Обработка нескольких input {#handling-multiple-inputs}
 
-Когда вы имеете дело с несколькими управляемыми элементами `input`, вы можете добавить каждому из них аттрибут `name`, что позволит функции—обработчику решать, что делать, основываясь на значении `event.target.name`.
+Когда вы имеете дело с несколькими управляемыми элементами `input`, вы можете добавить каждому из них атрибут `name`, что позволит функции-обработчику решать, что делать, основываясь на значении `event.target.name`.
 
 Пример:
 
@@ -277,7 +277,7 @@ this.setState(partialState);
 
 ## Значение null управляемого компонента {#controlled-input-null-value}
 
-Передача пропа value [управляемому компоненту](/docs/forms.html#controlled-components) позволит вам не дать пользователю изменить значение input без вашего желания. Если значение `value` передано но input остается редактируемым, возможно, значение `value` случайно было установлено в `undefined` или `null`.
+Передача пропа value [управляемому компоненту](/docs/forms.html#controlled-components) позволит вам не дать пользователю изменить значение input без вашего желания. Если значение `value` передано, но input остается редактируемым, возможно, значение `value` случайно было установлено в `undefined` или `null`.
 
 Код ниже это демонстрирует. (после небольшой задержки, сперва заблокированный для ввода input становится редактируемым.)
 
@@ -292,7 +292,7 @@ setTimeout(function() {
 
 ## Альтернативы управляемым компонентам {#alternatives-to-controlled-components}
 
-Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React компонент. Это может особенно раздражать если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с не—React библиотекой. В такой ситуации могут пригодиться [uncontrolled components](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
+Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React-компонент. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с другой библиотекой. В такой ситуации могут пригодиться [неуправляемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
 
 ## Полноценные решения {#fully-fledged-solutions}
 

From d9ccbc1cc2d389c6c1ac4f9436b552864cfd2999 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:35:01 +1300
Subject: [PATCH 06/31] Translate "Forms": add missing dash

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index cbe403e30..2233823b6 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -9,7 +9,7 @@ redirect_from:
   - "docs/forms-zh-CN.html"
 ---
 
-В React HTML элементы формы ведут себя несколько отлично от остальных DOM-элементов, так как у элементов формы изначально есть внутреннее состояние. К примеру, в HTML форму ниже можно ввести имя:
+В React HTML-элементы формы ведут себя несколько отлично от остальных DOM-элементов, так как у элементов формы изначально есть внутреннее состояние. К примеру, в HTML-форму ниже можно ввести имя:
 
 ```html
 <form>

From 61f5c61067f2e3de3f0aa3ae98429bdf8109e756 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:36:06 +1300
Subject: [PATCH 07/31] Translate "Forms": missing dash and correct quotes

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 2233823b6..38e34a6e8 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -21,7 +21,7 @@ redirect_from:
 </form>
 ```
 
-При отправке пользователем, поведением по умолчанию для такой HTML формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием "управляемые компоненты".
+При отправке пользователем, поведением по умолчанию для такой HTML-формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript-функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием «управляемые компоненты».
 
 ## Управляемые компоненты {#controlled-components}
 

From e69cd2729676d39cc19e6c1c5b75db49bb34349f Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:36:33 +1300
Subject: [PATCH 08/31] Translate "Forms": correct quotes

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 38e34a6e8..3e9febd9d 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -27,7 +27,7 @@ redirect_from:
 
 В HTML элементы формы, такие как `<input>`, `<textarea>` и `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
 
-Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться "управляемый компонент".
+Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться «управляемый компонент».
 
 Допустим, требуется, чтобы предыдущий пример при отправке выводил в лог имя. Тогда можно написать форму в виде управляемого компонента:
 

From c985055cb8d887c9d38929d252b7e62333059f04 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:37:22 +1300
Subject: [PATCH 09/31] Translate "Forms": remove space, missing comma

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 3e9febd9d..b1ea610fe 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -66,7 +66,7 @@ class NameForm extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/VmmPgp?editors=0010)
 
- На элементе формы input установлен атрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React-компонента "источником правды". А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, отображаемое значение будет обновляться по мере того как пользователь печатает.
+На элементе формы input установлен атрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React-компонента "источником правды". А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, отображаемое значение будет обновляться по мере того, как пользователь печатает.
 
 В управляемом компоненте с каждой мутацией состояния связана функция-обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать такой `handleChange`:
 

From 8b05614f8018a0c2251fc54bef6a75e4384ad705 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:38:09 +1300
Subject: [PATCH 10/31] =?UTF-8?q?Translate=20"Forms":=20=D0=BB=D0=BE=D0=B3?=
 =?UTF-8?q?=20->=20=D0=BA=D0=BE=D0=BD=D1=81=D0=BE=D0=BB=D1=8C?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index b1ea610fe..460846b38 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -29,7 +29,7 @@ redirect_from:
 
 Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться «управляемый компонент».
 
-Допустим, требуется, чтобы предыдущий пример при отправке выводил в лог имя. Тогда можно написать форму в виде управляемого компонента:
+Допустим, требуется, чтобы предыдущий пример при отправке выводил в консоль имя. Тогда можно написать форму в виде управляемого компонента:
 
 ```javascript{4,10-12,24}
 class NameForm extends React.Component {

From 26848ee8c7b59494d5d2c222db0e0840857c5318 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:43:25 +1300
Subject: [PATCH 11/31] =?UTF-8?q?Translate=20"Forms":=20=D0=A2=D1=8D=D0=B3?=
 =?UTF-8?q?=20->=20=D0=A2=D0=B5=D0=B3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 460846b38..4f1ed0d79 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -76,7 +76,7 @@ handleChange(event) {
 }
 ```
 
-## Тэг textarea {#the-textarea-tag}
+## Тег textarea {#the-textarea-tag}
 
 HTML-элемент `<textarea>` в качестве текста отображает дочерний элемент:
 

From c04529df56d99e323ca4efa6553a5abd107e0d75 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:48:22 +1300
Subject: [PATCH 12/31] Translate "Forms": missing comma

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 4f1ed0d79..03e6bc9c2 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -86,7 +86,7 @@ HTML-элемент `<textarea>` в качестве текста отображ
 </textarea>
 ```
 
-В React `<textarea>` использует атрибут `value`. Таким образом, форму с `<textarea>` можно написать почти тем же способом что и форму с однострочным `<input>`: 
+В React `<textarea>` использует атрибут `value`. Таким образом, форму с `<textarea>` можно написать почти тем же способом, что и форму с однострочным `<input>`: 
 
 ```javascript{4-6,12-14,26}
 class EssayForm extends React.Component {

From 3491ff96e06b0959c66749bba0eaa6856a1ded97 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 21:49:08 +1300
Subject: [PATCH 13/31] =?UTF-8?q?Translate=20"Forms":=20=D0=A2=D1=8D=D0=B3?=
 =?UTF-8?q?=20->=20=D0=A2=D0=B5=D0=B3?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 03e6bc9c2..97790a6e4 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -125,7 +125,7 @@ class EssayForm extends React.Component {
 
 Обратите внимание, что `this.state.value` инициализировано в конструкторе, так что в текстовой области изначально есть текст.
 
-## Тэг select {#the-select-tag}
+## Тег select {#the-select-tag}
 
 В HTML `<select>` создаёт выпадающий список. HTML-код в этом примере создаёт выпадающий список вкусов:
 

From 25c2a2194377ba08df43f2e9a371b36dc4f80477 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 22:02:39 +1300
Subject: [PATCH 14/31] Translate "Forms": remove original text

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 1 -
 1 file changed, 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 97790a6e4..4ab6c1653 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -191,7 +191,6 @@ class FlavorForm extends React.Component {
 >```
 
 ## Загрузка файла {#the-file-input-tag}
-## The file input Tag {#the-file-input-tag}
 
 В HTML `<input type="file">` позволяет пользователю выбрать один или несколько файлов для загрузки с устройства на сервер или обработки с помощью [File API](https://developer.mozilla.org/en-US/docs/Web/API/File/Using_files_from_web_applications) JavaScript. 
 

From 58d0bb1fac5811a161aa6e0977671c87718e0814 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 22:08:36 +1300
Subject: [PATCH 15/31] Translate

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 4ab6c1653..6b709ac52 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -192,7 +192,7 @@ class FlavorForm extends React.Component {
 
 ## Загрузка файла {#the-file-input-tag}
 
-В HTML `<input type="file">` позволяет пользователю выбрать один или несколько файлов для загрузки с устройства на сервер или обработки с помощью [File API](https://developer.mozilla.org/en-US/docs/Web/API/File/Using_files_from_web_applications) JavaScript. 
+В HTML `<input type="file">` позволяет пользователю выбрать один или несколько файлов для загрузки с устройства на сервер или управлять им через JavaScript с помощью [File API](https://developer.mozilla.org/ru/docs/Web/API/File/Using_files_from_web_applications).
 
 ```html
 <input type="file" />

From 894df89b8cc28a09148f843669a50f076da7db36 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Sat, 23 Feb 2019 22:11:05 +1300
Subject: [PATCH 16/31] Translate "Forms": rephrasing and fixing link

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 6b709ac52..a6974ac11 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -256,7 +256,7 @@ class Reservation extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/wgedvV?editors=0010)
 
-Обратите внимание, мы используем синтаксиса ES6 [вычисляемые имена](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names), чтобы обновить значение в `state` через ключ, который соответствует атрибуту name элемента input:
+Обратите внимание, мы используем ES6-возможность [вычисляемые имена свойств](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Object_initializer#%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D1%8F%D0%B5%D0%BC%D1%8B%D0%B5_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B0_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2), чтобы обновить значение в `state` через ключ, который соответствует атрибуту name элемента input:
 
 ```js{2}
 this.setState({

From 06eae301a03cc4d07a584613175ba6afd5e5a18d Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Sat, 23 Feb 2019 22:43:47 +1300
Subject: [PATCH 17/31] Translate "Forms": CR changes by Heegiiny

---
 content/docs/forms.md | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index a6974ac11..781b696a0 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -9,7 +9,7 @@ redirect_from:
   - "docs/forms-zh-CN.html"
 ---
 
-В React HTML-элементы формы ведут себя несколько отлично от остальных DOM-элементов, так как у элементов формы изначально есть внутреннее состояние. К примеру, в HTML-форму ниже можно ввести имя:
+В React HTML-элементы формы ведут себя несколько отлично от остальных DOM-элементов, так как у элементов формы изначально есть внутреннее состояние. К примеру, в эту HTML-форму можно ввести имя:
 
 ```html
 <form>
@@ -21,7 +21,7 @@ redirect_from:
 </form>
 ```
 
-При отправке пользователем, поведением по умолчанию для такой HTML-формы будет переход на новую страницу. Точно так же она будет вести себя и в React. Однако, чаще всего удобно обрабатывать отправку формы через JavaScript-функцию, которая имеет доступ к введённым в форму данным. Для этого можно воспользоваться стандартным способом под названием «управляемые компоненты».
+По умолчанию браузер переходит на другую страницу при отправке HTML-форм, в том числе и этой. Если вас это устраивает, то не надо ничего менять, в React формы работают как обычно. Однако, чаще всего форму удобнее обрабатывать с помощью JavaScript функции, у которой есть доступ к введённым данным. Стандартный способ реализации такого поведения называется «управляемые компоненты».
 
 ## Управляемые компоненты {#controlled-components}
 
@@ -29,7 +29,7 @@ redirect_from:
 
 Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться «управляемый компонент».
 
-Допустим, требуется, чтобы предыдущий пример при отправке выводил в консоль имя. Тогда можно написать форму в виде управляемого компонента:
+Допустим, мы хотим, чтобы предыдущий пример выводил в консоль имя, когда мы отправляем форму. Тогда можно написать форму в виде управляемого компонента:
 
 ```javascript{4,10-12,24}
 class NameForm extends React.Component {
@@ -66,7 +66,7 @@ class NameForm extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/VmmPgp?editors=0010)
 
-На элементе формы input установлен атрибут `value`, а его отображаемое значение всегда будет `this.state.value`, что делает состояние React-компонента "источником правды". А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, отображаемое значение будет обновляться по мере того, как пользователь печатает.
+Мы установили атрибут `value` для поля ввода, и теперь в нём всегда будет отображаться `this.state.value`. Состояние React-компонента стало «источником истины». А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, значение в поле будет обновляться по мере того как пользователь печатает.
 
 В управляемом компоненте с каждой мутацией состояния связана функция-обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать такой `handleChange`:
 
@@ -256,7 +256,7 @@ class Reservation extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/wgedvV?editors=0010)
 
-Обратите внимание, мы используем ES6-возможность [вычисляемые имена свойств](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Object_initializer#%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D1%8F%D0%B5%D0%BC%D1%8B%D0%B5_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B0_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2), чтобы обновить значение в `state` через ключ, который соответствует атрибуту name элемента input:
+Обратите внимание, что мы используем [вычисляемые имена свойств](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Operators/Object_initializer#%D0%92%D1%8B%D1%87%D0%B8%D1%81%D0%BB%D1%8F%D0%B5%D0%BC%D1%8B%D0%B5_%D0%B8%D0%BC%D0%B5%D0%BD%D0%B0_%D1%81%D0%B2%D0%BE%D0%B9%D1%81%D1%82%D0%B2), чтобы обновить значение в `state` через ключ, который соответствует атрибуту name элемента input:
 
 ```js{2}
 this.setState({

From c4c33fa23d238ea7a4bed63024195a73dd768f06 Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:03:29 +1300
Subject: [PATCH 18/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 781b696a0..5a4ad02e6 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -68,7 +68,7 @@ class NameForm extends React.Component {
 
 Мы установили атрибут `value` для поля ввода, и теперь в нём всегда будет отображаться `this.state.value`. Состояние React-компонента стало «источником истины». А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, значение в поле будет обновляться по мере того как пользователь печатает.
 
-В управляемом компоненте с каждой мутацией состояния связана функция-обработчик. Это делает валидацию или изменение пользовательского ввода простой задачей. Например, если требуется, чтобы имя обязательно состояло из заглавных букв, то можно написать такой `handleChange`:
+В управляемом компоненте с каждой мутацией состояния связана функция-обработчик. Благодаря этому валидация или изменение введённого значения становится простой задачей. Например, если мы хотим, чтобы имя обязательно было набрано заглавными буквами, можно написать такой `handleChange`:
 
 ```javascript{2}
 handleChange(event) {

From b1f0908ae265139ed52586dc5b02b9cf61aee270 Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:09:08 +1300
Subject: [PATCH 19/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 5a4ad02e6..807aac172 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -276,7 +276,7 @@ this.setState(partialState);
 
 ## Значение null управляемого компонента {#controlled-input-null-value}
 
-Передача пропа value [управляемому компоненту](/docs/forms.html#controlled-components) позволит вам не дать пользователю изменить значение input без вашего желания. Если значение `value` передано, но input остается редактируемым, возможно, значение `value` случайно было установлено в `undefined` или `null`.
+Если установить [управляемому компоненту](/docs/forms.html#controlled-components) проп `value`, то пользователь не сможет изменить его значение без вашего желания. Если вы установили `value`, а поле ввода по-прежнему можно редактировать, то, возможно, вы случайно задали `value`, равный `undefined` или `null`.
 
 Код ниже это демонстрирует. (после небольшой задержки, сперва заблокированный для ввода input становится редактируемым.)
 

From bb3f1c64bb4bad1bbf2f872daab33cbb78e63827 Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:09:52 +1300
Subject: [PATCH 20/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 807aac172..8fc45c616 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -291,7 +291,7 @@ setTimeout(function() {
 
 ## Альтернативы управляемым компонентам {#alternatives-to-controlled-components}
 
-Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние input через React-компонент. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с другой библиотекой. В такой ситуации могут пригодиться [неуправляемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
+Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние формы через компонент React. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с другой библиотекой. В такой ситуации могут пригодиться [неуправляемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
 
 ## Полноценные решения {#fully-fledged-solutions}
 

From eec0c9a28789c34846913c8e2c343ce68523ef27 Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:10:13 +1300
Subject: [PATCH 21/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 8fc45c616..fa18495aa 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -295,4 +295,4 @@ setTimeout(function() {
 
 ## Полноценные решения {#fully-fledged-solutions}
 
-При поиске полноценного решения, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, [Formik](https://jaredpalmer.com/formik) будет одной из популярных опций. Как бы то ни было, эта библиотека построена на принципах управляемых компонентов и управления состоянием, так что не пренебрегайте их изучением.
+Ели вы ищите полноценное решение, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, присмотритесь к [Formik](https://jaredpalmer.com/formik). Как бы то ни было, эта библиотека построена на принципах управляемых компонентов и управления состоянием, так что не пренебрегайте их изучением.

From e4e98b8f2d9d499e13e0724fb1db49898128466d Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:10:50 +1300
Subject: [PATCH 22/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index fa18495aa..9d94c1e89 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -278,7 +278,7 @@ this.setState(partialState);
 
 Если установить [управляемому компоненту](/docs/forms.html#controlled-components) проп `value`, то пользователь не сможет изменить его значение без вашего желания. Если вы установили `value`, а поле ввода по-прежнему можно редактировать, то, возможно, вы случайно задали `value`, равный `undefined` или `null`.
 
-Код ниже это демонстрирует. (после небольшой задержки, сперва заблокированный для ввода input становится редактируемым.)
+Код ниже это демонстрирует. (Изначально заблокированный `input` становится редактируемым после небольшой задержки.)
 
 ```javascript
 ReactDOM.render(<input value="Привет" />, mountNode);

From 0de46d69403e4b97b3fb000bac8e4a10b78be02b Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:11:18 +1300
Subject: [PATCH 23/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 9d94c1e89..3b1998115 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -123,7 +123,7 @@ class EssayForm extends React.Component {
 }
 ```
 
-Обратите внимание, что `this.state.value` инициализировано в конструкторе, так что в текстовой области изначально есть текст.
+Обратите внимание, что мы инициализировали `this.state.value` в конструкторе, так что в текстовой области изначально есть текст.
 
 ## Тег select {#the-select-tag}
 

From 2791540dcb1b369cd66c8af9a5656e38f8c90565 Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:13:26 +1300
Subject: [PATCH 24/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 3b1998115..275cd140a 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -184,7 +184,7 @@ class FlavorForm extends React.Component {
 
 > Примечание
 >
-> Вы можете передать массив внутрь атрибута `value`, что позволит выбрать несколько опций в теге `select`:
+> В атрибут `value` можно передать массив, что позволит выбрать несколько опций в теге `select`:
 >
 >```js
 ><select multiple={true} value={['Б', 'В']}>

From 6f0f2b5ca8e3b595976d230ed1c6447e29912e96 Mon Sep 17 00:00:00 2001
From: Heegiiny <minatko@gmail.com>
Date: Sat, 23 Feb 2019 23:13:56 +1300
Subject: [PATCH 25/31] Translate "Forms": rephrasing

Co-Authored-By: thechch <thech.ch@gmail.com>
---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 275cd140a..0961119cc 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -202,7 +202,7 @@ class FlavorForm extends React.Component {
 
 ## Обработка нескольких input {#handling-multiple-inputs}
 
-Когда вы имеете дело с несколькими управляемыми элементами `input`, вы можете добавить каждому из них атрибут `name`, что позволит функции-обработчику решать, что делать, основываясь на значении `event.target.name`.
+Если вам нужны несколько управляемых элементов `input`, вы можете назначить каждому из них атрибут `name`, что позволит функции-обработчику решать, что делать, основываясь на значении `event.target.name`.
 
 Пример:
 

From ceac2c2ad2ff94929710eb83768f8d500d211dc9 Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Sat, 23 Feb 2019 23:15:17 +1300
Subject: [PATCH 26/31] =?UTF-8?q?Translate=20"Forms":=20=D0=9E=D0=BF=D1=86?=
 =?UTF-8?q?=D0=B8=D1=8F=20->=20=D0=9F=D1=83=D0=BD=D0=BA=D1=82=20=D1=81?=
 =?UTF-8?q?=D0=BF=D0=B8=D1=81=D0=BA=D0=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 0961119cc..d26f351f2 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -138,7 +138,7 @@ class EssayForm extends React.Component {
 </select>
 ```
 
-Опция "Кокос" выбрана по умолчанию из-за установленного атрибута `selected`. React вместо этого атрибута использует `value` в корневом теге `select`. В управляемом компоненте так удобнее, потому что обновлять значение нужно только в одном месте (`state`). Пример:
+Пункт списка "Кокос" выбран по умолчанию из-за установленного атрибута `selected`. React вместо этого атрибута использует `value` в корневом теге `select`. В управляемом компоненте так удобнее, потому что обновлять значение нужно только в одном месте (`state`). Пример:
 
 ```javascript{4,10-12,24}
 class FlavorForm extends React.Component {

From c83e3009d1c614c4c055ca17d83a15b63767325c Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Sat, 23 Feb 2019 23:16:35 +1300
Subject: [PATCH 27/31] Translate "Forms": missing dash

---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index d26f351f2..6b2d74dbd 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -291,7 +291,7 @@ setTimeout(function() {
 
 ## Альтернативы управляемым компонентам {#alternatives-to-controlled-components}
 
-Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние формы через компонент React. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React приложения с другой библиотекой. В такой ситуации могут пригодиться [неуправляемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
+Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние формы через компонент React. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React-приложения с другой библиотекой. В такой ситуации могут пригодиться [неуправляемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
 
 ## Полноценные решения {#fully-fledged-solutions}
 

From 9facea48182d0ba3bcacf6e26dff404676b546ca Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Mon, 25 Feb 2019 21:59:03 +1300
Subject: [PATCH 28/31] Translate "Forms": rephrasing by Heegiiny

---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 6b2d74dbd..47dddbbfe 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -272,7 +272,7 @@ partialState[name] = value;
 this.setState(partialState);
 ```
 
-Кроме того, `setState()` автоматически производит [слияние части состояния с текущим состоянием](/docs/state-and-lifecycle.html#state-updates-are-merged), то есть можно вызывать этот метод только для изменяемых в данный момент частей `state`.
+Кроме того, `setState()` автоматически производит [слияние части состояния с текущим состоянием](/docs/state-and-lifecycle.html#state-updates-are-merged), то есть нам нужно передать в него только ту часть `state`, которую хотим изменить.
 
 ## Значение null управляемого компонента {#controlled-input-null-value}
 

From c40d731a6562a0cd1918eee22d11b270fae42c3c Mon Sep 17 00:00:00 2001
From: Anton Serous <aserous@th2.com>
Date: Mon, 25 Feb 2019 22:07:12 +1300
Subject: [PATCH 29/31] =?UTF-8?q?Translate=20"Forms":=20=D1=83=D0=BF=D1=80?=
 =?UTF-8?q?=D0=B0=D0=B2=D0=BB=D1=8F=D0=B5=D0=BC=D1=8B=D0=B9=20->=20=D0=BA?=
 =?UTF-8?q?=D0=BE=D0=BD=D1=82=D1=80=D0=BE=D0=BB=D0=B8=D1=80=D1=83=D0=B5?=
 =?UTF-8?q?=D0=BC=D1=8B=D0=B9?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 content/docs/forms.md | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 47dddbbfe..b779f61cf 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -21,15 +21,15 @@ redirect_from:
 </form>
 ```
 
-По умолчанию браузер переходит на другую страницу при отправке HTML-форм, в том числе и этой. Если вас это устраивает, то не надо ничего менять, в React формы работают как обычно. Однако, чаще всего форму удобнее обрабатывать с помощью JavaScript функции, у которой есть доступ к введённым данным. Стандартный способ реализации такого поведения называется «управляемые компоненты».
+По умолчанию браузер переходит на другую страницу при отправке HTML-форм, в том числе и этой. Если вас это устраивает, то не надо ничего менять, в React формы работают как обычно. Однако, чаще всего форму удобнее обрабатывать с помощью JavaScript функции, у которой есть доступ к введённым данным. Стандартный способ реализации такого поведения называется «контролируемые компоненты».
 
-## Управляемые компоненты {#controlled-components}
+## Контролируемые компоненты {#controlled-components}
 
 В HTML элементы формы, такие как `<input>`, `<textarea>` и `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
 
-Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и управлять её поведением в ответ на пользовательский ввод. Значением элемента формы input в этом случае будет управлять React, а сам элемент будет называться «управляемый компонент».
+Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и контролировать её поведение в ответ на пользовательский ввод. Значение элемента формы input в этом случае будет контролировать React, а сам элемент будет называться «контролируемый компонент».
 
-Допустим, мы хотим, чтобы предыдущий пример выводил в консоль имя, когда мы отправляем форму. Тогда можно написать форму в виде управляемого компонента:
+Допустим, мы хотим, чтобы предыдущий пример выводил в консоль имя, когда мы отправляем форму. Тогда можно написать форму в виде контролируемого компонента:
 
 ```javascript{4,10-12,24}
 class NameForm extends React.Component {
@@ -68,7 +68,7 @@ class NameForm extends React.Component {
 
 Мы установили атрибут `value` для поля ввода, и теперь в нём всегда будет отображаться `this.state.value`. Состояние React-компонента стало «источником истины». А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, значение в поле будет обновляться по мере того как пользователь печатает.
 
-В управляемом компоненте с каждой мутацией состояния связана функция-обработчик. Благодаря этому валидация или изменение введённого значения становится простой задачей. Например, если мы хотим, чтобы имя обязательно было набрано заглавными буквами, можно написать такой `handleChange`:
+В контролируемом компоненте с каждой мутацией состояния связана функция-обработчик. Благодаря этому валидация или изменение введённого значения становится простой задачей. Например, если мы хотим, чтобы имя обязательно было набрано заглавными буквами, можно написать такой `handleChange`:
 
 ```javascript{2}
 handleChange(event) {
@@ -138,7 +138,7 @@ class EssayForm extends React.Component {
 </select>
 ```
 
-Пункт списка "Кокос" выбран по умолчанию из-за установленного атрибута `selected`. React вместо этого атрибута использует `value` в корневом теге `select`. В управляемом компоненте так удобнее, потому что обновлять значение нужно только в одном месте (`state`). Пример:
+Пункт списка "Кокос" выбран по умолчанию из-за установленного атрибута `selected`. React вместо этого атрибута использует `value` в корневом теге `select`. В контролируемом компоненте так удобнее, потому что обновлять значение нужно только в одном месте (`state`). Пример:
 
 ```javascript{4,10-12,24}
 class FlavorForm extends React.Component {
@@ -180,7 +180,7 @@ class FlavorForm extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/JbbEzX?editors=0010)
 
-Подводя итог, `<input type="text">`, `<textarea>`, и `<select>` работают очень похоже. Все они принимают атрибут `value`, который можно использовать, чтобы реализовать управляемый компонент.
+Подводя итог, `<input type="text">`, `<textarea>`, и `<select>` работают очень похоже. Все они принимают атрибут `value`, который можно использовать, чтобы реализовать контролируемый компонент.
 
 > Примечание
 >
@@ -198,11 +198,11 @@ class FlavorForm extends React.Component {
 <input type="file" />
 ```
 
-Так как значение такого элемента доступно только для чтения, это **неуправляемый** React-компонент. Мы расскажем про этот и другие неуправляемые компоненты [далее в документации](/docs/uncontrolled-components.html#the-file-input-tag).
+Так как значение такого элемента доступно только для чтения, это **неконтролируемый** React-компонент. Мы расскажем про этот и другие неконтролируемые компоненты [далее в документации](/docs/uncontrolled-components.html#the-file-input-tag).
 
 ## Обработка нескольких input {#handling-multiple-inputs}
 
-Если вам нужны несколько управляемых элементов `input`, вы можете назначить каждому из них атрибут `name`, что позволит функции-обработчику решать, что делать, основываясь на значении `event.target.name`.
+Если вам нужны несколько контролируемых элементов `input`, вы можете назначить каждому из них атрибут `name`, что позволит функции-обработчику решать, что делать, основываясь на значении `event.target.name`.
 
 Пример:
 
@@ -274,9 +274,9 @@ this.setState(partialState);
 
 Кроме того, `setState()` автоматически производит [слияние части состояния с текущим состоянием](/docs/state-and-lifecycle.html#state-updates-are-merged), то есть нам нужно передать в него только ту часть `state`, которую хотим изменить.
 
-## Значение null управляемого компонента {#controlled-input-null-value}
+## Значение null контролируемого компонента {#controlled-input-null-value}
 
-Если установить [управляемому компоненту](/docs/forms.html#controlled-components) проп `value`, то пользователь не сможет изменить его значение без вашего желания. Если вы установили `value`, а поле ввода по-прежнему можно редактировать, то, возможно, вы случайно задали `value`, равный `undefined` или `null`.
+Если установить [контролируемому компоненту](/docs/forms.html#controlled-components) проп `value`, то пользователь не сможет изменить его значение без вашего желания. Если вы установили `value`, а поле ввода по-прежнему можно редактировать, то, возможно, вы случайно задали `value`, равный `undefined` или `null`.
 
 Код ниже это демонстрирует. (Изначально заблокированный `input` становится редактируемым после небольшой задержки.)
 
@@ -289,10 +289,10 @@ setTimeout(function() {
 
 ```
 
-## Альтернативы управляемым компонентам {#alternatives-to-controlled-components}
+## Альтернативы контролируемым компонентам {#alternatives-to-controlled-components}
 
-Использование управляемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние формы через компонент React. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React-приложения с другой библиотекой. В такой ситуации могут пригодиться [неуправляемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
+Использование контролируемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние формы через компонент React. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React-приложения с другой библиотекой. В такой ситуации могут пригодиться [неконтролируемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
 
 ## Полноценные решения {#fully-fledged-solutions}
 
-Ели вы ищите полноценное решение, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, присмотритесь к [Formik](https://jaredpalmer.com/formik). Как бы то ни было, эта библиотека построена на принципах управляемых компонентов и управления состоянием, так что не пренебрегайте их изучением.
+Ели вы ищите полноценное решение, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, присмотритесь к [Formik](https://jaredpalmer.com/formik). Как бы то ни было, эта библиотека построена на принципах контролируемых компонентов и управления состоянием, так что не пренебрегайте их изучением.

From 0ac734b8e948f67c79c29d7e32372a240495b6b7 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Fri, 1 Mar 2019 14:12:20 -0800
Subject: [PATCH 30/31] Update forms.md

---
 content/docs/forms.md | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index b779f61cf..3cc7bc2a4 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -25,7 +25,7 @@ redirect_from:
 
 ## Контролируемые компоненты {#controlled-components}
 
-В HTML элементы формы, такие как `<input>`, `<textarea>` и `<select>` обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
+В HTML элементы формы, такие как `<input>`, `<textarea>` и `<select>`, обычно сами управляют своим состоянием и обновляют его когда пользователь вводит данные. В React мутабельное состояние обычно содержится в свойстве компонентов `state` и обновляется только через вызов[`setState()`](/docs/react-component.html#setstate)
 
 Мы можем скомбинировать оба подхода и сделать состояние React-компонента "единственным источником правды". Тогда React-компонент будет рендерить форму и контролировать её поведение в ответ на пользовательский ввод. Значение элемента формы input в этом случае будет контролировать React, а сам элемент будет называться «контролируемый компонент».
 
@@ -66,7 +66,7 @@ class NameForm extends React.Component {
 
 [**Посмотреть на CodePen**](https://codepen.io/gaearon/pen/VmmPgp?editors=0010)
 
-Мы установили атрибут `value` для поля ввода, и теперь в нём всегда будет отображаться `this.state.value`. Состояние React-компонента стало «источником истины». А, так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, значение в поле будет обновляться по мере того как пользователь печатает.
+Мы установили атрибут `value` для поля ввода, и теперь в нём всегда будет отображаться значение `this.state.value`. Состояние React-компонента стало «источником истины». А так как каждое нажатие клавиши вызывает `handleChange`, который обновляет состояние React-компонента, значение в поле будет обновляться по мере того, как пользователь печатает.
 
 В контролируемом компоненте с каждой мутацией состояния связана функция-обработчик. Благодаря этому валидация или изменение введённого значения становится простой задачей. Например, если мы хотим, чтобы имя обязательно было набрано заглавными буквами, можно написать такой `handleChange`:
 
@@ -291,7 +291,7 @@ setTimeout(function() {
 
 ## Альтернативы контролируемым компонентам {#alternatives-to-controlled-components}
 
-Использование контролируемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние формы через компонент React. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React-приложения с другой библиотекой. В такой ситуации могут пригодиться [неконтролируемые компоненты](/docs/uncontrolled-components.html), альтернативная техника реализации ввода данных в форму.
+Использование контролируемых компонентов иногда может быть утомительным. Приходится писать обработчик события для каждого варианта изменения ваших данных и проводить всё состояние формы через компонент React. Это может особенно раздражать, если вы переносите существующую кодовую базу в React, или когда работаете над интеграцией React-приложения с другой библиотекой. В такой ситуации могут пригодиться [неконтролируемые компоненты](/docs/uncontrolled-components.html) — альтернативная техника реализации ввода данных в форму.
 
 ## Полноценные решения {#fully-fledged-solutions}
 

From 3b8a461fa02a5c350c19bb7914b1779715218bfb Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Fri, 1 Mar 2019 14:13:38 -0800
Subject: [PATCH 31/31] Update forms.md

---
 content/docs/forms.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/forms.md b/content/docs/forms.md
index 3cc7bc2a4..8a453cfa0 100644
--- a/content/docs/forms.md
+++ b/content/docs/forms.md
@@ -295,4 +295,4 @@ setTimeout(function() {
 
 ## Полноценные решения {#fully-fledged-solutions}
 
-Ели вы ищите полноценное решение, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, присмотритесь к [Formik](https://jaredpalmer.com/formik). Как бы то ни было, эта библиотека построена на принципах контролируемых компонентов и управления состоянием, так что не пренебрегайте их изучением.
+Если вы ищите полноценное решение, которое может валидировать ввод, запомнить посещённые поля формы и обработать ее отправку, присмотритесь к [Formik](https://jaredpalmer.com/formik). Эта библиотека построена на принципах контролируемых компонентов и управления состоянием, так что не пренебрегайте их изучением.