diff --git a/content/docs/reference-react.md b/content/docs/reference-react.md
index 16d394230..457f8c984 100644
--- a/content/docs/reference-react.md
+++ b/content/docs/reference-react.md
@@ -13,7 +13,7 @@ redirect_from:
   - "docs/top-level-api-zh-CN.html"
 ---
 
-React লাইব্রেরীর একদম শুরুর API হল `React`। আপনি যদি `<script>` ট্যাগ থেকে React লোড করেন, এই টপ ্লেভেল APIগুলো আপনারা `React` গ্লোবালে পাবেন। আপনি যদি ES6 এর সাথে npm ব্যবহার করে থাকেন, লিখতে পারেন `import React from 'react'`। আপনি যদি ES5 এর সাথে npm ব্যবহার করে থাকেন, লিখতে পারেন `var React = require('react')`। 
+React লাইব্রেরীর একদম শুরুর API হল `React`। আপনি যদি `<script>` ট্যাগ থেকে React লোড করেন, এই টপ লেভেল APIগুলো আপনারা `React` গ্লোবালে পাবেন। আপনি যদি ES6 এর সাথে npm ব্যবহার করে থাকেন, লিখতে পারেন `import React from 'react'`। আপনি যদি ES5 এর সাথে npm ব্যবহার করে থাকেন, লিখতে পারেন `var React = require('react')`। 
 
 ## একনজরে {#overview}
 
@@ -69,7 +69,6 @@ React কম্পোনেন্টগুলোকে wrap করা যায়
 
 *হুক* হচ্ছে React 16.8 এ যোগ হওয়া নতুন ফিচার। এটি আপনাকে কোন ক্লাস না লিখেই স্টেট এবং অন্যান্য বিভিন্ন React ফিচার ব্যবহারের সুযোগ দেয়। হুকের [নিজরই একটি ডক সেকশন](/docs/hooks-intro.html)এবং আলাদা একটি API রেফারেন্স রয়েছে।
 
