From 730d233afa8ce6d6fd97527053c72af2a96dfa52 Mon Sep 17 00:00:00 2001
From: anchal7299 <agarwalanchal72@gmail.com>
Date: Thu, 21 Mar 2019 13:55:02 +0530
Subject: [PATCH 01/16] Translated Lists-and-Keys page

---
 content/docs/lists-and-keys.md | 81 +++++++++++++++++-----------------
 1 file changed, 41 insertions(+), 40 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index f34e9e5d6..d52bae819 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -6,25 +6,25 @@ prev: conditional-rendering.html
 next: forms.html
 ---
 
-First, let's review how you transform lists in JavaScript.
+पहले, आइए समीक्षा करें कि आप जावास्क्रिप्ट में लिस्ट्स को कैसे बदलते हैं।
 
-Given the code below, we use the [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) function to take an array of `numbers` and double their values. We assign the new array returned by `map()` to the variable `doubled` and log it:
+
+नीचे दिए गए कोड में हम `numbers` की एक array लेने और उनके मूल्यों को दोगुना करने के लिए मैप फ़ंक्शन का उपयोग करते हैं। हम मैप द्वारा दिए गए नए array को `double` नाम के वेरिएबल को सौपते हैं और फिर लॉग करते हैं।
 
 ```javascript{2}
 const numbers = [1, 2, 3, 4, 5];
 const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
+यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग कर देगा।
 
-This code logs `[2, 4, 6, 8, 10]` to the console.
-
-In React, transforming arrays into lists of [elements](/docs/rendering-elements.html) is nearly identical.
+रियेक्ट में,array को लिस्ट ऑफ़ [एलिमेंट्स](/docs/rendering-elements.html) में बदलना लगभग समान है।
 
-### Rendering Multiple Components {#rendering-multiple-components}
+### कई कौम्पोनॅन्ट का की रेंडरिंग {# कई कौम्पोनॅन्ट का की रेंडरिंग }
 
-You can build collections of elements and [include them in JSX](/docs/introducing-jsx.html#embedding-expressions-in-jsx) using curly braces `{}`.
+आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें Jsx में शामिल करें](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
 
-Below, we loop through the `numbers` array using the JavaScript [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) function. We return a `<li>` element for each item. Finally, we assign the resulting array of elements to `listItems`:
+हमने जावास्क्रिप्ट [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फंक्शन का उपयोग करके `numbers` नाम की array में लूप लगाया है। हमने प्रत्येक आइटम के लिए  `<li>` एलिमेंट को रिटर्न किया है।  अंत में, हम परिणामस्वरूप  आयी हुई एलिमेंट्स की array को `listItems` को सौपते है। 
 
 ```javascript{2-4}
 const numbers = [1, 2, 3, 4, 5];
