From 24676559b8212665194d0db19fd0c05065e6edf9 Mon Sep 17 00:00:00 2001
From: Bogdan Ivanchenko <ivanchenko.b@gmail.com>
Date: Sun, 10 Feb 2019 18:48:03 +0200
Subject: [PATCH 01/49] Initial translate

---
 content/docs/reference-react.md         | 178 ++++++++++++------------
 examples/reference-react-forward-ref.js |   2 +-
 2 files changed, 90 insertions(+), 90 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index d506a1ad3..23ba1eb1d 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -1,6 +1,6 @@
 ---
 id: react-api
-title: React Top-Level API
+title: React API верхнего уровня
 layout: docs
 category: Reference
 permalink: docs/react-api.html
@@ -13,67 +13,67 @@ redirect_from:
   - "docs/top-level-api-zh-CN.html"
 ---
 
-`React` is the entry point to the React library. If you load React from a `<script>` tag, these top-level APIs are available on the `React` global. If you use ES6 with npm, you can write `import React from 'react'`. If you use ES5 with npm, you can write `var React = require('react')`.
+`React` — это точка входа в библиотеку React. Если вы подключаете React при помощи тега `<script>`, API верхнего уровня доступны в глобальном объекте `React`. Если вы используете ES6 и npm, вы можете написать `import React from 'react'`. Если вы используете ES5 и npm, вы можете написать `var React = require('react')`.
 
-## Overview {#overview}
+## Обзор {#overview}
 
-### Components {#components}
+### Компоненты {#components}
 
