From 9d56d2554e5d4280bfe29c487e3e5b6bd95a9239 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Sat, 30 Mar 2019 16:19:38 +0400
Subject: [PATCH 01/13] Translate overview and some detailed references

---
 content/docs/reference-react.md | 71 ++++++++++++++++-----------------
 1 file changed, 35 insertions(+), 36 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index d506a1ad3..87b23674b 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -1,8 +1,8 @@
 ---
 id: react-api
-title: React Top-Level API
+title: Üst Səviyyəli React API
 layout: docs
-category: Reference
+category: Arayış
 permalink: docs/react-api.html
 redirect_from:
   - "docs/reference.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 kitabxanası üçün başlanğıc nöqtəsidir. Əgər siz React-i `<script>` təqi ilə yükləyirsinizsə, bu üst səviyyəli API-lar `React` qlobalında mövcuddur. Əgər siz NPM ilə ES6 işlədirsinizsə, siz `import React from 'react'` yaza bilərsiniz. Əgər siz NPM ilə ES5 işlədirsinizsə, siz `var React = require('react')` yaza bilərsiniz.
 
-## Overview {#overview}
+## İcmal {#overview}
 
-### Components {#components}
+### Komponentlər {#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 komponentləri sizə UI-ı müstəqil, yenidən işlənə bilən hissələrə ayırmağa və bu hissələr haqqında ayrılıqda fikirləşməyə imkan yaradır. React komponentləri `React.Component` və ya `React.PureComponent` klaslarını genişləndirərək müəyyənləşdirilə bilir.
 
  - [`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.
+Əgər siz ES6 klasları istifadə etmirsinizsə, siz `create-react-class` modulundan istifadə edə bilərsiniz. Əlavə məlumat üçün, [ES6-sız React-in istifadəsi](/docs/react-without-es6.html) bölməsini oxuyun.
 
-React components can also be defined as functions which can be wrapped:
+React komponentləri həmçinin funskiyalar ilə də müəyyənləşdirilə bilərlər. Bu funskiyalar aşağıdakılar ilə əhatə oluna bilərələr:
 
 - [`React.memo`](#reactmemo)
 
-### Creating React Elements {#creating-react-elements}
+### React Elementlərinin Düzəldilməsi {#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.
+Biz UI-ın nə olacağını təsvir etmək üçün [JSX işlətməyi](/docs/introducing-jsx.html) tövsiyyə edirik. Hər bir JSX elementi [`React.createElement()`](#createelement) funskiyasını çağırmaq üçün gözəl sintaksisdir. JSX işlətdikdə adətən aşağıdakı funskiyaları birbaşa çağırmırsınız.
 
 - [`createElement()`](#createelement)
 - [`createFactory()`](#createfactory)
 
-See [Using React without JSX](/docs/react-without-jsx.html) for more information.
+Daha ətraflı məlumat üçün [JSX-siz React-in İşlənməsini](/docs/react-without-jsx.html) oxuyun.
 
-### Transforming Elements {#transforming-elements}
+### Elementlərin Transformasiyası {#transforming-elements}
 
-`React` provides several APIs for manipulating elements:
+`React` elementlərin manipulyasiyası üçün bir neçə API təmin edir:
 
 - [`cloneElement()`](#cloneelement)
 - [`isValidElement()`](#isvalidelement)
 - [`React.Children`](#reactchildren)
 
-### Fragments {#fragments}
+### Fraqmentlər {#fragments}
 
-`React` also provides a component for rendering multiple elements without a wrapper.
+`React` həmçinin bir neçə elmeentin əhatə olan elementsiz bir neçə elementi render etmək üçün kompoennt tmin edir.
 
 - [`React.Fragment`](#reactfragment)
 
-### Refs {#refs}
+### Reflər {#refs}
 
 - [`React.createRef`](#reactcreateref)
 - [`React.forwardRef`](#reactforwardref)
 
 ### 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 komponentləri render etməmişdən qabaq neyisə "gözləməsinə" imkan yaradır. Bugün, Suspense yalnız bir ssenarini dəstələyir: [komponentlərin `React.lazy` ilə dinamik yüklənməsi](/docs/code-splitting.html#reactlazy). Gələcəkdə, bu başqa ssenariləri (məsələn məklumatın yüklənməsi) də dəstəkləyəcək.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)
 
-### Hooks {#hooks}
+### Hooklar {#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:
+*Hooklar* React 16.8-a yeni əlavədir. Onlar sizə state və başqa React xüsusiyyətlərini klas yazmadan istifadə etməyə imkan yaradır. Hooklara [həsr olunmuş ayrıca sənədləri](/docs/hooks-intro.html) və API arayışları var:
 
-- [Basic Hooks](/docs/hooks-reference.html#basic-hooks)
+- [Əsas Hooklar](/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)
+- [Əlavə Hooklar](/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,21 +84,21 @@ Suspense lets components "wait" for something before rendering. Today, Suspense
 
 * * *
 
-## Reference {#reference}
+## Arayış {#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` [ES6 klasları](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Classes) ilə müəyyənləşdirilən React komponentləri üçün əsas klasdır:
 
 ```javascript
 class Greeting extends React.Component {
   render() {
-    return <h1>Hello, {this.props.name}</h1>;
+    return <h1>Salam, {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.
+`React.Component` əsas klasına aid Funskiya və parametrlərin siyahısı üçün [React.Component API Arayışına](/docs/react-component.html) baxın.
 
 * * *
 
@@ -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`.
+Elementin React elementi olmasını təsdiqləyir. `true` və ya `false` qaytarır.
 
 * * *
 
 ### `React.Children` {#reactchildren}
 
-`React.Children` provides utilities for dealing with the `this.props.children` opaque data structure.
+`React.Children` `this.props.children` qeyri şəffaf data strukturu ilə məşğul olmaq üçün faydalı funskiyalar ilə təmin edir.
 
 #### `React.Children.map` {#reactchildrenmap}
 
@@ -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) kimi amma massiv qaytarmır.
 
 #### `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`-də olan komponentlərin sayını qaytarır. Bu dəyər, `map` və ya `forEach` callback-inin neçə dəfə çağrılmasına bərabərdir.
 
 #### `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`-in yalnız bir uşağı (React elementi) olmasını təsqidləyir və bu elementi qaytarır. Əks halda, bu funksiya xəta atir.
 
-> Note:
+> Qeyd:
 >