-
 - [Basic Hooks](/docs/hooks-reference.html#basic-hooks)
   - [`useState`](/docs/hooks-reference.html#usestate)
   - [`useEffect`](/docs/hooks-reference.html#useeffect)
@@ -111,7 +110,7 @@ class Greeting extends React.Component {
 
 > নোট
 >
-> `React.PureComponent`এর `shouldComponentUpdate()` খুব অগভীরভাবে অব্জেক্টের মধ্যে তুলনা করে। যদি এদের মধ্যে জটিল ডাটা স্ট্রাকচার থাকে তবে, হায়ারার্কি ট্রির খুব গভীরে থাকা কোন অসমতার জন্য ফলস-নেগেটিভ ফলাফল দিতে পারে। যখন আপনার প্রপ এবং স্টেট একদম সরল হবে তখনই শুধুমাত্র `PureComponent` এক্সটেন্ড করবেন। আর যদি আপনি জেনে থাকেন ডাটা স্ট্রাকচারের গভীরে কিছু পরিবর্তন হয়ে আছে তবে [`forceUpdate()`](/docs/react-component.html#forceupdate) ব্যবহার করুন। অথবা, খুব দ্রুত এ ধরণের নেস্টেড ডেটা তুলনা করবার জন্য [immutable objects](https://facebook.github.io/immutable-js/) ব্যবহার করতে পারেন।
+> `React.PureComponent`এর `shouldComponentUpdate()` খুব অগভীরভাবে অব্জেক্টের মধ্যে তুলনা করে। যদি এদের মধ্যে জটিল ডেটা স্ট্রাকচার থাকে তবে, হায়ারার্কি ট্রির খুব গভীরে থাকা কোন অসমতার জন্য ফলস-নেগেটিভ ফলাফল দিতে পারে। যখন আপনার প্রপ এবং স্টেট একদম সরল হবে তখনই শুধুমাত্র `PureComponent` এক্সটেন্ড করবেন। আর যদি আপনি জেনে থাকেন ডেটা স্ট্রাকচারের গভীরে কিছু পরিবর্তন হয়ে আছে তবে [`forceUpdate()`](/docs/react-component.html#forceupdate) ব্যবহার করুন। অথবা, খুব দ্রুত এ ধরণের নেস্টেড ডেটা তুলনা করবার জন্য [immutable objects](https://facebook.github.io/immutable-js/) ব্যবহার করতে পারেন।
 >
 > এছাড়াও, `React.PureComponent` এর `shouldComponentUpdate()` পুরো কম্পোনেন্ট সাবট্রি জুড়েই প্রপ এর যেকোন পরিবর্তনকে অগ্রাহ্য করে। নিশ্চিত করুন যে প্রতিটা চাইল্ড কম্পোনেন্ট ও "পিওর"।
 
@@ -121,7 +120,7 @@ class Greeting extends React.Component {
 
 ```javascript
 const MyComponent = React.memo(function MyComponent(props) {
-  /* render using props */
+  /* প্রপ ব্যবহার করে রেন্ডার */
 });
 ```
 
@@ -129,27 +128,27 @@ const MyComponent = React.memo(function MyComponent(props) {
 
 যদি আপনার ফাংশন কম্পোনেন্ট একই প্রপের জন্য একই ফলাফল দিয়ে থাকে, তাহলে আপনি একে `React.memo` এর জন্য একটি কল এ wrap করে ফেলতে পারেন। এটি  কিছু কিছু ক্ষেত্রে ফলাফলগুলোকে মনে রাখার মাধ্যমে(memoizing) অ্যাপ্লিকেশনের কার্যক্ষমতা বাড়িয়ে দিতে পারে। অর্থাৎ, React বার বার কম্পোনেন্টটি রেন্ডার না করে সর্বশেষ রেন্ডার করা ফলাফল মনে রাখবে। 
 
-By default it will only shallowly compare complex objects in the props object. If you want control over the comparison, you can also provide a custom comparison function as the second argument.
+স্বাভাবিকভাবে, এটা অগভীরভাবে প্রপ্স অবজেক্টে জটিল অবজেক্টগুলোকে তুলনা করবে। যদি আপনি এই তুলনার উপরে কর্তৃত্ব চান, তাহলে আপনি দ্বিতীয় আর্গুমেন্ট হিসেবে আপনার নিজের বানানো একটি ফাংশন লিখে দিতে পারেন। 
 
 ```javascript
 function MyComponent(props) {
-  /* render using props */
+  /* প্রপ ব্যবহার করে রেন্ডার */
 }
 function areEqual(prevProps, nextProps) {
   /*
-  return true if passing nextProps to render would return
-  the same result as passing prevProps to render,
-  otherwise return false
+  যদি nextProps এবং prevProps কে রেন্ডার করার জন্য পাস করা হয়
+  এবং তা একই ফলাফল দেয় তবে true হবে
+  অন্যথায় false হবে
   */
 }
 export default React.memo(MyComponent, areEqual);
 ```
 
-This method only exists as a **[performance optimization](/docs/optimizing-performance.html).** Do not rely on it to "prevent" a render, as this can lead to bugs.
+এই মেথডটি শুধুমাত্র একটি **[পারফরমেন্স অপ্টিমাইজেশন](/docs/optimizing-performance.html)** হিসেবে রয়েছে। রেন্ডারিং থামাবার জন্য এটি ব্যবহার করবেন না। কারণ, পরবর্তীতে সেটা বিভিন্ন বাগ এর কারণ হিসেবে ধরা পড়তে পারে।
 
-> Note
+> নোট
 >
-> Unlike the [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) method on class components, the `areEqual` function returns `true` if the props are equal and `false` if the props are not equal. This is the inverse from `shouldComponentUpdate`.
+> ক্লাস কম্পোনেন্টের জন্য `areEqual` ফাংশনটি [`shouldComponentUpdate()`](/docs/react-component.html#shouldcomponentupdate) ফাংশনের ঠিক উলটো। `areEqual` ফাংশনটি প্রপ সমান হলে `true` এবং অসমান হলে `false` রিটার্ন করে।
 
 * * *
 
@@ -163,9 +162,9 @@ React.createElement(
 )
 ```
 
-Create and return a new [React element](/docs/rendering-elements.html) of the given type. The type argument can be either a tag name string (such as `'div'` or `'span'`), a [React component](/docs/components-and-props.html) type (a class or a function), or a [React fragment](#reactfragment) type.
+এটা নির্দিষ্ট ধরণের একটি নতুন [React এলিমেন্ট](/docs/rendering-elements.html) বানাতে এবং রিটার্ন করতে পারে। টাইপ আর্গুমেন্টটি হতে পারে কোন ট্যাগ নেম স্ট্রিং (ক্লাস বা ফাংশন), অথবা একটি [React ফ্র্যাগমেন্ট](#reactfragment) টাইপ, অথবা একটি [React কম্পোনেন্ট](/docs/components-and-props.html) টাইপ। 
 
-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) দিয়ে লেখা কোড `React.createElement()` ব্যবহার করবার জন্য রূপান্তরিত হয়ে যাবে। আপনি JSX ব্যবহার করে থাকলে সাধারণত `React.createElement()` সরাসরি ব্যবহার করবেন না। আরো জানবার জন্য [JSX ব্যতীত React](/docs/react-without-jsx.html) পেইজটি দেখুন। 
 
 * * *
 
@@ -179,17 +178,17 @@ React.cloneElement(
 )
 ```
 
-Clone and return a new React element using `element` as the starting point. The resulting element will have the original element's props with the new props merged in shallowly. New children will replace existing children. `key` and `ref` from the original element will be preserved.
+এটি একটি নতুন React এলিমেন্ট তৈরি করে, যার শুরুতে `element` থাকে। এর ফলে যে এলিমেন্টটি পাওয়া যাবে, মূল এলিমেন্টের প্রপ থাকবে এবং সাথে নতুন প্রপগুলো অগভীরভাবে যুক্ত করা থাকবে। আগের চাইল্ডগুলোকে নতুন চাইল্ডগুলো প্রতিস্থাপন করবে।মূল এলিমেন্টের  `key` এবং `ref` সুরক্ষিত থাকবে।
 
-`React.cloneElement()` is almost equivalent to:
+`React.cloneElement()` অনেকটাই নিচের অংশের সমতুল্য:
 
 ```js
 <element.type {...element.props} {...props}>{children}</element.type>
 ```
 
-However, it also preserves `ref`s. This means that if you get a child with a `ref` on it, you won't accidentally steal it from your ancestor. You will get the same `ref` attached to your new element.
+তবে এটি `ref`গুলোকেও সুরক্ষিত রাখে। অর্থাৎ, আপনি যদি একটি চাইল্ড পান যার মধ্যে `ref` আছে, তাহলে আপনি দুর্ঘটনাবশত হায়ারার্কিতে তার উপরের কোন কম্পোনেন্ট থেকে চুরি করবেন না। আপনার নতুন এলিমেন্টেও আপনি একই `ref` যুক্ত অবস্থায় পাবেন। 
 
-This API was introduced as a replacement of the deprecated `React.addons.cloneWithProps()`.
+নির্মাতারা যখন `React.addons.cloneWithProps()` API টি রাখতে নারাজ ছিলেন তখন এই `React.cloneElement()` API টি তার বদলি হিসেবে প্রতিষ্ঠা পায়।
 
 * * *
 
@@ -199,11 +198,11 @@ This API was introduced as a replacement of the deprecated `React.addons.cloneWi
 React.createFactory(type)
 ```
 
-Return a function that produces React elements of a given type. Like [`React.createElement()`](#createelement), the type argument can be either a tag name string (such as `'div'` or `'span'`), a [React component](/docs/components-and-props.html) type (a class or a function), or a [React fragment](#reactfragment) type.
+এটি এমন একটি ফাংশন রিটার্ন করে যা কোন নির্দিষ্ট React এলিমেন্ট তৈরি করে। [`React.createElement()`](#createelement) এর মত টাইপ আর্গুমেন্টটি হতে পারে কোন ট্যাগ নেম স্ট্রিং (ক্লাস বা ফাংশন), অথবা একটি [React ফ্র্যাগমেন্ট](#reactfragment) টাইপ, অথবা একটি [React কম্পোনেন্ট](/docs/components-and-props.html) টাইপ।
 
-This helper is considered legacy, and we encourage you to either use JSX or use `React.createElement()` directly instead.
+এই হেল্পারটিকে লেগাসি হিসেবে ধরা হয়, এবং JSX ব্যবহার করা অথবা `React.createElement()` এর মধ্যে যেকোন একটি করাকে আমরা সমর্থন করি। 
 
-You will not typically invoke `React.createFactory()` directly if you are using JSX. See [React Without JSX](/docs/react-without-jsx.html) to learn more.
+আপনি JSX ব্যবহার করে থাকলে সাধারণত `React.createFactory()` সরাসরি ব্যবহার করবেন না। আরো জানবার জন্য [JSX ব্যতীত React](/docs/react-without-jsx.html) পেইজটি দেখুন।
 
 * * *
 
@@ -213,13 +212,13 @@ You will not typically invoke `React.createFactory()` directly if you are using
 React.isValidElement(object)
 ```
 
-Verifies the object is a React element. Returns `true` or `false`.
+কোন একটি অবজেক্ট React এলিমেন্ট কিনা তা বের করার জন্য ব্যবহার করা হয়। এটি `true` অথবা `false` রিটার্ন করে। 
 
 * * *
 
 ### `React.Children` {#reactchildren}
 
-`React.Children` provides utilities for dealing with the `this.props.children` opaque data structure.
+`React.Children` API টি `this.props.children` এর মত অস্বচ্ছ ডেটা স্ট্রাকচারকে মোকাবেলা করবার জন্য দরকারি ফিচারসমূহ সরবরাহ করে। 
 
 #### `React.Children.map` {#reactchildrenmap}
 
@@ -227,11 +226,11 @@ Verifies the object is a React element. Returns `true` or `false`.
 React.Children.map(children, function[(thisArg)])
 ```
 
-Invokes a function on every immediate child contained within `children` with `this` set to `thisArg`. If `children` is an array it will be traversed and the function will be called for each child in the array. If children is `null` or `undefined`, this method will return `null` or `undefined` rather than an array.
+এটি হায়ারার্কিতে ঠিক পরের ধাপের প্রতিটি চাইল্ড যার `this` এর মান `thisArg` ঠিক করা আছে, সেগুলোর উপরে ফাংশন ইনভোক করে। যদি `children` একটা অ্যারে হয়, তাহলে এটি পুরো অ্যারের উপর প্রতিটি চাইল্ড এর জন্য চলবে। যদি চিল্ড্রেন `null` বা `undefined` হয় তাহলে এই মেথডটি অ্যারে রিটার্ন না করে `null` বা `undefined` রিটার্ন পাঠাবে। 
 
-> Note
+> নোট
 >
-> If `children` is a `Fragment` it will be treated as a single child and not traversed.
+> যদি `children` একটি `Fragment` হয়, তাহলে একে একটি সিংগল চাইল্ড হিসেবে ধরা হবে। এবং, এর উপরে ট্রাভার্স করা হবে না। 
 
 #### `React.Children.forEach` {#reactchildrenforeach}
 
@@ -239,7 +238,7 @@ Invokes a function on every immediate child contained within `children` with `th
 React.Children.forEach(children, function[(thisArg)])
 ```
 
-Like [`React.Children.map()`](#reactchildrenmap) but does not return an array.
+এটি [`React.Children.map()`](#reactchildrenmap) এর মতোই, তবে কোন অ্যারে রিটার্ন করে না। 
 
 #### `React.Children.count` {#reactchildrencount}
 
@@ -247,7 +246,7 @@ Like [`React.Children.map()`](#reactchildrenmap) but does not return an array.
 React.Children.count(children)
 ```
 
-Returns the total number of components in `children`, equal to the number of times that a callback passed to `map` or `forEach` would be invoked.
+`children` এ থাকা কম্পোনেন্ট এর সংখ্যা রিটার্ন করে যা মূলত `map` বা `forEach` এ পাঠানো কলব্যাকগুলোর ইনভোক হবার সংখ্যার সমান।  
 
 #### `React.Children.only` {#reactchildrenonly}
 
@@ -255,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.
+Verifies that `children` has only one child (a React element) and returns it. Otherwise this method throws an error. `children` এর শুধুমাত্র একটি চাইল্ড(একটি React এলিমেন্ট) আছে কি না দেখে, এবং থাকলে তা রিটার্ন করে। না থাকলে এরর দেখায়।  
 
-> Note:
+> নোট:
 >
->`React.Children.only()` does not accept the return value of [`React.Children.map()`](#reactchildrenmap) because it is an array rather than a React element.
+> [`React.Children.map()`](#reactchildrenmap) এর রিটার্ন করা মান `React.Children.only()` গ্রহণ করে না কারণ এটি একটি আরে। এটি কোন React এলিমেন্ট নয়।
 
 #### `React.Children.toArray` {#reactchildrentoarray}
 
@@ -267,17 +266,17 @@ Verifies that `children` has only one child (a React element) and returns it. Ot
 React.Children.toArray(children)
 ```
 
-Returns the `children` opaque data structure as a flat array with keys assigned to each child. Useful if you want to manipulate collections of children in your render methods, especially if you want to reorder or slice `this.props.children` before passing it down.
+এটি অস্বচ্ছ ডেটা স্ট্রাকচার `children` কে ফ্ল্যাট অ্যারে হিসেবে রিটার্ন করে। যেখানে প্রতিটা চাইল্ড এর সাথে key যুক্ত করা থাকে। এটি তখন কাজে লাগে যখন আপনি আপনার রেন্ডার মেথডে চিল্ড্রেন এর কালেকশনে পরিবর্তন ঘটাতে চান। আরো বিশেষভাবে তখন, যখন   `this.props.children` কে ট্রিতে নিচের দিকে পাঠিয়ে দেবার আগে আবার সাজাতে চান বা স্লাইস করতে চান।  
 
-> Note:
+> নোট:
 >
-> `React.Children.toArray()` changes keys to preserve the semantics of nested arrays when flattening lists of children. That is, `toArray` prefixes each key in the returned array so that each element's key is scoped to the input array containing it.
+> যখন চিল্ড্রেন এর লিস্ট ফ্ল্যাট করে ফেলে, তখন নেস্টেড (nested) অ্যারেগুলোর ভাষা ঠিক রাখবার জন্য key গুলো সুরক্ষিত রাখে। অর্থাৎ, যে অ্যারেটা রিটার্ন করা হয়, তার প্রতিটা কি এর আগে `toArray` প্রিফিক্স হিসেবে থাকে। এর ফলে প্রতিটা এলিমেন্ট যেই ইনপুট অ্যারেতে আছে, ওই এলিমেন্ট এর কি তার সাথেই সংযুক্ত থাকে। 
 
 * * *
 
 ### `React.Fragment` {#reactfragment}
 
-The `React.Fragment` component lets you return multiple elements in a `render()` method without creating an additional DOM element:
+`React.Fragment` কম্পোনেন্টটি কোনরকম DOM এলিমেন্ট তৈরি না করেই একটি `render()` মেথডে একাধিক এলিমেন্ট রিটার্ন করার সুযোগ দেয়। 
 
 ```javascript
 render() {
@@ -290,59 +289,59 @@ 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).
+আপনি একই কাজ `<></>` শর্টহ্যান্ড (shorthand) ব্যবহার করেও করতে পারেন। এ বিষয়ে আরো জানতে [React v16.2.0: ফ্র্যাগমেন্টের জন্য উন্নততর সাপোর্ট](/blog/2017/11/28/react-v16.2.0-fragment-support.html) পৃষ্ঠাটি দেখুন। 
 
 
 ### `React.createRef` {#reactcreateref}
 
-`React.createRef` creates a [ref](/docs/refs-and-the-dom.html) that can be attached to React elements via the ref attribute.
+`React.createRef` একটি [ref](/docs/refs-and-the-dom.html) তৈরি করে যা রেফ এট্ট্রিবিউট ব্যবহার করে বিভিন্ন React এলিমেন্টের সাথে যুক্ত করা যায়। 
 `embed:16-3-release-blog-post/create-ref-example.js`
 
 ### `React.forwardRef` {#reactforwardref}
 
-`React.forwardRef` creates a React component that forwards the [ref](/docs/refs-and-the-dom.html) attribute it receives to another component below in the tree. This technique is not very common but is particularly useful in two scenarios:
+`React.forwardRef` যে [রেফ](/docs/refs-and-the-dom.html) এট্ট্রিবিউট পায় (recieve করে), সেটাকে ট্রি এর ন্নিচের অন্য একটি কম্পোনেন্ট এ পাঠাবার জন্য একটি কম্পোনেন্ট তৈরি করে। এই বুদ্ধিটা খুব একটা ব্যবহৃত হয় না, তবে দুইটা বিশেষ দৃশ্যকল্পের জন্য এটি খুব কাজের:  
 
-* [Forwarding refs to DOM components](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
-* [Forwarding refs in higher-order-components](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
+* [DOM কম্পোনেন্ট এ রেফ পাঠানো](/docs/forwarding-refs.html#forwarding-refs-to-dom-components)
+* [হায়ার-অর্ডার-কম্পোনেন্ট এ রেফ পাঠানো ](/docs/forwarding-refs.html#forwarding-refs-in-higher-order-components)
 
-`React.forwardRef` accepts a rendering function as an argument. React will call this function with `props` and `ref` as two arguments. This function should return a React node.
+`React.forwardRef` রেন্ডারিং ফাংশনকে একটা আর্গুমেন্ট হিসেবে গ্রহণ করে। React `props` এবং `ref` কে দুইটি আর্গুমেন্ট হিসেবে ব্যবহার করে এই ফাংশনকে কল করবে। সেক্ষেত্রে এই ফাংশনের একটি React নোড রিটার্ন করবার কথা। 
 
 `embed:reference-react-forward-ref.js`
 
-In the above example, React passes a `ref` given to `<FancyButton ref={ref}>` element as a second argument to the rendering function inside the `React.forwardRef` call. This rendering function passes the `ref` to the `<button ref={ref}>` element.
+উপরের এই উদাহরণে, React`React.forwardRef` এর মধ্যে থাকা রেন্ডারিং ফাংশনের দ্বিতীয় আর্গুমেন্ট হিসেবে একটি `ref` পাঠায় যা `<FancyButton ref={ref}>` এলিমেন্টে দেওয়া আছে। আবার এই রেন্ডারিং ফাংশনটি `<button ref={ref}>` এলিমেন্টে `ref` টি পাঠিয়ে দেয়। 
 
-As a result, after React attaches the ref, `ref.current` will point directly to the `<button>` DOM element instance.
+As a result, after React attaches the ref, `ref.current` will point directly to the `<button>` DOM element instance. ফলস্বরূপ, React রেফ যুক্ত করলে `ref.current` সরাসরি `<button>` DOM এলিমেন্টটিকে নির্দেশ করবে। 
 
-For more information, see [forwarding refs](/docs/forwarding-refs.html).
+For more information, see [forwarding refs](/docs/forwarding-refs.html). আরো তথ্যের জন্য [রেফ ফরোয়ার্ড](/docs/forwarding-refs.html) প 
 
 ### `React.lazy` {#reactlazy}
 
-`React.lazy()` lets you define a component that is loaded dynamically. This helps reduce the bundle size to delay loading components that aren't used during the initial render.
+`React.lazy()` আপনাকে একটি কম্পোনেন্ট ডিফাইন করতে দিবে যা ডাইনামিকভাবে লোড হয়। প্রথম রেন্ডার এর সময় কিছু কম্পোনেন্ট ব্যবহৃত হয় না। কিন্তু এগুলো লোড করতে কিছু সময় নষ্ট হয়। `React.lazy()` এই বান্ডলের আকারটি কমিয়ে এনে লোড আরো দ্রুততর করে। 
 
-You can learn how to use it from our [code splitting documentation](/docs/code-splitting.html#reactlazy). You might also want to check out [this article](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) explaining how to use it in more detail.
+এটা ব্যবহার করা আপনি আমাদের [কোড স্প্লিটিং ডকুমেন্টেশন](/docs/code-splitting.html#reactlazy) থেকে শিখে নিতে পারেন। আরো বিস্তারিত জানবার জন্য [এই আর্টিকেলটি](https://medium.com/@pomber/lazy-loading-and-preloading-components-in-react-16-6-804de091c82d) পড়ে দেখতে পারেন। 
 
 ```js
-// This component is loaded dynamically
+// এই কম্পোনেন্ট ডাইনামিকভাবে লোড হয়েছে।
 const SomeComponent = React.lazy(() => import('./SomeComponent'));
 ```
 
-Note that rendering `lazy` components requires that there's a `<React.Suspense>` component higher in the rendering tree. This is how you specify a loading indicator.
+খেয়াল করে দেখবেন, `lazy` কম্পোনেন্ট ব্যবহার করবার জন্য রেন্ডারিং ট্রিতে উপরের দিকে কোথাও এক জায়গায়  `<React.Suspense>` কম্পোনেন্টটি থাকা দরকার। এর সাহায্যে আপনি লোড করা হচ্ছে কি না তার একটা নির্দেশক ঠিক করে ফেলতে পারেন।
 
-> **Note**
+> **নোট**
 >
-> Using `React.lazy`with dynamic import requires Promises to be available in the JS environment. This requires a polyfill on IE11 and below.
+> ডাইনামিক ইম্পোর্ট এর সাথে `React.lazy` ব্যবহারের জন্য আপনার জাভাস্ক্রিপ্ট এনভায়রনমেন্টে Promises থাকা জরুরী। IE11 বা তার নিচে কোথাও একটি polyfill থাকতে হবে। 
 
 ### `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` আপনাকে লোডিং এর একটি নির্দেশক(loading indicator) ঠিক করে দেবার সুযোগ দিবে। এর প্রয়োজন পড়বে যদি এর নিচে ট্রিতে কোথাও এমন একটি কম্পোনেন্ট থাকে যা রেন্ডারিং এর জন্য তৈরি না। এখন পর্যন্ত, `<React.Suspense>` সমর্থিত একমাত্র ব্যবহারযোগ্য অবস্থা হল এই lazy loading components:
 
 ```js
-// This component is loaded dynamically
+// এই কম্পোনেন্ট ডাইনামিকভাবে লোড হয়েছে।
 const OtherComponent = React.lazy(() => import('./OtherComponent'));
 
 function MyComponent() {
   return (
-    // Displays <Spinner> until OtherComponent loads
+    // যতক্ষণ না OtherComponent লোড হচ্ছে ডিস্প্লেতে <Spinner> দেখায়।
     <React.Suspense fallback={<Spinner />}>
       <div>
         <OtherComponent />
@@ -352,10 +351,10 @@ function MyComponent() {
 }
 ```
 
-It is documented in our [code splitting guide](/docs/code-splitting.html#reactlazy). Note that `lazy` components can be deep inside the `Suspense` tree -- it doesn't have to wrap every one of them. The best practice is to place `<Suspense>` where you want to see a loading indicator, but to use `lazy()` wherever you want to do code splitting.
+আমাদের [কোড স্প্লিটিং ডকুমেন্টেশন](/docs/code-splitting.html#reactlazy) এ এটি ব্যখ্যা করা আছে। লক্ষ্য করুন, `lazy` কম্পোনেন্টগুলো `Suspense` ট্রি এর খুব গভীরে অবস্থান করে থাকতে পারে। এদের প্রত্যেকটাকে wrap করবার কোন প্রয়োজন নেই। সবচেয়ে ভাল অভ্যাস হচ্ছে, লোড হবার নির্দেশক (loading indicator) যেখানে দরকার সেখানে `<Suspense>` ব্যবহার করা এবং যেখানে কোড স্প্লিটিং করা দরকার সেখানে `lazy()` ব্যবহার করা। 
 
-While this is not supported today, in the future we plan to let `Suspense` handle more scenarios such as data fetching. You can read about this in [our roadmap](/blog/2018/11/27/react-16-roadmap.html).
+ভবিষ্যতে আমরা `Suspense` এর সাহায্যে ডাটা ফেচ করবার মত বিভিন্ন অবস্থা নিয়ন্ত্রণ করার ব্যবস্থা করতে চাই, যা এখনো সম্ভব নয়। আমাদের পরিকল্পনা সম্বন্ধে আরো জানতে [আমাদের রোডম্যাপ](/blog/2018/11/27/react-16-roadmap.html) দেখুন।
 
->Note:
+>নোট:
 >
->`React.lazy()` and `<React.Suspense>` are not yet supported by `ReactDOMServer`. This is a known limitation that will be resolved in the future.
+>`ReactDOMServer` এখনো পর্যন্ত `React.lazy()` এবং `<React.Suspense>` কে সমর্থন করে না। এটি একটি পরিচিত সীমাবদ্ধতা যেখান থেকে ভবিষ্যতে আমরা বেরিয়া আসতে পারব বলে বিশ্বাস করি।