-React components let you split the UI into independent, reusable pieces, and think about each piece in isolation. React components can be defined by subclassing `React.Component` or `React.PureComponent`.
+React-компоненты позволяют разделить пользовательский интерфейс на независимые, повторно используемые элементы и думать о них по отдельности. React-компоненты могут быть обявлены путем создания подклассов `React.Component` или `React.PureComponent`.
 
  - [`React.Component`](#reactcomponent)
  - [`React.PureComponent`](#reactpurecomponent)
 
-If you don't use ES6 classes, you may use the `create-react-class` module instead. See [Using React without ES6](/docs/react-without-es6.html) for more information.
+Если вы не используете классы ES6, вместо них вы можете использовать модуль `create-react-class`. Для получения дополнительной информации см. [Использование React без ES6](/docs/react-without-es6.html).
 
-React components can also be defined as functions which can be wrapped:
+React-компоненты также могут быть обявлены как функции, которые могут быть обернуты:
 
 - [`React.memo`](#reactmemo)
 
-### Creating React Elements {#creating-react-elements}
+### Создание элементов React {#creating-react-elements}
 
-We recommend [using JSX](/docs/introducing-jsx.html) to describe what your UI should look like. Each JSX element is just syntactic sugar for calling [`React.createElement()`](#createelement). You will not typically invoke the following methods directly if you are using JSX.
+Мы рекомендуем [использовать JSX](/docs/introducing-jsx.html), чтобы описать то как должен выглядеть ваш UI. Каждый элемент JSX это просто синтаксический сахар для вызова [`React.createElement()`](#createelement). Обычно вам не нужно вызывать следующие методы напрямую, если вы используете JSX.
 
 - [`createElement()`](#createelement)
 - [`createFactory()`](#createfactory)
 
-See [Using React without JSX](/docs/react-without-jsx.html) for more information.
+См. [Использование React без JSX](/docs/react-without-jsx.html) для получения дополнительной информации.
 
-### Transforming Elements {#transforming-elements}
+### Трансформация компонентов {#transforming-elements}
 
-`React` provides several APIs for manipulating elements:
+`React` предоставляет несколько API для управления элементами:
 
 - [`cloneElement()`](#cloneelement)
 - [`isValidElement()`](#isvalidelement)
 - [`React.Children`](#reactchildren)
 
-### Fragments {#fragments}
+### Фрагменты {#fragments}
 
-`React` also provides a component for rendering multiple elements without a wrapper.
+`React` также предоставляет компонент для рендера нескольких элементов без обертки.
 
 - [`React.Fragment`](#reactfragment)
 
-### Refs {#refs}
+### Рефы {#refs}
 
 - [`React.createRef`](#reactcreateref)
 - [`React.forwardRef`](#reactforwardref)
 
-### Suspense {#suspense}
+### Неизвестность (Suspense) {#suspense}
 
-Suspense lets components "wait" for something before rendering. Today, Suspense only supports one use case: [loading components dynamically with `React.lazy`](/docs/code-splitting.html#reactlazy). In the future, it will support other use cases like data fetching.
+Suspense дает возможность компонентам «подождать» что-то перед рендером. Сегодня Suspense поддерживает только один вариант использования: [динамическая загрузка компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)
 
-### Hooks {#hooks}
+### Хуки {#hooks}
 
-*Hooks* are a new addition in React 16.8. They let you use state and other React features without writing a class. Hooks have a [dedicated docs section](/docs/hooks-intro.html) and a separate API reference:
+*Хуки* — это новое дополнение в React 16.8. Они позволяют вам использовать состояние и другие функции React без написания класса. У хуков есть [свой раздел документации](/docs/hooks-intro.html) и отдельная ссылка на API:
 
-- [Basic Hooks](/docs/hooks-reference.html#basic-hooks)
+- [Основные Хуки](/docs/hooks-reference.html#basic-hooks)
   - [`useState`](/docs/hooks-reference.html#usestate)
   - [`useEffect`](/docs/hooks-reference.html#useeffect)
   - [`useContext`](/docs/hooks-reference.html#usecontext)
-- [Additional Hooks](/docs/hooks-reference.html#additional-hooks)
+- [Дополнительные Хуки](/docs/hooks-reference.html#additional-hooks)
   - [`useReducer`](/docs/hooks-reference.html#usereducer)
   - [`useCallback`](/docs/hooks-reference.html#usecallback)
   - [`useMemo`](/docs/hooks-reference.html#usememo)
@@ -84,35 +84,35 @@ Suspense lets components "wait" for something before rendering. Today, Suspense
 
 * * *
 
-## Reference {#reference}
+## Cправка {#reference}
 
 ### `React.Component` {#reactcomponent}
 
-`React.Component` is the base class for React components when they are defined using [ES6 classes](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
+`React.Component` — это базовый класс для компонентов React, когда они объявлены при помощи [классов ES6](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
 
 ```javascript
 class Greeting extends React.Component {
   render() {
-    return <h1>Hello, {this.props.name}</h1>;
+    return <h1>Привет, {this.props.name}</h1>;
   }
 }
 ```
 
-See the [React.Component API Reference](/docs/react-component.html) for a list of methods and properties related to the base `React.Component` class.
+См. [Справочник по API React.Component](/docs/react-component.html) для получения списка методов и свойств, связанных с базовым классом `React.Component`.
 
 * * *
 
 ### `React.PureComponent` {#reactpurecomponent}
 
-`React.PureComponent` is similar to [`React.Component`](#reactcomponent). The difference between them is that [`React.Component`](#reactcomponent) doesn't implement [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), but `React.PureComponent` implements it with a shallow prop and state comparison. 
+`React.PureComponent` похож на [`React.Component`](#reactcomponent). Отличие заключается в том, что [`React.Component`](#reactcomponent) не реализует [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), а `React.PureComponent` реализует его с неглубоким сравнением пропсов и состояния.
 
-If your React component's `render()` function renders the same result given the same props and state, you can use `React.PureComponent` for a performance boost in some cases.
+Если метод `render()` вашего React компонента рендерит один и тот же результат с одинаковыми пропсами и состоянием, для повышения производительности в некоторых случаях вы можете использовать `React.PureComponent`.
 
-> Note
+> Примечание
 >
-> `React.PureComponent`'s `shouldComponentUpdate()` only shallowly compares the objects. If these contain complex data structures, it may produce false-negatives for deeper differences. Only extend `PureComponent` when you expect to have simple props and state, or use [`forceUpdate()`](/docs/react-component.html#forceupdate) when you know deep data structures have changed. Or, consider using [immutable objects](https://facebook.github.io/immutable-js/) to facilitate fast comparisons of nested data.
+> Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только неглубокое сравнение объектов. Если они содержат сложные структуры данных, это может привести к некоректной работе для более глубоких различий. Наследуйтесь от `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда вы знаете, что вложенные структуры данных изменились. Также рассмотрите возможность использования [неизменяемых объектов](https://facebook.github.io/immutable-js/) для облегчения быстрого сравнения вложенных данных.
 >
-> Furthermore, `React.PureComponent`'s `shouldComponentUpdate()` skips prop updates for the whole component subtree. Make sure all the children components are also "pure".
+> Кроме того, метод `shouldComponentUpdate()` базового класа `React.PureComponent` пропускает обновление пропсов для всего поддерева компонентов. Убедитесь, что все дочерние компоненты также являются «чистыми».
 
 * * *
 
@@ -120,35 +120,35 @@ If your React component's `render()` function renders the same result given the
 
 ```javascript
 const MyComponent = React.memo(function MyComponent(props) {
-  /* render using props */
+  /* рендер с использованием пропсов */
 });
 ```
 
-`React.memo` is a [higher order component](/docs/higher-order-components.html). It's similar to [`React.PureComponent`](#reactpurecomponent) but for function components instead of classes.
+`React.memo` — это [компонент высшего порядка](/docs/higher-order-components.html). Он похож на [`React.PureComponent`](#reactpurecomponent), но предназначен для функциональных компонентов.
 
-If your function component renders the same result given the same props, you can wrap it in a call to `React.memo` for a performance boost in some cases by memoizing the result. This means that React will skip rendering the component, and reuse the last rendered result.
+Если ваш функциональный компонент рендерит один и тот же результат с теми же пропсами, вы можете обернуть его в вызов `React.memo` для повышения производительности в некоторых случаях, мемоизируя результат. Это значит что React будет использовать последний результат рендера, избегая повторной отрисовки.
 
-By default it will only shallowly compare complex objects in the props object. If you want control over the comparison, you can also provide a custom comparison function as the second argument.
+По умолчанию он не глубоко сравнивает вложенные объекты в объекте `props`. Если вы хотите контролировать сравнение, вы можете предать свою функцию сравнения в качестве второго аргумента.
 
 ```javascript
 function MyComponent(props) {
-  /* render using props */
+  /* рендер с использованием пропсов */
 }
 function areEqual(prevProps, nextProps) {
   /*
-  return true if passing nextProps to render would return
-  the same result as passing prevProps to render,
-  otherwise return false
+  верните true если nextProps рендерит
+  тот же результат что и prevProps,
+  иначе верните false
   */
 }
 export default React.memo(MyComponent, areEqual);
 ```
 
-This method only exists as a **[performance optimization](/docs/optimizing-performance.html).** Do not rely on it to "prevent" a render, as this can lead to bugs.
+Этот метод предназначен только для **[оптимизации производительности](/docs/optimizing-performance.html).** Не полагайтесь на него, чтобы «предотвратить» рендер, так как это может привести к ошибкам.
 
-> Note
+> Примечание
 >
-> Unlike the [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) method on class components, the `areEqual` function returns `true` if the props are equal and `false` if the props are not equal. This is the inverse from `shouldComponentUpdate`.
+> В отличие от метода [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) для классовых компонентов, функция `areEqual` возвращает `true`, если пропсы равны, и значение `false`, если пропсы не равны. Это обратные значения для `shouldComponentUpdate`.
 
 * * *
 
@@ -162,9 +162,9 @@ React.createElement(
 )
 ```
 
-Create and return a new [React element](/docs/rendering-elements.html) of the given type. The type argument can be either a tag name string (such as `'div'` or `'span'`), a [React component](/docs/components-and-props.html) type (a class or a function), or a [React fragment](#reactfragment) type.
+Создаёт и возвращает новый [React элемент](/docs/rendering-elements.html) определенного типа. Аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция), или [React-фрагмент](#reactfragment).
 
-Code written with [JSX](/docs/introducing-jsx.html) will be converted to use `React.createElement()`. You will not typically invoke `React.createElement()` directly if you are using JSX. See [React Without JSX](/docs/react-without-jsx.html) to learn more.
+Код написанный с использованием JSX, будет преобразован в `React.createElement()`. Обычно вы не будете вызывать `React.createElement()` напрямую, если вы используете JSX. Смотрите [React без JSX](/docs/react-without-jsx.html), чтобы узнать больше.
 
 * * *
 
@@ -178,17 +178,17 @@ React.cloneElement(
 )
 ```
 
-Clone and return a new React element using `element` as the starting point. The resulting element will have the original element's props with the new props merged in shallowly. New children will replace existing children. `key` and `ref` from the original element will be preserved.
+Клонирует и возвращает новый элемент React, используя элемент в качестве отправной точки. Полученный элемент будет иметь пропсы исходного элемента, а новые пропсы будут не глубоко объединены. Новые дочерние элементы заменят существующие. `ключ` и `реф` из исходного элемента будут сохранены.
 
-`React.cloneElement()` is almost equivalent to:
+`React.cloneElement()` почти эквивалентен:
 
 ```js
 <element.type {...element.props} {...props}>{children}</element.type>
 ```
 
-However, it also preserves `ref`s. This means that if you get a child with a `ref` on it, you won't accidentally steal it from your ancestor. You will get the same `ref` attached to your new element.
+Однако, в этом случае, сохранятся `рефы`. Это означает если вы получите ребенка с рефом на нем, вы случайно не украдете его у родителя. Вы получите тот же `реф`, прикрепленный к вашему новому элементу.
 
-This API was introduced as a replacement of the deprecated `React.addons.cloneWithProps()`.
+Этот API был представлен как замена устаревшего `React.addons.cloneWithProps()`.
 
 * * *
 
@@ -198,11 +198,11 @@ This API was introduced as a replacement of the deprecated `React.addons.cloneWi
 React.createFactory(type)
 ```
 
-Return a function that produces React elements of a given type. Like [`React.createElement()`](#createElement), the type argument can be either a tag name string (such as `'div'` or `'span'`), a [React component](/docs/components-and-props.html) type (a class or a function), or a [React fragment](#reactfragment) type.
+Возвращает функцию, которая создавёт элементы React заданного типа. Как и [`React.createElement()`](#createElement), аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция), или [React-фрагмент](#reactfragment).
 
-This helper is considered legacy, and we encourage you to either use JSX or use `React.createElement()` directly instead.
+Этот помощник считается устаревшим, и мы рекомендуем вам либо использовать JSX, либо напрямую использовать `React.createElement()`.
 
-You will not typically invoke `React.createFactory()` directly if you are using JSX. See [React Without JSX](/docs/react-without-jsx.html) to learn more.
+Обычно вы не будете вызывать `React.createFactory()` напрямую, если вы используете JSX. Смотрите [React без JSX](/docs/react-without-jsx.html), чтобы узнать больше.
 
 * * *
 
@@ -212,13 +212,13 @@ You will not typically invoke `React.createFactory()` directly if you are using
 React.isValidElement(object)
 ```
 
-Verifies the object is a React element. Returns `true` or `false`.
+Проверяет, что объект является элементом React. Возвращает `true` или `false`.
 
 * * *
 
 ### `React.Children` {#reactchildren}
 
-`React.Children` provides utilities for dealing with the `this.props.children` opaque data structure.
+`React.Children` предоставляет утилиты для работы с непрозрачной структурой данных `this.props.children`.
 
 #### `React.Children.map` {#reactchildrenmap}
 
@@ -226,11 +226,11 @@ Verifies the object is a React element. Returns `true` or `false`.
 React.Children.map(children, function[(thisArg)])
 ```
 
-Invokes a function on every immediate child contained within `children` with `this` set to `thisArg`. If `children` is an array it will be traversed and the function will be called for each child in the array. If children is `null` or `undefined`, this method will return `null` or `undefined` rather than an array.
+Вызывает функцию для каждого непосредственного потомка, содержащегося в `children` передавая их по очереде в `thisArg`. Если `children` — это массив, он будет пройден, и функция будет вызвана для каждого потомка в массиве. Если `children` равен `null` или `undefined`, этот метод вернет `null` или `undefined`, а не массив.
 
-> Note
+> Примечание
 >
-> If `children` is a `Fragment` it will be treated as a single child and not traversed.
+> Если `children` — это `Fragment`, он будет рассматриваться как целый потомок, а элементы внутри не будут пройдены.
 
 #### `React.Children.forEach` {#reactchildrenforeach}
 
@@ -238,7 +238,7 @@ Invokes a function on every immediate child contained within `children` with `th
 React.Children.forEach(children, function[(thisArg)])
 ```
 
-Like [`React.Children.map()`](#reactchildrenmap) but does not return an array.
+Похож на [`React.Children.map()`](#reactchildrenmap), но не возвращает массив.
 
 #### `React.Children.count` {#reactchildrencount}
 
@@ -246,7 +246,7 @@ Like [`React.Children.map()`](#reactchildrenmap) but does not return an array.
 React.Children.count(children)
 ```
 
-Returns the total number of components in `children`, equal to the number of times that a callback passed to `map` or `forEach` would be invoked.
+Возвращает общее количество компонентов в `children`, равное числу раз которое будет вызван обратный вызов, переданный в `map` или `forEach`.
 
 #### `React.Children.only` {#reactchildrenonly}
 
@@ -254,11 +254,11 @@ Returns the total number of components in `children`, equal to the number of tim
 React.Children.only(children)
 ```
 
-Verifies that `children` has only one child (a React element) and returns it. Otherwise this method throws an error.
+Проверяет, что у `children` есть только один потомок (React элемент), и возвращает его. Иначе этот метод выдает ошибку.
 
-> Note:
+> Примечание:
 >
->`React.Children.only()` does not accept the return value of [`React.Children.map()`](#reactchildrenmap) because it is an array rather than a React element.
+> `React.Children.only()` не принимает возвращаемое значение [`React.Children.map()`](#reactchildrenmap), потому что это массив, а не элемент React.
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 
@@ -266,82 +266,82 @@ Verifies that `children` has only one child (a React element) and returns it. Ot
 React.Children.toArray(children)
 ```
 
-Returns the `children` opaque data structure as a flat array with keys assigned to each child. Useful if you want to manipulate collections of children in your render methods, especially if you want to reorder or slice `this.props.children` before passing it down.
+Возвращает непрозрачную структуру данных `children` в виде плоского массива с ключами, заданые каждому дочернему элементу. Полезно, если вы хотите манипулировать коллекциями потомков в ваших методах рендера, особенно если вы хотите отсортировать или срезать `this.props.children` перед передачей вниз.
 
-> Note:
+> Примечание:
 >
-> `React.Children.toArray()` changes keys to preserve the semantics of nested arrays when flattening lists of children. That is, `toArray` prefixes each key in the returned array so that each element's key is scoped to the input array containing it.
+> `React.Children.toArray()` изменяет ключи, чтобы сохранить семантику вложенных массивов, когда делает плоским списков дочерних элементов. То есть `toArray` ставит префикс перед каждым ключом в возвращаемом массиве, так что ключ каждого элемента находится в области входного массива, содержащего его.
 
 * * *
 
 ### `React.Fragment` {#reactfragment}
 
-The `React.Fragment` component lets you return multiple elements in a `render()` method without creating an additional DOM element:
+Компонент `React.Fragment` позволяет возвращать несколько элементов в методе `render()` без создания дополнительного элемента DOM:
 
 ```javascript
 render() {
   return (
     <React.Fragment>
-      Some text.
-      <h2>A heading</h2>
+      Какой-то текст.
+      <h2>Заголовок</h2>
     </React.Fragment>
   );
 }
 ```
 
-You can also use it with the shorthand `<></>` syntax. For more information, see [React v16.2.0: Improved Support for Fragments](/blog/2017/11/28/react-v16.2.0-fragment-support.html).
-
+Вы также можете использовать его сокращенный синтаксис `<></>`. Для получения дополнительной информации см. [React v16.2.0: Улучшенная поддержка фрагментов](/blog/2017/11/28/react-v16.2.0-fragment-support.html).
 
 ### `React.createRef` {#reactcreateref}
 
-`React.createRef` creates a [ref](/docs/refs-and-the-dom.html) that can be attached to React elements via the ref attribute.
+`React.createRef` создаёт [реф](/docs/refs-and-the-dom.html), который можно прикрепить к React элементам через атрибут ref.
 `embed:16-3-release-blog-post/create-ref-example.js`
 
 ### `React.forwardRef` {#reactforwardref}
 
-`React.forwardRef` creates a React component that forwards the [ref](/docs/refs-and-the-dom.html) attribute it receives to another component below in the tree. This technique is not very common but is particularly useful in two scenarios:
+`React.forwardRef` создаёт React компонент, который перенаправляет атрибут [ref](/docs/refs-and-the-dom.html), что он получает, другому компоненту ниже в дереве.
+Этот метод не очень распространен, но особенно полезен в двух сценариях:
 
-* [Forwarding refs to DOM components](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
-* [Forwarding refs in higher-order-components](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
+* [Пересылка рефов на компоненты DOM](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
+* [Пересылка рефов на компоненты высшего порядка](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
 
-`React.forwardRef` accepts a rendering function as an argument. React will call this function with `props` and `ref` as two arguments. This function should return a React node.
+`React.forwardRef` принимает функцию рендера в качестве аргумента. React будет вызывать эту функцию с пропсами и рефом в качестве двух аргументов. Эта функция должна возвращать узел React.
 
 `embed:reference-react-forward-ref.js`
 
-In the above example, React passes a `ref` given to `<FancyButton ref={ref}>` element as a second argument to the rendering function inside the `React.forwardRef` call. This rendering function passes the `ref` to the `<button ref={ref}>` element.
+В приведенном выше примере React передает `реф`, переданный элементу `<FancyButton ref={ref}>` в качестве второго аргумента функции рендера внутри вызова `React.forwardRef`. Функция рендера передает `реф` в элемент `<button ref={ref}>`.
 
-As a result, after React attaches the ref, `ref.current` will point directly to the `<button>` DOM element instance.
+В результате после того как React добавит реф, `ref.current` будет указывать непосредственно на экземпляр `<button>` элемента DOM.
 
-For more information, see [forwarding refs](/docs/forwarding-refs.html).
+Для получения дополнительной информации см. [Переадресация рефов](/docs/forwarding-refs.html).
 
 ### `React.lazy` {#reactlazy}
 
-`React.lazy()` lets you define a component that is loaded dynamically. This helps reduce the bundle size to delay loading components that aren't used during the initial render.
+`React.lazy()` позволяет вам определять компонент, который загружается динамически. Это помогает уменьшить размер сборки, откладывая загрузку компонентов, которые не используются во время первоначального рендера.
 
-You can learn how to use it from our [code splitting documentation](/docs/code-splitting.html#reactlazy). You might also want to check out [this article](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) explaining how to use it in more detail.
+Вы можете узнать, как пользоватся этим из нашей [документации по разделению кода](/docs/code-splitting.html#reactlazy). Вы также можете посмотреть [эту статью](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) с объяснением, как использовать этот метод более подробно.
 
 ```js
-// This component is loaded dynamically
+// Этот компонент загружается динамически
 const SomeComponent = React.lazy(() => import('./SomeComponent'));
 ```
 
-Note that rendering `lazy` components requires that there's a `<React.Suspense>` component higher in the rendering tree. This is how you specify a loading indicator.
+Обратите внимание, для рендера `ленивых` компонентов требуется чтобы выше в дереве находился компонент `<React.Suspense>`. Таким образом вы показываете индикатор загрузки.
 
-> **Note**
+> **Примечание**
 >
-> Using `React.lazy`with dynamic import requires Promises to be available in the JS environment. This requires a polyfill on IE11 and below.
+> Использование `React.lazy` с динамическим импортом требует доступности Promises в среде JS. Для IE11 и ниже необходим полифил.
 
 ### `React.Suspense` {#reactsuspense}
 
-`React.Suspense` let you specify the loading indicator in case some components in the tree below it are not yet ready to render. Today, lazy loading components is the **only** use case supported by `<React.Suspense>`:
+`React.Suspense` позволяет показать индикатор загрузки в случае если некоторые компоненты в дереве под ним еще не готовы к рендеру. Сегодня ленивая загрузка компонентов — это **единственный** вариант использования поддерживаемый `<React.Suspense>`:
 
 ```js
-// This component is loaded dynamically
+// Этот компонент загружается динамически
 const OtherComponent = React.lazy(() => import('./OtherComponent'));
 
 function MyComponent() {
   return (
-    // Displays <Spinner> until OtherComponent loads
+    // Отобразится <Spinner> до тех пор, пока не загрузится <OtherComponent />
     <React.Suspense fallback={<Spinner />}>
       <div>
         <OtherComponent />
@@ -351,10 +351,10 @@ function MyComponent() {
 }
 ```
 
-It is documented in our [code splitting guide](/docs/code-splitting.html#reactlazy). Note that `lazy` components can be deep inside the `Suspense` tree -- it doesn't have to wrap every one of them. The best practice is to place `<Suspense>` where you want to see a loading indicator, but to use `lazy()` wherever you want to do code splitting.
+Это задокументировано в нашем руководстве по [разделению кода](/docs/code-splitting.html#reactlazy). Обратите внимание, что `ленивые` компоненты могут быть глубоко внутри дерева `Suspense` -- не нужно оборачивать каждый из них. Лучшая практика, размещать `<Suspense>` там где вы хотите видеть индикатор загрузки, но использовать `lazy()` везде, где вы хотите разделить код. 
 
-While this is not supported today, in the future we plan to let `Suspense` handle more scenarios such as data fetching. You can read about this in [our roadmap](/blog/2018/11/27/react-16-roadmap.html).
+Хотя это не поддерживается сегодня, в будущем мы планируем позволить `Suspense` обрабатывать больше сценариев, таких как получение данных с API. Вы можете прочитать об этом в [нашей дорожной карте](/blog/2018/11/27/react-16-roadmap.html).
 
->Note:
+>Примечание:
 >
->`React.lazy()` and `<React.Suspense>` are not yet supported by `ReactDOMServer`. This is a known limitation that will be resolved in the future.
+> `React.lazy()` и `<React.Suspense>` еще не поддерживаются `ReactDOMServer`. Это известное ограничение, которое будет устранено в будущем.
diff --git a/examples/reference-react-forward-ref.js b/examples/reference-react-forward-ref.js
index f4d5f8e0e..1740fe281 100644
--- a/examples/reference-react-forward-ref.js
+++ b/examples/reference-react-forward-ref.js
@@ -5,6 +5,6 @@ const FancyButton = React.forwardRef((props, ref) => (
   </button>
 ));
 
-// You can now get a ref directly to the DOM button:
+// Теперь вы можете получить ссылку на элемент DOM:
 const ref = React.createRef();
 <FancyButton ref={ref}>Click me!</FancyButton>;

From e0e5d88d81ccca2acbf6cfd05892dca47e51a7cd Mon Sep 17 00:00:00 2001
From: Bogdan Ivanchenko <ivanchenko.b@gmail.com>
Date: Tue, 12 Feb 2019 13:49:49 +0200
Subject: [PATCH 02/49] Improved translate

---
 content/docs/reference-react.md | 46 +++++++++++++++++----------------
 1 file changed, 24 insertions(+), 22 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 23ba1eb1d..59d1baf9c 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -19,12 +19,12 @@ redirect_from:
 
 ### Компоненты {#components}
 
-React-компоненты позволяют разделить пользовательский интерфейс на независимые, повторно используемые элементы и думать о них по отдельности. React-компоненты могут быть обявлены путем создания подклассов `React.Component` или `React.PureComponent`.
+React-компоненты позволяют разделить пользовательский интерфейс на независимые, повторно используемые части и думать о них по отдельности. React-компоненты могут быть обявлены путем создания подклассов `React.Component` или `React.PureComponent`.
 
  - [`React.Component`](#reactcomponent)
  - [`React.PureComponent`](#reactpurecomponent)
 
-Если вы не используете классы ES6, вместо них вы можете использовать модуль `create-react-class`. Для получения дополнительной информации см. [Использование React без ES6](/docs/react-without-es6.html).
+Если вы не используете классы ES6, вместо них вы можете использовать модуль `create-react-class`. Чтобы узнать подробнее см. [Использование React без ES6](/docs/react-without-es6.html).
 
 React-компоненты также могут быть обявлены как функции, которые могут быть обернуты:
 
@@ -32,14 +32,14 @@ React-компоненты также могут быть обявлены ка
 
 ### Создание элементов React {#creating-react-elements}
 
-Мы рекомендуем [использовать JSX](/docs/introducing-jsx.html), чтобы описать то как должен выглядеть ваш UI. Каждый элемент JSX это просто синтаксический сахар для вызова [`React.createElement()`](#createelement). Обычно вам не нужно вызывать следующие методы напрямую, если вы используете JSX.
+Мы рекомендуем [использовать JSX](/docs/introducing-jsx.html), чтобы описать то, как должен выглядеть ваш UI. Каждый элемент JSX это просто синтаксический сахар для вызова [`React.createElement()`](#createelement). Обычно вам не нужно вызывать следующие методы напрямую, если вы используете JSX.
 
 - [`createElement()`](#createelement)
 - [`createFactory()`](#createfactory)
 
-См. [Использование React без JSX](/docs/react-without-jsx.html) для получения дополнительной информации.
+См. [Использование React без JSX](/docs/react-without-jsx.html) чтобы узнать подробнее.
 
-### Трансформация компонентов {#transforming-elements}
+### Трансформация элементов {#transforming-elements}
 
 `React` предоставляет несколько API для управления элементами:
 
@@ -58,9 +58,9 @@ React-компоненты также могут быть обявлены ка
 - [`React.createRef`](#reactcreateref)
 - [`React.forwardRef`](#reactforwardref)
 
-### Неизвестность (Suspense) {#suspense}
+### Задержка (Suspense) {#suspense}
 
-Suspense дает возможность компонентам «подождать» что-то перед рендером. Сегодня Suspense поддерживает только один вариант использования: [динамическая загрузка компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
+Задержка дает возможность компонентам «подождать» что-то перед рендером. Пока что Задержку можно использовать только для : [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)
@@ -69,11 +69,11 @@ Suspense дает возможность компонентам «подожда
 
 *Хуки* — это новое дополнение в React 16.8. Они позволяют вам использовать состояние и другие функции React без написания класса. У хуков есть [свой раздел документации](/docs/hooks-intro.html) и отдельная ссылка на API:
 
-- [Основные Хуки](/docs/hooks-reference.html#basic-hooks)
+- [Основные хуки](/docs/hooks-reference.html#basic-hooks)
   - [`useState`](/docs/hooks-reference.html#usestate)
   - [`useEffect`](/docs/hooks-reference.html#useeffect)
   - [`useContext`](/docs/hooks-reference.html#usecontext)
-- [Дополнительные Хуки](/docs/hooks-reference.html#additional-hooks)
+- [Дополнительные хуки](/docs/hooks-reference.html#additional-hooks)
   - [`useReducer`](/docs/hooks-reference.html#usereducer)
   - [`useCallback`](/docs/hooks-reference.html#usecallback)
   - [`useMemo`](/docs/hooks-reference.html#usememo)
@@ -88,7 +88,7 @@ Suspense дает возможность компонентам «подожда
 
 ### `React.Component` {#reactcomponent}
 
-`React.Component` — это базовый класс для компонентов React, когда они объявлены при помощи [классов ES6](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
+`React.Component` — это базовый класс для компонентов React, объявленных как [ES6-классы](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
 
 ```javascript
 class Greeting extends React.Component {
@@ -98,19 +98,21 @@ class Greeting extends React.Component {
 }
 ```
 
-См. [Справочник по API React.Component](/docs/react-component.html) для получения списка методов и свойств, связанных с базовым классом `React.Component`.
+Со списком методов и свойств базового класса `React.Component` можно ознакомиться на [справочной странице для `React.Component`](/docs/react-component.html).
 
 * * *
 
 ### `React.PureComponent` {#reactpurecomponent}
 
-`React.PureComponent` похож на [`React.Component`](#reactcomponent). Отличие заключается в том, что [`React.Component`](#reactcomponent) не реализует [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), а `React.PureComponent` реализует его с неглубоким сравнением пропсов и состояния.
+`React.PureComponent` похож на [`React.Component`](#reactcomponent). Отличие заключается в том, что [`React.Component`](#reactcomponent) не реализует [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), а `React.PureComponent` реализует его с поверхностным сравнением пропсов и состояния.
 
 Если метод `render()` вашего React компонента рендерит один и тот же результат с одинаковыми пропсами и состоянием, для повышения производительности в некоторых случаях вы можете использовать `React.PureComponent`.
 
 > Примечание
 >
-> Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только неглубокое сравнение объектов. Если они содержат сложные структуры данных, это может привести к некоректной работе для более глубоких различий. Наследуйтесь от `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда вы знаете, что вложенные структуры данных изменились. Также рассмотрите возможность использования [неизменяемых объектов](https://facebook.github.io/immutable-js/) для облегчения быстрого сравнения вложенных данных.
+> Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только поверхностное сравнение объектов. Если они содержат сложные структуры данных, это может привести к неправильной работе для более глубоких различий. Наследуйтесь от `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда вы знаете, что вложенные структуры данных изменились. Также подумайте об использовании [неизменяемых объектов](https://facebook.github.io/immutable-js/) чтобы упростить процесс сравнения вложенных данных.
+>
+>
 >
 > Кроме того, метод `shouldComponentUpdate()` базового класа `React.PureComponent` пропускает обновление пропсов для всего поддерева компонентов. Убедитесь, что все дочерние компоненты также являются «чистыми».
 
@@ -128,7 +130,7 @@ const MyComponent = React.memo(function MyComponent(props) {
 
 Если ваш функциональный компонент рендерит один и тот же результат с теми же пропсами, вы можете обернуть его в вызов `React.memo` для повышения производительности в некоторых случаях, мемоизируя результат. Это значит что React будет использовать последний результат рендера, избегая повторной отрисовки.
 
-По умолчанию он не глубоко сравнивает вложенные объекты в объекте `props`. Если вы хотите контролировать сравнение, вы можете предать свою функцию сравнения в качестве второго аргумента.
+По умолчанию он поверхностно сравнивает вложенные объекты в объекте `props`. Если вы хотите контролировать сравнение, вы можете предать свою функцию сравнения в качестве второго аргумента.
 
 ```javascript
 function MyComponent(props) {
@@ -178,7 +180,7 @@ React.cloneElement(
 )
 ```
 
-Клонирует и возвращает новый элемент React, используя элемент в качестве отправной точки. Полученный элемент будет иметь пропсы исходного элемента, а новые пропсы будут не глубоко объединены. Новые дочерние элементы заменят существующие. `ключ` и `реф` из исходного элемента будут сохранены.
+Клонирует и возвращает новый React элемент, используя элемент в качестве отправной точки. Полученный элемент будет иметь пропсы исходного элемента, а новые пропсы будут поверхностно объединены. Новые дочерние элементы заменят существующие. `key` и `ref` из исходного элемента будут сохранены.
 
 `React.cloneElement()` почти эквивалентен:
 
@@ -186,7 +188,7 @@ React.cloneElement(
 <element.type {...element.props} {...props}>{children}</element.type>
 ```
 
-Однако, в этом случае, сохранятся `рефы`. Это означает если вы получите ребенка с рефом на нем, вы случайно не украдете его у родителя. Вы получите тот же `реф`, прикрепленный к вашему новому элементу.
+Однако, в этом случае, сохранятся `ref`. Это означает если вы получите ребенка с `ref` на нем, вы случайно не украдете его у родителя. Вы получите тот же `ref`, прикрепленный к вашему новому элементу.
 
 Этот API был представлен как замена устаревшего `React.addons.cloneWithProps()`.
 
@@ -258,7 +260,7 @@ React.Children.only(children)
 
 > Примечание:
 >
-> `React.Children.only()` не принимает возвращаемое значение [`React.Children.map()`](#reactchildrenmap), потому что это массив, а не элемент React.
+> `React.Children.only()` не принимает возвращаемое значение [`React.Children.map()`](#reactchildrenmap), потому что это массив, а не React элемент.
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 
@@ -289,7 +291,7 @@ render() {
 }
 ```
 
-Вы также можете использовать его сокращенный синтаксис `<></>`. Для получения дополнительной информации см. [React v16.2.0: Улучшенная поддержка фрагментов](/blog/2017/11/28/react-v16.2.0-fragment-support.html).
+Вы также можете использовать его сокращенный синтаксис `<></>`. Чтобы узнать подробнее см. [React v16.2.0: Улучшенная поддержка фрагментов](/blog/2017/11/28/react-v16.2.0-fragment-support.html).
 
 ### `React.createRef` {#reactcreateref}
 
@@ -308,11 +310,11 @@ render() {
 
 `embed:reference-react-forward-ref.js`
 
-В приведенном выше примере React передает `реф`, переданный элементу `<FancyButton ref={ref}>` в качестве второго аргумента функции рендера внутри вызова `React.forwardRef`. Функция рендера передает `реф` в элемент `<button ref={ref}>`.
+В приведенном выше примере React передает `ref`, переданный элементу `<FancyButton ref={ref}>` в качестве второго аргумента функции рендера внутри вызова `React.forwardRef`. Функция рендера передает `ref` в элемент `<button ref={ref}>`.
 
 В результате после того как React добавит реф, `ref.current` будет указывать непосредственно на экземпляр `<button>` элемента DOM.
 
-Для получения дополнительной информации см. [Переадресация рефов](/docs/forwarding-refs.html).
+Чтобы узнать подробнее см. [Переадресация рефов](/docs/forwarding-refs.html).
 
 ### `React.lazy` {#reactlazy}
 
@@ -325,7 +327,7 @@ render() {
 const SomeComponent = React.lazy(() => import('./SomeComponent'));
 ```
 
-Обратите внимание, для рендера `ленивых` компонентов требуется чтобы выше в дереве находился компонент `<React.Suspense>`. Таким образом вы показываете индикатор загрузки.
+Обратите внимание, для рендера `lazy` компонентов требуется чтобы выше в дереве находился компонент `<React.Suspense>`. Это позволит вам отображать индикатор загрузки.
 
 > **Примечание**
 >
@@ -351,7 +353,7 @@ function MyComponent() {
 }
 ```
 
-Это задокументировано в нашем руководстве по [разделению кода](/docs/code-splitting.html#reactlazy). Обратите внимание, что `ленивые` компоненты могут быть глубоко внутри дерева `Suspense` -- не нужно оборачивать каждый из них. Лучшая практика, размещать `<Suspense>` там где вы хотите видеть индикатор загрузки, но использовать `lazy()` везде, где вы хотите разделить код. 
+Это задокументировано в нашем руководстве по [разделению кода](/docs/code-splitting.html#reactlazy). Обратите внимание, что `lazy` компоненты могут быть глубоко внутри дерева `Suspense` -- не нужно оборачивать каждый из них. Лучшая практика, размещать `<Suspense>` там где вы хотите видеть индикатор загрузки, но использовать `lazy()` везде, где вы хотите разделить код. 
 
 Хотя это не поддерживается сегодня, в будущем мы планируем позволить `Suspense` обрабатывать больше сценариев, таких как получение данных с API. Вы можете прочитать об этом в [нашей дорожной карте](/blog/2018/11/27/react-16-roadmap.html).
 

From 12b23366dc2ab55ea2ac52daf776199cdaeeb676 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:39:52 +0200
Subject: [PATCH 03/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 59d1baf9c..efe73a459 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -41,7 +41,7 @@ React-компоненты также могут быть обявлены ка
 
 ### Трансформация элементов {#transforming-elements}
 
-`React` предоставляет несколько API для управления элементами:
+`React` предоставляет несколько API-методов для управления элементами:
 
 - [`cloneElement()`](#cloneelement)
 - [`isValidElement()`](#isvalidelement)

From ec3973277fe0845c583f35ca731ab861eb149d30 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:40:14 +0200
Subject: [PATCH 04/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index efe73a459..ac57fb479 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -60,7 +60,7 @@ React-компоненты также могут быть обявлены ка
 
 ### Задержка (Suspense) {#suspense}
 
-Задержка дает возможность компонентам «подождать» что-то перед рендером. Пока что Задержку можно использовать только для : [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
+Задержка дает возможность компонентам «подождать» что-то перед рендером. Пока что задержку можно использовать только для [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)

From ca8302ffddf6011811139fbdbd092ea78e488221 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:40:35 +0200
Subject: [PATCH 05/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index ac57fb479..57cdc0a55 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -67,7 +67,7 @@ React-компоненты также могут быть обявлены ка
 
 ### Хуки {#hooks}
 
-*Хуки* — это новое дополнение в React 16.8. Они позволяют вам использовать состояние и другие функции React без написания класса. У хуков есть [свой раздел документации](/docs/hooks-intro.html) и отдельная ссылка на API:
+*Хуки* — это новое дополнение в React 16.8. Они позволяют вам использовать состояние и другие функции React без написания класса. У хуков есть [свой раздел документации](/docs/hooks-intro.html) и отдельный API-справочник:
 
 - [Основные хуки](/docs/hooks-reference.html#basic-hooks)
   - [`useState`](/docs/hooks-reference.html#usestate)

From 9c29ea173dc56af2f445e9be3169818ee04fde82 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:41:00 +0200
Subject: [PATCH 06/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 57cdc0a55..db7372933 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -84,7 +84,7 @@ React-компоненты также могут быть обявлены ка
 
 * * *
 
-## Cправка {#reference}
+## Справочник {#reference}
 
 ### `React.Component` {#reactcomponent}
 

From c823d02ead7f6d0dc711c5eb280abdd1752c0033 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:41:19 +0200
Subject: [PATCH 07/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index db7372933..f58d07111 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -88,7 +88,7 @@ React-компоненты также могут быть обявлены ка
 
 ### `React.Component` {#reactcomponent}
 
-`React.Component` — это базовый класс для компонентов React, объявленных как [ES6-классы](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes):
+`React.Component` — это базовый класс для компонентов React, объявленных как [ES6-классы](https://developer.mozilla.org/ru/docs/Web/JavaScript/Reference/Classes):
 
 ```javascript
 class Greeting extends React.Component {

From e4e696831699102f1644966a9501a7424d206b24 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:42:04 +0200
Subject: [PATCH 08/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index f58d07111..abd758db2 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -98,7 +98,7 @@ class Greeting extends React.Component {
 }
 ```
 
-Со списком методов и свойств базового класса `React.Component` можно ознакомиться на [справочной странице для `React.Component`](/docs/react-component.html).
+Со списком методов и свойств базового класса `React.Component` можно ознакомиться в [API-справочнике по `React.Component`](/docs/react-component.html).
 
 * * *
 

From 5e303b3f27e48a76b042bd6b36d557310c8c02f6 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:42:22 +0200
Subject: [PATCH 09/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index abd758db2..69a88cc82 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -106,7 +106,7 @@ class Greeting extends React.Component {
 
 `React.PureComponent` похож на [`React.Component`](#reactcomponent). Отличие заключается в том, что [`React.Component`](#reactcomponent) не реализует [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), а `React.PureComponent` реализует его с поверхностным сравнением пропсов и состояния.
 
-Если метод `render()` вашего React компонента рендерит один и тот же результат с одинаковыми пропсами и состоянием, для повышения производительности в некоторых случаях вы можете использовать `React.PureComponent`.
+Если метод `render()` вашего React-компонента рендерит один и тот же результат с одинаковыми пропсами и состоянием, для повышения производительности в некоторых случаях вы можете использовать `React.PureComponent`.
 
 > Примечание
 >

From eae96a92bf2107d029e52882a7eac460cc295afb Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:49:01 +0200
Subject: [PATCH 10/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 69a88cc82..f54b49c67 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -128,7 +128,7 @@ const MyComponent = React.memo(function MyComponent(props) {
 
 `React.memo` — это [компонент высшего порядка](/docs/higher-order-components.html). Он похож на [`React.PureComponent`](#reactpurecomponent), но предназначен для функциональных компонентов.
 
-Если ваш функциональный компонент рендерит один и тот же результат с теми же пропсами, вы можете обернуть его в вызов `React.memo` для повышения производительности в некоторых случаях, мемоизируя результат. Это значит что React будет использовать последний результат рендера, избегая повторной отрисовки.
+Если ваш функциональный компонент рендерит один и тот же результат с теми же пропсами, вы можете обернуть его в вызов `React.memo` для повышения производительности в некоторых случаях, мемоизируя результат. Это значит, что React будет использовать последний результат рендера, избегая повторной отрисовки.
 
 По умолчанию он поверхностно сравнивает вложенные объекты в объекте `props`. Если вы хотите контролировать сравнение, вы можете предать свою функцию сравнения в качестве второго аргумента.
 

From f19f3e7f271b45c33e111a5fbc4ed7837bec8d7d Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:49:30 +0200
Subject: [PATCH 11/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index f54b49c67..d7a624902 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -138,7 +138,7 @@ function MyComponent(props) {
 }
 function areEqual(prevProps, nextProps) {
   /*
-  верните true если nextProps рендерит
+  возвращает true, если nextProps рендерит
   тот же результат что и prevProps,
   иначе верните false
   */

From 548dce11412e0d5fd04eec3fd1368ae57b2c736e Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:49:48 +0200
Subject: [PATCH 12/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index d7a624902..36c71bb5a 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -140,7 +140,7 @@ function areEqual(prevProps, nextProps) {
   /*
   возвращает true, если nextProps рендерит
   тот же результат что и prevProps,
-  иначе верните false
+  иначе возвращает false
   */
 }
 export default React.memo(MyComponent, areEqual);

From 1f3c00beb72c98170be6aa86f5e8436593f68a83 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:50:15 +0200
Subject: [PATCH 13/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 36c71bb5a..43b809a57 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -164,7 +164,7 @@ React.createElement(
 )
 ```
 
-Создаёт и возвращает новый [React элемент](/docs/rendering-elements.html) определенного типа. Аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция), или [React-фрагмент](#reactfragment).
+Создаёт и возвращает новый [React-элемент](/docs/rendering-elements.html) определенного типа. Аргументом `type` может быть строка, содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция) или [React-фрагмент](#reactfragment).
 
 Код написанный с использованием JSX, будет преобразован в `React.createElement()`. Обычно вы не будете вызывать `React.createElement()` напрямую, если вы используете JSX. Смотрите [React без JSX](/docs/react-without-jsx.html), чтобы узнать больше.
 

From 69afc50723f8d8da6d24182610a9e570868ecbb4 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:50:57 +0200
Subject: [PATCH 14/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 43b809a57..637b42622 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -200,7 +200,7 @@ React.cloneElement(
 React.createFactory(type)
 ```
 
-Возвращает функцию, которая создавёт элементы React заданного типа. Как и [`React.createElement()`](#createElement), аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция), или [React-фрагмент](#reactfragment).
+Возвращает функцию, которая создавёт элементы React заданного типа. Как и [`React.createElement()`](#createElement), аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция) или [React-фрагмент](#reactfragment).
 
 Этот помощник считается устаревшим, и мы рекомендуем вам либо использовать JSX, либо напрямую использовать `React.createElement()`.
 

From baac94788e9dd4b8957cc7af4459a7a31777fd04 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:51:41 +0200
Subject: [PATCH 15/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 637b42622..983caf7f2 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -202,7 +202,7 @@ React.createFactory(type)
 
 Возвращает функцию, которая создавёт элементы React заданного типа. Как и [`React.createElement()`](#createElement), аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция) или [React-фрагмент](#reactfragment).
 
-Этот помощник считается устаревшим, и мы рекомендуем вам либо использовать JSX, либо напрямую использовать `React.createElement()`.
+Этот вспомогательный метод считается устаревшим, и мы рекомендуем использовать либо JSX, либо напрямую `React.createElement()`.
 
 Обычно вы не будете вызывать `React.createFactory()` напрямую, если вы используете JSX. Смотрите [React без JSX](/docs/react-without-jsx.html), чтобы узнать больше.
 

From 9c3ac75367216d9226bfa52b1c1e0383bfa5df13 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:52:14 +0200
Subject: [PATCH 16/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 983caf7f2..b8a3ac7a7 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -260,7 +260,7 @@ React.Children.only(children)
 
 > Примечание:
 >
-> `React.Children.only()` не принимает возвращаемое значение [`React.Children.map()`](#reactchildrenmap), потому что это массив, а не React элемент.
+> `React.Children.only()` не принимает возвращаемое значение [`React.Children.map()`](#reactchildrenmap), потому что это массив, а не React-элемент.
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 

From 29ba050c91922e65e8c008ad28905ba9c38d7fba Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:52:37 +0200
Subject: [PATCH 17/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index b8a3ac7a7..aa358cad5 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -295,7 +295,7 @@ render() {
 
 ### `React.createRef` {#reactcreateref}
 
-`React.createRef` создаёт [реф](/docs/refs-and-the-dom.html), который можно прикрепить к React элементам через атрибут ref.
+`React.createRef` создаёт [реф](/docs/refs-and-the-dom.html), который можно прикрепить к React-элементам через атрибут ref.
 `embed:16-3-release-blog-post/create-ref-example.js`
 
 ### `React.forwardRef` {#reactforwardref}

From 5fb2d1f7e2e1afd3251bd40e3b8a4b406ee28884 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:55:30 +0200
Subject: [PATCH 18/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index aa358cad5..e264dba47 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -303,7 +303,7 @@ render() {
 `React.forwardRef` создаёт React компонент, который перенаправляет атрибут [ref](/docs/refs-and-the-dom.html), что он получает, другому компоненту ниже в дереве.
 Этот метод не очень распространен, но особенно полезен в двух сценариях:
 
-* [Пересылка рефов на компоненты DOM](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
+* [Перенаправление рефов в DOM-компоненты](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
 * [Пересылка рефов на компоненты высшего порядка](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
 
 `React.forwardRef` принимает функцию рендера в качестве аргумента. React будет вызывать эту функцию с пропсами и рефом в качестве двух аргументов. Эта функция должна возвращать узел React.

From 3aa731935909e72560192e0b310ff970e0cf18f8 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:55:46 +0200
Subject: [PATCH 19/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index e264dba47..5acee52b1 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -304,7 +304,7 @@ render() {
 Этот метод не очень распространен, но особенно полезен в двух сценариях:
 
 * [Перенаправление рефов в DOM-компоненты](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
-* [Пересылка рефов на компоненты высшего порядка](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
+* [Перенаправление рефов в компонентах высшего порядка](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
 
 `React.forwardRef` принимает функцию рендера в качестве аргумента. React будет вызывать эту функцию с пропсами и рефом в качестве двух аргументов. Эта функция должна возвращать узел React.
 

From defb24426f1d7f778a5a4208d7d16824cf4510bc Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Mon, 18 Feb 2019 12:56:07 +0200
Subject: [PATCH 20/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 5acee52b1..4df7601e2 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -335,7 +335,7 @@ const SomeComponent = React.lazy(() => import('./SomeComponent'));
 
 ### `React.Suspense` {#reactsuspense}
 
-`React.Suspense` позволяет показать индикатор загрузки в случае если некоторые компоненты в дереве под ним еще не готовы к рендеру. Сегодня ленивая загрузка компонентов — это **единственный** вариант использования поддерживаемый `<React.Suspense>`:
+`React.Suspense` позволяет показать индикатор загрузки в случае, если некоторые компоненты в дереве под ним еще не готовы к рендеру. Сегодня ленивая загрузка компонентов — это **единственный** вариант использования, поддерживаемый `<React.Suspense>`:
 
 ```js
 // Этот компонент загружается динамически

From 50a8dd4c7ca9c636e121f5815935c72aa616ea4d Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Tue, 19 Feb 2019 12:22:12 +0200
Subject: [PATCH 21/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 4df7601e2..8afa9beba 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -110,7 +110,7 @@ class Greeting extends React.Component {
 
 > Примечание
 >
-> Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только поверхностное сравнение объектов. Если они содержат сложные структуры данных, это может привести к неправильной работе для более глубоких различий. Наследуйтесь от `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда вы знаете, что вложенные структуры данных изменились. Также подумайте об использовании [неизменяемых объектов](https://facebook.github.io/immutable-js/) чтобы упростить процесс сравнения вложенных данных.
+> Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только поверхностное сравнение объектов. Если они содержат сложные структуры данных, это может привести к неправильной работе для более глубоких различий. Наследуйте класс `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда знаете, что вложенные структуры данных изменились. Также подумайте об использовании [иммутабельных объектов](https://facebook.github.io/immutable-js/), чтобы упростить процесс сравнения вложенных данных.
 >
 >
 >

From b22a92a466d2358ae5d1019790882dde7c56239e Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Tue, 19 Feb 2019 12:23:23 +0200
Subject: [PATCH 22/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 8afa9beba..213752a4c 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -24,7 +24,7 @@ React-компоненты позволяют разделить пользов
  - [`React.Component`](#reactcomponent)
  - [`React.PureComponent`](#reactpurecomponent)
 
-Если вы не используете классы ES6, вместо них вы можете использовать модуль `create-react-class`. Чтобы узнать подробнее см. [Использование React без ES6](/docs/react-without-es6.html).
+Если вы не используете классы ES6, вместо них вы можете использовать модуль `create-react-class`. Читайте [Использование React без ES6](/docs/react-without-es6.html), чтобы получить подробную информацию.
 
 React-компоненты также могут быть обявлены как функции, которые могут быть обернуты:
 

From 97761cfa04eb47c33f71ae10962b602b43a0de72 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Tue, 19 Feb 2019 12:23:43 +0200
Subject: [PATCH 23/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 213752a4c..0689e96d1 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -37,7 +37,7 @@ React-компоненты также могут быть обявлены ка
 - [`createElement()`](#createelement)
 - [`createFactory()`](#createfactory)
 
-См. [Использование React без JSX](/docs/react-without-jsx.html) чтобы узнать подробнее.
+Читайте [Использование React без JSX](/docs/react-without-jsx.html), чтобы получить подробную информацию.
 
 ### Трансформация элементов {#transforming-elements}
 

From 9f37e6c2cbb0d91ab4bfe07c54b94e3cce385a70 Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Tue, 19 Feb 2019 12:24:13 +0200
Subject: [PATCH 24/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 0689e96d1..451188589 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -166,7 +166,7 @@ React.createElement(
 
 Создаёт и возвращает новый [React-элемент](/docs/rendering-elements.html) определенного типа. Аргументом `type` может быть строка, содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция) или [React-фрагмент](#reactfragment).
 
-Код написанный с использованием JSX, будет преобразован в `React.createElement()`. Обычно вы не будете вызывать `React.createElement()` напрямую, если вы используете JSX. Смотрите [React без JSX](/docs/react-without-jsx.html), чтобы узнать больше.
+Код, написанный с использованием JSX, будет преобразован в `React.createElement()`. Обычно вы не будете вызывать `React.createElement()` напрямую, если вы используете JSX. Смотрите [React без JSX](/docs/react-without-jsx.html), чтобы получить подробную информацию.
 
 * * *
 

From 6714f1e46ea664016816b2d6879d97499394d65c Mon Sep 17 00:00:00 2001
From: Alexey Pyltsyn <lex61rus@gmail.com>
Date: Tue, 19 Feb 2019 12:24:57 +0200
Subject: [PATCH 25/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 451188589..6a2e7f267 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -314,7 +314,7 @@ render() {
 
 В результате после того как React добавит реф, `ref.current` будет указывать непосредственно на экземпляр `<button>` элемента DOM.
 
-Чтобы узнать подробнее см. [Переадресация рефов](/docs/forwarding-refs.html).
+Читайте [Переадресация рефов](/docs/forwarding-refs.html), чтобы получить подробную информацию.
 
 ### `React.lazy` {#reactlazy}
 

From 48c93c50de304d9a2272ab10de956400681fe111 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Fri, 22 Feb 2019 09:50:05 +0200
Subject: [PATCH 26/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 6a2e7f267..714b35fe3 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -60,7 +60,7 @@ React-компоненты также могут быть обявлены ка
 
 ### Задержка (Suspense) {#suspense}
 
-Задержка дает возможность компонентам «подождать» что-то перед рендером. Пока что задержку можно использовать только для [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
+Задержка дает возможность компонентам «дождаться» чего-то перед рендером. Пока что задержку можно использовать только для [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)

From 58eba52eb4bc9b7b51dc7b73c34eb672735982ac Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Fri, 22 Feb 2019 09:53:12 +0200
Subject: [PATCH 27/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 714b35fe3..dcf6a4979 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -106,7 +106,7 @@ class Greeting extends React.Component {
 
 `React.PureComponent` похож на [`React.Component`](#reactcomponent). Отличие заключается в том, что [`React.Component`](#reactcomponent) не реализует [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), а `React.PureComponent` реализует его с поверхностным сравнением пропсов и состояния.
 
-Если метод `render()` вашего React-компонента рендерит один и тот же результат с одинаковыми пропсами и состоянием, для повышения производительности в некоторых случаях вы можете использовать `React.PureComponent`.
+Если метод `render()` вашего React-компонента всегда рендерит одинаковый результат при одних и тех же пропсах и состояниях, для повышения производительности в некоторых случаях вы можете использовать `React.PureComponent`.
 
 > Примечание
 >

From cfcb1281deb8d0274484157ad9f47db9e688669a Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 08:57:13 +0200
Subject: [PATCH 28/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index dcf6a4979..daabe357c 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -104,7 +104,7 @@ class Greeting extends React.Component {
 
 ### `React.PureComponent` {#reactpurecomponent}
 
-`React.PureComponent` похож на [`React.Component`](#reactcomponent). Отличие заключается в том, что [`React.Component`](#reactcomponent) не реализует [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), а `React.PureComponent` реализует его с поверхностным сравнением пропсов и состояния.
+`React.PureComponent` похож на [`React.Component`](#reactcomponent). Отличие заключается в том, что [`React.Component`](#reactcomponent) не реализует [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate), а `React.PureComponent` реализует его поверхностным сравнением пропсов и состояния.
 
 Если метод `render()` вашего React-компонента всегда рендерит одинаковый результат при одних и тех же пропсах и состояниях, для повышения производительности в некоторых случаях вы можете использовать `React.PureComponent`.
 

From f7a44678abb7975a64836601ed57e69cb6dbd8e2 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 08:58:11 +0200
Subject: [PATCH 29/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index daabe357c..57d317f76 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -110,7 +110,7 @@ class Greeting extends React.Component {
 
 > Примечание
 >
-> Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только поверхностное сравнение объектов. Если они содержат сложные структуры данных, это может привести к неправильной работе для более глубоких различий. Наследуйте класс `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда знаете, что вложенные структуры данных изменились. Также подумайте об использовании [иммутабельных объектов](https://facebook.github.io/immutable-js/), чтобы упростить процесс сравнения вложенных данных.
+> Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только поверхностное сравнение объектов. Если они содержат сложные структуры данных, это может привести к неправильной работе для более глубоких различий (то есть, различий, не выраженных на поверхности структуры). Наследуйте класс `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда знаете, что вложенные структуры данных изменились. Также подумайте об использовании [иммутабельных объектов](https://facebook.github.io/immutable-js/), чтобы упростить процесс сравнения вложенных данных.
 >
 >
 >

From 8ae55ef31377ecf6d5e2db7c542c9ff979015d9c Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 08:58:53 +0200
Subject: [PATCH 30/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 57d317f76..ca76e8f0c 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -128,7 +128,7 @@ const MyComponent = React.memo(function MyComponent(props) {
 
 `React.memo` — это [компонент высшего порядка](/docs/higher-order-components.html). Он похож на [`React.PureComponent`](#reactpurecomponent), но предназначен для функциональных компонентов.
 
-Если ваш функциональный компонент рендерит один и тот же результат с теми же пропсами, вы можете обернуть его в вызов `React.memo` для повышения производительности в некоторых случаях, мемоизируя результат. Это значит, что React будет использовать последний результат рендера, избегая повторной отрисовки.
+Если ваш функциональный компонент всегда рендерит одинаковый результат для одих и тех же пропсов, вы можете обернуть его в вызов `React.memo` для повышения производительности в некоторых случаях, мемоизируя результат. Это значит, что React будет использовать результат последнего рендера, избегая повторного рендеринга.
 
 По умолчанию он поверхностно сравнивает вложенные объекты в объекте `props`. Если вы хотите контролировать сравнение, вы можете предать свою функцию сравнения в качестве второго аргумента.
 

From 5443787d83ae27d089c3f530c72caa01ac3df190 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 08:59:27 +0200
Subject: [PATCH 31/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index ca76e8f0c..1b4620c31 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -180,7 +180,7 @@ React.cloneElement(
 )
 ```
 
-Клонирует и возвращает новый React элемент, используя элемент в качестве отправной точки. Полученный элемент будет иметь пропсы исходного элемента, а новые пропсы будут поверхностно объединены. Новые дочерние элементы заменят существующие. `key` и `ref` из исходного элемента будут сохранены.
+Клонирует и возвращает новый React элемент, используя элемент в качестве отправной точки. Полученный элемент будет иметь пропсы исходного элемента, а новые пропсы будут поверхностно слиты воедино. Новые дочерние элементы заменят существующие. `key` и `ref` из исходного элемента будут сохранены.
 
 `React.cloneElement()` почти эквивалентен:
 

From bc1bcf6dd6cbd3cb458b326e6a5e6a834e6020d2 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 08:59:57 +0200
Subject: [PATCH 32/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 1b4620c31..a44aa137e 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -200,7 +200,7 @@ React.cloneElement(
 React.createFactory(type)
 ```
 
-Возвращает функцию, которая создавёт элементы React заданного типа. Как и [`React.createElement()`](#createElement), аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция) или [React-фрагмент](#reactfragment).
+Возвращает функцию, которая создаёт элементы React заданного типа. Как и [`React.createElement()`](#createElement), аргументом `type` может быть строка содержащая имя тега (например, `'div'` или `'span'`), React-компонент (класс или функция) или [React-фрагмент](#reactfragment).
 
 Этот вспомогательный метод считается устаревшим, и мы рекомендуем использовать либо JSX, либо напрямую `React.createElement()`.
 

From fd35782ee1f3c42cf7592bf000c29d47cb3ad335 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 09:00:16 +0200
Subject: [PATCH 33/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index a44aa137e..030347fa1 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -220,7 +220,7 @@ React.isValidElement(object)
 
 ### `React.Children` {#reactchildren}
 
-`React.Children` предоставляет утилиты для работы с непрозрачной структурой данных `this.props.children`.
+`React.Children` предоставляет функции для работы с непрозрачной структурой данных `this.props.children`.
 
 #### `React.Children.map` {#reactchildrenmap}
 

From 65b2101b857d27cce7f3581cbb537f4170c0b878 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 09:00:51 +0200
Subject: [PATCH 34/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 030347fa1..c4d8c72c6 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -268,7 +268,7 @@ React.Children.only(children)
 React.Children.toArray(children)
 ```
 
-Возвращает непрозрачную структуру данных `children` в виде плоского массива с ключами, заданые каждому дочернему элементу. Полезно, если вы хотите манипулировать коллекциями потомков в ваших методах рендера, особенно если вы хотите отсортировать или срезать `this.props.children` перед передачей вниз.
+Возвращает непрозрачную структуру данных `children` в виде плоского массива с ключами, заданые каждому дочернему элементу. Полезно, если вы хотите манипулировать коллекциями потомков в ваших методах рендера, особенно если вы хотите отсортировать или извлечь часть `this.props.children` перед её передачей куда-либо.
 
 > Примечание:
 >

From b98cd9ac0ee15a2775fbb9a85cc28c4d74d0ffb9 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 09:01:17 +0200
Subject: [PATCH 35/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index c4d8c72c6..b2c67e52e 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -310,7 +310,7 @@ render() {
 
 `embed:reference-react-forward-ref.js`
 
-В приведенном выше примере React передает `ref`, переданный элементу `<FancyButton ref={ref}>` в качестве второго аргумента функции рендера внутри вызова `React.forwardRef`. Функция рендера передает `ref` в элемент `<button ref={ref}>`.
+В приведенном выше примере React обнаруживает `ref`, переданный элементу `<FancyButton ref={ref}>`, и передаёт его через второй аргумент в функцию рендера внутри вызова `React.forwardRef`. В свою очередь, функция рендера передает `ref` в элемент `<button ref={ref}>`.
 
 В результате после того как React добавит реф, `ref.current` будет указывать непосредственно на экземпляр `<button>` элемента DOM.
 

From 1905fd43239f20d2cf8e4e8cb943bc70809ea57a Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 09:01:35 +0200
Subject: [PATCH 36/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index b2c67e52e..02a7c5900 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -312,7 +312,7 @@ render() {
 
 В приведенном выше примере React обнаруживает `ref`, переданный элементу `<FancyButton ref={ref}>`, и передаёт его через второй аргумент в функцию рендера внутри вызова `React.forwardRef`. В свою очередь, функция рендера передает `ref` в элемент `<button ref={ref}>`.
 
-В результате после того как React добавит реф, `ref.current` будет указывать непосредственно на экземпляр `<button>` элемента DOM.
+В результате, после того как React добавит реф, `ref.current` будет указывать непосредственно на экземпляр `<button>` элемента DOM.
 
 Читайте [Переадресация рефов](/docs/forwarding-refs.html), чтобы получить подробную информацию.
 

From db0a73569389801a2cdf56ff63305bd8912f4dd3 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 09:01:55 +0200
Subject: [PATCH 37/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 02a7c5900..8c51c347e 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -320,7 +320,7 @@ render() {
 
 `React.lazy()` позволяет вам определять компонент, который загружается динамически. Это помогает уменьшить размер сборки, откладывая загрузку компонентов, которые не используются во время первоначального рендера.
 
-Вы можете узнать, как пользоватся этим из нашей [документации по разделению кода](/docs/code-splitting.html#reactlazy). Вы также можете посмотреть [эту статью](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) с объяснением, как использовать этот метод более подробно.
+Вы можете узнать, как этим пользоватся из нашей [документации по разделению кода](/docs/code-splitting.html#reactlazy). Вы также можете посмотреть [эту статью](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) с объяснением, как использовать этот метод более подробно.
 
 ```js
 // Этот компонент загружается динамически

From 8b7a00e4cb5393ba33a4783de453c39d04f12557 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 09:02:33 +0200
Subject: [PATCH 38/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 8c51c347e..26c019326 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -353,7 +353,7 @@ function MyComponent() {
 }
 ```
 
-Это задокументировано в нашем руководстве по [разделению кода](/docs/code-splitting.html#reactlazy). Обратите внимание, что `lazy` компоненты могут быть глубоко внутри дерева `Suspense` -- не нужно оборачивать каждый из них. Лучшая практика, размещать `<Suspense>` там где вы хотите видеть индикатор загрузки, но использовать `lazy()` везде, где вы хотите разделить код. 
+Это задокументировано в нашем руководстве по [разделению кода](/docs/code-splitting.html#reactlazy). Обратите внимание, что `lazy` компоненты могут быть глубоко внутри дерева `Suspense` -- не нужно оборачивать каждый из них. Считается хорошей практикой использовать `<Suspense>` для индикции загрузки, а `lazy()` -- для разделения кода. 
 
 Хотя это не поддерживается сегодня, в будущем мы планируем позволить `Suspense` обрабатывать больше сценариев, таких как получение данных с API. Вы можете прочитать об этом в [нашей дорожной карте](/blog/2018/11/27/react-16-roadmap.html).
 

From 822d250505c45b3686c83abf4c88c12aeca78e67 Mon Sep 17 00:00:00 2001
From: ANOTHER GUY <another-guy@users.noreply.github.com>
Date: Wed, 27 Feb 2019 09:03:02 +0200
Subject: [PATCH 39/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 26c019326..b8edf45ba 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -355,7 +355,7 @@ function MyComponent() {
 
 Это задокументировано в нашем руководстве по [разделению кода](/docs/code-splitting.html#reactlazy). Обратите внимание, что `lazy` компоненты могут быть глубоко внутри дерева `Suspense` -- не нужно оборачивать каждый из них. Считается хорошей практикой использовать `<Suspense>` для индикции загрузки, а `lazy()` -- для разделения кода. 
 
-Хотя это не поддерживается сегодня, в будущем мы планируем позволить `Suspense` обрабатывать больше сценариев, таких как получение данных с API. Вы можете прочитать об этом в [нашей дорожной карте](/blog/2018/11/27/react-16-roadmap.html).
+Хотя это не поддерживается сегодня, в будущем мы планируем позволить `Suspense` обрабатывать больше сценариев, таких как получение данных от API. Вы можете прочитать об этом в [нашей дорожной карте](/blog/2018/11/27/react-16-roadmap.html).
 
 >Примечание:
 >

From d9e5ec79d45ab50fa1171b595bcd520a6b17971a Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:03:51 +0200
Subject: [PATCH 40/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index b8edf45ba..96dd918e4 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -19,7 +19,7 @@ redirect_from:
 
 ### Компоненты {#components}
 
-React-компоненты позволяют разделить пользовательский интерфейс на независимые, повторно используемые части и думать о них по отдельности. React-компоненты могут быть обявлены путем создания подклассов `React.Component` или `React.PureComponent`.
+React-компоненты позволяют разделить пользовательский интерфейс на независимые, повторно используемые части и думать о них по отдельности. React-компоненты могут быть обявлены путём создания подклассов `React.Component` или `React.PureComponent`.
 
  - [`React.Component`](#reactcomponent)
  - [`React.PureComponent`](#reactpurecomponent)

From 54af03d311f49f46953d64dcd02137a99e2f0bb2 Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:04:03 +0200
Subject: [PATCH 41/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 96dd918e4..3fe1c468c 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -26,7 +26,7 @@ React-компоненты позволяют разделить пользов
 
 Если вы не используете классы ES6, вместо них вы можете использовать модуль `create-react-class`. Читайте [Использование React без ES6](/docs/react-without-es6.html), чтобы получить подробную информацию.
 
-React-компоненты также могут быть обявлены как функции, которые могут быть обернуты:
+React-компоненты также могут быть обявлены как функции, которые могут быть обёрнуты:
 
 - [`React.memo`](#reactmemo)
 

From 97b18b73ace603bdd21d6e3e376a869c59c6ba82 Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:04:12 +0200
Subject: [PATCH 42/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 3fe1c468c..15e5365e8 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -49,7 +49,7 @@ React-компоненты также могут быть обявлены ка
 
 ### Фрагменты {#fragments}
 
-`React` также предоставляет компонент для рендера нескольких элементов без обертки.
+`React` также предоставляет компонент для рендера нескольких элементов без обёртки.
 
 - [`React.Fragment`](#reactfragment)
 

From bb96ce6013cc140568b5fff8fd806050b09b7d55 Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:04:24 +0200
Subject: [PATCH 43/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 15e5365e8..59173d5e2 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -60,7 +60,7 @@ React-компоненты также могут быть обявлены ка
 
 ### Задержка (Suspense) {#suspense}
 
-Задержка дает возможность компонентам «дождаться» чего-то перед рендером. Пока что задержку можно использовать только для [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
+Задержка даёт возможность компонентам «дождаться» чего-то перед рендером. Пока что задержку можно использовать только для [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)

From 9368f1d34c6c646bc7205f39efe9a96bf585f4d6 Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:04:34 +0200
Subject: [PATCH 44/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 59173d5e2..3ab8657a0 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -188,7 +188,7 @@ React.cloneElement(
 <element.type {...element.props} {...props}>{children}</element.type>
 ```
 
-Однако, в этом случае, сохранятся `ref`. Это означает если вы получите ребенка с `ref` на нем, вы случайно не украдете его у родителя. Вы получите тот же `ref`, прикрепленный к вашему новому элементу.
+Однако, в этом случае, сохранятся `ref`. Это означает если вы получите ребёнка с `ref` на нем, вы случайно не украдёте его у родителя. Вы получите тот же `ref`, прикреплённый к вашему новому элементу.
 
 Этот API был представлен как замена устаревшего `React.addons.cloneWithProps()`.
 

From 7b4115b5a791b3c288392e7d44d602f8a4a7e0ed Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:04:47 +0200
Subject: [PATCH 45/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 3ab8657a0..89dba7506 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -228,7 +228,7 @@ React.isValidElement(object)
 React.Children.map(children, function[(thisArg)])
 ```
 
-Вызывает функцию для каждого непосредственного потомка, содержащегося в `children` передавая их по очереде в `thisArg`. Если `children` — это массив, он будет пройден, и функция будет вызвана для каждого потомка в массиве. Если `children` равен `null` или `undefined`, этот метод вернет `null` или `undefined`, а не массив.
+Вызывает функцию для каждого непосредственного потомка, содержащегося в `children` передавая их по очереде в `thisArg`. Если `children` — это массив, он будет пройден, и функция будет вызвана для каждого потомка в массиве. Если `children` равен `null` или `undefined`, этот метод вернёт `null` или `undefined`, а не массив.
 
 > Примечание
 >

From 2cd22dfe9f0603e6640e9ad80c089be3fc5cad0d Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:05:05 +0200
Subject: [PATCH 46/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 89dba7506..20f701c6b 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -335,7 +335,7 @@ const SomeComponent = React.lazy(() => import('./SomeComponent'));
 
 ### `React.Suspense` {#reactsuspense}
 
-`React.Suspense` позволяет показать индикатор загрузки в случае, если некоторые компоненты в дереве под ним еще не готовы к рендеру. Сегодня ленивая загрузка компонентов — это **единственный** вариант использования, поддерживаемый `<React.Suspense>`:
+`React.Suspense` позволяет показать индикатор загрузки в случае, если некоторые компоненты в дереве под ним ещё не готовы к рендеру. Сегодня ленивая загрузка компонентов — это **единственный** вариант использования, поддерживаемый `<React.Suspense>`:
 
 ```js
 // Этот компонент загружается динамически

From 6a66ca255c909df60836f7e0d8286e809b01e3e6 Mon Sep 17 00:00:00 2001
From: Nick Tishkevich <Nikolai.Tishkevich@artezio.com>
Date: Wed, 27 Feb 2019 09:05:17 +0200
Subject: [PATCH 47/49] Update content/docs/reference-react.md

Co-Authored-By: ModPhoenix <ivanchenko.b@gmail.com>
---
 content/docs/reference-react.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 20f701c6b..7bd92581d 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -359,4 +359,4 @@ function MyComponent() {
 
 >Примечание:
 >
-> `React.lazy()` и `<React.Suspense>` еще не поддерживаются `ReactDOMServer`. Это известное ограничение, которое будет устранено в будущем.
+> `React.lazy()` и `<React.Suspense>` ещё не поддерживаются `ReactDOMServer`. Это известное ограничение, которое будет устранено в будущем.

From cdcf2a833fb633d102589ceec0b6e39766f944f5 Mon Sep 17 00:00:00 2001
From: Bogdan Ivanchenko <ivanchenko.b@gmail.com>
Date: Wed, 27 Feb 2019 09:14:08 +0200
Subject: [PATCH 48/49] Improved translate 2

---
 content/docs/reference-react.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 7bd92581d..33536dd3a 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -60,7 +60,7 @@ React-компоненты также могут быть обявлены ка
 
 ### Задержка (Suspense) {#suspense}
 
-Задержка даёт возможность компонентам «дождаться» чего-то перед рендером. Пока что задержку можно использовать только для [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных с API.
+Задержка даёт возможность компонентам «дождаться» чего-то перед рендером. Пока что задержку можно использовать только для [динамической загрузки компонентов с помощью `React.lazy`](/docs/code-splitting.html#reactlazy). В будущем будут поддерживаться и другие варианты использования, такие как получение данных от API.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)
@@ -310,7 +310,7 @@ render() {
 
 `embed:reference-react-forward-ref.js`
 
-В приведенном выше примере React обнаруживает `ref`, переданный элементу `<FancyButton ref={ref}>`, и передаёт его через второй аргумент в функцию рендера внутри вызова `React.forwardRef`. В свою очередь, функция рендера передает `ref` в элемент `<button ref={ref}>`.
+В приведённом выше примере React обнаруживает `ref`, переданный элементу `<FancyButton ref={ref}>`, и передаёт его через второй аргумент в функцию рендера внутри вызова `React.forwardRef`. В свою очередь, функция рендера передает `ref` в элемент `<button ref={ref}>`.
 
 В результате, после того как React добавит реф, `ref.current` будет указывать непосредственно на экземпляр `<button>` элемента DOM.
 

From 44beb235c710e61afa73f117a2e81d3c4c155650 Mon Sep 17 00:00:00 2001
From: Bogdan Ivanchenko <ivanchenko.b@gmail.com>
Date: Wed, 27 Feb 2019 09:22:37 +0200
Subject: [PATCH 49/49] Fixed markup

---
 content/docs/reference-react.md | 2 --
 1 file changed, 2 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 33536dd3a..1affe7041 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -112,8 +112,6 @@ class Greeting extends React.Component {
 >
 > Метод `shouldComponentUpdate()` базового класа `React.PureComponent` делает только поверхностное сравнение объектов. Если они содержат сложные структуры данных, это может привести к неправильной работе для более глубоких различий (то есть, различий, не выраженных на поверхности структуры). Наследуйте класс `PureComponent` только тогда, когда вы ожидаете использовать простые пропсы и состояние, или используйте [`forceUpdate()`](/docs/react-component.html#forceupdate), когда знаете, что вложенные структуры данных изменились. Также подумайте об использовании [иммутабельных объектов](https://facebook.github.io/immutable-js/), чтобы упростить процесс сравнения вложенных данных.
 >
->
->
 > Кроме того, метод `shouldComponentUpdate()` базового класа `React.PureComponent` пропускает обновление пропсов для всего поддерева компонентов. Убедитесь, что все дочерние компоненты также являются «чистыми».
 
 * * *