->`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) funskiyasının qaytardığı dəyəri qəbul etmir. Çünki bu funskiyaının qaytardığı massivdir, React elementi deyil.
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 
@@ -276,7 +276,7 @@ Returns the `children` opaque data structure as a flat array with keys assigned
 
 ### `React.Fragment` {#reactfragment}
 
-The `React.Fragment` component lets you return multiple elements in a `render()` method without creating an additional DOM element:
+`React.Fragment` komponenti bir neçə elementi, əlavə DOM elementi yaratmadan `render()` funskiyasından qaytarmağa imkan yaradır:
 
 ```javascript
 render() {
@@ -289,12 +289,11 @@ render() {
 }
 ```
 
-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).
-
+Siz həmçinin `<></>` qısa sintaksisi işlədə bilərsiniz. Daha ətraflı məlumat üçün, [React v16.2.0: Fraqmentlərin Dəstəyinin Təkmilləşdirilməsi](/blog/2017/11/28/react-v16.2.0-fragment-support.html) yazısını oxuyun.
 
 ### `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` React elementlərinə ref parametri ilə qoşulan [ref](/docs/refs-and-the-dom.html) yaradır.
 `embed:16-3-release-blog-post/create-ref-example.js`
 
 ### `React.forwardRef` {#reactforwardref}

From 8b8f021b2b1f730e44ccb3d0cedbb8dca2210503 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Sat, 30 Mar 2019 16:38:29 +0400
Subject: [PATCH 02/13] Translate children reference

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

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 87b23674b..d50de241f 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -226,11 +226,11 @@ Elementin React elementi olmasını təsdiqləyir. `true` və ya `false` qaytar
 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`-da olan hər birbaşa ola uşağın üzərində funskiya çağırır. Bu funskiyada `this`, `thisArg` ilə təyin edilir. Əgər `children` masivdirsə, massiv traver edəcək və funskiya hər uşaqda çağrılacaq. Əgər `children` `null` və ya `undefined`-dirsə, bu funskiya massiv əvəzinə `null` və ya `undefined` qaytaracaq.
 
-> Note
+> Qeyd
 >
-> If `children` is a `Fragment` it will be treated as a single child and not traversed.
+> Əgər `children` `Fragment`-dirsə, bu bir uşaq kimi sayılacaq və travers olunmayacaq.
 
 #### `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)])
 ```
 
-[`React.Children.map()`](#reactchildrenmap) kimi amma massiv qaytarmır.
+[`React.Children.map()`](#reactchildrenmap) kimi. Amma massiv qaytarmır.
 
 #### `React.Children.count` {#reactchildrencount}
 
@@ -266,11 +266,11 @@ React.Children.only(children)
 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` data strukturundan yastı massiv yaradır, uşaqları açarlar ilə təyin edir, və yaranan massivi qaytarır. Uşaqların kolleksiyalarıni render zamanı manipulyasiya etmək, xüsusilədə `this.props.children`-ı render etməmişdən oncə sıralamaq və ya parçalamaq, üçün yararlıdır.
 
-> Note:
+> Qeyd:
 >
-> `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()` uşaqların siyahısını yastıladıqda, iç içə massivlərin semantikasını qorumaq üçün açarları dəyişir. Yəni, `toArray`, qaytarılan massivin daxilində olan hər massivin elementlərin açarlarının düzgün əhatəsi üçün, bütün açarlara prefix əlavə edir.
 
 * * *
 

From 4fbf87739df3a41493a57af64ca287bcce5a9be4 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Mon, 8 Apr 2019 15:36:34 +0400
Subject: [PATCH 03/13] Translate PureComponent reference

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

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index d50de241f..19672b65e 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -104,15 +104,15 @@ class Greeting extends 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-inə`](#reactcomponent) bənzəyir. Bu ikisi arasında fərq [`React.Component-in`](#reactcomponent) [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) funskiyasını tətbiq etməsəsi, `React.PureComponent`-in isə bu funskiyasının dayaz prop və state müqayisəsi ilə tətbiq etməsidir.
 
-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.
+Əgər React komponentin `render()` funskiyası verilən proplar və state əsasında eyni nəticəni render edirsə, siz bəzi hallarda performans üçün `React.PureComponent`-dən istifadə edə bilərsiniz.
 
-> Note
+> Qeyd
 >
-> `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.
+> `React.PureComponent`-in `shouldComponentUpdate()` funskiyası obyektləri yalnız dayaz müqayisə edir. Əgər kompleks data strukturlar varsa, bu sizə dərin müqayisələrdə səhv-neqativlər verə bilər. Komponentinizə `PureComponent` ilə yalnız sadə proplar və state olduqda işlədin. Əks halda dərin data stukturlarının dəyişdiyini bildiyiniz zaman [`forceUpdate()`](/docs/react-component.html#forceupdate) funskiyasından istifadə edin. Və ya dərin məlumatların tez müqayisəsi üçün [dəyişməyən obyektlərdən](https://facebook.github.io/immutable-js/) istifadə edin.
 >
-> Furthermore, `React.PureComponent`'s `shouldComponentUpdate()` skips prop updates for the whole component subtree. Make sure all the children components are also "pure".
+> Əlavə olaraq, `React.PureComponent`-in `shouldComponentUpdate()` funskiyası komponentdən başlayan komponent ağacının prop yeniliklərini saymır. Əmin olunki, bütün uşaq komponentlərdə "təmizdirlər."
 
 * * *
 
@@ -124,7 +124,7 @@ const MyComponent = React.memo(function MyComponent(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` [yüksək dərəcəli komponentdir](/docs/higher-order-components.html). Bu [`React.PureComponent`](#reactpurecomponent) ilə oxşardır. Lakin bu klaslar əvəzinə funskiya komponentləri ilə işlənilir.
 
 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.
 

From 52043d06949a3b1322ddff4a334b9facab7c52ab Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Mon, 8 Apr 2019 15:48:23 +0400
Subject: [PATCH 04/13] Tranlate createElement

---
 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 19672b65e..ea0446473 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -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.
+Verilmiş tip ilə yeni [React elementi](/docs/rendering-elements.html) yarat və qaytar. Element tipi təq adı yazısı (məsələn `'div'` və ya `'span'`), [React komponenti](/docs/components-and-props.html) tipi (klas və ya funskiya), və ya [React fraqmenti](#reactfragment) tipi ola bilər.
 
-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](/docs/introducing-jsx.html) ilə yazılmış kod `React.createElement()`-ə çevriləcək. Siz JSX işlətdiyiniz zaman çox vaxt siz `React.createElement()` funskiyasını birbaşa çağırmırsınız. Ətraflı məlumat üçün [JSX-siz React](/docs/react-without-jsx.html) sənədinə baxın.
 
 * * *
 

From 9cead6552d55f1329a8bd5313d0fa7c665764761 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Mon, 8 Apr 2019 15:57:10 +0400
Subject: [PATCH 05/13] Translate cloneElement

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

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index ea0446473..84371130b 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -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.
+`element`-i başlanğıc nöqtəsi götürərək, elementi kopiyalayıb, yeni React elementi qaytar. Nəticədə yaranan elementdə orijinal elementin propları ilə yeni propların dayaz birləşməsi var. Yeni uşaqlar olan uşaqları əvəz edəcəklar. `key` və `ref` orijinal elementdəki kimi qalacaq.
 
-`React.cloneElement()` is almost equivalent to:
+`React.cloneElement()` aşağıdakı ifadə ilə təxminən eynidir:
 
 ```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.
+Lakin, bu həmçinin `ref`-ləridə saxlayır. Bu deməkdir ki, əgər sizə üstündə `ref` olan uşaq gəlirsə, siz təsadüfən, ref-i əcdad komponentdən oğurlamayacaqsınız. Siz yeni `ref` qoşulmuş yeni element alacaqsınız.
 
-This API was introduced as a replacement of the deprecated `React.addons.cloneWithProps()`.
+Bu API, köhnəlmiş `React.addons.cloneWithProps()` funskiyasının əvəzləmək üçün təqdim edilmişdir.
 
 * * *
 

From c780391a07da66ef0954f5fec2ee4e26d765d099 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Mon, 8 Apr 2019 16:01:18 +0400
Subject: [PATCH 06/13] Teanslate createFactory

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

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 84371130b..e6f5b0455 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -198,11 +198,14 @@ Bu API, köhnəlmiş `React.addons.cloneWithProps()` funskiyasının əvəzləm
 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.
+Verilmiş tip ilə React elementlər yaradan funskiya qaytarır. [`React.createElement()`] kimi, tip arqumenti təq adı yazısı (məsələn `'div'` və ya `'span'`), [React komponenti](/docs/components-and-props.html) tipi (klas və ya funskiya), və ya [React fraqmenti](#reactfragment) tipi ola bilər.
 
-This helper is considered legacy, and we encourage you to either use JSX or use `React.createElement()` directly instead.
+Bu köməkçi funskiya köhnəlmiş kimi hesab edilir, və biz bu funksiyanı işlətmək əvəzinə birbaşa JSX və ya `React.createElement()` işlətməyi təşviq edirik.
 
-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.
+Siz JSX işlətdiyiniz zaman, birbaşa
+
+
+Siz JSX işlətdiyiniz zaman çox vaxt siz `React.createFactory()` funskiyasını birbaşa çağırmırsınız. Ətraflı məlumat üçün [JSX-siz React](/docs/react-without-jsx.html) sənədinə baxın.
 
 * * *
 

From a958e840f95bd1c8b8bcb9387a2ba7c677547b97 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Mon, 8 Apr 2019 16:09:29 +0400
Subject: [PATCH 07/13] Translate React.lazy reference

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

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index e6f5b0455..b320e0510 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -318,20 +318,20 @@ For more information, see [forwarding refs](/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()` sizə dinamik yüklənən komponent müəyyən etməyə icazə verir. Bu ilkin render zamanı işlənməyən komponentlərinin yüklənməsinin gecikdirərək, sizin applikasiyanızın paket ölçüsünü azaltmağa kömək edir.
 
-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.
+Siz bunu necə işlətməyi [kod parçalanması sənədindən](/docs/code-splitting.html#reactlazy) öyrənə bilərsiniz. Siz həmçinin bunu işlətmək haqqında daha ətraflı izahat üçün [bu məqaləni](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) oxuya bilərsiniz.
 
 ```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.
+Qeyd edin ki, `lazy` komponentləri render etmək üçün komponent ağacında üstdə `<React.Suspense>` komponenti olmalıdır. Siz belə formada yükləmə göstəricisini müəyyənləşdirirsiniz.
 
-> **Note**
+> **Qeyd**
 >
-> 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`-ni dinamik import ilə işlətmək üçün Javascript mühitində Promise-in olması tələb olunur. Bu, IE11 və aşağı versiyalarda polifilin işlədilməsini tələb edir.
 
 ### `React.Suspense` {#reactsuspense}
 

From 2491d003a85cfd7cca1918500bcb6792a9c07c8a Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Sat, 4 May 2019 16:46:44 +0400
Subject: [PATCH 08/13] Translate Suspense API in React ref

---
 content/docs/reference-react.md | 15 ++++++++-------
 1 file changed, 8 insertions(+), 7 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index b320e0510..414bd0d93 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -335,15 +335,15 @@ Qeyd edin ki, `lazy` komponentləri render etmək üçün komponent ağacında 
 
 ### `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`, ağacda olan komponentlərin render-ə hazır olmadığı halda sizə yükləmə indikatoru müəyyənləşdirməyə icazə verir. Bugün, `<React.Suspense>` **yalnız** komponentlərin lazy yüklənməsini dəstəkləyir:
 
 ```js
-// This component is loaded dynamically
+// Bu komponent dinamik yüklənir
 const OtherComponent = React.lazy(() => import('./OtherComponent'));
 
 function MyComponent() {
   return (
-    // Displays <Spinner> until OtherComponent loads
+    // OtherComponent yüklənənədək <Spinner> render olunur
     <React.Suspense fallback={<Spinner />}>
       <div>
         <OtherComponent />
@@ -353,10 +353,11 @@ 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.
+Bu funksionallıq, [kod parçalanması sənədində](/docs/code-splitting.html#reactlazy) göstərilmişdir. Qeyd edinki, `lazy` komponentlər `Suspense` ağacının dərinliklərində də ola bilər. Suspense hər bir `lazy` komponenti əhatə etməməlidir. Yükləmə indikatoru görmək istədiyiniz yerdə `<Suspense>`-i əlavə etmək, amma `lazy()`-ni kod parçalaması etmək istədiyiniz yerdə işlətmək ən yaxşı praktikadır.
+
+İndiki gündə dəstəklənməməsinə baxmayaraq, biz gələcəkdə `Suspense`-in məlumat yüklənməsi kimi ssenarilərini dəstəkləməsini planlaşdırırıq. Bu haqda əlavə məlumat üçün, [yol xəritəmizi](/blog/2018/11/27/react-16-roadmap.html) oxuya bilərsiniz.
 
-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).
 
->Note:
+>Qeyd:
 >
->`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()` və `<React.Suspense>` `ReactDOMServer` tərəfindən dəstəklənmir. Bu məlum olan məhdudiyyət gələcəkdə həll olunacaq.

From d9fcfbb38c52180e9472b7b29ec0ffdb79a6518d Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Sat, 4 May 2019 17:02:04 +0400
Subject: [PATCH 09/13] Translate forwarding refs in reference

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

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 414bd0d93..c3dca8aa5 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -301,20 +301,20 @@ Siz həmçinin `<></>` qısa sintaksisi işlədə bilərsiniz. Daha ətraflı m
 
 ### `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` qəbul etdiyi [ref-i](/docs/refs-and-the-dom.html) aşağısında olan digər komponentə yönləndirən React komponenti yaradır. Bu texnika tez-tez istifadə olunmur; bu yalnız iki ssenaridə faydalıdır:
 
-* [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)
+* [Ref-lərin DOM komponentlərə yönləndirilməsi](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
+* [Yüksək dərəcəli komponentlərdə ref-lərin yönləndirilməsi](/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` render funskiyasını arqument kimi qəbul edir. React bu funskiyanı `props` və `ref` arqumentləri ilə çağırır. Bu funskiya React nodu qaytarmalıdır.
 
 `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.
+Bu nümunədə, React, `<FancyButton ref={ref}>` elementinə verilən `ref`-i `React.forwardRef` funskiyasında olan render funskiyasının ikinci arqumentinə ötürür. Bu rendering funskiyası `ref`-i `<button ref={ref}>` elementinə ötürür.
 
-As a result, after React attaches the ref, `ref.current` will point directly to the `<button>` DOM element instance.
+Nəticədə, React ref-i əlavə etdikdən sonra, `ref.current` birbaşa `button` DOM elementini qeyd edəcək.
 
-For more information, see [forwarding refs](/docs/forwarding-refs.html).
+Əlavə məlumat üçün, [ref-lərin yönləndirilməsini](/docs/forwarding-refs.html) oxuyun.
 
 ### `React.lazy` {#reactlazy}
 
diff --git a/examples/reference-react-forward-ref.js b/examples/reference-react-forward-ref.js
index f4d5f8e0e..a2c1ec6ec 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:
+// Siz indi DOM düyməsinə ref-i birbaşa əldə edə bilərsiniz:
 const ref = React.createRef();
 <FancyButton ref={ref}>Click me!</FancyButton>;

From 803563e6255607f5572979dcf9ae536c4585e305 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Sat, 4 May 2019 17:14:46 +0400
Subject: [PATCH 10/13] Translate React.mamo API reference

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

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index c3dca8aa5..203ecf91f 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -120,35 +120,35 @@ class Greeting extends React.Component {
 
 ```javascript
 const MyComponent = React.memo(function MyComponent(props) {
-  /* render using props */
+  /* proplar ilə render edin */
 });
 ```
 
 `React.memo` [yüksək dərəcəli komponentdir](/docs/higher-order-components.html). Bu [`React.PureComponent`](#reactpurecomponent) ilə oxşardır. Lakin bu klaslar əvəzinə funskiya komponentləri ilə işlənilir.
 
-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.
+Əgər sizin komponent funskiyanız eyni proplar ilə həmişə eyni nəticəni verirsə, siz funskiyanı `React.memo` ilə əhatə edib bəzi hallarda nətinəni memoize edərək performansı artıra bilərsiniz. Bu deməkdirki, React komponentin renderini atlayıb, keçmiş renderdə olan nəticəni işlədəcək.
 
-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.
+Default halda, bu props obyektində olan kompleks obyektləri dayaz formada müqayisə edəcək. Əgər siz müqayisəni kontrol etmək istəyirsinizsə, siz xüsusi müqayisə funksiyasını ikinci arqument kimi göndərə bilərsiniz.
 
 ```javascript
 function MyComponent(props) {
-  /* render using props */
+  /* proplar ilə render edin */
 }
 function areEqual(prevProps, nextProps) {
   /*
-  return true if passing nextProps to render would return
-  the same result as passing prevProps to render,
-  otherwise return false
+  Əgər nextProps-u render-ə göndərdikdə qaytarılan nəticə,
+  prevProps-u render-ə göndərdikdə qaytarılan nəticə ilə eynidirsə,
+  true qaytarın. Əks halda false qaytarın.
   */
 }
 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.
+Bu metod yalnız **[performans optimizasiyası](/docs/optimizing-performance.html)** yararlıdır. Bu funskiyaya render-in qarşısını almaq üçün etibar etməyin -- bu sizdə baqlara səbəb ola bilər.
 
-> Note
+> Qeyd
 >
-> 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`.
+> Klass komponentlərdə [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) funskiyasından fərqli olaraq, `areEqual` funksiyası proplar eyni olduqda `true`, fərqli olduqda isə `false` qaytarır. Bu `shouldComponentUpdate` funskiyasının tərsidir.
 
 * * *
 

From 7664ace4ea61ff986533ddeaf725cd5f5673d7c2 Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Mon, 27 May 2019 04:22:39 +0400
Subject: [PATCH 11/13] Fix reference React mistakes

---
 content/docs/reference-react.md | 74 ++++++++++++++++-----------------
 1 file changed, 36 insertions(+), 38 deletions(-)

diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 94df225de..8d2b440bc 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -26,13 +26,13 @@ React komponentləri sizə UI-ı müstəqil, yenidən işlənə bilən hissələ
 
 Əgər siz ES6 klasları istifadə etmirsinizsə, siz `create-react-class` modulundan istifadə edə bilərsiniz. Əlavə məlumat üçün, [ES6-sız React-in istifadəsi](/docs/react-without-es6.html) bölməsini oxuyun.
 
-React komponentləri həmçinin funskiyalar ilə də müəyyənləşdirilə bilərlər. Bu funskiyalar aşağıdakılar ilə əhatə oluna bilərələr:
+React komponentləri həmçinin funksiyalar ilə də müəyyənləşdirilə bilərlər. Bu funksiyalar aşağıdakılar ilə əhatə oluna bilərlər:
 
 - [`React.memo`](#reactmemo)
 
 ### React Elementlərinin Düzəldilməsi {#creating-react-elements}
 
-Biz UI-ın nə olacağını təsvir etmək üçün [JSX işlətməyi](/docs/introducing-jsx.html) tövsiyyə edirik. Hər bir JSX elementi [`React.createElement()`](#createelement) funskiyasını çağırmaq üçün gözəl sintaksisdir. JSX işlətdikdə adətən aşağıdakı funskiyaları birbaşa çağırmırsınız.
+Biz UI-ın nə olacağını təsvir etmək üçün [JSX işlətməyi](/docs/introducing-jsx.html) tövsiyyə edirik. Hər bir JSX elementi [`React.createElement()`](#createelement) funksiyasını çağırmaq üçün gözəl sintaksisdir. JSX işlətdikdə adətən aşağıdakı funksiyaları birbaşa çağırmırsınız.
 
 - [`createElement()`](#createelement)
 - [`createFactory()`](#createfactory)
@@ -49,7 +49,8 @@ Daha ətraflı məlumat üçün [JSX-siz React-in İşlənməsini](/docs/react-w
 
 ### Fraqmentlər {#fragments}
 
-`React` həmçinin bir neçə elmeentin əhatə olan elementsiz bir neçə elementi render etmək üçün kompoennt tmin edir.
+
+React həmçinin əhatə edən element olmadan bir neçə elementi render etmək üçün komponent təmin edir.
 
 - [`React.Fragment`](#reactfragment)
 
@@ -60,7 +61,7 @@ Daha ətraflı məlumat üçün [JSX-siz React-in İşlənməsini](/docs/react-w
 
 ### Suspense {#suspense}
 
-Suspense komponentləri render etməmişdən qabaq neyisə "gözləməsinə" imkan yaradır. Bugün, Suspense yalnız bir ssenarini dəstələyir: [komponentlərin `React.lazy` ilə dinamik yüklənməsi](/docs/code-splitting.html#reactlazy). Gələcəkdə, bu başqa ssenariləri (məsələn məklumatın yüklənməsi) də dəstəkləyəcək.
+Suspense komponentləri render etməmişdən qabaq nəyisə "gözləməsinə" imkan yaradır. Bu gün, Suspense yalnız bir ssenarini dəstələyir: [komponentlərin `React.lazy` ilə dinamik yüklənməsi](/docs/code-splitting.html#reactlazy). Gələcəkdə bu başqa ssenariləri (məsələn məklumatın yüklənməsi) də dəstəkləyəcək.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)
@@ -98,21 +99,21 @@ class Greeting extends React.Component {
 }
 ```
 
-`React.Component` əsas klasına aid Funskiya və parametrlərin siyahısı üçün [React.Component API Arayışına](/docs/react-component.html) baxın.
+`React.Component` əsas klasına aid funksiya və parametrlərin siyahısı üçün [React.Component API Arayışına](/docs/react-component.html) baxın.
 
 * * *
 
 ### `React.PureComponent` {#reactpurecomponent}
 
-`React.PureComponent` [`React.Component-inə`](#reactcomponent) bənzəyir. Bu ikisi arasında fərq [`React.Component-in`](#reactcomponent) [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) funskiyasını tətbiq etməsəsi, `React.PureComponent`-in isə bu funskiyasının dayaz prop və state müqayisəsi ilə tətbiq etməsidir.
+`React.PureComponent` [`React.Component-inə`](#reactcomponent) bənzəyir. Bu ikisi arasında fərq [`React.Component-in`](#reactcomponent) [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) funksiyasını tətbiq etməməsi, `React.PureComponent`-in isə bu funksiyasının dayaz prop və state müqayisəsi ilə tətbiq etməsidir.
 
-Əgər React komponentin `render()` funskiyası verilən proplar və state əsasında eyni nəticəni render edirsə, siz bəzi hallarda performans üçün `React.PureComponent`-dən istifadə edə bilərsiniz.
+Əgər React komponentin `render()` funksiyası verilən proplar və state əsasında eyni nəticəni render edirsə, siz bəzi hallarda performans üçün `React.PureComponent`-dən istifadə edə bilərsiniz.
 
 > Qeyd
 >
-> `React.PureComponent`-in `shouldComponentUpdate()` funskiyası obyektləri yalnız dayaz müqayisə edir. Əgər kompleks data strukturlar varsa, bu sizə dərin müqayisələrdə səhv-neqativlər verə bilər. Komponentinizə `PureComponent` ilə yalnız sadə proplar və state olduqda işlədin. Əks halda dərin data stukturlarının dəyişdiyini bildiyiniz zaman [`forceUpdate()`](/docs/react-component.html#forceupdate) funskiyasından istifadə edin. Və ya dərin məlumatların tez müqayisəsi üçün [dəyişməyən obyektlərdən](https://facebook.github.io/immutable-js/) istifadə edin.
+> `React.PureComponent`-in `shouldComponentUpdate()` funksiyası obyektləri yalnız dayaz müqayisə edir. Əgər kompleks data strukturlar varsa, bu sizə dərin müqayisələrdə səhv-neqativlər verə bilər. Komponentinizi `PureComponent` ilə yalnız sadə proplar və state olduqda genişləndirin. Əks halda dərin data strukturlarının dəyişdiyini bildiyiniz zaman [`forceUpdate()`](/docs/react-component.html#forceupdate) funksiyasından istifadə edin. Əlavə olaraq, dərin məlumatların tez müqayisəsi üçün [dəyişməyən obyektlərdən](https://facebook.github.io/immutable-js/) istifadə edin.
 >
-> Əlavə olaraq, `React.PureComponent`-in `shouldComponentUpdate()` funskiyası komponentdən başlayan komponent ağacının prop yeniliklərini saymır. Əmin olunki, bütün uşaq komponentlərdə "təmizdirlər."
+> Əlavə olaraq, `React.PureComponent`-in `shouldComponentUpdate()` funksiyası komponentdən başlayan komponent ağacının prop yeniliklərini saymır. Əmin olun ki, bütün uşaq komponentlər də "təmizdirlər."
 
 * * *
 
@@ -124,9 +125,9 @@ const MyComponent = React.memo(function MyComponent(props) {
 });
 ```
 
-`React.memo` [yüksək dərəcəli komponentdir](/docs/higher-order-components.html). Bu [`React.PureComponent`](#reactpurecomponent) ilə oxşardır. Lakin bu klaslar əvəzinə funskiya komponentləri ilə işlənilir.
+`React.memo` [yüksək dərəcəli komponentdir](/docs/higher-order-components.html). Bu [`React.PureComponent`](#reactpurecomponent) ilə oxşardır. Lakin bu klaslar əvəzinə funksiya komponentləri ilə işlənilir.
 
-Əgər sizin komponent funskiyanız eyni proplar ilə həmişə eyni nəticəni verirsə, siz funskiyanı `React.memo` ilə əhatə edib bəzi hallarda nətinəni memoize edərək performansı artıra bilərsiniz. Bu deməkdirki, React komponentin renderini atlayıb, keçmiş renderdə olan nəticəni işlədəcək.
+Əgər sizin komponent funksiyanız eyni proplar ilə həmişə eyni nəticəni verirsə, siz funksiyanı `React.memo` ilə əhatə edib bəzi hallarda nəticəni memoize edərək performansı artıra bilərsiniz. Bu deməkdir ki, React komponentin renderini atlayıb, keçmiş renderdə olan nəticəni işlədəcək.
 
 Default halda, bu props obyektində olan kompleks obyektləri dayaz formada müqayisə edəcək. Əgər siz müqayisəni kontrol etmək istəyirsinizsə, siz xüsusi müqayisə funksiyasını ikinci arqument kimi göndərə bilərsiniz.
 
@@ -144,11 +145,11 @@ function areEqual(prevProps, nextProps) {
 export default React.memo(MyComponent, areEqual);
 ```
 
-Bu metod yalnız **[performans optimizasiyası](/docs/optimizing-performance.html)** yararlıdır. Bu funskiyaya render-in qarşısını almaq üçün etibar etməyin -- bu sizdə baqlara səbəb ola bilər.
+Bu metod yalnız **[performans optimizasiyası](/docs/optimizing-performance.html)** üçün yararlıdır. Bu funksiyaya render-in qarşısını almaq üçün etibar etməyin -- bu sizdə baqlara səbəb ola bilər.
 
 > Qeyd
 >
-> Klass komponentlərdə [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) funskiyasından fərqli olaraq, `areEqual` funksiyası proplar eyni olduqda `true`, fərqli olduqda isə `false` qaytarır. Bu `shouldComponentUpdate` funskiyasının tərsidir.
+> Klass komponentlərdə [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) funksiyasından fərqli olaraq, `areEqual` funksiyası proplar eyni olduqda `true`, fərqli olduqda isə `false` qaytarır. Bu `shouldComponentUpdate` funksiyasının tərsidir.
 
 * * *
 
@@ -162,9 +163,9 @@ React.createElement(
 )
 ```
 
-Verilmiş tip ilə yeni [React elementi](/docs/rendering-elements.html) yarat və qaytar. Element tipi təq adı yazısı (məsələn `'div'` və ya `'span'`), [React komponenti](/docs/components-and-props.html) tipi (klas və ya funskiya), və ya [React fraqmenti](#reactfragment) tipi ola bilər.
+Verilmiş tip ilə yeni [React elementi](/docs/rendering-elements.html) yaradın və qaytarın. Element tipi təq ad yazısı (məsələn `'div'` və ya `'span'`), [React komponent](/docs/components-and-props.html) tipi (klas və ya funksiya) və ya [React fraqment](#reactfragment) tipi ola bilər.
 
-[JSX](/docs/introducing-jsx.html) ilə yazılmış kod `React.createElement()`-ə çevriləcək. Siz JSX işlətdiyiniz zaman çox vaxt siz `React.createElement()` funskiyasını birbaşa çağırmırsınız. Ətraflı məlumat üçün [JSX-siz React](/docs/react-without-jsx.html) sənədinə baxın.
+[JSX](/docs/introducing-jsx.html) ilə yazılmış kod `React.createElement()`-ə çevriləcək. Siz JSX işlətdiyiniz zaman çox vaxt `React.createElement()` funksiyasını birbaşa çağırmırsınız. Ətraflı məlumat üçün [JSX-siz React](/docs/react-without-jsx.html) sənədinə baxın.
 
 * * *
 
@@ -178,7 +179,7 @@ React.cloneElement(
 )
 ```
 
-`element`-i başlanğıc nöqtəsi götürərək, elementi kopiyalayıb, yeni React elementi qaytar. Nəticədə yaranan elementdə orijinal elementin propları ilə yeni propların dayaz birləşməsi var. Yeni uşaqlar olan uşaqları əvəz edəcəklar. `key` və `ref` orijinal elementdəki kimi qalacaq.
+`element`-i başlanğıc nöqtəsi götürərək, elementi kopiyalayıb, yeni React elementi qaytar. Nəticədə yaranan elementdə orijinal elementin propları ilə yeni propların dayaz birləşməsi var. Yeni uşaqlar mövcud uşaqları əvəz edəcək. `key` və `ref` orijinal elementdəki kimi qalacaq.
 
 `React.cloneElement()` aşağıdakı ifadə ilə təxminən eynidir:
 
@@ -188,7 +189,7 @@ React.cloneElement(
 
 Lakin, bu həmçinin `ref`-ləridə saxlayır. Bu deməkdir ki, əgər sizə üstündə `ref` olan uşaq gəlirsə, siz təsadüfən, ref-i əcdad komponentdən oğurlamayacaqsınız. Siz yeni `ref` qoşulmuş yeni element alacaqsınız.
 
-Bu API, köhnəlmiş `React.addons.cloneWithProps()` funskiyasının əvəzləmək üçün təqdim edilmişdir.
+Bu API, köhnəlmiş `React.addons.cloneWithProps()` funksiyasının əvəzləmək üçün təqdim edilmişdir.
 
 * * *
 
@@ -198,14 +199,11 @@ Bu API, köhnəlmiş `React.addons.cloneWithProps()` funskiyasının əvəzləm
 React.createFactory(type)
 ```
 
-Verilmiş tip ilə React elementlər yaradan funskiya qaytarır. [`React.createElement()`](#createelement) kimi, tip arqumenti təq adı yazısı (məsələn `'div'` və ya `'span'`), [React komponenti](/docs/components-and-props.html) tipi (klas və ya funskiya), və ya [React fraqmenti](#reactfragment) tipi ola bilər.
-
-Bu köməkçi funskiya köhnəlmiş kimi hesab edilir, və biz bu funksiyanı işlətmək əvəzinə birbaşa JSX və ya `React.createElement()` işlətməyi təşviq edirik.
-
-Siz JSX işlətdiyiniz zaman, birbaşa
+Verilmiş tip ilə React elementlər yaradan funksiya qaytarır. [`React.createElement()`](#createelement) kimi, tip arqumenti təq ad yazısı (məsələn `'div'` və ya `'span'`), [React komponent](/docs/components-and-props.html) tipi (klas və ya funksiya) və ya [React fraqment](#reactfragment) tipi ola bilər.
 
+Bu köməkçi funksiya köhnəlmiş kimi hesab edilir və biz bu funksiyanı işlətmək əvəzinə birbaşa JSX və ya `React.createElement()` işlətməyi təşviq edirik.
 
-Siz JSX işlətdiyiniz zaman çox vaxt siz `React.createFactory()` funskiyasını birbaşa çağırmırsınız. Ətraflı məlumat üçün [JSX-siz React](/docs/react-without-jsx.html) sənədinə baxın.
+Siz JSX işlətdiyiniz zaman çox vaxt `React.createFactory()` funksiyasını birbaşa çağırmırsınız. Ətraflı məlumat üçün [JSX-siz React](/docs/react-without-jsx.html) sənədinə baxın.
 
 * * *
 
@@ -221,7 +219,7 @@ Elementin React elementi olmasını təsdiqləyir. `true` və ya `false` qaytar
 
 ### `React.Children` {#reactchildren}
 
-`React.Children` `this.props.children` qeyri şəffaf data strukturu ilə məşğul olmaq üçün faydalı funskiyalar ilə təmin edir.
+`React.Children` `this.props.children` qeyri şəffaf data strukturu ilə məşğul olmaq üçün faydalı funksiyalar ilə təmin edir.
 
 #### `React.Children.map` {#reactchildrenmap}
 
@@ -229,7 +227,7 @@ Elementin React elementi olmasını təsdiqləyir. `true` və ya `false` qaytar
 React.Children.map(children, function[(thisArg)])
 ```
 
-`children`-da olan hər birbaşa ola uşağın üzərində funskiya çağırır. Bu funskiyada `this`, `thisArg` ilə təyin edilir. Əgər `children` masivdirsə, massiv traver edəcək və funskiya hər uşaqda çağrılacaq. Əgər `children` `null` və ya `undefined`-dirsə, bu funskiya massiv əvəzinə `null` və ya `undefined` qaytaracaq.
+`children`-da olan hər birbaşa ola uşağın üzərində funksiya çağırır. Bu funksiyada `this`, `thisArg` ilə təyin edilir. Əgər `children` massivdirsə, massiv traver edəcək və funksiya hər uşaqda çağrılacaq. Əgər `children` `null` və ya `undefined`-dirsə, bu funksiya massiv əvəzinə `null` və ya `undefined` qaytaracaq.
 
 > Qeyd
 >
@@ -257,11 +255,11 @@ React.Children.count(children)
 React.Children.only(children)
 ```
 
-`children`-in yalnız bir uşağı (React elementi) olmasını təsqidləyir və bu elementi qaytarır. Əks halda, bu funksiya xəta atir.
+`children`-in yalnız bir uşağı (React elementi) olmasını təsqidləyir və bu elementi qaytarır. Əks halda, bu funksiya xəta atır.
 
 > Qeyd:
 >
->`React.Children.only()` [`React.Children.map()`](#reactchildrenmap) funskiyasının qaytardığı dəyəri qəbul etmir. Çünki bu funskiyaının qaytardığı massivdir, React elementi deyil.
+>`React.Children.only()` [`React.Children.map()`](#reactchildrenmap) funksiyasının qaytardığı dəyəri qəbul etmir. Çünki bu funksiyaının qaytardığı massivdir, React elementi deyil.
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 
@@ -269,24 +267,24 @@ React.Children.only(children)
 React.Children.toArray(children)
 ```
 
- `children` data strukturundan yastı massiv yaradır, uşaqları açarlar ilə təyin edir, və yaranan massivi qaytarır. Uşaqların kolleksiyalarıni render zamanı manipulyasiya etmək, xüsusilədə `this.props.children`-ı render etməmişdən oncə sıralamaq və ya parçalamaq, üçün yararlıdır.
+ `children` data strukturundan yastı massiv yaradır, uşaqları açarlar ilə təyin edir və yaranan massivi qaytarır. Uşaqların kolleksiyalarını render zamanı manipulyasiya etmək, xüsusilə də `this.props.children`-ı render etməmişdən öncə sıralamaq və ya parçalamaq üçün yararlıdır.
 
 > Qeyd:
 >
-> `React.Children.toArray()` uşaqların siyahısını yastıladıqda, iç içə massivlərin semantikasını qorumaq üçün açarları dəyişir. Yəni, `toArray`, qaytarılan massivin daxilində olan hər massivin elementlərin açarlarının düzgün əhatəsi üçün, bütün açarlara prefix əlavə edir.
+> `React.Children.toArray()` uşaqların siyahısını yastıladıqda, iç-içə massivlərin semantikasını qorumaq üçün açarları dəyişir. Yəni, `toArray`, qaytarılan massivin daxilində olan hər massiv elementlərin açarlarının düzgün əhatəsi üçün bütün açarlara prefix əlavə edir.
 
 * * *
 
 ### `React.Fragment` {#reactfragment}
 
-`React.Fragment` komponenti bir neçə elementi, əlavə DOM elementi yaratmadan `render()` funskiyasından qaytarmağa imkan yaradır:
+`React.Fragment` komponenti bir neçə elementi, əlavə DOM elementi yaratmadan `render()` funksiyasından qaytarmağa imkan yaradır:
 
 ```javascript
 render() {
   return (
     <React.Fragment>
-      Some text.
-      <h2>A heading</h2>
+      Bir mətn.
+      <h2>Başlıq</h2>
     </React.Fragment>
   );
 }
@@ -306,11 +304,11 @@ Siz həmçinin `<></>` qısa sintaksisi işlədə bilərsiniz. Daha ətraflı m
 * [Ref-lərin DOM komponentlərə yönləndirilməsi](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
 * [Yüksək dərəcəli komponentlərdə ref-lərin yönləndirilməsi](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
 
-`React.forwardRef` render funskiyasını arqument kimi qəbul edir. React bu funskiyanı `props` və `ref` arqumentləri ilə çağırır. Bu funskiya React nodu qaytarmalıdır.
+`React.forwardRef` render funksiyasını arqument kimi qəbul edir. React bu funksiyanı `props` və `ref` arqumentləri ilə çağırır. Bu funksiya React nodu qaytarmalıdır.
 
 `embed:reference-react-forward-ref.js`
 
-Bu nümunədə, React, `<FancyButton ref={ref}>` elementinə verilən `ref`-i `React.forwardRef` funskiyasında olan render funskiyasının ikinci arqumentinə ötürür. Bu rendering funskiyası `ref`-i `<button ref={ref}>` elementinə ötürür.
+Bu nümunədə, React, `<FancyButton ref={ref}>` elementinə verilən `ref`-i `React.forwardRef` funksiyasında olan render funksiyasının ikinci arqumentinə ötürür. Bu rendering funksiyası `ref`-i `<button ref={ref}>` elementinə ötürür.
 
 Nəticədə, React ref-i əlavə etdikdən sonra, `ref.current` birbaşa `button` DOM elementini qeyd edəcək.
 
@@ -318,16 +316,16 @@ Nəticədə, React ref-i əlavə etdikdən sonra, `ref.current` birbaşa `button
 
 ### `React.lazy` {#reactlazy}
 
-`React.lazy()` sizə dinamik yüklənən komponent müəyyən etməyə icazə verir. Bu ilkin render zamanı işlənməyən komponentlərinin yüklənməsinin gecikdirərək, sizin applikasiyanızın paket ölçüsünü azaltmağa kömək edir.
+`React.lazy()` sizə dinamik yüklənən komponenti müəyyən etməyə icazə verir. Bu ilkin render zamanı işlənməyən komponentlərin yüklənməsini gecikdirərək, sizin applikasiyanızın paket ölçüsünü azaltmağa kömək edir.
 
 Siz bunu necə işlətməyi [kod parçalanması sənədindən](/docs/code-splitting.html#reactlazy) öyrənə bilərsiniz. Siz həmçinin bunu işlətmək haqqında daha ətraflı izahat üçün [bu məqaləni](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) oxuya bilərsiniz.
 
 ```js
-// This component is loaded dynamically
+// Bu komponent dinamik olaraq yüklənir
 const SomeComponent = React.lazy(() => import('./SomeComponent'));
 ```
 
-Qeyd edin ki, `lazy` komponentləri render etmək üçün komponent ağacında üstdə `<React.Suspense>` komponenti olmalıdır. Siz belə formada yükləmə göstəricisini müəyyənləşdirirsiniz.
+Nəzərə alın ki, `lazy` komponentləri render etmək üçün komponent ağacında üstdə `<React.Suspense>` komponenti olmalıdır. Siz belə formada yükləmə göstəricisini müəyyənləşdirirsiniz.
 
 > **Qeyd**
 >
@@ -353,7 +351,7 @@ function MyComponent() {
 }
 ```
 
-Bu funksionallıq, [kod parçalanması sənədində](/docs/code-splitting.html#reactlazy) göstərilmişdir. Qeyd edinki, `lazy` komponentlər `Suspense` ağacının dərinliklərində də ola bilər. Suspense hər bir `lazy` komponenti əhatə etməməlidir. Yükləmə indikatoru görmək istədiyiniz yerdə `<Suspense>`-i əlavə etmək, amma `lazy()`-ni kod parçalaması etmək istədiyiniz yerdə işlətmək ən yaxşı praktikadır.
+Bu funksionallıq, [kod parçalanması sənədində](/docs/code-splitting.html#reactlazy) göstərilmişdir. Qeyd edin ki, `lazy` komponentlər `Suspense` ağacının dərinliklərində də ola bilər. Suspense hər bir `lazy` komponenti əhatə etməməlidir. Yükləmə indikatoru görmək istədiyiniz yerdə `<Suspense>`-i əlavə etmək, amma `lazy()`-ni kod parçalaması etmək istədiyiniz yerdə işlətmək ən yaxşı praktikadır.
 
 İndiki gündə dəstəklənməməsinə baxmayaraq, biz gələcəkdə `Suspense`-in məlumat yüklənməsi kimi ssenarilərini dəstəkləməsini planlaşdırırıq. Bu haqda əlavə məlumat üçün, [yol xəritəmizi](/blog/2018/11/27/react-16-roadmap.html) oxuya bilərsiniz.
 

From 911849de3335db8c91c33ad1ac83c79c6948f5ef Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Wed, 31 Jul 2019 13:00:33 +0300
Subject: [PATCH 12/13] Fix plural verbs in some cases

---
 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 8d2b440bc..40ac15e4f 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -26,7 +26,7 @@ React komponentləri sizə UI-ı müstəqil, yenidən işlənə bilən hissələ
 
 Əgər siz ES6 klasları istifadə etmirsinizsə, siz `create-react-class` modulundan istifadə edə bilərsiniz. Əlavə məlumat üçün, [ES6-sız React-in istifadəsi](/docs/react-without-es6.html) bölməsini oxuyun.
 
-React komponentləri həmçinin funksiyalar ilə də müəyyənləşdirilə bilərlər. Bu funksiyalar aşağıdakılar ilə əhatə oluna bilərlər:
+React komponentləri həmçinin funksiyalar ilə də müəyyənləşdirilə bilər. Bu funksiyalar aşağıdakılar ilə əhatə oluna bilər:
 
 - [`React.memo`](#reactmemo)
 

From 01d137911f1a4fa41d1fad09ac14d21520b08fab Mon Sep 17 00:00:00 2001
From: Gasim Gasimzada <gasim@appristas.io>
Date: Wed, 31 Jul 2019 15:34:27 +0300
Subject: [PATCH 13/13] Fix punctuation issues

---
 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 40ac15e4f..776bde163 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -61,7 +61,7 @@ React həmçinin əhatə edən element olmadan bir neçə elementi render etmək
 
 ### Suspense {#suspense}
 
-Suspense komponentləri render etməmişdən qabaq nəyisə "gözləməsinə" imkan yaradır. Bu gün, Suspense yalnız bir ssenarini dəstələyir: [komponentlərin `React.lazy` ilə dinamik yüklənməsi](/docs/code-splitting.html#reactlazy). Gələcəkdə bu başqa ssenariləri (məsələn məklumatın yüklənməsi) də dəstəkləyəcək.
+Suspense komponentləri render etməmişdən qabaq nəyisə "gözləməsinə" imkan yaradır. Bu gün Suspense yalnız bir ssenarini dəstələyir: [komponentlərin `React.lazy` ilə dinamik yüklənməsi](/docs/code-splitting.html#reactlazy). Gələcəkdə bu başqa ssenariləri (məsələn məklumatın yüklənməsi) də dəstəkləyəcək.
 
 - [`React.lazy`](#reactlazy)
 - [`React.Suspense`](#reactsuspense)