@@ -33,7 +33,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-We include the entire `listItems` array inside a `<ul>` element, and [render it to the DOM](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
+पुरे `listItems` ऐरे को `<ul>` एलिमेंट में शामिल करके इसे [DOM को रेंडर करे](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
 
 ```javascript{2}
 ReactDOM.render(
@@ -42,15 +42,15 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
+[**कोडपेन पर इसे आजमाएं**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
 
-This code displays a bullet list of numbers between 1 and 5.
+यह कोड 1 से 5 के बीच संख्याओं की एक बुलेट लिस्ट प्रदर्शित करता है।
 
-### Basic List Component {#basic-list-component}
+###मूल लिस्टस कौम्पोनॅन्ट{#मूल लिस्टस कौम्पोनॅन्ट}
 
-Usually you would render lists inside a [component](/docs/components-and-props.html).
+आमतौर पर आप एक [कौम्पोनॅन्ट](/docs/components-and-props.html) के अंदर लिस्ट प्रस्तुत करेंगे। 
 
-We can refactor the previous example into a component that accepts an array of `numbers` and outputs a list of elements.
+हम पिछले उदाहरण को एक कौम्पोनॅन्ट में बदल सकते हैं जो `numbers ` की एक array को स्वीकार करता है और एलिमेंटस की लिस्ट को आउटपुट करता है।
 
 ```javascript{3-5,7,13}
 function NumberList(props) {
@@ -70,9 +70,10 @@ ReactDOM.render(
 );
 ```
 
-When you run this code, you'll be given a warning that a key should be provided for list items. A "key" is a special string attribute you need to include when creating lists of elements. We'll discuss why it's important in the next section.
+जब आप यह कोड चलाते हैं, तो आपको एक चेतावनी दी जाती है कि लिस्ट आइटम के लिए एक key प्रदान की जानी चाहिए। "key" एक विशेष स्ट्रिंग विशेषता है जिसे आपको 
+एलिमेंटस की सूची बनाते समय शामिल करने की आवश्यकता होती है। हम चर्चा करेंगे अगले भाग में कि यह महत्वपूर्ण क्यों है।
 
-Let's assign a `key` to our list items inside `numbers.map()` and fix the missing key issue.
+आइए `numbers.map() ` के अंदर हमारी लिस्ट आइटम की एक `key`असाइन करें और लापता key की समस्या को ठीक करें।
 
 ```javascript{4}
 function NumberList(props) {
@@ -94,11 +95,11 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
+[**कोडपेन पर इसे आजमाएं**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
 
-## Keys {#keys}
+## Keys{#Keys}
 
-Keys help React identify which items have changed, are added, or are removed. Keys should be given to the elements inside the array to give the elements a stable identity:
+Keys प्रतिक्रिया को पहचानने में मदद करती हैं कि कौन से आइटम बदले गए हैं, जोड़े गए हैं, या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर तत्वों को key  दी जानी चाहिए:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -109,7 +110,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-The best way to pick a key is to use a string that uniquely identifies a list item among its siblings. Most often you would use IDs from your data as keys:
+key चुनने का सबसे अच्छा तरीका एक स्ट्रिंग का उपयोग करना है जो विशिष्ट रूप से अपने भाई-बहनों के बीच एक लिस्ट आइटम की पहचान करता है। अक्सर आप चाबी के रूप में अपने डेटा से आईडी का उपयोग करेंगे:
 
 ```js{2}
 const todoItems = todos.map((todo) =>
@@ -119,7 +120,7 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-When you don't have stable IDs for rendered items, you may use the item index as a key as a last resort:
+जब आपके पास प्रदान की गई वस्तुओं के लिए स्थिर आईडी नहीं है, तो आप अंतिम उपाय के रूप में key के रूप में आइटम इंडेक्स का उपयोग कर सकते हैं:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
@@ -130,17 +131,16 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-We don't recommend using indexes for keys if the order of items may change. This can negatively impact performance and may cause issues with component state. Check out Robin Pokorny's article for an [in-depth explanation on the negative impacts of using an index as a key](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). If you choose not to assign an explicit key to list items then React will default to using indexes as keys.
-
-Here is an [in-depth explanation about why keys are necessary](/docs/reconciliation.html#recursing-on-children) if you're interested in learning more.
+यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग करने की अनुशंसा नहीं करते हैं। यह प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है और कौम्पोनॅन्ट की अवस्था के साथ समस्या पैदा कर सकता है। [इंडेक्स को key  के रूप में उपयोग करने के नकारात्मक प्रभावों](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). पर गहन व्याख्या के लिए रॉबिन पोकोर्न के लेख को देखें। यदि आप आइटमों को सूचीबद्ध करने के लिए एक स्पष्ट key  निर्दिष्ट नहीं करने का विकल्प चुनते हैं तो रिएक्ट key  के रूप में इंडेक्स का उपयोग करने के लिए डिफ़ॉल्ट होगा।
 
-### Extracting Components with Keys {#extracting-components-with-keys}
+यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children) , इस बारे में गहराई से व्याख्या की गई है।
+###key  के साथ कौम्पोनॅन्ट निकालना{#key के साथ कौम्पोनॅन्ट निकालना}
 
-Keys only make sense in the context of the surrounding array.
+keys केवल आस-पास के array के संदर्भ में समझ में आती हैं।
 
-For example, if you [extract](/docs/components-and-props.html#extracting-components) a `ListItem` component, you should keep the key on the `<ListItem />` elements in the array rather than on the `<li>` element in the `ListItem` itself.
+उदाहरण के लिए, यदि आप एक ListItem कौम्पोनॅन्ट को [निकालते](/docs/components-and-props.html#extracting-components) हैं,तो आपको key  array के `<ListItem />` एलिमेंट पर रखनी चाहिए बजाये खुद `ListItem` के `<li>` एलिमेंट पर रखने के। 
 
-**Example: Incorrect Key Usage**
+**उदाहरण: गलत key  का उपयोग**
 
 ```javascript{4,5,14,15}
 function ListItem(props) {
@@ -173,7 +173,7 @@ ReactDOM.render(
 );
 ```
 
-**Example: Correct Key Usage**
+**उदाहरण:key  का सही उपयोग**
 
 ```javascript{2,3,9,10}
 function ListItem(props) {
@@ -202,13 +202,13 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
+[**कोडपेन पर इसे आजमाएं**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
 
-A good rule of thumb is that elements inside the `map()` call need keys.
+एक अच्छा नियम यह है कि एलिमेंटस  को `map()` कॉल के समय पर key  की जरुरत पड़ती है।  
 
-### Keys Must Only Be Unique Among Siblings {#keys-must-only-be-unique-among-siblings}
+### keys सिर्फ़ भाई-बहनों के बीच अद्वितीय होनी चाहिए{#कीज़ सिर्फ़ भाई-बहनों के बीच अद्वितीय होनी चाहिए}
 
-Keys used within arrays should be unique among their siblings. However they don't need to be globally unique. We can use the same keys when we produce two different arrays:
+arrays के भीतर उपयोग की जाने वाली key उनके भाई-बहनों के बीच अद्वितीय होनी चाहिए। हालाँकि उन्हें विश्व स्तर पर अद्वितीय होने की आवश्यकता नहीं है। जब हम दो अलग-अलग arrays का उत्पादन करते हैं, तो हम उसी key  का उपयोग कर सकते हैं
 
 ```js{2,5,11,12,19,21}
 function Blog(props) {
@@ -246,9 +246,9 @@ ReactDOM.render(
 );
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
+[**CodePen पर इसे आज़माएं**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
 
-Keys serve as a hint to React but they don't get passed to your components. If you need the same value in your component, pass it explicitly as a prop with a different name:
+keys रियेक्ट के लिए संकेत के रूप में काम करती हैं  लेकिन वे आपके कौम्पोनॅन्टस  को पास नहीं की जाती हैं।  यदि आपको अपने कौम्पोनॅन्ट में समान मूल्य की आवश्यकता है,तो इसे अलग नाम के साथ prop के रूप में स्पष्ट रूप से पास करें:
 
 ```js{3,4}
 const content = posts.map((post) =>
@@ -259,11 +259,11 @@ const content = posts.map((post) =>
 );
 ```
 
-With the example above, the `Post` component can read `props.id`, but not `props.key`.
+ऊपर के उदाहरण के साथ,`Post` कौम्पोनॅन्ट `props.id` पढ़ सकता है, लेकिन `props.key` नहीं।
 
-### Embedding map() in JSX {#embedding-map-in-jsx}
+### JSX में मैप की एम्बेडिंग  {#JSX में मैप की एम्बेडिंग}
 
-In the examples above we declared a separate `listItems` variable and included it in JSX:
+ऊपर दिए गए उदाहरणों में हमने एक अलग `listItems` वेरिएबल को घोषित किया था और इसे JSX में शामिल किया था:
 
 ```js{3-6}
 function NumberList(props) {
@@ -281,6 +281,7 @@ function NumberList(props) {
 ```
 
 JSX allows [embedding any expression](/docs/introducing-jsx.html#embedding-expressions-in-jsx) in curly braces so we could inline the `map()` result:
+JSX कर्ली ब्रेसिज़ में किसी भी एक्सप्रेशन को एम्बेडिंग करने की अनुमति देता है ताकि हम `map()` के परिणाम को इनलाइन कर सकें:
 
 ```js{5-8}
 function NumberList(props) {
@@ -296,6 +297,6 @@ function NumberList(props) {
 }
 ```
 
-[**Try it on CodePen**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
+[**CodePen पर इसे आज़माएं**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
-Sometimes this results in clearer code, but this style can also be abused. Like in JavaScript, it is up to you to decide whether it is worth extracting a variable for readability. Keep in mind that if the `map()` body is too nested, it might be a good time to [extract a component](/docs/components-and-props.html#extracting-components).
+कभी-कभी इसका परिणाम स्पष्ट कोड होता है, लेकिन इस शैली का दुरुपयोग भी किया जा सकता है। जावास्क्रिप्ट की तरह, यह आपको तय करना है कि यह पठनीयता के लिए एक चर निकालने के लायक है या नहीं। ध्यान रखें कि यदि `map()` बॉडी बहुत नेस्टेड है, तो [कंपोनेंट निकालने](/docs/components-and-props.html#extracting-components).का अच्छा समय हो सकता है।

From 273a390adee0203012b5d7b3c712dcc91286dcf4 Mon Sep 17 00:00:00 2001
From: anchal7299 <agarwalanchal72@gmail.com>
Date: Thu, 28 Mar 2019 00:58:44 +0530
Subject: [PATCH 02/16] Changes made for the first part

---
 content/docs/lists-and-keys.md | 47 +++++++++++++++++-----------------
 1 file changed, 23 insertions(+), 24 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index d52bae819..24e2e4745 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -8,23 +8,23 @@ next: forms.html
 
 पहले, आइए समीक्षा करें कि आप जावास्क्रिप्ट में लिस्ट्स को कैसे बदलते हैं।
 
-
-नीचे दिए गए कोड में हम `numbers` की एक array लेने और उनके मूल्यों को दोगुना करने के लिए मैप फ़ंक्शन का उपयोग करते हैं। हम मैप द्वारा दिए गए नए array को `double` नाम के वेरिएबल को सौपते हैं और फिर लॉग करते हैं।
+नीचे दिए गए कोड में हम `numbers` की एक array लेने और उनके मूल्यों को दोगुना करने के लिए [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फ़ंक्शन का उपयोग करते हैं। हम `map()` द्वारा दिए गए नए array को `double` नाम के वेरिएबल को सौपते हैं और फिर लॉग करते हैं।
 
 ```javascript{2}
 const numbers = [1, 2, 3, 4, 5];
 const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
-यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग कर देगा।
 
-रियेक्ट में,array को लिस्ट ऑफ़ [एलिमेंट्स](/docs/rendering-elements.html) में बदलना लगभग समान है।
+यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग  करता है।।
+
+रियेक्ट में, array को  [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
 
-### कई कौम्पोनॅन्ट का की रेंडरिंग {# कई कौम्पोनॅन्ट का की रेंडरिंग }
+### कई कौम्पोनॅन्टस को रेंडर करना{#rendering-multiple-components}
 
-आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें Jsx में शामिल करें](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
+आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें Jsx में शामिल कर सकते हैं।](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
 
-हमने जावास्क्रिप्ट [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फंक्शन का उपयोग करके `numbers` नाम की array में लूप लगाया है। हमने प्रत्येक आइटम के लिए  `<li>` एलिमेंट को रिटर्न किया है।  अंत में, हम परिणामस्वरूप  आयी हुई एलिमेंट्स की array को `listItems` को सौपते है। 
+हमने जावास्क्रिप्ट [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फंक्शन का उपयोग करके `numbers` नाम की array में लूप लगाया है। हमने प्रत्येक आइटम के लिए  `<li>` एलिमेंट को रिटर्न किया है। अंत में, हम परिणामस्वरूप आयी हुई एलिमेंट्स की array को `listItems` को सौपते है:
 
 ```javascript{2-4}
 const numbers = [1, 2, 3, 4, 5];
@@ -33,7 +33,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-पुरे `listItems` ऐरे को `<ul>` एलिमेंट में शामिल करके इसे [DOM को रेंडर करे](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
+हम पुरे `listItems` array को `<ul>` एलिमेंट में शामिल करके इसे [DOM में रेंडर करते हैं](/docs/rendering-elements.html#rendering-an-element-into-the-dom):
 
 ```javascript{2}
 ReactDOM.render(
@@ -42,15 +42,15 @@ ReactDOM.render(
 );
 ```
 
-[**कोडपेन पर इसे आजमाएं**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
+[** CodePen पर इसे आजमाएं**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
 
 यह कोड 1 से 5 के बीच संख्याओं की एक बुलेट लिस्ट प्रदर्शित करता है।
 
-###मूल लिस्टस कौम्पोनॅन्ट{#मूल लिस्टस कौम्पोनॅन्ट}
+### मूल लिस्टस कौम्पोनॅन्{#basic-list-component}
 
-आमतौर पर आप एक [कौम्पोनॅन्ट](/docs/components-and-props.html) के अंदर लिस्ट प्रस्तुत करेंगे। 
+आमतौर पर आप एक [कौम्पोनॅन्ट](/docs/components-and-props.html) के अंदर लिस्ट रेंडर करते हैं।। 
 
-हम पिछले उदाहरण को एक कौम्पोनॅन्ट में बदल सकते हैं जो `numbers ` की एक array को स्वीकार करता है और एलिमेंटस की लिस्ट को आउटपुट करता है।
+हम पिछले उदाहरण को एक कौम्पोनॅन्ट में बदल सकते हैं जो `numbers` की एक array को स्वीकार करता है और एलिमेंटस की लिस्ट को आउटपुट करता है।
 
 ```javascript{3-5,7,13}
 function NumberList(props) {
@@ -69,11 +69,10 @@ ReactDOM.render(
   document.getElementById('root')
 );
 ```
-
 जब आप यह कोड चलाते हैं, तो आपको एक चेतावनी दी जाती है कि लिस्ट आइटम के लिए एक key प्रदान की जानी चाहिए। "key" एक विशेष स्ट्रिंग विशेषता है जिसे आपको 
-एलिमेंटस की सूची बनाते समय शामिल करने की आवश्यकता होती है। हम चर्चा करेंगे अगले भाग में कि यह महत्वपूर्ण क्यों है।
+एलिमेंटस की सूची बनाते समय शामिल करने की आवश्यकता होती है। हम अगले भाग में चर्चा करेंगे कि यह महत्वपूर्ण क्यों है।
 
-आइए `numbers.map() ` के अंदर हमारी लिस्ट आइटम की एक `key`असाइन करें और लापता key की समस्या को ठीक करें।
+आइए `numbers.map()` के अंदर हमारी लिस्ट आइटम की एक `key`असाइन करें और लापता key की समस्या को ठीक करें।
 
 ```javascript{4}
 function NumberList(props) {
@@ -95,11 +94,11 @@ ReactDOM.render(
 );
 ```
 
-[**कोडपेन पर इसे आजमाएं**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
+[**CodePen पर इसे आजमाएं**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
 
 ## Keys{#Keys}
 
-Keys प्रतिक्रिया को पहचानने में मदद करती हैं कि कौन से आइटम बदले गए हैं, जोड़े गए हैं, या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर तत्वों को key  दी जानी चाहिए:
+Keys प्रतिक्रिया को पहचानने में मदद करती हैं कि कौन से आइटम बदले गए हैं, जोड़े गए हैं, या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर तत्वों को key दी जानी चाहिए:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -110,7 +109,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-key चुनने का सबसे अच्छा तरीका एक स्ट्रिंग का उपयोग करना है जो विशिष्ट रूप से अपने भाई-बहनों के बीच एक लिस्ट आइटम की पहचान करता है। अक्सर आप चाबी के रूप में अपने डेटा से आईडी का उपयोग करेंगे:
+key चुनने का सबसे अच्छा तरीका एक String का उपयोग करना है जो विशिष्ट रूप से अपने भाई-बहनों के बीच एक लिस्ट आइटम की पहचान करता है। अक्सर आप अपने डेटा की IDs को key के रूप में उपयोग करेंगे:
 
 ```js{2}
 const todoItems = todos.map((todo) =>
@@ -120,7 +119,7 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-जब आपके पास प्रदान की गई वस्तुओं के लिए स्थिर आईडी नहीं है, तो आप अंतिम उपाय के रूप में key के रूप में आइटम इंडेक्स का उपयोग कर सकते हैं:
+जब आपके पास प्रदान की गई वस्तुओं के लिए स्थिर ID नहीं है, तो आप अंतिम उपाय के रूप में key के रूप में आइटम इंडेक्स का उपयोग कर सकते हैं:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
@@ -131,10 +130,10 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग करने की अनुशंसा नहीं करते हैं। यह प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है और कौम्पोनॅन्ट की अवस्था के साथ समस्या पैदा कर सकता है। [इंडेक्स को key  के रूप में उपयोग करने के नकारात्मक प्रभावों](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). पर गहन व्याख्या के लिए रॉबिन पोकोर्न के लेख को देखें। यदि आप आइटमों को सूचीबद्ध करने के लिए एक स्पष्ट key  निर्दिष्ट नहीं करने का विकल्प चुनते हैं तो रिएक्ट key  के रूप में इंडेक्स का उपयोग करने के लिए डिफ़ॉल्ट होगा।
+यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग करने की सिफारिश करते हैं। यह प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है और कौम्पोनॅन्ट की अवस्था के साथ समस्या पैदा कर सकता है। [इंडेक्स को key  के रूप में उपयोग करने के नकारात्मक प्रभावों](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). पर गहन व्याख्या के लिए रॉबिन पोकोर्न के लेख को देखें। यदि आप आइटमों को सूचीबद्ध करने के लिए एक स्पष्ट key  निर्दिष्ट नहीं करने का विकल्प चुनते हैं तो React key  के रूप में इंडेक्स का उपयोग करने के लिए डिफ़ॉल्ट होगा।
 
-यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children) , इस बारे में गहराई से व्याख्या की गई है।
-###key  के साथ कौम्पोनॅन्ट निकालना{#key के साथ कौम्पोनॅन्ट निकालना}
+यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children) , इस बारे में गहराई से व्याख्या करे ।
+###key के साथ कंपोनेंट्स निकालना{#Extracting-Components-with-Keys}
 
 keys केवल आस-पास के array के संदर्भ में समझ में आती हैं।
 
@@ -206,7 +205,7 @@ ReactDOM.render(
 
 एक अच्छा नियम यह है कि एलिमेंटस  को `map()` कॉल के समय पर key  की जरुरत पड़ती है।  
 
-### keys सिर्फ़ भाई-बहनों के बीच अद्वितीय होनी चाहिए{#कीज़ सिर्फ़ भाई-बहनों के बीच अद्वितीय होनी चाहिए}
+### keys सिर्फ़ भाई-बहनों के बीच अद्वितीय होनी चाहिए{#Keys-Must-Only-Be-Unique-Among-Siblings}
 
 arrays के भीतर उपयोग की जाने वाली key उनके भाई-बहनों के बीच अद्वितीय होनी चाहिए। हालाँकि उन्हें विश्व स्तर पर अद्वितीय होने की आवश्यकता नहीं है। जब हम दो अलग-अलग arrays का उत्पादन करते हैं, तो हम उसी key  का उपयोग कर सकते हैं
 
@@ -261,7 +260,7 @@ const content = posts.map((post) =>
 
 ऊपर के उदाहरण के साथ,`Post` कौम्पोनॅन्ट `props.id` पढ़ सकता है, लेकिन `props.key` नहीं।
 
-### JSX में मैप की एम्बेडिंग  {#JSX में मैप की एम्बेडिंग}
+### JSX में मैप की एम्बेडिंग  {#Embedding-map()-in-JSX}
 
 ऊपर दिए गए उदाहरणों में हमने एक अलग `listItems` वेरिएबल को घोषित किया था और इसे JSX में शामिल किया था:
 

From 4007c82875a509af60f89f55c2088c27183c263b Mon Sep 17 00:00:00 2001
From: anchal7299 <agarwalanchal72@gmail.com>
Date: Thu, 28 Mar 2019 12:24:31 +0530
Subject: [PATCH 03/16] further changes in same feedback

---
 content/docs/lists-and-keys.md | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 24e2e4745..6cde6832e 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -16,13 +16,13 @@ const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
 
-यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग  करता है।।
+यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग करता है।।
 
-रियेक्ट में, array को  [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
+React में, array को [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
 
-### कई कौम्पोनॅन्टस को रेंडर करना{#rendering-multiple-components}
+### कई कौम्पोनॅन्टस को रेंडर करना  {#rendering-multiple-components}
 
-आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें Jsx में शामिल कर सकते हैं।](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
+आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें JSX में शामिल कर सकते हैं।](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
 
 हमने जावास्क्रिप्ट [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फंक्शन का उपयोग करके `numbers` नाम की array में लूप लगाया है। हमने प्रत्येक आइटम के लिए  `<li>` एलिमेंट को रिटर्न किया है। अंत में, हम परिणामस्वरूप आयी हुई एलिमेंट्स की array को `listItems` को सौपते है:
 
@@ -46,7 +46,7 @@ ReactDOM.render(
 
 यह कोड 1 से 5 के बीच संख्याओं की एक बुलेट लिस्ट प्रदर्शित करता है।
 
-### मूल लिस्टस कौम्पोनॅन्{#basic-list-component}
+### मूल लिस्टस कौम्पोनॅन्ट {#basic-list-component}
 
 आमतौर पर आप एक [कौम्पोनॅन्ट](/docs/components-and-props.html) के अंदर लिस्ट रेंडर करते हैं।। 
 
@@ -69,8 +69,8 @@ ReactDOM.render(
   document.getElementById('root')
 );
 ```
-जब आप यह कोड चलाते हैं, तो आपको एक चेतावनी दी जाती है कि लिस्ट आइटम के लिए एक key प्रदान की जानी चाहिए। "key" एक विशेष स्ट्रिंग विशेषता है जिसे आपको 
-एलिमेंटस की सूची बनाते समय शामिल करने की आवश्यकता होती है। हम अगले भाग में चर्चा करेंगे कि यह महत्वपूर्ण क्यों है।
+
+जब आप यह कोड चलाते हैं, तो आपको एक चेतावनी दी जाती है कि लिस्ट आइटम के लिए एक key प्रदान की जानी चाहिए। "key" एक विशेष स्ट्रिंग विशेषता है जिसे आपको एलिमेंटस की सूची बनाते समय शामिल करने की आवश्यकता होती है। हम अगले भाग में चर्चा करेंगे कि यह महत्वपूर्ण क्यों है।
 
 आइए `numbers.map()` के अंदर हमारी लिस्ट आइटम की एक `key`असाइन करें और लापता key की समस्या को ठीक करें।
 
@@ -96,7 +96,7 @@ ReactDOM.render(
 
 [**CodePen पर इसे आजमाएं**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
 
-## Keys{#Keys}
+## Keys {#Keys}
 
 Keys प्रतिक्रिया को पहचानने में मदद करती हैं कि कौन से आइटम बदले गए हैं, जोड़े गए हैं, या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर तत्वों को key दी जानी चाहिए:
 

From 62cee183bbd2912cc25ca41ca8255c6425c2cdb0 Mon Sep 17 00:00:00 2001
From: anchal7299 <agarwalanchal72@gmail.com>
Date: Mon, 1 Apr 2019 15:15:30 +0530
Subject: [PATCH 04/16] removed extra space

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 6cde6832e..fce788312 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -1,4 +1,4 @@
----
+---
 id: lists-and-keys
 title: Lists and Keys
 permalink: docs/lists-and-keys.html
@@ -20,7 +20,7 @@ console.log(doubled);
 
 React में, array को [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
 
-### कई कौम्पोनॅन्टस को रेंडर करना  {#rendering-multiple-components}
+### कई कौम्पोनॅन्टस को रेंडर करना{#rendering-multiple-components}
 
 आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें JSX में शामिल कर सकते हैं।](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
 
@@ -201,7 +201,7 @@ ReactDOM.render(
 );
 ```
 
-[**कोडपेन पर इसे आजमाएं**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
+[**CodePen पर इसे आजमाएं**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
 
 एक अच्छा नियम यह है कि एलिमेंटस  को `map()` कॉल के समय पर key  की जरुरत पड़ती है।  
 

From a6faf5015aaea42605fe558e02745ac0cf0c6d4f Mon Sep 17 00:00:00 2001
From: anchal7299 <agarwalanchal72@gmail.com>
Date: Tue, 2 Apr 2019 15:44:25 +0530
Subject: [PATCH 05/16] Further Changes

---
 content/docs/lists-and-keys.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index fce788312..f8db16bba 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -18,9 +18,9 @@ console.log(doubled);
 
 यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग करता है।।
 
-React में, array को [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
+React में,  array को [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
 
-### कई कौम्पोनॅन्टस को रेंडर करना{#rendering-multiple-components}
+### कई कौम्पोनॅन्टस को रेंडर करना {#rendering-multiple-components}
 
 आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें JSX में शामिल कर सकते हैं।](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
 

From b56b2668dd60efcd1126493d033bd3d2c26e1d92 Mon Sep 17 00:00:00 2001
From: anchal7299 <agarwalanchal72@gmail.com>
Date: Thu, 4 Apr 2019 14:37:57 +0530
Subject: [PATCH 06/16] Further changes Done

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index f8db16bba..f492739f6 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -16,7 +16,7 @@ const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
 
-यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग करता है।।
+यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग करता है।
 
 React में,  array को [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
 

From 58b853e5bab8d41cc95abcbe9e5d32088f1edc2c Mon Sep 17 00:00:00 2001
From: anchal7299 <agarwalanchal72@gmail.com>
Date: Sat, 6 Apr 2019 22:55:24 +0530
Subject: [PATCH 07/16] Pending Changes Done

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index f492739f6..8001e6eb3 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -18,7 +18,7 @@ console.log(doubled);
 
 यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग करता है।
 
-React में,  array को [एलिमेंट्स] की लिस्ट(/docs/rendering-elements.html) में बदलना लगभग समान है।
+React में,  array को [एलिमेंट्स](/docs/rendering-elements.html) की लिस्ट में बदलना लगभग समान है।
 
 ### कई कौम्पोनॅन्टस को रेंडर करना {#rendering-multiple-components}
 

From 35d9accc8e573029861eae9a54315625f0053f39 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=A4nchal7299?= <agarwalanchal72@gmail.com>
Date: Mon, 15 Apr 2019 22:43:29 +0530
Subject: [PATCH 08/16] Further changes

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 8001e6eb3..9131f61a7 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -18,7 +18,7 @@ console.log(doubled);
 
 यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग करता है।
 
-React में,  array को [एलिमेंट्स](/docs/rendering-elements.html) की लिस्ट में बदलना लगभग समान है।
+React में, array को [एलिमेंट्स](/docs/rendering-elements.html) की लिस्ट में बदलना लगभग समान है।
 
 ### कई कौम्पोनॅन्टस को रेंडर करना {#rendering-multiple-components}
 

From 263c4ba80a70a5c9cfb11f0217f2e667f1afd0da Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=A4nchal7299?= <agarwalanchal72@gmail.com>
Date: Fri, 26 Apr 2019 23:34:50 +0530
Subject: [PATCH 09/16] Changes Done

---
 content/docs/lists-and-keys.md | 50 ++++++++++++++++------------------
 1 file changed, 24 insertions(+), 26 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 9131f61a7..44b8d5134 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -42,7 +42,7 @@ ReactDOM.render(
 );
 ```
 
-[** CodePen पर इसे आजमाएं**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
+[**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/GjPyQr?editors=0011)
 
 यह कोड 1 से 5 के बीच संख्याओं की एक बुलेट लिस्ट प्रदर्शित करता है।
 
@@ -94,11 +94,11 @@ ReactDOM.render(
 );
 ```
 
-[**CodePen पर इसे आजमाएं**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
+[**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/jrXYRR?editors=0011)
 
-## Keys {#Keys}
+## Keys {#keys}
 
-Keys प्रतिक्रिया को पहचानने में मदद करती हैं कि कौन से आइटम बदले गए हैं, जोड़े गए हैं, या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर तत्वों को key दी जानी चाहिए:
+Keys React को पहचानने में मदद करती हैं कि कौन से आइटम ऐड किये गए, जोड़े गए हैं या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर एलिमेंट्स को key दी जानी चाहिए:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -109,7 +109,7 @@ const listItems = numbers.map((number) =>
 );
 ```
 
-key चुनने का सबसे अच्छा तरीका एक String का उपयोग करना है जो विशिष्ट रूप से अपने भाई-बहनों के बीच एक लिस्ट आइटम की पहचान करता है। अक्सर आप अपने डेटा की IDs को key के रूप में उपयोग करेंगे:
+Key चुनने का सबसे अच्छा तरीका एक string का उपयोग करना है जो विशिष्ट रूप से अपने सिब्लिंग्स के बीच एक लिस्ट आइटम की पहचान करता है। अक्सर आप अपने डेटा की IDs को key के रूप में उपयोग करेंगे:
 
 ```js{2}
 const todoItems = todos.map((todo) =>
@@ -119,7 +119,7 @@ const todoItems = todos.map((todo) =>
 );
 ```
 
-जब आपके पास प्रदान की गई वस्तुओं के लिए स्थिर ID नहीं है, तो आप अंतिम उपाय के रूप में key के रूप में आइटम इंडेक्स का उपयोग कर सकते हैं:
+जब आपके पास प्रदान की गई वस्तुओं के लिए स्थिर ID नहीं है, तो आप अंतिम उपाय के रूप में आइटम इंडेक्स का key के रूप में उपयोग कर सकते हैं:
 
 ```js{2,3}
 const todoItems = todos.map((todo, index) =>
@@ -130,16 +130,16 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग करने की सिफारिश करते हैं। यह प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है और कौम्पोनॅन्ट की अवस्था के साथ समस्या पैदा कर सकता है। [इंडेक्स को key  के रूप में उपयोग करने के नकारात्मक प्रभावों](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318). पर गहन व्याख्या के लिए रॉबिन पोकोर्न के लेख को देखें। यदि आप आइटमों को सूचीबद्ध करने के लिए एक स्पष्ट key  निर्दिष्ट नहीं करने का विकल्प चुनते हैं तो React key  के रूप में इंडेक्स का उपयोग करने के लिए डिफ़ॉल्ट होगा।
+यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग ना करने की सिफारिश करते हैं। यह प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है और कौम्पोनॅन्ट की अवस्था के साथ समस्या पैदा कर सकता है। Robin Pokorny के [इंडेक्स को key के रूप में उपयोग करने के नकारात्मक प्रभाव](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318) के आर्टिकल को देखें। यदि आप आइटमों को सूचीबद्ध करने के लिए एक स्पष्ट key निर्दिष्ट नहीं करते हैं तो React key के रूप में इंडेक्स का उपयोग करता है।
 
-यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children) , इस बारे में गहराई से व्याख्या करे ।
-###key के साथ कंपोनेंट्स निकालना{#Extracting-Components-with-Keys}
+यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children), इस बारे में गहराई से व्याख्या करें।
+### Key के साथ कौम्पोनॅन्टस निकालना {#extracting-components-with-keys}
 
-keys केवल आस-पास के array के संदर्भ में समझ में आती हैं।
+keys केवल उनके array के लिए ही होती है|।
 
-उदाहरण के लिए, यदि आप एक ListItem कौम्पोनॅन्ट को [निकालते](/docs/components-and-props.html#extracting-components) हैं,तो आपको key  array के `<ListItem />` एलिमेंट पर रखनी चाहिए बजाये खुद `ListItem` के `<li>` एलिमेंट पर रखने के। 
+उदाहरण के लिए, यदि आप एक ListItem कौम्पोनॅन्ट को [निकालते](/docs/components-and-props.html#extracting-components) हैं, तो आपको key `ListItem` के `<li>` एलिमेंट पर रखने के बजाये array में `<ListItem />` एलिमेंट पर रखनी चाहिए। 
 
-**उदाहरण: गलत key  का उपयोग**
+**उदाहरण: key का गलत उपयोग**
 
 ```javascript{4,5,14,15}
 function ListItem(props) {
@@ -172,7 +172,7 @@ ReactDOM.render(
 );
 ```
 
-**उदाहरण:key  का सही उपयोग**
+**उदाहरण: key का सही उपयोग**
 
 ```javascript{2,3,9,10}
 function ListItem(props) {
@@ -201,13 +201,12 @@ ReactDOM.render(
 );
 ```
 
-[**CodePen पर इसे आजमाएं**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
+[**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
 
-एक अच्छा नियम यह है कि एलिमेंटस  को `map()` कॉल के समय पर key  की जरुरत पड़ती है।  
+एक अच्छा नियम यह है कि एलिमेंटस को `map()` कॉल के समय पर key की जरुरत होती है।  
 
-### keys सिर्फ़ भाई-बहनों के बीच अद्वितीय होनी चाहिए{#Keys-Must-Only-Be-Unique-Among-Siblings}
-
-arrays के भीतर उपयोग की जाने वाली key उनके भाई-बहनों के बीच अद्वितीय होनी चाहिए। हालाँकि उन्हें विश्व स्तर पर अद्वितीय होने की आवश्यकता नहीं है। जब हम दो अलग-अलग arrays का उत्पादन करते हैं, तो हम उसी key  का उपयोग कर सकते हैं
+### Keys सिर्फ़ सिब्लिंग्स के बीच अद्वितीय होनी चाहिए {#keys-must-only-be-unique-among-siblings}
+Arrays के भीतर उपयोग की जाने वाली key उनके सिब्लिंग्स के बीच अद्वितीय होनी चाहिए। हालाँकि उन्हें विश्व स्तर पर अद्वितीय होने की आवश्यकता नहीं है। जब हम दो अलग-अलग arrays का उत्पादन करते हैं, तो हम उसी key का उपयोग कर सकते हैं:
 
 ```js{2,5,11,12,19,21}
 function Blog(props) {
@@ -245,9 +244,9 @@ ReactDOM.render(
 );
 ```
 
-[**CodePen पर इसे आज़माएं**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
+[**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
 
-keys रियेक्ट के लिए संकेत के रूप में काम करती हैं  लेकिन वे आपके कौम्पोनॅन्टस  को पास नहीं की जाती हैं।  यदि आपको अपने कौम्पोनॅन्ट में समान मूल्य की आवश्यकता है,तो इसे अलग नाम के साथ prop के रूप में स्पष्ट रूप से पास करें:
+Keys React के लिए संकेत के रूप में काम करती हैं लेकिन वे आपके कौम्पोनॅन्टस को पास नहीं की जाती हैं। यदि आपको अपने कौम्पोनॅन्ट में समान वैल्यू की आवश्यकता है, तो इसे अलग नाम के साथ स्पष्ट रूप से prop की तरह पास करें:
 
 ```js{3,4}
 const content = posts.map((post) =>
@@ -258,9 +257,9 @@ const content = posts.map((post) =>
 );
 ```
 
-ऊपर के उदाहरण के साथ,`Post` कौम्पोनॅन्ट `props.id` पढ़ सकता है, लेकिन `props.key` नहीं।
+ऊपर के उदाहरण के साथ, `Post` कौम्पोनॅन्ट `props.id` पढ़ सकता है, लेकिन `props.key` नहीं।
 
-### JSX में मैप की एम्बेडिंग  {#Embedding-map()-in-JSX}
+### JSX में map() की एम्बेडिंग {#embedding-map-in-jsx}
 
 ऊपर दिए गए उदाहरणों में हमने एक अलग `listItems` वेरिएबल को घोषित किया था और इसे JSX में शामिल किया था:
 
@@ -279,8 +278,7 @@ function NumberList(props) {
 }
 ```
 
-JSX allows [embedding any expression](/docs/introducing-jsx.html#embedding-expressions-in-jsx) in curly braces so we could inline the `map()` result:
-JSX कर्ली ब्रेसिज़ में किसी भी एक्सप्रेशन को एम्बेडिंग करने की अनुमति देता है ताकि हम `map()` के परिणाम को इनलाइन कर सकें:
+JSX कर्ली ब्रेसिज़ में किसी भी [एक्सप्रेशन की एम्बेडिंग](/docs/introducing-jsx.html#embedding-expressions-in-jsx) करने की अनुमति देता है ताकि हम `map()` के परिणाम को इनलाइन कर सकें:
 
 ```js{5-8}
 function NumberList(props) {
@@ -296,6 +294,6 @@ function NumberList(props) {
 }
 ```
 
-[**CodePen पर इसे आज़माएं**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
+[**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
-कभी-कभी इसका परिणाम स्पष्ट कोड होता है, लेकिन इस शैली का दुरुपयोग भी किया जा सकता है। जावास्क्रिप्ट की तरह, यह आपको तय करना है कि यह पठनीयता के लिए एक चर निकालने के लायक है या नहीं। ध्यान रखें कि यदि `map()` बॉडी बहुत नेस्टेड है, तो [कंपोनेंट निकालने](/docs/components-and-props.html#extracting-components).का अच्छा समय हो सकता है।
+कभी-कभी इसका परिणाम स्पष्ट कोड होता है, लेकिन इस शैली का दुरुपयोग भी किया जा सकता है। जैसे जावास्क्रिप्ट में ये आपको तय करना होता है की Readability के लिए एक variable को extract करना चाहिए या नहीं। ध्यान रखें कि यदि `map()` बॉडी बहुत नेस्टेड है, तो [कंपोनेंट निकालने](/docs/components-and-props.html#extracting-components) का अच्छा समय हो सकता है।

From 05f67f96843f59b23735a90fa13f763d20e57647 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=A4nchal7299?= <agarwalanchal72@gmail.com>
Date: Sun, 28 Apr 2019 11:40:13 +0530
Subject: [PATCH 10/16] Further Changes

---
 content/docs/lists-and-keys.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 44b8d5134..5899cb81c 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -98,7 +98,7 @@ ReactDOM.render(
 
 ## Keys {#keys}
 
-Keys React को पहचानने में मदद करती हैं कि कौन से आइटम ऐड किये गए, जोड़े गए हैं या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर एलिमेंट्स को key दी जानी चाहिए:
+Keys React को पहचानने में मदद करती हैं कि कौन से आइटम ऐड किये गए हैं, या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर एलिमेंट्स को key दी जानी चाहिए:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -135,7 +135,8 @@ const todoItems = todos.map((todo, index) =>
 यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children), इस बारे में गहराई से व्याख्या करें।
 ### Key के साथ कौम्पोनॅन्टस निकालना {#extracting-components-with-keys}
 
-keys केवल उनके array के लिए ही होती है|।
+
+Keys केवल उनके array के लिए ही होती है।
 
 उदाहरण के लिए, यदि आप एक ListItem कौम्पोनॅन्ट को [निकालते](/docs/components-and-props.html#extracting-components) हैं, तो आपको key `ListItem` के `<li>` एलिमेंट पर रखने के बजाये array में `<ListItem />` एलिमेंट पर रखनी चाहिए। 
 
@@ -296,4 +297,4 @@ function NumberList(props) {
 
 [**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/BLvYrB?editors=0010)
 
-कभी-कभी इसका परिणाम स्पष्ट कोड होता है, लेकिन इस शैली का दुरुपयोग भी किया जा सकता है। जैसे जावास्क्रिप्ट में ये आपको तय करना होता है की Readability के लिए एक variable को extract करना चाहिए या नहीं। ध्यान रखें कि यदि `map()` बॉडी बहुत नेस्टेड है, तो [कंपोनेंट निकालने](/docs/components-and-props.html#extracting-components) का अच्छा समय हो सकता है।
+कभी-कभी इसका परिणाम स्पष्ट कोड होता है, लेकिन इस शैली का दुरुपयोग भी किया जा सकता है। जैसे जावास्क्रिप्ट में ये आपको तय करना होता है की readability के लिए एक variable को extract करना चाहिए या नहीं। ध्यान रखें कि यदि `map()` बॉडी बहुत नेस्टेड है, तो [कंपोनेंट निकालने](/docs/components-and-props.html#extracting-components) का अच्छा समय हो सकता है।

From b00935b5b581f56e03c72db520d7b2757af9980d Mon Sep 17 00:00:00 2001
From: Arshad Kazmi <arshadkazmi42@gmail.com>
Date: Sun, 5 May 2019 18:27:21 +0530
Subject: [PATCH 11/16] Line break added

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 5899cb81c..ca49411b1 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -133,8 +133,8 @@ const todoItems = todos.map((todo, index) =>
 यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग ना करने की सिफारिश करते हैं। यह प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है और कौम्पोनॅन्ट की अवस्था के साथ समस्या पैदा कर सकता है। Robin Pokorny के [इंडेक्स को key के रूप में उपयोग करने के नकारात्मक प्रभाव](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318) के आर्टिकल को देखें। यदि आप आइटमों को सूचीबद्ध करने के लिए एक स्पष्ट key निर्दिष्ट नहीं करते हैं तो React key के रूप में इंडेक्स का उपयोग करता है।
 
 यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children), इस बारे में गहराई से व्याख्या करें।
-### Key के साथ कौम्पोनॅन्टस निकालना {#extracting-components-with-keys}
 
+### Key के साथ कौम्पोनॅन्टस निकालना {#extracting-components-with-keys}
 
 Keys केवल उनके array के लिए ही होती है।
 

From 1b9fce14c3bb8d30267e11efde4f97d412b28ae7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=A4nchal7299?= <agarwalanchal72@gmail.com>
Date: Thu, 23 May 2019 12:46:58 +0530
Subject: [PATCH 12/16] Changes done as per feedback

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index ca49411b1..6f0dcc7f2 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -8,7 +8,7 @@ next: forms.html
 
 पहले, आइए समीक्षा करें कि आप जावास्क्रिप्ट में लिस्ट्स को कैसे बदलते हैं।
 
-नीचे दिए गए कोड में हम `numbers` की एक array लेने और उनके मूल्यों को दोगुना करने के लिए [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फ़ंक्शन का उपयोग करते हैं। हम `map()` द्वारा दिए गए नए array को `double` नाम के वेरिएबल को सौपते हैं और फिर लॉग करते हैं।
+नीचे दिए गए कोड में हम `numbers` की एक array के मूल्यों को दोगुना करने के लिए [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फ़ंक्शन का उपयोग करते हैं। हम `map()` द्वारा दिए गए नए array को `doubled` नाम के वेरिएबल को सौपते हैं और फिर लॉग करते हैं।
 
 ```javascript{2}
 const numbers = [1, 2, 3, 4, 5];
@@ -16,7 +16,7 @@ const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
 
-यह कोड [2, 4, 6, 8, 10] को कंसोल पर लोग करता है।
+यह कोड [2, 4, 6, 8, 10] को कंसोल main लोग करता है।
 
 React में, array को [एलिमेंट्स](/docs/rendering-elements.html) की लिस्ट में बदलना लगभग समान है।
 
@@ -24,7 +24,7 @@ React में, array को [एलिमेंट्स](/docs/rendering-elem
 
 आप एलिमेंट्स का संग्रह बना सकते हैं और कर्ली ब्रेसिज़ `{}` का उपयोग करके [उन्हें JSX में शामिल कर सकते हैं।](/docs/introducing-jsx.html#embedding-expressions-in-jsx)
 
-हमने जावास्क्रिप्ट [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फंक्शन का उपयोग करके `numbers` नाम की array में लूप लगाया है। हमने प्रत्येक आइटम के लिए  `<li>` एलिमेंट को रिटर्न किया है। अंत में, हम परिणामस्वरूप आयी हुई एलिमेंट्स की array को `listItems` को सौपते है:
+हमने जावास्क्रिप्ट [`map()`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) फंक्शन का उपयोग करके `numbers` नाम की array में लूप लगाया है। हमने प्रत्येक आइटम के लिए `<li>` एलिमेंट को रिटर्न किया है। अंत में, हम परिणामस्वरूप आयी हुई एलिमेंट्स की array को `listItems` को सौपते है:
 
 ```javascript{2-4}
 const numbers = [1, 2, 3, 4, 5];
@@ -48,7 +48,7 @@ ReactDOM.render(
 
 ### मूल लिस्टस कौम्पोनॅन्ट {#basic-list-component}
 
-आमतौर पर आप एक [कौम्पोनॅन्ट](/docs/components-and-props.html) के अंदर लिस्ट रेंडर करते हैं।। 
+आमतौर पर आप एक [कौम्पोनॅन्ट](/docs/components-and-props.html) के अंदर लिस्ट रेंडर करते हैं। 
 
 हम पिछले उदाहरण को एक कौम्पोनॅन्ट में बदल सकते हैं जो `numbers` की एक array को स्वीकार करता है और एलिमेंटस की लिस्ट को आउटपुट करता है।
 
@@ -70,9 +70,9 @@ ReactDOM.render(
 );
 ```
 
-जब आप यह कोड चलाते हैं, तो आपको एक चेतावनी दी जाती है कि लिस्ट आइटम के लिए एक key प्रदान की जानी चाहिए। "key" एक विशेष स्ट्रिंग विशेषता है जिसे आपको एलिमेंटस की सूची बनाते समय शामिल करने की आवश्यकता होती है। हम अगले भाग में चर्चा करेंगे कि यह महत्वपूर्ण क्यों है।
+जब आप यह कोड चलाते हैं, तो आपको एक चेतावनी दी जाती है कि लिस्ट आइटम के लिए एक key प्रदान की जानी चाहिए। "key" एक विशेष स्ट्रिंग एट्रिब्यूट है जिसे आपको एलिमेंटस की सूची बनाते समय शामिल करने की आवश्यकता होती है। हम अगले भाग में चर्चा करेंगे कि यह महत्वपूर्ण क्यों है।
 
-आइए `numbers.map()` के अंदर हमारी लिस्ट आइटम की एक `key`असाइन करें और लापता key की समस्या को ठीक करें।
+आइए `numbers.map()` के अंदर हमारी लिस्ट आइटम को एक `key`असाइन करें और लापता key की समस्या को ठीक करें।
 
 ```javascript{4}
 function NumberList(props) {

From d627b83d4bdd7baaaa4fa4e385a503c60d246feb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=A4nchal7299?= <agarwalanchal72@gmail.com>
Date: Sun, 26 May 2019 01:52:13 +0530
Subject: [PATCH 13/16] Changes Done

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 6f0dcc7f2..7b2210de7 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -16,7 +16,7 @@ const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
 
-यह कोड [2, 4, 6, 8, 10] को कंसोल main लोग करता है।
+यह कोड [2, 4, 6, 8, 10] को कंसोल मैं लोग करता है।
 
 React में, array को [एलिमेंट्स](/docs/rendering-elements.html) की लिस्ट में बदलना लगभग समान है।
 
@@ -98,7 +98,7 @@ ReactDOM.render(
 
 ## Keys {#keys}
 
-Keys React को पहचानने में मदद करती हैं कि कौन से आइटम ऐड किये गए हैं, या हटा दिए गए हैं। एलिमेंटस को स्थिर पहचान देने के लिए array के अंदर एलिमेंट्स को key दी जानी चाहिए:
+Keys React को पहचानने में मदद करती हैं कि कौन से आइटम ऐड किये गए हैं, या हटा दिए गए हैं। एलिमेंट्स को स्टेबल करने के लिए array के अंदर एलिमेंट्स को key दी जानी चाहिए:
 
 ```js{3}
 const numbers = [1, 2, 3, 4, 5];
@@ -130,9 +130,9 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग ना करने की सिफारिश करते हैं। यह प्रदर्शन को नकारात्मक रूप से प्रभावित कर सकता है और कौम्पोनॅन्ट की अवस्था के साथ समस्या पैदा कर सकता है। Robin Pokorny के [इंडेक्स को key के रूप में उपयोग करने के नकारात्मक प्रभाव](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318) के आर्टिकल को देखें। यदि आप आइटमों को सूचीबद्ध करने के लिए एक स्पष्ट key निर्दिष्ट नहीं करते हैं तो React key के रूप में इंडेक्स का उपयोग करता है।
+यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग ना करने की सिफारिश करते हैं। इसका नकारात्मक प्रभाव पड़ सकता हैं और यह कौम्पोनॅन्ट की अवस्था के साथ समस्या भी पैदा कर सकता है। अधिक जानकारी के लिए Robin Pokorny के [इंडेक्स को key के रूप में उपयोग करने के नकारात्मक प्रभाव](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318) के आर्टिकल को देखें। यदि आप लिस्ट आइटम्स को एक explicit key नहीं देते हैं, तो React key के रूप में इंडेक्स का उपयोग करता है।
 
-यदि आप अधिक सीखने में रुचि रखते हैं, [तो key क्यों आवश्यक है](/docs/reconciliation.html#recursing-on-children), इस बारे में गहराई से व्याख्या करें।
+यदि आप अधिक सीखने में रुचि रखते हैं, तो यहाँ [key की आवशयकताओ के बारे में गहराई से स्पष्टीकरणं](/docs/reconciliation.html#recursing-on-children), दिया गया हैं।
 
 ### Key के साथ कौम्पोनॅन्टस निकालना {#extracting-components-with-keys}
 

From c3a9cb33b9f7a6e85bc57fa35ef0de5099a742ab Mon Sep 17 00:00:00 2001
From: Saransh Kataria <saransh@wisdomgeek.com>
Date: Sun, 26 May 2019 14:45:53 -0700
Subject: [PATCH 14/16] updated typo

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 7b2210de7..3ef2387a1 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -16,7 +16,7 @@ const doubled = numbers.map((number) => number * 2);
 console.log(doubled);
 ```
 
-यह कोड [2, 4, 6, 8, 10] को कंसोल मैं लोग करता है।
+यह कोड [2, 4, 6, 8, 10] को कंसोल में लोग करता है।
 
 React में, array को [एलिमेंट्स](/docs/rendering-elements.html) की लिस्ट में बदलना लगभग समान है।
 

From d0f15428317fefaccdb1fae4dc140cd73d2fedbf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=C3=A4nchal7299?= <agarwalanchal72@gmail.com>
Date: Fri, 31 May 2019 17:39:44 +0530
Subject: [PATCH 15/16] commited changes

---
 content/docs/lists-and-keys.md | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index 3ef2387a1..c3e960d4e 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -130,9 +130,9 @@ const todoItems = todos.map((todo, index) =>
 );
 ```
 
-यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग ना करने की सिफारिश करते हैं। इसका नकारात्मक प्रभाव पड़ सकता हैं और यह कौम्पोनॅन्ट की अवस्था के साथ समस्या भी पैदा कर सकता है। अधिक जानकारी के लिए Robin Pokorny के [इंडेक्स को key के रूप में उपयोग करने के नकारात्मक प्रभाव](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318) के आर्टिकल को देखें। यदि आप लिस्ट आइटम्स को एक explicit key नहीं देते हैं, तो React key के रूप में इंडेक्स का उपयोग करता है।
+यदि आइटम का क्रम बदल सकता है तो हम key के लिए इंडेक्स का उपयोग ना करने की सिफारिश करते हैं। इसका नकारात्मक प्रभाव पड़ सकता हैं और यह कौम्पोनॅन्ट की अवस्था के साथ समस्या भी पैदा कर सकता है। अधिक जानकारी के लिए Robin Pokorny के [इंडेक्स को key के रूप में उपयोग करने के नकारात्मक प्रभाव](https://medium.com/@robinpokorny/index-as-a-key-is-an-anti-pattern-e0349aece318) के आर्टिकल को देखें। यदि आप लिस्ट आइटम्स को एक स्पष्ट key नहीं देते हैं, तो React key के रूप में इंडेक्स का उपयोग करता है।
 
-यदि आप अधिक सीखने में रुचि रखते हैं, तो यहाँ [key की आवशयकताओ के बारे में गहराई से स्पष्टीकरणं](/docs/reconciliation.html#recursing-on-children), दिया गया हैं।
+यदि आप अधिक सीखने में रुचि रखते हैं, तो यहाँ [key की आवशयकताओ के बारे में गहराई से स्पष्टीकरणं](/docs/reconciliation.html#recursing-on-children) दिया गया हैं।
 
 ### Key के साथ कौम्पोनॅन्टस निकालना {#extracting-components-with-keys}
 
@@ -204,10 +204,11 @@ ReactDOM.render(
 
 [**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/ZXeOGM?editors=0010)
 
-एक अच्छा नियम यह है कि एलिमेंटस को `map()` कॉल के समय पर key की जरुरत होती है।  
+एक अच्छा नियम यह है `map()` कॉल के एलिमेंट्स को key की आवशयकता होती हैं ।  
 
 ### Keys सिर्फ़ सिब्लिंग्स के बीच अद्वितीय होनी चाहिए {#keys-must-only-be-unique-among-siblings}
-Arrays के भीतर उपयोग की जाने वाली key उनके सिब्लिंग्स के बीच अद्वितीय होनी चाहिए। हालाँकि उन्हें विश्व स्तर पर अद्वितीय होने की आवश्यकता नहीं है। जब हम दो अलग-अलग arrays का उत्पादन करते हैं, तो हम उसी key का उपयोग कर सकते हैं:
+
+Arrays के भीतर उपयोग की जाने वाली key उनके सिब्लिंग्स के बीच अद्वितीय होनी चाहिए। हालाँकि उन्हें पूरी तरह से अद्वितीय होने की आवश्यकता नहीं है। हम अलग-अलग arrays के लिए सामान keys का उपयोग कर सकते हैं:
 
 ```js{2,5,11,12,19,21}
 function Blog(props) {
@@ -247,7 +248,7 @@ ReactDOM.render(
 
 [**इसे CodePen पर आज़माएँ**](https://codepen.io/gaearon/pen/NRZYGN?editors=0010)
 
-Keys React के लिए संकेत के रूप में काम करती हैं लेकिन वे आपके कौम्पोनॅन्टस को पास नहीं की जाती हैं। यदि आपको अपने कौम्पोनॅन्ट में समान वैल्यू की आवश्यकता है, तो इसे अलग नाम के साथ स्पष्ट रूप से prop की तरह पास करें:
+Keys React के लिए संकेत के रूप में काम करती हैं लेेकिन वह आपके कौम्पोनॅन्टस को नहीं दी जाती हैं। यदि आपको अपने कौम्पोनॅन्ट में समान वैल्यू की आवश्यकता है, तो इसे अलग नाम के साथ स्पष्ट रूप से prop की तरह पास करें:
 
 ```js{3,4}
 const content = posts.map((post) =>
@@ -260,7 +261,7 @@ const content = posts.map((post) =>
 
 ऊपर के उदाहरण के साथ, `Post` कौम्पोनॅन्ट `props.id` पढ़ सकता है, लेकिन `props.key` नहीं।
 
-### JSX में map() की एम्बेडिंग {#embedding-map-in-jsx}
+### JSX में map() को एम्बेड करना {#embedding-map-in-jsx}
 
 ऊपर दिए गए उदाहरणों में हमने एक अलग `listItems` वेरिएबल को घोषित किया था और इसे JSX में शामिल किया था:
 

From 9e277a7563339e3bacde95c5174701edb3b9ca76 Mon Sep 17 00:00:00 2001
From: Saransh Kataria <saransh@wisdomgeek.com>
Date: Mon, 3 Jun 2019 14:56:21 -0700
Subject: [PATCH 16/16] final changes to translation of list and keys

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

diff --git a/content/docs/lists-and-keys.md b/content/docs/lists-and-keys.md
index c3e960d4e..448ef64ac 100644
--- a/content/docs/lists-and-keys.md
+++ b/content/docs/lists-and-keys.md
@@ -136,7 +136,7 @@ const todoItems = todos.map((todo, index) =>
 
 ### Key के साथ कौम्पोनॅन्टस निकालना {#extracting-components-with-keys}
 
-Keys केवल उनके array के लिए ही होती है।
+Keys केवल आस-पास के array के संदर्भ में ही समझ में आती हैं।
 
 उदाहरण के लिए, यदि आप एक ListItem कौम्पोनॅन्ट को [निकालते](/docs/components-and-props.html#extracting-components) हैं, तो आपको key `ListItem` के `<li>` एलिमेंट पर रखने के बजाये array में `<ListItem />` एलिमेंट पर रखनी चाहिए।