49 |
50 | );
51 | }
52 | ```
53 |
54 | ### `condition ? true : false - Ternery Operator`
55 |
56 | আমাদের কন্ডিশন যদি অনেক বেশি কমপ্লেক্স না হয় এবং ম্যক্সিমাম ২-৩ লেবেলের বেশি ডিপ না হয় তাহলে আমরা খুব সহজেই `JSX` এর ভিতরেই `Ternery Operator` ব্যাবহার করে কন্ডিশনাল রেন্ডারিং করতে পারি।
57 |
58 | ** উদাহরণঃ**
59 |
60 | ```javascript filename="Item.jsx" showLineNumbers
61 | function Item({ name, isPacked }) {
62 | return
{isPacked ? name + " ✅" : name}
;
63 | }
64 | ```
65 |
66 | ### `&& - Logical AND Operator`
67 |
68 | যদি আমাদের কন্ডিশন এমন হয় যে, কন্ডিশন মিললে কিছু রেন্ডার করবো আর না মিললে কিছুই রেন্ডার করবোনা,তাহলে আমরা আরও শর্টকাটে `&& - Logical AND Operator` ব্যাবহার করে সেটা করতে পারি।
69 |
70 | ```javascript filename="Item.jsx" showLineNumbers
71 | function Item({ name, isPacked }) {
72 | return (
73 |
74 | {name} {isPacked && "✅"}
75 |
76 | );
77 | }
78 | ```
79 |
80 | লজিকাল `&&` এর মানে হলো যে, `&&` এর বাম পাশে `truthy` ভ্যালু হয় তাহলে ডান পাশের ভ্যালু রিটার্ন করবে,আর `falsy` হলে কিছুই রিটার্ন করবেনা।
81 |
82 | ```javascript showLineNumbers
83 | let logic = "true";
84 | logic && "Something to Render"; // এখানে লজিকের ভ্যালু `truthy` হলেই শুধ্যমাত্র `&&` এর ডান পাশে যা থাকবে তা রিটার্ন করবে,আর না হলে কিছুই রিটার্ন করবেনা।
85 | ```
86 |
87 | তবে এক্ষেত্র মনে রাখতে হবে যে, `&&` এর বাম পাশের ডাটাটাইপ যেন নাম্বার না হয়,কেননা যদি নাম্বার হয় তাহলে নাম্বারের `falsy` ভ্যালু হিসেবে `0`রিটার্ন করে দিবে।
88 |
89 | ### `|| - Logical OR operator`
90 |
91 | লজিকাল `&&` এর মতো `|| - Logical OR operator` ব্যাবহার করেও সেম কাজ করতে পারি।
92 |
93 | ```javascript filename="Item.jsx" showLineNumbers
94 | function Item({ name, isPacked }) {
95 | return (
96 |
97 | {name} {isPacked || "✅"}
98 |
99 | );
100 | }
101 | ```
102 |
103 | তবে লজিকাল `||` এর মানে হলো যে, `||` এর বাম পাশে `falsy` (`0`,`null`,`undefined`,`""`,`false`,`NaN`) ভ্যালু হয় তাহলেই শুধুমাত্র ডান পাশের ভ্যালু রিটার্ন করবে,আর না হলে কিছুই রিটার্ন করবেনা।
104 |
105 | ```javascript showLineNumbers
106 | let logic = "false";
107 | logic || "Something to Render"; // এখানে লজিকের ভ্যালু `falsy` হলেই শুধ্যমাত্র `||` এর ডান পাশে যা থাকবে তা রিটার্ন করবে,আর না হলে কিছুই রিটার্ন করবেনা।
108 | ```
109 |
110 | ### `?? - Nullish Coalesing operator`
111 |
112 | যদি কোন ডাইনামিক ভ্যালু `null` অথবা `undefined` হয় তাহলে যদি আমরা কোন কিছু করতে চাই, তাহলে আমরা `?? - Nullish Coalesing operator` ব্যাবহার করে তা করতে পারি।
113 |
114 | ```javascript filename="Item.jsx" showLineNumbers
115 | function Item({ name, isPacked, data }) {
116 | return (
117 | data ?? (
118 |
119 | {name} {isPacked || "✅"}
120 |
121 | )
122 | );
123 | }
124 | ```
125 |
126 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-1/introduction-to-react.mdx:
--------------------------------------------------------------------------------
1 | ## `React` কি ?
2 |
3 | রিয়াক্ট হলো ফেসবুকের ডেভেলপ করা একটা জাভাস্ক্রিপ্ট লাইব্রেরি। যা একই সাথে ন্যটিভ এবং ওয়েব ইন্টারফেস ডিজাইন করতে সহায়তা করে থাকে। এটি জাভাস্ক্রিপ্ট এ লেখা জাভাস্ক্রিপ্ট এর ই একটা লাইব্রেরি।
4 |
5 | ফেসবুকের সফটওয়্যার ইঞ্জিনিয়ার Jordan Walke 2011 সালে PHP এর একটা Component Based Framework XHP-js থেকে ইন্সপায়ার হয়ে React.js তৈরি করেন। 2011 সালে এটা প্রথম ফেসবুকের নিউজফিডে ইম্পিলিমেন্ট করা হয় এবং ২০১২ সালে এটা ইন্সটাগ্রামে ব্যবহার করা হয়। ২০১৩ সালে React.js কে ওপেন সোর্স করে দেয় ফেসবুক কোম্পানি। রিয়্যাক্ট এর ওপেন সোর্স গিটহাব রিপোজিটরি [React.js](https://github.com/facebook/react) এ ভ্যানিলা জাভাস্ক্রিপ্ট ছাড়া আর কিচ্ছু নাই।
6 |
7 | ## `React`কেন ব্যাবহার করা উচিত,ভ্যানিলা জাভাস্ক্রিপ্ট এ কি প্রব্লেম ?
8 |
9 | যখন আমরা ভ্যানিলা জাভাস্ক্রিপ্ট এ কাজ করি,তখন যেটা হয় যে, ইউজারের ইন্টারেকশনের কারনে যখন কোথাও কোন UI চেঞ্জ করা লাগে, তখন আমাদের প্রতিটা UI চেঞ্জ ম্যানুয়ালি করে দিতে হয়। কিন্তু `React` এ আমাদের তা করা লাগেনা। রিয়াক্টে ইউজারেরে কোন ইন্টারেকশনের কারনে যখনি কোন ডেটা বা স্টেট চেঞ্জ হয়,তখন UI টা অটোমেটিক রিয়াক্ট করে,এবং UI টা অটোমেটিক চেঞ্জ হয়। এইযে বার বার যেই UI আপডেট করার প্রসেস, এই প্রসেসটাই অটোমেটিক করার জন্যই মূলত রিয়াক্ট তৈরি করাব হয়েছে।
10 |
11 | ## `React` এবং `React DOM` কি ?
12 |
13 | একটা UI বানাতে আসলে তিনটা দিক ম্যানেজ করা লাগে,
14 |
15 | - 1. UI/ DOM টাকে বানানো।
16 | - 2. User Interaction হ্যান্ডেল করা।
17 | - 3. DOM টা ব্রাউজারে রেন্ডার করা ।
18 |
19 | `React` এবং `React DOM` এই দুইটা প্যাকেজ আসলে এই কাজগুলোই করে থাকে।
20 |
21 | `React` USER INTERFACE বানাতে হেল্প করে এবং ইউজারের ইন্টারেকশনের কারনে যদি কোন ডাটা চেঞ্জ হয় সেটা ম্যানেজ করে।
22 |
23 | `React DOM` এই প্যাকেজটা DOM টাকে ব্রাউজারে রেন্ডার করে,এবং একবার ব্রাউজারে রেন্ডার করানো হয়ে গেলে সে ডেটা চেঞ্জ এর জন্য অপেক্ষা করতে থাকে,যদি কোথাও কোন ডেটা চেঞ্জ হয়,তাহলে সে তার `VERTUAL DOM` এর সেই চেঞ্জটাকে শনাক্ত করে, UI এর যা যা চেঞ্জ করা লাগে তা করে সরাসরি ব্রাউজারে পেইন্ট করে দেয়। এবং ইউজার আপডেটেড UI তা দেখতে পারে।
24 |
25 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-1/javascript-in-jsx.mdx:
--------------------------------------------------------------------------------
1 | **`JSX`এ আমরা জাভাস্ক্রিপ্ট এবং `HTML` মার্কাপ একসাথে লিখতে পারি। যখনি মার্কাপে কোন ডাইয়ামিক ভ্যালু ব্যাবহার করতে হয়,অথবা কোন লজিকাল অপারেসন চালাতে হয় এমনকি যদি কোন ভ্যারিয়াবল বা অবজেক্টের ভ্যালু এক্সেস করার প্রয়োজন হয়,তখন তা `{ }` ডাবল কার্লি ব্রেসেস এর ভিতরে লিখতে হয়।**
2 |
3 | উদাহরনঃ
4 |
5 | ```javascript filename="Profile.jsx" showLineNumbers {5-6,8}
6 | export default function Profile(name) {
7 | let age = 30;
8 | return (
9 |
10 |
Hello Mr {name}
// name হলো একটা ডাইনামিক ভ্যালূ যা {} দিয়ে
11 | জাভাস্ক্রিপ্টের মাধ্যমে লেখা হয়েছে।
12 |
Your age is {age}
// age একটা ভ্যারিয়েবল থেকে পাওয়া ডাইনামিক ভ্যালু
13 | যা {} দিয়ে লেখা হয়েছে।
14 |
15 | You are {age >= 21 ? "Eligable" : "Not Eligable"} for Marraige
16 | // এই লাইনে জাভাস্ক্রিপ্টের মাধ্যমে লজিকাল অপারেশন করা হয়েছে
17 |
18 |
19 | );
20 | }
21 | ```
22 |
23 | অর্থাৎ `{ }` দিয়ে এর ভিতরে আমরা জাভাস্ক্রিপ্টের এক্সপ্রেশন লিখতে পারি।
24 |
25 | ## Using “double curlies”: CSS and other objects in JSX
26 |
27 | উদাহরনঃ
28 |
29 | ```javascript filename="Profile.jsx" showLineNumbers {6,8-11}
30 | export default function Profile(name) {
31 | let age = 30;
32 | return (
33 |
41 |
Hello Mr {name}
// name হলো একটা ডাইনামিক ভ্যালূ যা {} দিয়ে
42 | জাভাস্ক্রিপ্টের মাধ্যমে লেখা হয়েছে।
43 |
Your age is {age}
// age একটা ভ্যারিয়েবল থেকে পাওয়া ডাইনামিক ভ্যালু
44 | যা {} দিয়ে লেখা হয়েছে।
45 |
46 | You are {age >= 21 ? "Eligable" : "Not Eligable"} for Marraige
47 | // এই লাইনে জাভাস্ক্রিপ্টের মাধ্যমে লজিকাল অপারেশন করা হয়েছে
48 |
49 |
50 | );
51 | }
52 | ```
53 |
54 | যখন `JSX` এ `{ }` এর ভিতরে কোন অবজেক্ট লিখা লাগবে তখনও একই স্টেপ ফলো করতে হবে, এতে হয়তো মনে হতে পারে যে আমরা দুইবার `{ }` ব্যাবহার করছি, কিন্তু না, প্রথম `{ }` টা হলো জাভাস্ক্রিপ্টের জন্য জায়গা বানানো এবং দ্বিতীয় `{ }` টা হলো অবজেক্ট এর জন্য।
55 |
56 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-1/jsx-markup.mdx:
--------------------------------------------------------------------------------
1 | ## `JSX` কি ?
2 |
3 | `JSX` হলো জাভাস্ক্রিপ্টের একটি সিনট্যাক্স এক্সটেনশন যা আমাদেরকে `HTML` এর মতো মার্কাপ লিখতে সাহায্য করে । `JSX` এর বড় সুবিধা হলো এখানে একই জায়গায়(কম্পোনেন্টের ভিতর) জাভাস্ক্রিপ্টের লজিক ও `HTML` এর মার্কাপ লিখা যায়। যা পরবর্তিতে কোথাও কিছু চেঞ্জ করতে হলে আমাদের এক্সট্রা ফ্লেক্সিবিলিটি দেয়।
4 |
5 | `JSX` দেখতে একদম `HTML` এর মতো হলেও এটা কিন্তু `HTML` নয়,বরং `HTML` এর চাইতে অনেক বেশি `Strict`। `JSX` এ কোথাও কোন ভুল করলে তা সাথে সাথে `Error` দিয়ে দেয়।
6 |
7 | `HTML` এ আমরা শুধুমাত্র স্ট্যাটিক কন্টেন্ট লিখতে পারি,কিন্তু `JSX` এ আমারা ডাইনামিক ভ্যালু ব্যাবহার করতে পারি।
8 |
9 | ## `JSX` লিখার রুলসগুলো কি কি ?
10 |
11 | `JSX` এ বেশ কিছু রুলস ফলো করতে হয় তা হলোঃ
12 |
13 | ### 1. Return a Single root element:
14 |
15 | `JSX` এক্টিমাত্র সিঙ্গেল রুট এলিমেন্ট রিটার্ন করতে হবে, যদি মাল্টিপল এলিমেন্ট রিটার্ন করতে হয় তাহলে অবশ্যই একটি প্যারেন্ট এলিমেন্ট দিয়ে `wrap` করে দিতে হবে। এক্ষেত্র চাইলে `
` এলিমেন্ট ব্যাবহার করা যায়। তবে `
` ব্যাবহার করলে `HTML` এর `Eliment Tree` তে একটা অতিরিক্ত `
24 | // এই কোডটা কাজ করবেনা,কারণ দুইটা এলিমেন্টকে রিটার্ন করা হয়েছে
25 | );
26 | }
27 | ```
28 |
29 | ✅ সঠিক
30 |
31 | ```javascript filename= "Profile.jsx "
32 | export default function Profile() {
33 | return (
34 |
35 |
Hello Mr XX
36 |
Your age is 30
37 |
38 | // এই কোডটা কাজ করবে,কারণ দুইটা এলিমেন্টকে একটা প্যারেন্ট `
` দিয়ে wrap করা হয়েছে
39 | );
40 | }
41 | ```
42 |
43 | তবে আপানর ইচ্ছা যদি হয় যে আপনি কোন অতিরিক্ত `
` এলিমেন্ট রেন্ডার করবেন না তাহলে, `<>>` এভাবে ব্যাবহার করতে পারেন। এটাকে বলা হয় `Fragment` ট্যাগ। আবার যদি কখনও `Fragment` এর ভিতরে `key` পাস করা লাগে,তাহলে ফ্রাগমেন্ট `<>>` এভাবে না লিখে `` এভাবে লিখতে হবে।
44 |
45 | #### কেন আমাদের একটি মূল JSX রিটার্ন করতে হয়?
46 |
47 | **Credit to : Saffaullah Shuvo**
48 |
49 | Well, যে কোন প্রোগ্রামিং এই function থেকে কেবল একটি data type/structure এর ডেটা রিটার্ন করা যায়। যেমন একটি সিম্পল নাম্বার অথবা কোন কমপ্লেক্স ডেটা স্ট্রাকচার,
50 |
51 | ```javascript
52 | function returnOne() { return 1; } // দুইটা নাম্বার রিটার্ন করা কি সম্ভব?
53 | function returnTwo() { return (100 500) } // এটা একটা syntax error // তারমানে Compiler এইরকম syntax সাপোর্ট করেনা
54 |
55 | ```
56 |
57 | তাহলে দুইটা নাম্বার কি রিটার্ন করা যাবে না? যাবে-
58 |
59 | ```javascript
60 | function returnTwo() { return [100, 500]; // আরো অনেকভাবেই করা যায় }
61 | ```
62 |
63 | JSX গুলা যেহেতু javascript Object তাই
64 |
65 | ```javascript
66 | function returnTwoJSX() {
67 | return (
Hi
Hello
)
68 | }
69 | // Behind the scene
70 | function returnTwoJSX() {
71 | return (
72 | {type: 'h1', props: { children: 'Hi'}} // object1
73 | {type: 'h2', props: { children: 'Hello'}} // object2
74 | )
75 | }
76 | // তাই এটাও syntax error
77 |
78 | ```
79 |
80 | কিন্তু আমরা একটা Array এর ভিতরে রেখে কিংবা একটা প্যারেন্ট এলিমেন্টের ভিতরে রেখে একটা ডেটা হিসেবেই return করতে পারি।
81 |
82 | - সল্যুশন ১ - প্যারেন্ট এলিমেন্ট দিয়ে Wrap করে দেয়া
83 |
84 | ```javascript
85 | function returnParentJSX() {
86 | return (
87 |
88 |
Hi
89 |
Hello
90 |
91 | );
92 | }
93 | // Behind the scene
94 | function returnParentJSX() {
95 | return {
96 | type: "div",
97 | props: { children: [object1, object2] },
98 | // ...additional properties
99 | };
100 | }
101 | ```
102 |
103 | - সল্যুশন ২ - প্যারেন্ট হিসেবে Fragment ব্যবহার করা।
104 |
105 | ```javascript
106 | function returnFragmentJSX() {
107 | return (
108 |
109 | {" "}
110 | // short form <>>
111 |
Hi
112 |
Hello
113 |
114 | );
115 | }
116 | // Behind the scene
117 | function returnFragmentJSX() {
118 | return {
119 | type: Symbol(react.fragment),
120 | props: { children: [object1, object2] }, // ...additional property
121 | };
122 | }
123 | ```
124 |
125 | JSX এর বদলে ডিরেক্ট Object Return করলে কি কাজ করবে? যেমনঃ
126 |
127 | ```javascript
128 | function returnDirectObject() {
129 | return {
130 | type: "div",
131 | props: {
132 | className: "bg-white",
133 | children: [
134 | {
135 | type: "h1",
136 | props: { className: "text-2xl", children: "Hi" },
137 | },
138 | { type: "p", props: { children: "Hello World" } },
139 | ],
140 | },
141 | };
142 | }
143 | ```
144 |
145 | না, কারন এই Object টা React এর ওয়েতে বানানো হয়নি। রিয়েক্ট আরও Additional Property রাখে Object er ভিতর। রিয়েক্ট যেভাবে বানায় -
146 |
147 | ```javascript
148 | import { createElement } from "react";
149 |
150 | function returnDirectObject() {
151 | return createElement(
152 | "div",
153 | { className: "bg-white" },
154 | createElement("h1", { className: "text-2xl" }, "Hi"),
155 | createElement("p", null, "Hello World")
156 | );
157 | }
158 | ```
159 |
160 | ### 2. Close all the tags:
161 |
162 | `JSX` এ ব্যাবহার করা প্রতিটা ট্যাগ অবশ্যই ক্লোজ করা লাগবে। সেলফ ক্লোজিং ট্যাগ যেগুলো আছে যেমনঃ ``,``,সেগুলোও অবশ্যই এভাবে ``,`` ক্লোজ করা লাগবে ।
163 |
164 | ### 3. camelCase ~all~ most of the things!:
165 |
166 | `JSX` এ যেহেতু আমারা `JavaScript` লিখছি,সেহেতু আমাদের জাভাস্ক্রিপ্ট এর রুলস অনুযায়ী `multiple-word` এর `Attribute` গুলোকে `camelCase` এ লিখতে হবে।
167 |
168 | **`class` Attribute টা যেহেতু জাভাস্ক্রিপ্টের রিজার্ভ কিওয়ার্ড,তাই আমরা `class` ব্যাবহার করতে পারবোনা। `class` এর পরিবর্তে আমদের `className` ব্যাবহার করতে হবে ।**
169 |
170 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-1/pure-components.mdx:
--------------------------------------------------------------------------------
1 | ### পিওর ফাংশন কী?
2 |
3 | একটি ফাংশনকে পিওর (pure) বলা হয় যদি তা নিচের দুটি শর্ত পূরণ করে:
4 |
5 | 1. **সেম ইনপুটের জন্য সেম আউটপুট**: পিওর ফাংশন সবসময় তার ইনপুট অনুযায়ী নির্দিষ্ট আউটপুট প্রদান করে। অর্থাৎ একই ইনপুটের জন্য সবসময় একই আউটপুট পাওয়া যাবে।
6 | 2. **সাইড-ইফেক্টের অনুপস্থিতি**: পিওর ফাংশন বাইরের কোনো স্টেট বা ভ্যারিয়েবল পরিবর্তন করে না। এটি শুধুমাত্র ইনপুট অনুযায়ী কাজ করে এবং বাইরে কোনো পরিবর্তন আনে না।
7 |
8 | #### পিওর ফাংশনের উদাহরণ:
9 |
10 | ```javascript
11 | function add(a, b) {
12 | return a + b;
13 | }
14 | ```
15 |
16 | এখানে `add` ফাংশনটি পিওর, কারণ এটি কেবল তার ইনপুট অনুযায়ী আউটপুট দিচ্ছে এবং বাহ্যিক কোনো স্টেট পরিবর্তন করছে না।
17 |
18 | #### ইমপিওর ফাংশনের উদাহরণ:
19 |
20 | ```javascript
21 | let x = 10;
22 |
23 | function addWithSideEffect(a, b) {
24 | x = a + b; // বাহিরের ভ্যারিয়েবল পরিবর্তন করা হচ্ছে
25 | return x;
26 | }
27 | ```
28 |
29 | এই ফাংশনটি ইমপিওর, কারণ এটি বাহ্যিক ভ্যারিয়েবল `x` এর মান পরিবর্তন করছে, যা একটি সাইড-ইফেক্ট সৃষ্টি করছে।
30 |
31 | ---
32 |
33 | ### কেন React-এ পিওর ফাংশনাল কম্পোনেন্ট ব্যবহার করা উচিত?
34 |
35 | React কম্পোনেন্টগুলোকে পিওর রাখতে রিকমেন্ড, কারণ এতে বেশ কিছু সুবিধা রয়েছে। মূলত, পিওর ফাংশনাল কম্পোনেন্ট ব্যবহারের মাধ্যমে React এর পারফরম্যান্স ও ব্যবহারে সুবিধা পাওয়া যায়। আসুন, এই সুবিধাগুলো বিস্তারিতভাবে দেখি:
36 |
37 | ### ১. **অপ্রয়োজনীয় রেন্ডার এড়ানো**
38 |
39 | React পিওর ফাংশনাল কম্পোনেন্টগুলোর ক্ষেত্রে ইনপুট বা প্রপসে কোনো পরিবর্তন না হলে কম্পোনেন্টটি পুনরায় রেন্ডার করে না। অর্থাৎ, ইনপুট এক থাকলে React আগের আউটপুট ব্যবহার করতে পারে, যা অ্যাপ্লিকেশনের রেন্ডারিংয়ের কার্যকারিতা বৃদ্ধি করে।
40 |
41 | #### উদাহরণ:
42 |
43 | ```javascript
44 | import React from "react";
45 |
46 | const Greeting = React.memo(function Greeting({ name }) {
47 | console.log("Rendering Greeting");
48 | return
Hello, {name}!
;
49 | });
50 | ```
51 |
52 | এখানে `React.memo` ব্যবহারের মাধ্যমে এই কম্পোনেন্টকে পিওর করা হয়েছে। যদি `name` প্রপসের কোনো পরিবর্তন না ঘটে, তাহলে React পূর্বের রেন্ডারকৃত আউটপুটই পুনরায় ব্যবহার করবে, নতুন করে রেন্ডার করা প্রয়োজন হবে না।
53 |
54 | ### ২. **সহজ এবং ক্লিন কোড**
55 |
56 | পিওর ফাংশনাল কম্পোনেন্টের ব্যবহারে কোড সহজ ও ক্লিন হয়। যেহেতু এগুলো শুধু ইনপুটের ওপর নির্ভরশীল এবং কোনো বাহ্যিক স্টেটের উপর নির্ভর করে না, তাই এগুলো সহজেই বোঝা যায় এবং প্রয়োগ করা যায়।
57 |
58 | #### উদাহরণ:
59 |
60 | ```javascript
61 | function WelcomeMessage({ user }) {
62 | return
Welcome, {user}!
;
63 | }
64 | ```
65 |
66 | এই ধরনের কম্পোনেন্ট অত্যন্ত ক্লিন এবং সহজপাঠ্য, কারণ এটি কোনো বাহ্যিক স্টেট পরিবর্তন করে না, বরং শুধুমাত্র প্রপসের মাধ্যমে আউটপুট প্রদান করে।
67 |
68 | ### ৩. **প্রেডিক্টেবল আচরণ**
69 |
70 | পিওর ফাংশনাল কম্পোনেন্ট সবসময় নির্দিষ্ট ইনপুট অনুযায়ী নির্দিষ্ট আউটপুট দেয়। এতে করে এদের আচরণ প্রেডিক্টেবল হয়, অর্থাৎ আগেভাগেই অনুমান করা সম্ভব। এটি ডিবাগিং এবং বাগ সমাধানের ক্ষেত্রে গুরুত্বপূর্ণ, কারণ আচরণ সবসময় পূর্বানুমানযোগ্য থাকে।
71 |
72 | ### ৪. **সহজ টেস্টিং**
73 |
74 | পিওর ফাংশনাল কম্পোনেন্ট সহজেই টেস্ট করা যায়, কারণ এগুলো ইনপুট এবং আউটপুটের উপর নির্ভরশীল। ইনপুট অনুযায়ী আউটপুট পরীক্ষা করলেই সহজে বোঝা যায় যে ফাংশনটি সঠিকভাবে কাজ করছে কি না।
75 |
76 | #### উদাহরণ:
77 |
78 | ```javascript
79 | function sum(a, b) {
80 | return a + b;
81 | }
82 |
83 | // টেস্টিং উদাহরণ:
84 | console.log(sum(2, 3)); // আউটপুট হবে: 5
85 | ```
86 |
87 | ### ৫. **Memoization এর সুবিধা**
88 |
89 | React-এ পিওর ফাংশনাল কম্পোনেন্ট ব্যবহারের ফলে `memoization` সহজ হয়। একই ইনপুটের জন্য React আগের আউটপুট সংরক্ষণ করতে পারে, ফলে অপ্রয়োজনীয় রেন্ডার এড়িয়ে পারফরম্যান্স উন্নত করা যায়। `React.memo` এই কাজে বিশেষভাবে ব্যবহৃত হয়।
90 |
91 | ---
92 |
93 | React-এ পিওর ফাংশনাল কম্পোনেন্ট ব্যবহারের মাধ্যমে কোডের সহজ হয়, প্রেডিক্টেবিলিটি এবং পারফরম্যান্স বৃদ্ধি পায়। অপ্রয়োজনীয় রেন্ডারিং এড়ানো, সহজে টেস্ট করা, এবং কোড ক্লিন রাখার জন্য পিওর ফাংশন ব্যবহার অত্যন্ত গুরুত্বপূর্ণ। তাছাড়া, React এর `memoization` ফিচারের কারণে পিওর ফাংশনাল কম্পোনেন্ট ব্যবহারের মাধ্যমে অ্যাপ্লিকেশনের কার্যকারিতা উল্লেখযোগ্যভাবে বৃদ্ধি পায়।
94 |
95 | ### যদি আমাদেরকে এমন কোন কাজ করতেই হয় যাতে কম্পোনেন্টের পিওরিটি নষ্ট হলেও করতে হবে,এমনবস্থায় কি করবো ?
96 |
97 | হ্যা,এটা ঠিক যে সবসময় কম্পোনেন্টের পিওরিটি বজায় রাখা সম্ভব নাও হতে পারে,আমাদের এমন কিছু করা লাগতে পারে যাতে হয়তো কম্পোনেন্টের পিওরিটি নষ্ট হবে, এমন অবস্থায় আমরা দুটি কাজ করতে পাড়িঃ
98 |
99 | #### Manage With Event Handler:
100 |
101 | যেসব সাইড-এফেক্টগুলো আমরা `event-handler` এর মাধ্যমে করতে পারবো,তা আমরা `event-handler` এর ভিতর করার চেষ্টা করবো। কারণ `event-handler` রিয়াক্টের রেন্ডারিং টাইমে একটিভ হয়না তাই `event-handler` পিওর হউয়ার প্রয়োজন নাই । ` event-handler` `Hydration` **(রিয়াক্টের কম্পোনেন্ট লোড হউয়ায়র পর যেই টাইমটায় জাভাস্ক্রিপ্ট একটিভ হয়, ওই প্রসেসটা হলো `Hydration`)** টাইমে একটিভ হয়। মূল কোথা হলো যাতে রিয়াক্টের রেন্ডারিং টাইমে কোন সাইড-এফেক্ট না হয় ।
102 |
103 | #### `useEffect` হুকের মাধ্যমে সাইড-এফেক্ট ম্যানেজ করাঃ
104 |
105 | যদি আর কোন উপায় নাই থাকে,তাহলে একেবারে লাস্ট স্টেজ হিসেবে রিয়াক্ট সাইড-এফেক্ট হ্যান্ডেল করার জন্য একটা বিল্ট-ইন হুক দিয়ে দিয়েছে,যার নাম `useEffect`। এই হুক ব্যাবহার করে সাইড-এফেক্ট ম্যানেজ করতে হবে। এই হুকটাও রিয়াক্টের রেন্ডারিং শেষ হয়ে যাওয়ার পর একটিভ হয়। তাই সাইড-এফেক্ট হ্যান্ডেল করার জন্য এই হুকটা ইউজ করা যেতে পারে,তবে সেটা হলো একেবারে সর্বশেষ রাস্তা।
106 |
107 | ### ফাংশনের ভিতরের ভ্যারিয়েবলগুলো কি চেঞ্জ করা যাবে?
108 |
109 | হ্যা,ফাংশনের ভিতরের ভ্যারিয়েবল চেঞ্জ করা যাবে। এতে কম্পোনেন্টের পিওরিটি নষ্ট হবেনা। এটাকে বলা হয় `local mutation`। লোকাল মিউটেশনে কোন সমস্যা নাই।
110 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-1/rendering-list.mdx:
--------------------------------------------------------------------------------
1 | রিয়াক্টে আমাদেরকে প্রায় সময়ই লিস্ট অফ ডাটা বা ডাটা `Array` থেকে ডাটা রেন্ডার করার প্রয়োজন হয়। সেক্ষেত্রে আমারা `map`, `filter` ব্যাবহার করে তা দেখাতে পারি।
2 |
3 | **উদাহরনঃ**
4 |
5 | ```javascript
6 | const users = ["Mr x", "Mr y", "Mr z"];
7 |
8 | export function ListOfUser() {
9 | const user = users.map((person) =>
;
33 | }
34 | ```
35 |
36 | ## `key` কিভাবে পেতে পারি ?
37 |
38 | বিভিন্ন ডাটা থেকে বিভিন্ন ভাবে `key` পেতে পারি, যেমনঃ
39 |
40 | - **ডাটাবেস থেকে প্রাপ্ত ডাটাঃ** যেসব ডাটা আমরা ডাটাবেস থেকে পাই সেগুলোর সাথে আমারা অটোমেটিক `Id` পেয়ে যাই, এই `Id` আমরা `key` হিসেবে ব্যাবহার করতে পারি।
41 |
42 | - **লোকাল ডাটার ক্ষেত্রেঃ** যেসব ডাটা লোকালি অটোমেটিক জেনারেটেড হয় সেসব ডাটার ক্ষেত্রে আমারা `crypto.randomUUID()` অথবা `uuid` ব্যাবহার করে `id/key` জেনারেট করে সেভ করতে পারি।
43 |
44 | ## রুলস অফ `key`
45 |
46 | - `key` অবশ্যই ইউনিক হতে হবে। একই লিস্টের বিভিন্ন এলিমেন্টে একই `key` ব্যাবহার করা যাবেনা।
47 |
48 | - `key` পরিবর্তন করা যাবেনা বা রেন্ডারিং এর সময়ে `key` জেনারেট করে ব্যবাহার করা যাবেনা।
49 |
50 | - `Array`র ইনডেক্সকে কখনো কি হিসেবে ব্যাবহার করা যাবেনা।
51 |
52 | ## রিয়াক্টে কেন `key` ব্যাবহার করা লাগে?
53 |
54 | রিয়াক্ট তার `DOM TREE`তে প্রতিটা আইটেমকে ইউনিকভাবে আইডেন্টিফাই করার জন্য `key`র প্রয়োজন হয়। যাতে কখনও লিস্ট থেকে কোন আইটেম ডিলিট হয়ে গেলে,বা কখনো `sort` করা লাগলে যেন রিয়াক্ট সহজে বুঝতে পারে যে কোন আইটেমে পরিবর্তন হয়েছে।
55 |
56 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-1/vertual-dom.mdx:
--------------------------------------------------------------------------------
1 | ## DOM কি আসলেই স্লো?
2 |
3 | নাহ, ডম কখনোই স্লো না । আসলে যদি ভালোভাবে কোড করা হয় তাহলে ডম যেকোন কিছুর থেকে ফাস্ট। কিন্তু বর্তমান বিশ্বে ওয়েব অ্যাপ্লিকেশনগুলো অনেক বেশি ইন্টারেক্টিভ,তাই যখনই ইউজার কোন ইন্টারেকশন করে তখন ব্রাউজারকে আবার তা নতুন করে পুরো ওয়েবসাইটটা রি-পেইন্ট করতে হয়। এইরকম যখন অনেকগুলো রিয়াকশনের কারনে ব্রাউজারকে বার বার রি পেইন্ট করতে হয় তখন সেই রি-পেইন্টিং প্রসেসটা স্লো হয়ে যায়,মুলত ডম কিন্তু স্লো নয় ।
4 |
5 | ## ব্রাউজার কিভাবে DOM রেন্ডার করে ?
6 |
7 | 
8 |
9 | আমরা দেখতে পাচ্ছি যে উপরে একটা গ্রাফ এর মাদ্ধমে ব্রাউজার এর রেন্ডারিং প্রসেস দেখানো হয়েছে । এখানে আমরা কি দেখতে পাচ্ছি ? আমরা দেখতে পাচ্ছি যে, যখন ব্রাউজার কোন `HTML` `CSS` ফাইল পায়,তখন সেই ফাইলটা একটা পারসিং এর মদ্ধে দিয়ে নিয়ে যায়, এক্ষেত্রে `HTML` এর জন্য `HTML PARSER` ও `CSS` এর জন্য `CSS PERSER` ব্যাবহার হয়। এসব পারসার দিয়ে পারসিং এর পর ব্রাউসার `HTML` দিয়ে একটা `DOM TREE` বানায় এর `CSS` দিয়ে `CSSOM` নামে একটা `STYLE RULES` বানায় , এবং `DOM TREE` ও `STYLE RULES` একসাথে ATTACH হয়ে একটা `RENDER TREE` বানায়। এই `RENDER TREE` ব্রাউসারে একটা `LAYOUT` ফেস এর মদ্ধে দিয়ে যায়। এই `LAYOUT` ফেস এ `DOM TREE` টা ব্রাউসার এর কোথায় রেন্ডার হবে তার একটা CORDINATE রেডি হয়ে যায় । এবং ফাইনালি ব্রাউজার তার PAINTING মেকানিজম এর মাদ্ধমে তা ব্রাউসারে পেইন্ট করে দেয় এবং আমরা ফাইনাল আউটপুট দেখতে পাই।
10 |
11 | ## ভার্চুয়াল ডম কি ? কিভাবে ভার্চুয়াল ডম কাজ করে?
12 |
13 | ভার্চুয়াল ডম রিয়াক্ট এর একটা ফান্ডামেন্টাল বিষয় । রিয়াক্ট এর ভিত্তিটাই মূলত এই ভার্চুয়াল ডম ।
14 |
15 | ব্রাউজারের রি-পেন্টিং প্রসেসটা এপ্লিকেশনকে স্লো ডাউন করে দেয়, এই সমস্যা এড়ানোর জন্য আমরা কি করতে পারি ভাবুনতো। আমরা মূলত দুইটা ভাবে এটার সমাধান করতে পারি :
16 |
17 | - আমরা ব্যাচ আপডেট করতে পারি,
18 | - আমরা ডম ম্যানুপুলেশন কম করতে পারি।
19 |
20 | রিয়াক্ট তার ভার্চুয়াল ডমের মাদ্ধমে সেই কাজটাই করে । রিয়াক্ট একেবারে মিনিমাম ডম ম্যানুপুলেশন করে ।
21 |
22 | 
23 |
24 | যখন এপ্লিকেশনে কোন ইউজার কোন ইন্টারেকশন করে তখন যদি `UI` তে কোন চেঞ্জ করতে হয় তখন রিয়াক্ট সরাসরি `HTML` এর `DOM TREE` টাকে চেঞ্জ করে দেয়না। যখনি `UI` তে কোন চেঞ্জ আসে,রিয়াক্ট তার ভার্চুয়াল `DOM` এর সাহায্যে `UI` এর একটা রেপ্লিকা বা কপি বানিয়ে নেয় । তারপর রিয়াক্ট তার একটা নিজস্ব বানানো এলগরিদম `Diffng` বা `Reconciliation` এলগরিদম এর মাদ্ধমে চেক করে যে `UI` এর ঠিক কোন জায়গায় চেঞ্জ হয়েছে । এতে করে পুরো ওয়েবসাইটটা রি-রেন্ডার না করে শুধুমাত্র যেই অংশে পরিবর্তন হয়েছে,সেই অংশটুকু `DOM` এ আপডেট করে দেয়। এতে করে রিয়াক্ট মিনিমাম ডম অপারেশনের মাদ্ধমে এপ্লিকেশনএর পার্ফমেন্স ইম্প্রুভ করে ।
25 |
26 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-1/your-ui-as-a-tree.mdx:
--------------------------------------------------------------------------------
1 | ### রেন্ডার ট্রি (Render Tree) এবং মডিউল ট্রি (Module Tree) – রিয়াক্টের প্রেক্ষাপটে
2 |
3 | #### ১. **রেন্ডার ট্রি (Render Tree) কী?**
4 |
5 | **রেন্ডার ট্রি** হলো ডকুমেন্ট অবজেক্ট মডেল (DOM) এবং স্টাইলিং ইনফরমেশন (CSS) এর সম্মিলিত রূপ। এটি একটি ট্রি স্ট্রাকচার যেখানে প্রতিটি নোড একটি UI এলিমেন্টের প্রতিনিধিত্ব করে।
6 |
7 | রিয়াক্টে, আমরা JSX দিয়ে কম্পোনেন্ট লিখি, যা শেষে HTML DOM এ রূপান্তরিত হয়। রিয়াক্ট তখন একটি ভার্চুয়াল DOM তৈরি করে এবং সেই DOM এর ওপর কাজ করে।
8 |
9 | #### **রেন্ডার ট্রি কিভাবে কাজ করে?**
10 |
11 | 1. **DOM ও CSSOM তৈরি:** প্রথমে ব্রাউজার HTML থেকে একটি DOM (ডকুমেন্ট অবজেক্ট মডেল) তৈরি করে। তারপর CSS থেকে CSSOM (CSS অবজেক্ট মডেল) তৈরি করে।
12 | 2. **রেন্ডার ট্রি নির্মাণ:** DOM এবং CSSOM একসাথে মিলে রেন্ডার ট্রি তৈরি করে।
13 |
14 | 3. **লেআউট এবং পেইন্টিং:** এরপর ব্রাউজার প্রতিটি এলিমেন্টকে তার যথাযথ জায়গায় বসিয়ে দেয় (লেআউট), এবং পরিশেষে সেই এলিমেন্টগুলোকে পেইন্ট করে।
15 |
16 | #### **রেন্ডার ট্রির প্রয়োজনীয়তা ও সুবিধা:**
17 |
18 | - রেন্ডার ট্রি প্রয়োজন, কারণ এটি ব্রাউজারের কাছে নির্দিষ্ট ভাবে জানায়, কিভাবে পেজটি দেখাবে।
19 | - এর মাধ্যমে DOM এর পরিবর্তন হলে, ব্রাউজার শুধু সংশ্লিষ্ট অংশটুকু পুনরায় রেন্ডার করে। ফলে পারফরম্যান্স বৃদ্ধি পায়।
20 | - রিয়াক্টের **ভি-ডম (Virtual DOM)** রেন্ডার ট্রির উপর ভিত্তি করে কাজ করে। ভি-ডম পারফরম্যান্স অপটিমাইজ করার জন্য রেন্ডার ট্রির শুধুমাত্র পরিবর্তিত অংশ পুনরায় আপডেট করে।
21 |
22 | #### উদাহরণ:
23 |
24 | ```jsx
25 | function App() {
26 | return (
27 |
28 |
React Render Tree Example
29 |
This is a paragraph.
30 |
31 | );
32 | }
33 | ```
34 |
35 | - `div` এবং তার child nodes (`h1` এবং `p`) একসাথে রেন্ডার ট্রি তৈরি করবে।
36 | - যদি শুধু `p` ট্যাগ আপডেট হয়, রিয়াক্ট শুধুমাত্র সেই অংশে রেন্ডার করবে, বাকি অংশ অপরিবর্তিত থাকবে।
37 |
38 | #### ২. **মডিউল ট্রি (Module Tree) কী?**
39 |
40 | **মডিউল ট্রি** হলো আমাদের অ্যাপ্লিকেশনের সব জাভাস্ক্রিপ্ট মডিউলগুলোর একটি ডিপেনডেন্সি চেইন। এটি দেখায় কোন মডিউলটি কোন মডিউলের উপর নির্ভর করে।
41 |
42 | #### **মডিউল ট্রি কিভাবে কাজ করে?**
43 |
44 | রিয়াক্ট এবং অন্যান্য মডুলার ফ্রেমওয়ার্কে, বিভিন্ন ফাইল/মডিউল একে অপরের উপর নির্ভর করে কাজ করে। Webpack বা অন্য কোন মডিউল বান্ডলার, মডিউলগুলোকে একটি ট্রি স্ট্রাকচারে সাজায় যেখানে প্রতিটি মডিউল অন্য মডিউলের সাথে সম্পর্কিত হয়।
45 |
46 | #### উদাহরণ:
47 |
48 | ধরা যাক, আপনার তিনটি ফাইল আছে: `App.js`, `Header.js`, এবং `Footer.js`। `App.js` তে আপনি `Header.js` এবং `Footer.js` কে ইম্পোর্ট করছেন।
49 |
50 | ```js
51 | // App.js
52 | import Header from "./Header";
53 | import Footer from "./Footer";
54 |
55 | function App() {
56 | return (
57 | <>
58 |
59 |
60 | >
61 | );
62 | }
63 |
64 | export default App;
65 | ```
66 |
67 | এখানে **মডিউল ট্রি** এরূপ হবে:
68 |
69 | ```
70 | App.js
71 | ├── Header.js
72 | └── Footer.js
73 | ```
74 |
75 | #### **মডিউল ট্রির প্রয়োজনীয়তা ও সুবিধা:**
76 |
77 | - মডিউল ট্রির কারণে অ্যাপ্লিকেশনকে ছোট ছোট মডিউলে ভাগ করা সম্ভব হয়, যা রক্ষণাবেক্ষণ সহজ করে।
78 | - এটি কোডের পুনরায় ব্যবহারযোগ্যতা বাড়ায়।
79 | - মডিউল ডিপেনডেন্সি বুঝতে এবং অপ্রয়োজনীয় মডিউল বাদ দিতে সাহায্য করে।
80 |
81 | ### রেন্ডার ট্রি এবং মডিউল ট্রির সম্মিলিত কাজ
82 |
83 | রিয়াক্ট অ্যাপ্লিকেশন যখন ব্রাউজারে চলে, তখন মডিউল ট্রি মডিউলগুলোকে লোড এবং রিজলভ করে এবং এরপর রেন্ডার ট্রি সেই সব মডিউল থেকে UI রেন্ডার করে।
84 |
85 | ---
86 |
87 | #### ইলাস্ট্রেশন:
88 |
89 | - **রেন্ডার ট্রি:** একটি গাছের মতো যেখানে প্রতিটি শাখা DOM এর একটি অংশ। শীর্ষে `div` থাকে এবং তার নিচে child elements।
90 | - **মডিউল ট্রি:** একটি ডিপেনডেন্সি গাছ যেখানে `App.js` হলো মূল শাখা এবং অন্যান্য child modules তার সাথে যুক্ত থাকে।
91 |
92 | ### সংক্ষেপে:
93 |
94 | - **রেন্ডার ট্রি** UI কে ব্রাউজারে দেখানোর জন্য DOM এবং CSSOM এর সম্মিলিত অবস্থা।
95 | - **মডিউল ট্রি** অ্যাপ্লিকেশনের মডিউলগুলো একে অপরের সাথে কিভাবে সংযুক্ত তা বুঝায়।
96 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-2/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "responding-to-event": "2.1 - Responding to Events - Adding Event Handlers",
3 | "event-propagation": "2.2 - Responding to Events - Event Propagation",
4 | "understanding-state": "2.3 - Understanding State - A Component's Memory",
5 | "how-rendering-works": "2.4 - How Rendering Works",
6 | "state-as-a-snapshot": "2.5 - State as a Snapshot",
7 | "queueing-state": "2.6 - Queueing a Series of State Updates",
8 | "updating-object-in-state": "2.7 - Updating Objects in a State",
9 | "updateing-array-in-state": "2.8 - Updating Arrays in a State"
10 | }
11 |
12 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-2/how-rendering-works.mdx:
--------------------------------------------------------------------------------
1 | import { Steps } from "nextra/components";
2 |
3 | রিয়াক্ট এপ্লিকেশনে আমরা ব্রাউজার স্ক্রিনে যা কিছু দেখি তার সবকিছুই রিয়াক্টের দ্বারা রেন্ডার হয়ে আসতে হয় ।
4 |
5 | ### রেন্ডার এবং কমিট
6 |
7 | এই যে স্ক্রিনে আমরা `UI` দেখতে পাই তা রিয়াক্টের তিনটা প্রসেসের পর স্ক্রিনে ভিসিবল হয় । চলুন তাহলে জেনে নেই রিয়াক্টের রেন্ডারিং এর এই তিনটা প্রসেস কি আর কিভাবে কাজ করে ।
8 |
9 | 1. **Trigering a render:**
10 | 2. **Rendering the component:**
11 | 3. **Commiting to the DOM:**
12 |
13 |
14 | ### Trigger a render (ট্রিগারিং স্টেপ):
15 |
16 | মূলত দুইটা করনে রিয়াক্টের `render` মেথডটা কল হয় বা রেন্ডারিং ট্রিগার হয়ঃ
17 |
18 | 1. **ইনিশিয়াল রেন্ডার (initial render):** একদম সর্বপ্রথম যখন এপ্লিকেশন রান হয় তখন রিয়াক্ট `HTML` এর একটা `root` এলিমেন্টের ভিতর রিয়াক্টের সমস্ত কম্পোনেন্টকে রেন্ডার করে দেয় তার `React.render()` মেথডটাকে কল করার মাধ্যমে ।
19 |
20 | 2. **যখন কোন স্টেট আপডেট হয় (Re-render when state update):** প্রথমবার সমস্ত কম্পোনেন্ট `UI` তে এসে যাওয়ার পর, যখন কোন কম্পোনেন্টের ভিতরে কোন স্টেট চেঞ্জ হয় তখন রিয়াক্ট অটেমেটিক ভাবে তার `render()` মেথডকে কল করে বা রি-রেন্ডার ট্রিগার হয় ।
21 |
22 | ### React render your component (রেন্ডারিং স্টেপ):
23 |
24 | যখন রিয়াক্টের রেন্ডারিং টা ট্রিগার হয় তখন রিয়াক্ট তার কম্পোনেন্টগুলোকে কল করে। যাতে সে বুঝতে পারে কোথায় পরিবর্তনটা হয়েছে।
25 |
26 | - **এক্ষেত্রে প্রথম রেন্ডারে রিয়াক্ট তার রুট (root) কম্পোনেন্টকে কল করে**
27 |
28 | - **পরবর্তি সময়ে রি-রেন্ডার ট্রিগার হলে যেই কম্পোনেন্ট থেকে রি-রেন্ডার ট্রিগার হয়েছে সেই কম্পোনেন্টকে কল করে এবং তার প্রথম রেন্ডারের যে `Render Tree` তার একটা `snapshot` নিয়ে রাখে এবং পরবর্তি রেন্ডারেরে একটা `snapshot` নিয়ে তার ভার্চুয়াল ডম এ `Diffing` এলগরিদমের মাধ্যমে কেলকুলেট করে যে কোথায় পরিবর্তন হয়েছে । তারপর সে নেক্সট স্টেপে চলে যায় কমিট করার জন্য ।**
29 |
30 | **রেন্ডারিং প্রসেসটা রিকারসিভলি হয়ে থাকে, তার মানে হলো রিয়াক্ট রেন্ডারিং এ যেই কম্পোনেন্টকে কল করেছে তার ভিতর যদি নেস্টেড আরও কোন কম্পোনেন্ট থাকে সেগুলাও রি-রেন্ডার হয়**
31 |
32 | ### React Commits changes to the DOM (কমিটিং স্টেপ):
33 |
34 | কমিটিং ফেজে এসে রিয়াক্ট `DOM` মডিফাই করে । এক্ষেত্রে,
35 |
36 | - **প্রথম রেন্ডারে রিয়াক্ট `DOM` এর `appendChild()` কল করে সমস্ত `DOM Nodes`গুলোকে রুট এলিমেটে এড করে দেয়**
37 |
38 | - **রি-রেন্ডারের ক্ষেত্রে রিয়াক্ট তার ভার্চুয়াল ডম এ যেই অংশটুকুর পরিবর্তন ডিটেক্ট করতে পারে শুধুমাত্র সেই অংশটুকু `DOM`এ চেঞ্জ করে দেয়**
39 |
40 | **প্রথমবার রেন্ডার হয়ে যাওয়ার পর রিয়াক্ট শুধু তখনি `DOM` এ চেঞ্জ করে যখন সে দেখতে পারে আগের রেন্ডার এবং পরের রেন্ডারে কোন পার্থক্য আছে। যেই সকল কম্পোনেন্টে কোন প্রকার চেঞ্জ দেখা যায়না রিয়াক্ট সেই সকল কম্পোনেন্টে হাত ই দেয়না।**
41 |
42 |
43 |
44 | ### সবশেষে ব্রাউজার পেইন্ট হয়ঃ
45 |
46 | রেন্ডারিং এবং কমিট হয়ে যাওয়ার পর যখন রিয়াক্ট তার `DOM` টাকে আপডেট করে ফেলে,তখন সে `Updated DOM`টা ব্রাউজারকে দিয়ে দেয়। এবং ব্রাউজার তা স্ক্রিনে রি-পেইন্ট করে দেয়।
47 |
48 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-2/queueing-state.mdx:
--------------------------------------------------------------------------------
1 | **রিয়াক্ট প্রতিটা রেন্ডারে মাল্টিপল স্টেট আপডেটকে `Queue` হিসেবে নেয় এবং একসাথে ব্যাচ করে আপডেট করে । এজন্য বলা হয় `React Queueing a Series of State Updates` চলুন এ-ব্যাপেরে বিস্তারিত বুঝিঃ**
2 |
3 | ### React batches multiple state updates (রিয়াক্ট মাল্টিপল স্টেট আপডেট গুলোকে ব্যাচ করে):
4 |
5 | চলুন একটা কোডের মাধ্যমে বুঝিঃ
6 |
7 | চিন্তা করুন আপনি হোটেলে এসেছেন এবং হোটেলের ওয়েটারকে হয়তো কোন একটা ডিস অর্ডার করেছেন, এবং কিছুক্ষণ পর ওয়েটার আপনাকে আপনার ডিসের অবস্থা জানাবে বা পরিবেশন করবে ।
8 |
9 | চলুন এবার একটু কোডের দিকে তাকাই,
10 |
11 | ```jsx filename="App.jsx" showLineNumbers
12 | import { useState } from "react";
13 |
14 | export default function App() {
15 | const [disStatus, setDishStatus] = useState(
16 | "মাত্র অর্ডার রিসিভ করা হয়েছে এবং রান্নার জন্য পাঠানো হয়েছে"
17 | );
18 |
19 | return (
20 | <>
21 |
{disStatus}
22 |
32 | >
33 | );
34 | }
35 | ```
36 |
37 | আপনি যখন ওর্ডার দিয়েছেন তখন আপনার ডিশের স্টেট হলো `মাত্র অর্ডার রিসিভ করা হয়েছে এবং রান্নার জন্য পাঠানো হয়েছে` যা এই কোডে রিয়াক্টের ইনিশিয়াল স্টেট।
38 |
39 | এরপর আপনি আপনার ডিসের অবস্থা জানার জন্য `আমাদের ডিসের কি অবস্থা ?` `button` এ ক্লিক করলেন ।
40 |
41 | আপনি যখন বাটনে ক্লিক করলেন তখন বাটনের হেন্ডেলার ফাংশনের ভিতরে তিনটি ধাপে আপনার ডিসের স্ট্যাটাস চেঞ্জ হচ্ছে বা স্টেট আপডেট হচ্ছে।
42 |
43 | 1. প্রথম স্টেট আপডেটে ডিসের স্ট্যাটাস `disStatus` করা হয়েছে `আপনার ডিশটি রান্না করা হচ্ছে`
44 |
45 | 2. দ্বিতীয় স্টেট আপডেটে ডিসের স্ট্যাটাস `disStatus` করা হয়েছে `আপনার ডিসটি রান্না করা হয়ে গেছে`
46 |
47 | 3. তৃতীয় স্টেট আপডেটে ডিসের স্ট্যাটাস `disStatus` করা হয়েছে `আপনার ডিসটি পরিবেশন করা হয়েছে , ইনজয় দ্যা ডিস`
48 |
49 | এখন কি মনে হচ্ছে, আপনি কয়টি স্ট্যাটাস দেখতে পাবেন স্ক্রিনে ? পরপর তিনটি স্ট্যাটাস ই কি দেখতে পাওয়ার কথা যেহেতু এখানে তিনবার স্টেট চেঞ্জ হয়েছে তাহলে তিনবার কম্পোনেন্ট রি-রেন্ডার হবে এবং তিনবার এ তিনটি স্ট্যাটাস দেখতে পাওয়া যাবে ।
50 |
51 | **না এখানে তা দেখতে পাবেন না । এখানে আপনি একটা স্ট্যাটাস এ দেখতে পাবেন এবং তা হলো ফাইনাল স্ট্যাটাস `আপনার ডিসটি পরিবেশন করা হয়েছে , ইনজয় দ্যা ডিস`**
52 |
53 | ---
54 |
55 | এবার চলুন বুঝি এমন কেন হলো বা রিয়াক্ট কিভাবে এই কাজটা করলোঃ
56 |
57 | - **রিয়াক্ট স্টেটগুলোকে ব্যাচ আপডেট করে:** তারমানে হলো কোন একটা `event handler function` এর ভিতর যদি স্টেট আপডেট হয় এবং যদি সেই ইভেন্ট হেন্ডেলারের ভিতর মাল্টিপল স্টেট আপডেট থাকে, যেমনঃ
58 |
59 | ```jsx
60 | export default function App() {
61 | ;
69 | }
70 | ```
71 |
72 | এই কোডে তিনবার `setDishStatus` করা হয়েছে । তাহলে **রিয়াক্ট শুধু প্রথম `setter function` পেয়েই সাথে সাথে রি-রেন্ডার ট্রিগার করেনা বরং ওই `event handler function` এর ভিতরের সমস্ত কোড এক্সিকিউট হউয়ার পর ট্রিগার হয় ।** এবং তখন ওই `event handler function` এর ভিতরের সমস্ত স্টেট আপডেটকে ব্যাচ করে নিয়ে যায় এবং একটা স্টেটের কিউ ম্যেনেজ করে। এবং তারপর কিউ থেকে প্রতিটা স্টেট এক এক করে চেঞ্জ করে। এবং পরের রেন্ডারে সমস্ত আউটপুট একসাথে পাওয়া যায়।
73 |
74 | এখন প্রশ্ন জাগতে পারে যে,যদি তাই হয় তাহলেতো আমরা প্রথম উদাহরণের কোডের আউটপুট হিসেবে তিনটা স্টেট চেঞ্জের আউটপুট ই পেতাম।
75 |
76 | তাহলে চলুন এটাও আরেকটু ভালোভাবে বুঝিঃ
77 |
78 | ### Updating the same state multiple times before the next render
79 |
80 | রিয়াক্ট এর স্টেট আপডেট করা জন্য যেই ফাংশনে আপরা স্টেট চেঞ্জ করি সেখানে দুইটা উপায়ে করা যায়ঃ
81 |
82 | 1. `Replace the value of state with setter function`:
83 |
84 | ```jsx
85 | export default function App() {
86 | const [disStatus, setDishStatus] = useState(
87 | "মাত্র অর্ডার রিসিভ করা হয়েছে এবং রান্নার জন্য পাঠানো হয়েছে"
88 | );
89 | ;
97 | }
98 | ```
99 |
100 | আমরা যখন এইভাবে স্টেট আপডেট করছি তখন আসলে স্টেট এর পূর্বের ভ্যালুটাকে রিপ্লেস করে দিয়ে নতুন ভ্যালু দিচ্ছি। তাই উপরের উদাহরণে যখন লাস্ট `setter function` কল হয়েছে তখন `disStatus` রিপ্লেস হয়ে গিয়েছে। তাই আমরা আউটপুটে শুধু `আপনার ডিসটি পরিবেশন করা হয়েছে , ইনজয় দ্যা ডিস` এটাই দেখতে পেয়েছি।
101 |
102 | 2. `Update the value of state with updater function`:
103 |
104 | ```jsx
105 | export default function App() {
106 | const [disStatus, setDishStatus] = useState(
107 | "মাত্র অর্ডার রিসিভ করা হয়েছে এবং রান্নার জন্য পাঠানো হয়েছে"
108 | );
109 | ;
119 | }
120 | ```
121 |
122 | এখানে আমরা `setDishStatus` এর ভিতরে একটা `anonymous Arrow` ফাংশনের সিনট্যাক্স ব্যাবহার করেছি, যা প্যারামিটারে আগের স্টেট ভ্যালুটা রিসিভ করে। এবং তারপর তার সাথে নতুন ভ্যালু যোগ করে ভ্যালু আপডেট করে।
123 |
124 | এভাবে করলে প্রতিটা স্টেট আপডেট করার সময় আগের স্টেটের ভ্যালুটা পাওয়া যায়,এবং সেই ভ্যালু দিয়ে নতুন ভ্যালু আপডেট করা যায়।
125 |
126 | উপরের `updater function` এর উপায়ে যদি আমরা স্টেট আপডেট করি তাহলে আমরা তিনটা চেঞ্জ ভেলুই ফাইনালি দেখতে পাবো এভাবেঃ `মাত্র অর্ডার রিসিভ করা হয়েছে এবং রান্নার জন্য পাঠানো হয়েছে,আপনার ডিশটি রান্না করা হচ্ছে,আপনার ডিসটি রান্না করা হয়ে গেছে,আপনার ডিসটি পরিবেশন করা হয়েছে , ইনজয় দ্যা ডিস`
127 |
128 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-2/responding-to-event.mdx:
--------------------------------------------------------------------------------
1 | import { Callout, Steps } from "nextra/components";
2 |
3 | রিয়াক্ট আমাদের ইভেন্ট হ্যন্ডেল করার সিস্টেম দিয়ে দিয়েছে। ইভেন্ট হ্যান্ডেলার হলো মূলত যখন কোন ইভেন্ট ট্রিগার হয়, যেমন ঃ ক্লিক,হভার,ফোকাস এসব।
4 |
5 | ### Adding Event Handler to JSX
6 |
7 | রিয়াক্টে আমরা দুটি স্টেপে `Event Handler` এড করতে পারিঃ
8 |
9 |
10 | ### হ্যান্ডেলার ফাংশন ডিক্লেয়ার করা এবং লজিক এড করাঃ
11 | প্রথমত একটা হ্যান্ডেলার ফাংশন ডিক্লেয়ার করতে হবে এবং এতে লজিক ইমপ্লিমেন্ট করতে হবে।
12 | ধরুন, একটা `button` এ ক্লিক করলে আমরা দেখাতে চাই যে "বাটনে ক্লিক করা হয়েছে" সেক্ষেত্রে আমাদের হ্যান্ডেলার ফাংশন ও লজিক হবে এমনঃ
13 |
14 | ```jsx filename="Button.jsx"
15 | export default function Button(){
16 |
17 | function handleClick(){ // এখনে handleClick নামে একটা হ্যন্ডেলার ফাংশন ডিক্লেয়ার করা হয়েছে এবং তার ভিতরে লজিক ইমপ্লিমেন্ট করা হয়েছে।
18 | alert("বাটনে ক্লিক করা হয়েছে");
19 | }
20 |
21 | }
22 |
23 | ```
24 | ### হ্যান্ডেলার ফাংশনটি বাটনে এড করাঃ
25 | এরপর হ্যান্ডেলার ফাংশনটি `button` এলিমেন্টে এড করতে হবেঃ
26 |
27 | ```jsx filename="Button.jsx"
28 | export default function Button(){
29 |
30 | function handleClick(){
31 | alert("বাটনে ক্লিক করা হয়েছে");
32 | }
33 |
34 | return // এখনে বাটনের onClick এ হ্যান্ডেলার ফাংশনটি এড করা হয়েছে।
35 |
36 | }
37 | ```
38 |
39 |
40 |
41 | **এছাড়াও আমরা `JSX` এর ইনলাইনেও `Event Handler` ফাংশন এড করতে পারি ।**
42 |
43 | যেমনঃ
44 |
45 | ```jsx filename="Button.jsx"
46 | export default function Button(){
47 |
48 | return // এখনে বাটনের onClick এ হ্যান্ডেলার ফাংশনটি এড করা হয়েছে।
51 |
52 | }
53 | ```
54 |
55 | অথবা আরও ছোট করেও লিখতে পারি `Arrow Function` এর সিনট্যাক্সেঃ
56 |
57 | ```jsx filename="Button.jsx"
58 | export default function Button() {
59 | return (
60 |
66 | ); // এখনে বাটনের onClick এ হ্যান্ডেলার ফাংশনটি এড করা হয়েছে।
67 | }
68 | ```
69 |
70 | এখানে একটি ফাংশন ডিফাইন করা হয়েছে `handleClick` নামে এবং তা `button` এলিমেন্টে `as a props` পাস করা হয়েছে । `handleClick` ফাংশনটি একটা `event handler` ফাংশন।
71 |
72 |
75 | - 👉 ইভেন্ট হ্যান্ডেলার ফাংশনগুলো কম্পোনেন্ট এর ভিতরে ডিফাইন করতে হয় ।
76 |
77 | - 👉 কনভেনশন অনুযায়ী `event handler`এর নামগুলোর শুরুতে `handle` এবং তারপর
78 | `event name` দিয়ে লিখতে হয়। যেমনঃ`handleClick` `handleMouseEnter`
79 | `handleMouseLeave`
80 |
81 |
82 |
83 | ---
84 |
85 |
88 |
89 | ইভেন্ট হ্যান্ডেলার ফাংশনগুলো কম্পোনেন্ট এর ভিতরে পাস করতে হবে, **অবশ্যই শুধুমাত্র পাস করা লাগবে, কল করা যাবেনা**
90 | যেমনঃ
91 |
92 | |✅ শুধুমাত্র পাস করা হয়েছে | ❌ সরাসরি কল করা হয়েছে |
93 | |:------------------:|:----------------:|
94 | |`
106 |
107 | ### Reading Props in Event Handler
108 |
109 | ইভেন্ট হ্যান্ডেলারগুলো যেহেতু কম্পোনেন্টের ভিতরে লেখা হয় তাই কম্পোনেন্টের যেসব প্রপস আছে তা `event handler function`গুলো সরাসরি এক্সেস করতে পারে ।
110 |
111 | ### Pass Event Handler to Child Components as Props
112 |
113 | কখনো কখনো আমাদের প্যারেন্ট কম্পোনেন্ট থেকে চাইল্ড কম্পোনেন্ট এর ইভেন্ট কে ম্যানেজ করা লাগে। সেই ক্ষেত্রে প্যারেন্ট কম্পোনেন্টে `event handler function` ডিফাইন করে তা প্রপস আকারে চাইল্ড কম্পোনেন্টে পাস করা যায়।
114 |
115 | চলুন একটু বিস্তারিত বুঝিঃ
116 |
117 | ```jsx filename="App.jsx"
118 | export default function App() {
119 | function handlePlay() {
120 | alert("Movie is playing");
121 | }
122 | return ;
123 | }
124 | ```
125 |
126 | ```jsx filename="MovieCard.jsx"
127 | export default function MovieCard({ onPlay }) {
128 | return Play;
129 | }
130 | ```
131 |
132 | এখানে `App` কম্পোনেন্ট একটি প্যারেন্ট কম্পোনেন্ট এবং এর চাইল্ড হিসেবে রয়েছে একটা `MovieCard` কম্পোনেন্ট। এবং মুভিকার্ড কম্পোনেন্ট এ একটা প্রপ্স পাস করা হয়েছে `onPlay` নামে। এই `onPlay` প্রপস এর মাধ্যমে মূলত `handlePlay` নামক একটা ইভেন্ট হ্যান্ডেলার পাস করা হয়েছে ।
133 |
134 | চাইল্ড কম্পোনেন্ট `MovieCard` সেই প্রপস টাকে রিসিভ করেছে এবং বাটনের `onClick` এ তা ট্রিগার করা হয়েছে।
135 |
136 | তার মানে হলো চাইল্ড কম্পোনেন্ট `MovieCard` এর বাটনে ক্লিক হলে কোন হ্যন্ডেলার ফাংশন কল হবে তা আমরা প্যারেন্ট কম্পোনেন্টেই ডিফাইন করতে পারি এবং তা প্রপস আকারে পাঠাতে পারি ।
137 |
138 | ### Naming Conventions of event handler props
139 |
140 |
143 | - 👉 ইভেন্ট হ্যান্ডেলার প্রপস এর নামের শুরুতে `on` দিয়ে শুরু করতে হয়।
144 | - 👉 যেসব রিসার্ভড কিওয়ার্ড আছে যেমনঃ `onClick`,`onHover` এসব শুধুমাত্র `html` এর নেটিভ ইলিমেন্টে ব্যাবহার করা উচিত।
145 |
146 | - 👉 `on`দিয়ে শুরু করে তারপর প্রসঙ্গত যেকোন নামেই ব্যাবহার করা যায়। যেমনঃ `onClick` এর পরিবর্তে `onSmash` ব্যাবহার করা যায় ।
147 |
148 |
149 |
150 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-2/state-as-a-snapshot.mdx:
--------------------------------------------------------------------------------
1 | স্টেট ভেরিয়েবল নরমাল জাবাস্ক্রিপ্ট ভেরিয়েবলের মতো মনে হলেও এটা মোটেও জাবাস্ক্রিপটের নরমাল ভেরিয়েবল এর মতো কাজ করেনা। চলুন বিস্তারিত জেনে নেয়া যাক।
2 |
3 | ### Rendering takes a snapshot in time:
4 |
5 | এর মানে হলো রিয়াক্ট তার প্রতিটা রেন্ডারে একটা করে `snapshot` নেয়। এবং তা মনে রাখে। যখনি কোন স্টেট এর ভ্যালু চেঞ্জ হয় তখন রিয়াক্ট কম্পোনেন্টকে রি-রেন্ডার করে এবং পরের রেন্ডারে গিয়ে তার ভ্যালু আপডেট হয়। তার মানে হলো আমরা নরমাল ভেরিয়েবল এ যেমন কোন ভ্যালু চেঞ্জ করলে পরের লাইনেই তা এক্সেস করতে পারি কিন্তু রিয়াক্টে তা পারিনা,কেননা রিয়াক্ট ইনপ্লেস ভ্যালু চেঞ্জ করেনা। ভ্যালুটা চেঞ্জ হয় তার পরের রেন্ডারে।
6 |
7 | একটা উদাহরণের মাধ্যমে বুঝা যাকঃ
8 |
9 | ```jsx filename="App.jsx" showLineNumbers
10 | import { useState } from "react";
11 | export default function App() {
12 | const [number, setNumber] = useState(1);
13 |
14 | function handleClick() {
15 | setNumbers(number + 5);
16 | console.log(number);
17 | }
18 |
19 | return Incriment the number;
20 | }
21 | ```
22 |
23 | উপরের কোডটার কনসলে আউটপুট কত আশার কথা? স্বাভাবিক ভাবে দেখলে মনে হয় যে আউটপুত `6`আসার কথা। কিন্তু না , এখানে আউটপুট আসবে `1`। কারণ রিয়াক্ট তার স্টেট চেঞ্জ হলেই ডিরেক্ট ভ্যালু চেঞ্জ করে দেয়না, তাই সেই ভ্যালুটা পরের লাইনগুলোতে এক্সেস করা যায়না।
24 |
25 | যেই হেন্ডেলার ফাংশনে `setter function` কল করা হয়েছে সেই হেন্ডেলার এর পুরো কোডটা এক্সিকিউট হয়ে যাওয়ার পর রি-রেন্ডার ট্রিগার হয় এবং পরের রেন্ডারে আপডেটেড ভ্যালু পাওয়া যায়।
26 |
27 | আরেকটা উদাহরণ যদি আমারা দেখিঃ
28 |
29 | ```jsx filename="App.jsx" showLineNumbers
30 | import { useState } from "react";
31 |
32 | export default function Counter() {
33 | const [number, setNumber] = useState(0);
34 |
35 | return (
36 | <>
37 |
{number}
38 | {
40 | setNumber(number + 1);
41 | setNumber(number + 1);
42 | setNumber(number + 1);
43 | }}>
44 | +3
45 |
46 | >
47 | );
48 | }
49 | ```
50 |
51 | এখানে একটা বাটনে তিনবার `setter function` কল করা হয়েছে এবং তিনবার স্টেট এর ভ্যালু আপডেট করা হয়েছে। এই কোডটা রান করে আমরা যদি বাটনে ক্লিক করি তাহলে আউটপুট কত আসার কথা- `3`?
52 |
53 | কিন্তু না আউটপুট আসবে `1` ।
54 |
55 | যেহেতু স্টেট শুধুমাত্র পরের রেন্ডারে চেঞ্জ হয় তাই প্রথম রেন্ডারে স্টেট এর ভ্যালু ছিল `0`। তাই প্রথম রেন্ডারে তিনবার `setter function` কল হলেও তিনবার এ সে স্টেটের ইনিশিয়াল ভ্যালু পাবে `0`। আর তাই `নাম্বার` এর আউটপুট আসবে `1`
56 |
57 | ```jsx filename="App.jsx" showLineNumbers
58 | {
60 | setNumber(number + 1);
61 | setNumber(number + 1);
62 | setNumber(number + 1);
63 | }}>
64 | +3
65 |
66 | ```
67 |
68 | এখানে যেটা হচ্ছে প্রথম রেন্ডারে প্রথমবার যখন `setNumber(number + 1)` করা হচ্ছে তখন আসলে `0 + 1 = 1` করা হচ্ছে যা পরের রেন্ডারে আউটপুটে আসবে,
69 |
70 | কিন্তু পরের রেন্ডারে যাওয়ার আগে আরও দুইবার `setNumber(number + 1)` করা হয়েছে,
71 |
72 | তার মানে তখনও কিন্তু `0 + 1 = 1` ই করা হচ্ছে ।
73 |
74 | তারমানে শেষবার যখন `setNumber(number + 1)` করা হয়েছে, তখন কিন্তু `0 + 1 = 1` ই করা হয়েছে এবং স্টেট তার মেমরিতে `1` নিয়েই পরের রেন্ডার ট্রিগার করেছে এবং আউটপুটে `1` প্রিন্ট হয়েছে ।
75 |
76 | ```jsx filename="App.jsx" showLineNumbers
77 | {
79 | setNumber(0 + 1);
80 | setNumber(0 + 1);
81 | setNumber(0 + 1);
82 | }}>
83 | +3
84 |
85 | ```
86 |
87 | আবার যদি কোডটা এমন হয়ঃ
88 |
89 | ```jsx filename="App.jsx" showLineNumbers
90 | export default function Counter() {
91 | const [number, setNumber] = useState(0);
92 |
93 | return (
94 | <>
95 |
{number}
96 | {
98 | setNumber(number + 5);
99 | setTimeout(() => {
100 | alert(number);
101 | }, 3000);
102 | }}>
103 | +5
104 |
105 | >
106 | );
107 | }
108 | ```
109 |
110 | এখানে বাটনে নাম্বারের স্টেট চেঞ্জ করা হয়েছে এবং একটা `setTimeout()` কল করা হয়েছে ৩ সেকেন্ডের জন্য। এবং তাতে নাম্বার এর ভ্যালুটা এলার্টে নেয়া হয়েছে।
111 |
112 | এখানেও হয়তো মনে হতে পারে যে নাম্বার এর ভ্যালু এলার্টে `5` আসবে,কেননা যতক্ষণে ৩ সেকেন্ড টাইমার শেষ হবে ততক্ষণে স্টেট রি-রেন্ডার হয়ে যাবে এবং আমরা এলার্টে আপডেটেড ভ্যালু পাবো ।
113 |
114 | কিন্তু না এখানেও ব্যাপারটাকে `snapshot` হিসেবে চিন্তা করতে হবে, এখানে `timeOut` টা তিন সেকেন্ড পরে হলেও যখন টাইমআউট শুরু হয়েছে তখন কিন্তু সে `number` এর ভ্যালু `0` নিয়েই গিয়েছে, তাই টাইমার যতই নিয়ে যাক প্রথম রেন্ডারে সে তাই পাবে যেটা তার ইনিশিয়াল ভ্যালু।
115 |
116 | **অর্থাৎ রিয়াক্টের একটা রেন্ডারে কখনই সরাসরি ভ্যালু চেঞ্জ হয়না, বরং স্টেট চেঞ্জ হলে একটা রি-রেন্ডার ট্রিগার হয় এবং পরের রেন্ডারে গিয়ে তার আপডেটেড ভ্যালু পাওয়া যায়।**
117 |
118 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-3/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "declaretive-imperative": "3.1 - Declarative vs Imperative UI",
3 | "thinking-about-ui": "3.2 - Thinking About UI Declaratively in React",
4 | "choosing-the-state-structure": "3.3 - Choosing the state Structure in React",
5 | "lifting-state-up": "3.4 - Share State Between Components: Lifting State Up",
6 | "preserving-and-reseting-state": "3.5 - Preserving and Reseting State : Default Behaviour",
7 | "reseting-state-at-same-position": "3.6 - Resetting State at Same Position : Changing Default Behaviour",
8 | "extracting-state-logic-into-reducer": "3.7 - Extracting State Logic into Reducers",
9 | "passing-data-deeply-with-context": "3.8 - Passing Data Deeply With Context - Introduction to Context API",
10 | "scaling-up-with-reducer-and-context": "3.9 - Scaling Up with Reducers and Context"
11 | }
12 |
13 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-3/choosing-the-state-structure.mdx:
--------------------------------------------------------------------------------
1 | **রিয়াক্টে স্টেট ডিজাইন করার সময় আমাদের কিছু পিন্সিপাল মনে রাখা অবশ্যই জরুরি,এতে আমরা আরও সুন্দর ও ইফিশিয়েন্ট ভাবে স্টেটগুলো ম্যানেজ করতে পারবো। চলুন জেনে নেয়া যাক সেই প্রিন্সিপালগুলো,যেগুলো রিয়াক্টের স্টেট এর স্ট্রাকচার করার সময় আমাদের অবশ্যই মাথায় রাখতে হবে**
2 |
3 | 1. **Group Related State**
4 | 2. **Avoid Contradictions in State**
5 | 3. **Avoid Redundant State**
6 | 4. **Avoid Duplication is State**
7 | 5. **Avoid Deeply Nested State**
8 |
9 | ### Group Related State (একইজাতীয় বা পারস্পারিক সম্পর্কযুক্ত স্টেটগুলোকে একটা স্টেটে গ্রুপ করে নেয়া)
10 |
11 | যদি এমন হয় যে মাল্টিপল স্টেট কিন্তু একটা আরেকটার সাথে সম্পর্কযুক্ত,এবং একটা চেঞ্জ করলে অন্যটাও চেঞ্জ করার প্রয়োজন পরে সেই ক্ষেত্রে স্টেটগুলোকে একটা স্টেট হিসেবে গ্রুপ করে নেয়া উচিত। যেমন ঃ
12 |
13 | ```jsx
14 | const [x, setX] = useState(0);
15 | const [y, setY] = useState(0);
16 | ```
17 |
18 | এখানে একটা কাস্টম কার্সর বানানোর জন্য `x` এবং `y` নামে দুইটা স্টেট নেয়া হয়েছে, এবং মাউসমুভ করার সাথে সাথে স্টেটগুলো আপডেট হতে হবে, তার মানে মাউসমুভ হলেই আমাকে `x` এবং `y` দুইটা স্টেট পরিবর্তন করতে হবে। তাহলে আমরা এভাবে দুইটা স্টেট না নিয়ে বরং একটা স্টেট নিতে পারি `position`নামে এবং এর ভ্যালু হিসেবে `x` এবং `y` কে একটা অবজেক্ট আকারে রাখতে পারি।
19 |
20 | ```jsx
21 | const [position, setPosition] = useState({ x: 0, y: 0 });
22 | ```
23 |
24 | ### Avoid contradictions in state (একই সাথে দুইটাই কখনও সত্য অথবা মিথ্যা না হলে দুইটা কে একটা স্টেট হিসেবে নেয়া)
25 |
26 | এমন অনেক সিনারিও আসতে পারে যেখানে হয়তো দুইটা স্টেট আছে যেখানে হয়তো দুইটা স্টেট আছে,কিন্তু স্টেট দুইটা কখনোই একইসাথে সত্য অথবা একই সাথে মিথ্যা হতে পারেনা। এসব স্টেটকে বলা হয় `Contradiction in State`। এমন হলে দুইটা স্টেট কখনোই নেয়া উচিত না,বরং একটা স্টেট দিয়েই দুইটাকেই ম্যনেজ করা উচিত।
27 |
28 | উদাহরণসরূপ একটা লাইটের কথা চিন্তা করুনঃ
29 |
30 | একটা লাইট আছে, যার দুইটা স্টেট
31 |
32 | ১। লাইট জালানো অবস্থা (`isOn`)
33 |
34 | ২। লাইট বন্ধ অবস্থা (`isOff`)
35 |
36 | ```jsx
37 | const [isOn, setIsOn] = useState(true);
38 | const [isOff, setIsOff] = useState(true);
39 | ```
40 |
41 | এখানে এই দুইটা স্টেট কি কখনো একইসাথে দুইটাই `true` অথবা `false` হতে পারে? মানে একই সাথে লাইট জালানো বা বন্ধ করা থাকতে পারে ? না সেটা কখনই হতে পারেনা, এটাকেই বলা হয় `Contradiction in State`। এমন অবস্থায় আমাদের একটাই স্টেট নেয়া উচিত যেমনঃ
42 |
43 | ```jsx
44 | const [lightStatus, setLigthStatus] = useState("on");
45 | ```
46 |
47 | এভাবে আমরা একটা স্টেট দিয়েই লাইটের দুইটা অবস্থা ম্যানেজ করতে পারি।
48 |
49 | ### Avoid redundant state (অপ্রয়োজনীয় স্টেট না নেয়া বা পরিহার করা)
50 |
51 | যদি আমরা কোন স্টেটকে অন্য স্টেট থেকে কেলকুলেট করে নিয়ে ব্যাভারা করতে পারি তাহলে আমাদের নতুন স্টেট না নিয়ে সেই কেলকুলেটেড স্টেট দিয়েই কাজ করা উচিত।
52 |
53 | **এটাকে `Derived State`ও বলা হয়ে থাকে**
54 |
55 | - **Derived State**: যখন কোন ভ্যালু অন্য কোন স্টেট এর ভ্যালু থেকে `calculate` করে ব্যাবহার করা যায়, তখন সেই `Calculated` ভ্যারিয়েবল কে `Derived State` বলা হয়
56 |
57 | ধরুন আমাদের এমন তিনটা স্টেট ম্যানেজ করা লাগবে,`firstName`, `lastName`, `fullName`। এখেত্রে আমদের স্টেট গুলো হবে এমন,
58 |
59 | ```jsx
60 | const [firstName, setFirstName] = useState("Shahadat");
61 | const [lastName, setLastName] = useState("Hussain");
62 | const [fullName, setFullName] = useState("Shahadat Hussain");
63 | ```
64 |
65 | চিন্তা করে দেখেনতো, এখানে কি আমাদের `fullName` স্টেট-এর কোন দরকার ছিল? আমরা চাইলেইতো `firstName`,এবং `lastName` থেকে `fullName` টা বানিয়ে নিতে পারতাম এভাবে,
66 |
67 | ```jsx
68 | const fullName = firstName + " " + lastName;
69 | ```
70 |
71 | এক্ষেত্রে
72 |
73 | ```jsx
74 | const [fullName, setFullName] = useState("Shahadat Hussain");
75 | ```
76 |
77 | এই স্টেট টা ছিল `Redundant` বা অপ্রয়োজনীয়। আমাদের এসব `Redundant` স্টেটকে Avoid করতে হবে।
78 |
79 | #### Don't mirror props in state (প্রপ্স মিরর করা এড়িয়ে চলতে হবে)
80 |
81 | একটা স্টেটকে যখন প্যারেন্ট কম্পোনেন্ট এ ডিক্লেয়ার করে সেটার ভ্যালুটা চাইল্ড কম্পোনেন্টে পাস করা হয়, এবং চাইল্ড কম্পোনেন্ট সেই প্রপ্সটা নিয়ে আবার তার নিজস্ব স্টেট এর ভ্যালুকে ইনিশিয়ালাইজ করে,সেটা কে বলা হয় প্রপ্স মিরর করা।
82 |
83 | এটা করা যাবেনা, কেননা যদি আপনি একবার কোন স্টেট ভ্যালু প্যারেন্ট থেকে চাইল্ডে পাস করেছেন এবং সেটা চাইল্ডের নিজস্ব স্টেট ভ্যরিয়েবল এর ইনিশিয়াল ভ্যালু হিসেবে ব্যাবহার করেছেন,
84 |
85 | তখন যদি আপনি চাইল্ড কম্পোনেন্ট থেকে স্টেট ভ্যালু চেঞ্জ করেত চান,তখন চাইল্ড থেকে সেটা পরিবর্তন করতে পারলেও, যদি প্যারেন্ট থেকে সেট স্টেট যেটা আপনি প্রপ্স হিসেবে চাইল্ডে পাঠিয়েছেন,সেটার কোন কন্ট্রোল থাকবেনা,এবং প্যারেন্ট থেকে তা পরিবর্তন করা যাবেনা। কেননা স্টেট এর ইনিশিয়াল ভ্যালু কম্পোনেন্টের প্রথম রেন্ডারেই ইনিশিয়ালাইজ হয়, পরে আর ইনিশিয়াল ভ্যালু চেঞ্জ হয়না। শুধু `setter function` এর মাধ্যমেই সেই স্টেট এর ভ্যালু চেঞ্জ করা যায়।
86 |
87 | তাই এখেত্রে প্যারেন্ট কম্পোনেন্টে সেই স্টেটটা পরিবর্তন করলেও তা কিন্তু প্রপ্স হয়ে আর চাইল্ড কম্পোনেন্টে যাবেনা, কেননা প্রথম রেন্ডারেই চাইল্ডের স্টেটের ইনিশিয়াল ভ্যালু সেট হয়ে গেছে।
88 |
89 | ### Avoid duplication in state (ডুপ্লিকেট স্টেট নেয়া যাবেনা)
90 |
91 | একি ভ্যালু যদি মাল্টিপল স্টেট ভ্যারিয়েবল ব্যাবহার করে সেটাকে ডুপ্লিকেট করা বলে। আমাদের এসব ডুপ্লিকেট স্টেট এর ব্যাপারে সতর্ক থাকতে হবে।
92 |
93 | অর্থাৎ যদি এমন হয় যে আমাদের কোন স্টেট ভ্যারিয়েবল এ কিছু ভ্যালু আছে,এবং সেই একই ভ্যালু দিয়ে আমরা আরও একটা স্টেট নিয়েছি, সেটাকে ডুপ্লিকেট করা বলা হয়, স্টেট ডুপ্লিকেট করা যাবেনা,প্রয়োজনে এক্ষেত্রে `Derived State` ব্যাবহার করতে হবে।
94 |
95 | ### Avoid deeply nested state (ডিপলি নেস্টেড অবজেক্ট কে স্টেট হিসেবে নেয়া থেকে বিরত থাকতে হবে)
96 |
97 | যদি এমন হয় যে আমাদের এমন একটা স্টেট আছে যা একটা অবজেক্ট এবং তার প্রপারর্টি হিসেবে আরও একটা অবজেক্ট আছে, এবং সেই নেস্টেড অবজেক্ট এর-ও আরও নেস্টেড অনেক অবঞ্জেক্ট আছে, এভাবে অনেক লেয়ার ডীপ একটা নেশটেড অবজেক্ট । যা একটা কমপ্লেক্স স্ট্রাকচার।
98 |
99 | এমন স্ট্রাকচার নিয়ে কাজ করলে স্টেট আপডেট করতে হলে সেটা কোডের কপ্লেক্সিটি বাড়াবে,বাগ হতে পারে, কোডটার রিডেবিলিটি নষ্ট হবে। তাই এমন অবজেক্টকে স্টেট হিসেবে নেয়া পরিহার করতে হবে।
100 |
101 | সেক্ষেত্রে সেই অবজেক্ট ডাটাকে `normalize` বা `flatten` করে নিয়ে তারপর স্টেট হিসেবে ব্যাবহার করতে হবে।
102 |
103 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-3/declaretive-imperative.mdx:
--------------------------------------------------------------------------------
1 | **ডিক্লারেটিভ (Declarative) এবং ইম্পারেটিভ (Imperative) প্রোগ্রামিং এপ্রোচ দুটি প্রোগ্রামিং করার ভিন্ন ভিন্ন পদ্ধতি। আসুন, প্রথমে প্রতিটি এপ্রোচের মূল ধারণা বুঝি, তারপরে কোডের উদাহরণ দেখি।**
2 |
3 | ### ১. ইম্পারেটিভ (Imperative) এপ্রোচ:
4 |
5 | ইম্পারেটিভ প্রোগ্রামিংয়ে আপনি **কীভাবে কিছু করবেন** তা ধাপে ধাপে বলে দেন। আপনি প্রতিটি পদক্ষেপ নির্দিষ্টভাবে বর্ণনা করেন এবং কম্পিউটার সেই পদক্ষেপগুলি ঠিকমতো অনুসরণ করে। এটি অনেকটা রান্নার রেসিপির মতো, যেখানে প্রতিটি ধাপ স্টেপ বাই স্টেপ বলে দেয়া থাকে।
6 |
7 | #### উদাহরণ:
8 |
9 | ধরুন, আমাদের একটি অ্যারের উপাদানগুলিকে ২ দিয়ে গুণ করতে হবে।
10 |
11 | ```javascript
12 | // Imperative approach
13 | const numbers = [1, 2, 3, 4, 5];
14 | const doubledNumbers = [];
15 |
16 | for (let i = 0; i < numbers.length; i++) {
17 | doubledNumbers.push(numbers[i] * 2);
18 | }
19 |
20 | console.log(doubledNumbers); // Output: [2, 4, 6, 8, 10]
21 | ```
22 |
23 | এখানে আমরা একটি লুপ দিয়ে প্রতিটি উপাদানকে ২ দিয়ে গুণ করে নতুন অ্যারেতে পুশ করছি। প্রতিটি পদক্ষেপ যেমনঃ
24 |
25 | - লুপিং,
26 | - গুণ,
27 | - পুশ
28 |
29 | স্পষ্টভাবে বলে দেয়া হয়েছে।
30 |
31 | ### ২. ডিক্লারেটিভ (Declarative) এপ্রোচ:
32 |
33 | ডিক্লারেটিভ প্রোগ্রামিংয়ে আপনি **কী করতে চান** সেটি বলেন, তবে **কীভাবে করবেন** তা নির্দিষ্টভাবে উল্লেখ করেন না। কম্পিউটারকে নির্দিষ্টভাবে প্রতিটা স্টেপ বলে দিতে হয় না।
34 |
35 | এই এপ্রোচে আপনি মূলত কী চান শুধু তা বলে দেন, আর ভেতরের ইম্প্লিমেন্টেশন কম্পিউটার নিজেই বোঝে নেয় ।
36 |
37 | #### উদাহরণ:
38 |
39 | উপরে যে একই কাজ করলাম, এবার ডিক্লারেটিভ এপ্রোচে করবো:
40 |
41 | ```javascript
42 | // Declarative approach
43 | const numbers = [1, 2, 3, 4, 5];
44 | const doubledNumbers = numbers.map((num) => num * 2);
45 |
46 | console.log(doubledNumbers); // Output: [2, 4, 6, 8, 10]
47 | ```
48 |
49 | এখানে `.map()` ফাংশন ব্যবহার করেছি, যা প্রত্যেকটি উপাদানকে ২ দিয়ে গুণ করছে এবং নতুন অ্যারে তৈরি করছে। তবে, কোন লুপের উল্লেখ নেই—অ্যারের উপরে কাজ করতে কীভাবে গুণ করতে হবে, তা সরাসরি বলিনি। শুধু বলেছি, **"প্রতিটি উপাদানকে ২ দিয়ে গুণ করো"**।
50 |
51 | ### প্রধান পার্থক্য:
52 |
53 | 1. **ইম্পারেটিভ:** প্রতিটি ধাপ স্টেপ বাই স্টেপ বলে দিতে হয়,কীভাবে কাজটি সম্পন্ন হবে তা নির্দিষ্টভাবে উল্লেখ করতে হয়।
54 | 2. **ডিক্লারেটিভ:** শুধু কী করতে হবে তা বলে দিতে হয়, আর কীভাবে করতে হবে তা গোপন থাকে বা কম্পিউটার নিজেই বুঝে নেয়।
55 |
56 | ---
57 |
58 | ### রিয়াক্ট কি এপ্রোচে তার ইউ আই চেঞ্জ করে?
59 |
60 | React মূলত **ডিক্লারেটিভ (Declarative)** এপ্রোচে তার UI পরিবর্তন করে। এর অর্থ হলো, React-এ আপনি কীভাবে UI আপডেট হবে তা নিয়ে চিন্তা করার পরিবর্তে, **UI-র বর্তমান অবস্থা কেমন হবে তা** বর্ণনা করেন, আর React নিজেই সেই UI-টি আপডেট করার জন্য ভেতরে ভেতরে প্রয়োজনীয় কাজ করে নেয়।
61 |
62 | ### React-এর ডিক্লারেটিভ এপ্রোচ কীভাবে কাজ করে?
63 |
64 | 1. **Declarative Components:** React-এ আপনি প্রতিটি UI অংশ (component) তৈরি করার সময়, প্রতিটি কম্পোনেন্টকে বলে দেন কীভাবে সেটা দেখতে হবে। আপনি **UI এর শেষ অবস্থা** (final state) বলে দেন, কিন্তু সেই অবস্থা কীভাবে পরিবর্তন হবে তা নির্দিষ্টভাবে বলে দিতে হয় না।
65 |
66 | উদাহরণ:
67 |
68 | ```javascript
69 | function Greeting({ name }) {
70 | return
Hello, {name}!
;
71 | }
72 | ```
73 |
74 | এখানে আমরা শুধু বলে দিচ্ছি, "এই component-টি কেমন দেখতে হবে," কিন্তু কীভাবে render হবে বা কতবার হবে তা চিন্তা করতে হচ্ছে না। React সেই কাজগুলো নিজের মতো করে করে নিচ্ছে।
75 |
76 | 2. **State Changes:** React-এর ডিক্লারেটিভ এপ্রোচের আরেকটি গুরুত্বপূর্ণ বিষয় হলো **state**। আপনি যখন কোনো state পরিবর্তন করেন, React সেই state অনুযায়ী UI-কে আপডেট করে।
77 |
78 | উদাহরণ:
79 |
80 | ```javascript
81 | import React, { useState } from "react";
82 |
83 | function Counter() {
84 | const [count, setCount] = useState(0);
85 |
86 | return (
87 |
88 |
You clicked {count} times
89 | setCount(count + 1)}>Click me
90 |
91 | );
92 | }
93 | ```
94 |
95 | এখানে, আমরা state (`count`) এর মান পরিবর্তন করলে, React সেই অনুযায়ী UI-কে রি-রেন্ডার করে। আমরা শুধু জানাচ্ছি UI কেমন দেখতে হবে যখন state পরিবর্তন হবে, কিন্তু কিভাবে DOM ম্যানিপুলেট হবে বা পরিবর্তনগুলো কীভাবে ঘটবে, তা React-এর দায়িত্ব।
96 |
97 | 3. **Virtual DOM:** React-এর ডিক্লারেটিভ UI পরিবর্তনের আরেকটি বড় বিষয় হলো **Virtual DOM**। যখন state বা props পরিবর্তিত হয়, React প্রথমে সেই পরিবর্তনগুলোকে Virtual DOM-এর মাধ্যমে চেক করে, এবং তারপর প্রয়োজনীয় স্থানে শুধুমাত্র প্রয়োজনীয় UI অংশটুকু আপডেট করে।
98 |
99 | React নিজেই Virtual DOM ব্যবহার করে কীভাবে পরিবর্তন করতে হবে, সেটি নির্ধারণ করে নেয়। ফলে ডেভেলপারকে DOM নিয়ে চিন্তা করতে হয় না।
100 |
101 | React-এর UI আপডেটিং পদ্ধতি ডিক্লারেটিভ এপ্রোচে কাজ করে। এর ফলে ডেভেলপাররা কেবল UI-র শেষ অবস্থা কী হবে তা বলে দেয়, আর React ভেতরে ভেতরে কীভাবে সেই পরিবর্তনগুলো ঘটাবে তা নিজে থেকেই করে।
102 |
103 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-3/lifting-state-up.mdx:
--------------------------------------------------------------------------------
1 | **`lifting state up` বা স্টেটকে উপরে নিয়ে যাওয়া, এটা হচ্ছে রিয়াক্টের বেস্ট ডিজাইন প্যাটার্নগুলোর মধ্যে একটা**
2 |
3 | #### লিফটং স্টেট আপ বলতে কি বুঝায় ?
4 |
5 | রিয়াক্টে কোন স্টেট কে কম্পোনেন্টের লোকাল জায়গায় না রেখে সেটাকে লিফট করে প্যারেন্ট কম্পোনেন্ট এ নিয়ে যাওয়াকে লিফটিং স্টেট আপ বা স্টেট উপরে নিয়া যাওয়া বুঝায়।
6 |
7 | #### লিফটিং স্টেট আপ কেন করতে হয়?
8 |
9 | আমরা জানি যে, রিয়াক্ট কম্পোনেন্টের স্টেটগুলো সেই কম্পোনেন্টের ভিতর আইসোলেটেড থাকে, মানে তা হলো তার নিজস্ব কম্পোনেন্ট। সেই কম্পোনেন্ট একাধিকবার ব্যাবহার করা হলেও প্রতিটা ইউজে সে আলাদা আলাদা স্টেট মেন্টেইন করবে, কখনো একটা আরেকটার সাথে সিঙ্ক থাকবেনা। আবার এমনও হতে পারে যে কোন একটা কম্পোনেন্টে দুইটা বা তিনটা `Sibling` কম্পোনেন্ট আছে, যেমনঃ
10 |
11 | ```jsx filename="App.js"
12 | const App = () => {
13 | return (
14 |
15 |
16 |
17 |
18 | );
19 | };
20 |
21 | export default App;
22 | ```
23 |
24 | এখানে `App` নামে একটা প্যারেন্ট কম্পোনেন্ট আছে, যার দুইটা চাইল্ড কম্পোনেন্ট হলো `Product` এবং `Cart`। `Product` এবং `Cart` এরা নিজেরা আবার `Sibling`
25 |
26 | এখন ধরুন আমাদের `Product` কম্পোনেন্টের একটা লোকাল স্টেট আছে সেই কম্পোনেন্টের ভিতরে। এখন যদি সেই স্টেট টা আমাদের চাইল্ড কম্পোনেন্টের ভিতরে প্রয়োজন হয় তাহলে আমরা কি করতে পারি? আমরা কিভাবে `Product` এর লোকাল স্টেট কে `Cart` এ পাঠাবো?
27 |
28 | এই ক্ষেত্রেই কাজে লাগে **lifting state up** প্যাটার্ণ। আমরা `Product`কম্পোনেন্টের লোকাল স্টেটকে তাদের ইমিডিয়েট প্যারেন্ট কম্পোনেন্ট `App` এ নিয়ে আসতে পারি। এবং `App` থেকে `Props` পাস করার মাধ্যমে আমরা একই স্টেট `Product` এবং `Cart` দুটো কম্পোনেন্টেই পাঠাতে পারি।
29 |
30 | #### Controlled and Uncontrolled Components
31 |
32 | `Controlled and Uncontrolled Components` এটা সম্পূর্ন রিয়াক্টের একটা টার্ম,এটা কোন প্রোগ্রামিং এর টেকনিক্যাল টার্ম না।
33 |
34 | ##### Controlled Components
35 |
36 | রিয়াক্টে `Controlled Component` বলতে বুঝায় যেসব কম্পোনেন্টের কনট্রোল সম্পুর্নভাবে প্যারেন্টের কাছে থাকে, মানে প্যারেন্ট তার নিজস্ব স্পেসে স্টেট ম্যানেজ করছে, এবং শুধু ডাটাগুলো `Props` এর মাধ্যমে চাইল্ডে পাঠিয়ে দিচ্ছে, এমন কম্পোনেন্ট কে রিয়াক্টে `Controlled Component `বলা হয়।
37 |
38 | অর্থাৎ `Controlled Component `গুলো `Props` এর উপর নির্ভর করে।
39 |
40 | ##### UnControlled Components
41 |
42 | যেসব রিয়াক্ট কম্পোনেন্ট তার নিজ লোকাল স্পেসে স্টেট নিয়ে সেই স্টেট দিয়ে কাজ করে,সেটা হলো `UnControlled Component`
43 |
44 | মানে হলো সেই কম্পোনেন্টের উপর প্যারেন্টের কোন কনট্রোল নেই,সে তার নিজস্ব স্টেট ডাটার উপর নির্ভর করে, প্যারেন্টর `Props`এর উপর নির্ভর করেনা।
45 |
46 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-3/reseting-state-at-same-position.mdx:
--------------------------------------------------------------------------------
1 | ### Resetting state at the same position
2 |
3 | **আমরা জানি কোন কম্পনেন্ট একই পজিশনে যতক্ষণ থাকবে ততক্ষণ রিয়াক্ট তার স্টেট ধরে রাখবে।**
4 |
5 | কিন্তু যদি আমাদের এমন প্রয়োজন হয় যে আমরা একই পজিশনে কম্পনেন্টের স্টেট রিসেট করবো। তাহলে দুইটা উপায়ে আমরা সেটা করতে পারিঃ
6 |
7 | 1. Rendering a component in different positions
8 | 2. Give each component an explicit identity with `key`
9 |
10 | #### Rendering a component in different positions
11 |
12 | ```jsx filename="App.jsx"
13 | import { useState } from "react";
14 |
15 | export default function Scoreboard() {
16 | const [isPlayerA, setIsPlayerA] = useState(true);
17 | return (
18 |
53 | );
54 | }
55 | ```
56 |
57 | এখানে একটা কম্পোনেন্টে প্লেয়ারের স্কোর কাউন্ট করা হচ্ছে, আমরা যখন `Add One` বাটনে চাপ দিয়ে স্কোর বারাচ্ছি,তখন স্কোর এর স্টেট চেঞ্জ হচ্ছে, আবার আমরা নিচে একটা বাটন রেখেছি `Next Player` নামে, এবং আমরা চাইছি যে বাটনে চাপ দিলে প্লেয়ার এর নাম চেঞ্জ হবে এবং স্কোরটা রিসেট হয়ে যাবে। কিন্তু এখানে সেটা হচ্ছেনা, কারণ হলো এখানে একই পজিশনে কাউন্টার কম্পোনেন্ট তার পজিশনে ধরে রেখছে,তাই স্টেট রিসেট হচ্ছে।
58 |
59 | কিন্তু যদি আমরা কোডটা এভাবে লিখি,
60 |
61 | ```jsx
62 | // প্রথম কোড যা স্টেট ধরে রাখবে
63 | {
64 | isPlayerA ? : ;
65 | }
66 | ```
67 |
68 | ```jsx
69 | {
70 | isPlayerA && ; // এখানে যদি isPlayerA না হয় তাহলে এই পজিশনে null রিটার্ন হবে
71 | }
72 | {
73 | !isPlayerA && ; // এখানে যদি isPlayerA হয় তাহলে এই পজিশনে null রিটার্ন হবে
74 | }
75 | ```
76 |
77 | একানে রেন্ডার ট্রি-এর স্ট্রাকচার টা হয় এমনঃ 
78 |
79 | তাহলে দেখা যাচ্ছে যে `isPlayerA` না হয় তাহলে নিচের কম্পোনেন্ট রেন্ডার হবে। এখানে কিন্তু দুইটা কম্পোনেন্ট দুইটা আলাদা পজিশনে আছে, কেননা একটা যদি `true` না হয় সেই পজিশনে কিন্তু একটা `null` রিটার্ন হয়, এবং অন্য কম্পোনেন্ট টা আলাদা একটা পজিশনে রেন্ডার হয়।
80 |
81 | #### Resetting state with a `key`
82 |
83 | আরেকটা সবচাইতে এফিসিয়েন্ট উপায় হলো `key` প্রপ্স ব্যাবহার করা, আমরা লিস্ট রেন্ডার করার সময় `key`প্রপ্স এর সাথে পরিচিত হয়েছিলাম,
84 |
85 | `key` প্রপ্স শুধুমাত্র লিস্ট রেন্ডারিং এর জন্য ব্যবহার হয়না। `key` প্রপ্স এর মানে হলো সেই কম্পোনেন্টকে রিয়াক্টের কাছে একটা আলাদা কম্পোনেন্ট হিসেবে রিপ্রেজেন্ট করা।
86 |
87 | তাই আমরা যদি আগের মতো করেই কোড করি এবং শুধু স্টেটগুলো রিসেট করতে চাই তাহলে আমরা এভাবে `key` প্রপ্স ব্যাবহার করতে পারি।
88 |
89 | ```jsx
90 | {
91 | isPlayerA ? (
92 |
96 | ) : (
97 |
101 | );
102 | }
103 | ```
104 |
105 | এখানে `key` প্রপ্স এর মানে হলো একই পজিশনে দুইটা সম্পুর্ন আলাদা কম্পোনেন্ট ।
106 |
107 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-3/thinking-about-ui.mdx:
--------------------------------------------------------------------------------
1 | import { Steps } from "nextra/components";
2 |
3 | ### ইউ আই-কে ডিক্লারেটিভলি ভাবা (Thinking about UI declaratively)
4 |
5 | আমরা যখনি রিয়াক্টের কোন UI কে পরিবর্তন বা ম্যানেজ করতে চাইবো তখন আমাদের স্টেট দিয়ে তা ম্যানেজ করা লাগবে । একটা কম্পোনেন্টে কি কি স্টেট থাকতে পারে বা কিভাবে খুব সুন্দর করে স্টেটগুলো ম্যনেজ করতে হবে তা খুব ভালোভাবে বুঝতে হলে আমাদের কয়েকটা স্টেপ অবশ্যই ফলো করতে হবে। নিচে এই স্টেপগুলো নিয়ে বিস্তারিত আলোচনা করবো। এই স্টেপগুলো খুব ভালোভাবে বুঝতে পারলে যেকোন কমপ্লেক্স UI এর স্টেট ম্যানেজমেন্ট খুব সহজেই করে ফেলা সম্ভব। চলুন স্টেপগুলো জানি,
6 |
7 | 1. **Identify Components differnet visual states**
8 | 2. **Determine What trigger those state changes**
9 | 3. **Represent the state in memory useing `useState`**
10 | 4. **Remove any not-essential state variables**
11 | 5. **Connent the event handlers to set the state**
12 |
13 |
14 | ### Identify Components differnet visual states (কম্পোনেন্টের কি কি পরিবর্তন বা অবস্থা হতে পারে,তা নির্ধারণ করা)
15 |
16 | প্রথমেই আমাদের বুঝতে হবে যে আমাদের UI তে কি কি পরিবর্তন হতে পারে। মানে UI টা কি কি অবস্থায় স্ক্রিনে দেখা যাবে।
17 |
18 | উদাহরণ হিসেবে, ধরুন আমারা একটা ফর্ম এর কথা ভাবি, ফরমটা একটা প্রশ্নের উত্তর নেয়, এবং উত্তর সঠিক হলে সাকসেস মেসেজ দেখায় আর ভুল হলে ইরর মেসেজ দেখায়। আর ফর্ম টায় কোন কিছু না লিখা হলে ফর্মটা ডিসেবল থাকে, আর কিছু লিখে ফর্মটা সাবমিট করা হলে একটা লোডীং দেখায়।
19 |
20 | তাহলে চলুন একটু ভিজুয়ালাইজ করি আমাদের এর কম্পোনেন্টের কি কি ভিজুয়াল স্টেট হতে পারে:
21 |
22 | ১।  ২।  ৩। ৪।  ৫। 
23 |
24 | তাহলে এখানে আমরা UI তে পাচটি স্টেট দেখতে পাচ্ছি,`empty`, `typing`, `submitting`, `success`, `error` এতে আমরা ক্লিয়ার ধারনা পাই যা আমাদের UI তে কি কি পরিবর্তন হবে আর কখন কোন স্টেট এ থাকবে। এই ভাবে একটা কম্পোনেন্টের প্রতিটা ভিজুয়াল চেঞ্জকে রিপ্রেজেন্ট করা কে **স্টোরিবুকস** বলা হয়
25 |
26 | ### Determine what triggers those state changes (কোন কোন কারনে স্টেট এর পরিবর্তনগুলো ট্রিগার হবে তা নির্ধারন করা)
27 |
28 | UI তে যেই স্টেট এর পরিবর্তনগুলো হবে,সেগুলো কিভাবে ট্রিগার হবে তা নির্ধারন করতে হবে। স্টেট এর পরিবর্তনগুলো কি ইউজারেরে কোন ইন্টারেকশনের কারনে হবে নাকি কম্পিউটার অটোমেটিক করবে তা নির্ধারন করতে হবে।
29 |
30 | এক্ষেত্রে যেমন ইউজার ইনপুট ফিল্ডে কিছু লিখলে স্টেট হবে টাইপিং,আর সাবমিট করলে হবে সাবমিটিং।
31 |
32 | আর ইরর হবে নাকি সাকসেস হবে সেটা কম্পিউটার নিজে ডিসিশন নিবে।
33 |
34 | অর্থাৎ দ্বিতীয় স্টেপে আমাদের বুঝতে হবে যে, কখন কিভাবে স্টেট চেঞ্জ গুলো ট্রিগার হবে।
35 |
36 | এই স্টেট চেঞ্জের স্টেপগুলোকে আমরা একটা ডায়াগ্রামে রিপ্রেজেন্ট করতে পারলে পুরো স্টেট চেঞ্জের ফ্লো-টা বোঝা অনেক সহজ হয়ে যায়। যেমনঃ
37 |
38 | 
39 |
40 | ### Represent the state in memory with `useState` (`useState`ব্যবহার করে স্টেটগুলো কে রিপ্রেজেন্ট করা)
41 |
42 | এই স্টেপে আমাদের যেসব স্টেটগুলো প্রয়োজন হবে সেগুলো কে `useState` হুক দিয়ে ইনিশিয়ালিজ করতে হবে বা ডিফাইন করতে হবে। এই উদাহরণে স্বাভাবিকভাবে দেখলে আমাদের পাঁচটা স্টেট লাগবে,
43 |
44 | ```jsx
45 | const [isEmpty, setIsEmpty] = useState(true);
46 | const [isTyping, setIsTyping] = useState(false);
47 | const [isSubmitting, setIsSubmitting] = useState(false);
48 | const [isSuccess, setIsSuccess] = useState(false);
49 | const [isError, setIsError] = useState(false);
50 | ```
51 |
52 | এছাড়াও আমাদেরকে ফর্মের ইনপুট হ্যান্ডেল করা আর ইরর হয়েছে কিনা তা বুঝার জন্য আরও দুইটা স্টেট অবশ্যই নেয়া লাগতে পারে।
53 |
54 | ```jsx
55 | const [answer, setAnswer] = useState("");
56 | const [error, setError] = useState(null);
57 | ```
58 |
59 | ### Remove any non-essential state variables(অপ্রয়োজনীয় স্টেট ভ্যারিয়েবল রিমুভ করে দেয়া)
60 |
61 | এই পর্যায়ে আমাদের বুঝতে হবে যে আমরা যেই `state` গুলো ডিফাইন করেছি তার **প্রত্যেকটাই কি আমাদের লাগবে কিনা**, **কোন একটা স্টেট ভ্যারিয়েবল দিয়ে অন্যটার কাজ হয়ে যাচ্ছে কিনা** বা **কোন স্টেট ডুপ্লিকেট হচ্ছে কিনা** এবং **একই সময়ে দুইটা স্টেট কখনো সত্যি অথবা মিথ্যা (Paradox) হতে পারেনা এমন ক্ষেত্রে একই স্টেট নেয়া**
62 |
63 | অর্থাৎ এই পর্যায়ে আমাদের স্টেটকে ক্লিনাপ করা লাগবে, অপ্রয়োজনীয় স্টেট ভ্যরিয়েবলগুলোকে রিমুভ করে দিতে হবে।
64 |
65 | এক্ষেত্রে যেমন আমরা `empty` আর `typing` দুইটা ইনফরমেশনএর স্টেট দুইটা বাদ দিয়ে শুধুমাত্র `answer` স্টেট থেকেই সবকিছু ম্যনেজ করতে পারি। যেমন `answer.length == 0` মানে হলো `empty` আর `0` না হলে `typing` তাহলে আমরা খুব সহজেই `empty` আর `typing` এই দুইটা স্টেট রিমুভ করে দিতে পারি।
66 |
67 | আবার বাকি তিনটা অবস্থা `submitting` `success`অথবা `error` আমরা শুধু একটা স্টেট ভ্যারিয়েবল `status` নিয়েই আমরা মেনেজ করতে পারি।
68 |
69 | ```jsx
70 | const [status, setStatus] = useState("typing"); // 'submitting', or 'success / error'
71 | ```
72 |
73 | তাহলে এখানে আমাদের শুধু তিনটা স্টেট নিলেই সমস্ত কিছু পারফেক্টলি হয়ে যাচ্ছে,
74 |
75 | ```jsx
76 | const [answer, setAnswer] = useState("");
77 | const [error, setError] = useState(null);
78 | const [status, setStatus] = useState("typing"); // 'submitting', or 'success / error'
79 | ```
80 |
81 | ### Connect the event handlers to set state(স্টেটগুলো চেঞ্জ করার জন্য ইভেন্ট হ্যন্ডেলারগুলো কানেক্ট করিয়ে দিতে হবে)
82 |
83 | এই পর্যায়ে আমাদের শুধু স্টেট এর সেটার ফাংশনগুলোকে ইভেন্ট হ্যান্ডেলারের সাথে কানেক্ট করিয়ে দিতে হবে, যাতে ইভেন্ট ট্রিগার হলেই স্টেটগুলো আপডেট হতে থাকে।
84 |
85 |
86 |
87 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "referencing-values-with-refs": "4.1 - Referenceing Values with Refs",
3 | "manipulating-dom-with-refs": "4.2 - Manipulating DOM with Refs",
4 | "forwarding-refs": "4.3 - Forwarding Refs : Accessing another component’s DOM nodes ",
5 | "useImperativeHandle": "4.4 - UseImperativeHandle : Exposing the subset of the API with an Imperative Handle",
6 | "flushing-state-updates-synchronously": "4.5 - Flushing State Updates Synchronously with flushSync",
7 | "syncronising-with-effets-overview": "4.6 - Synchronising with Effects: Overview and How To Write Effects",
8 | "handling-effects-firing-twice": "4.7 - Handling Effects Firing Twice in Development",
9 | "fatching-data": "4.8 - Synchronising with Effects: Fatching Data",
10 | "you-might-not-need-an-effect": "4.9 - You Might Not Need an Effect",
11 | "the-lifecycle-of-an-effect": "4.10 - The Lifecycle of an Effect",
12 | "effect-react-to-reactive-values": "4.11 - Effect React To Reactive Values",
13 | "seperating-events-from-effects": "4.12 - Separating Events from Effects",
14 | "removing-effect-dependecies": "4.13 - Removing Effect Dependencies",
15 | "reusing-logic-with-custom-hook": "4.14 - Reusing Logic with Custom Hook",
16 | "performance-optimization": "4.15 - Performance Optimization"
17 | }
18 |
19 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/effect-react-to-reactive-values.mdx:
--------------------------------------------------------------------------------
1 | ### Effects "react" to reactive values (রিয়াক্টিভ ভ্যালুগুলোতে ইফেক্ট রিয়াক্ট করে)
2 |
3 | ```jsx
4 | const serverUrl = "https://localhost:1234";
5 |
6 | function ChatRoom({ roomId }) {
7 | useEffect(() => {
8 | const connection = createConnection(serverUrl, roomId);
9 | connection.connect();
10 | return () => {
11 | connection.disconnect();
12 | };
13 | }, [roomId]);
14 | // ...
15 | }
16 | ```
17 |
18 | উপরের উদাহরণ অনুযায়ী ইফেক্টে দুইটা ভ্যারিয়েবল ব্যাবহার করা হয়েছে, কিন্তু ইফেক্টের ডিপেন্ডেন্সি হিসেবে ব্যাবহার করা হয়েছে একটা ভ্যারিয়েবল `roomId`, এটা কেন? কেন `serverUrl` ইফেক্টের ডিপেন্ডেন্সিতে ব্যাবহার করা হলোনা ?
19 |
20 | এর কারণ হলো `serverUrl` হলো একটা স্ট্যাটিক ভ্যালু এবং এটা কম্পোনেন্টের বাহিরে ডিক্লেয়ার করা হয়েছে, তাই এটা কখনই কোন রি-রেন্ডারে চেঞ্জ হবেনা। যেই ভ্যারিয়েবলগুলো কম্পোনেন্টের বাহিরে ডিক্লেয়ার করা হয় এবং যেগুলো কখনো চেঞ্জ হওয়ার সম্ভাবনা নেই,সেগুলো রিয়াক্টিভ ভ্যালু না। আর ইফেক্টের ডিপেন্ডেন্সিতে শুধুমাত্র রিয়াক্টিভ ভ্যালুগুলোই ব্যাবহার করতে হয়।
21 |
22 | অন্যদিকে `roomId` ভ্যারিয়েবলটা প্রপে এসেছে, প্রপ,স্টেট এগুলা রি-রেন্ডারে চেঞ্জ হতে পারে,তাই এগুলো রিয়াক্টিভ ভ্যালু কেননা এগুলা রিয়াক্টের কম্পোনেন্ট এর ভিতরে ডিক্লেয়ার করা হয়েছে তাই এগুলো রেন্ডারিং এ কেলকুলেট হবে, আর তাই এসব ভ্যালু রিয়াক্টিভ।
23 |
24 | যদি `serverUrl` ভ্যারিয়েবলটা প্রপ হিসেবে আসতো, তাহলে এটাও রিয়াক্টিভ ভ্যালু হতো। রিয়াক্টিভ ভ্যালু যেগুলো ইফেক্টের মধ্যে ব্যাবহার করা হয়েছে,সেগুলো অবশ্যই ইফেক্টের ডিপেন্ডেন্সিতে এড করা লাগবে।
25 |
26 | ### What an Effect with empty dependencies means (ইফেক্টের ইম্পটি ডিপেন্ডেন্সি মানে কি?)
27 |
28 | ```jsx
29 | const serverUrl = "https://localhost:1234";
30 | const roomId = "general";
31 |
32 | function ChatRoom() {
33 | useEffect(() => {
34 | const connection = createConnection(serverUrl, roomId);
35 | connection.connect();
36 | return () => {
37 | connection.disconnect();
38 | };
39 | }, []); // ✅ All dependencies declared
40 | // ...
41 | }
42 | ```
43 |
44 | যদি এমন হয় যে আমদের ইফেক্ট শুধুমাত্র একবার রান করবে একবার চ্যাট রুমের সাথে কানেক্ট হবে যখন কম্পোনেন্ট মাউন্ট হবে, পরে আর কখনোই ইফেক্ট রান করার প্রয়োজন নেই, এবং শুধুমাত্র কম্পোনেন্ট আনমাউন্ট হলে কানেকশন স্টপ হবে, তাহলে আমরা ডিপেন্ডেন্সি ভ্যারিয়েবল গুলো কপোনেন্টের বাহিরে নিয়ে স্ট্যাটিক ভ্যালু হিসেবে রাখতে পারি। এবং এতে যেহেতু কোন রিয়াক্টিভ ভ্যালু ইফেক্টের ভিতরে ব্যাবহার করা হয়নি,তাই এখানে ডিপেন্ডেন্সি ইম্পটি থাকতে পারে।
45 |
46 | **আসলে আমাদের কম্পোনেন্টের মাউন্ট -আনমাউন্ট নিয়ে চিন্তা করার কোন দরকার এ নেই, আমরা শুধুমাত্র এফেক্টের স্টার্ট আর স্টপ লিখবো ইফেক্টের ভিতরে, বাকিটা রিয়াক্ট নিজে বুঝে নিবে। যদি কোন ডিপেন্ডেন্সি দেয়ার প্রয়োজন হয়,সেটা আমদের `eslint` সাজেশন দিবে।**
47 |
48 | ### All variables declared in the component body are reactive (কম্পোনেন্টের ভিতরে যে সকল ভ্যারিয়েবল ডিক্লেয়ার করা হয়,তা সব রিয়াক্টিভ ভ্যালু)
49 |
50 | শুধুমাত্র প্রপ আর স্টেট ই রিয়াক্টিভ ভ্যালু নয়, আমাদের কম্পোনেন্টের ভিতরে ডিক্লেয়ার করা ভ্যারিয়েবলগুলোও রিয়াক্টিভ, কেননা যদি এমন হয় যে আমাদের কম্পোনেন্টের ভিতরে কোন ভ্যালু আমরা কনটেক্সট থেকে রিড করেছি এবং তা কম্পোনেন্টের ভিতরে ডিক্লেয়ার করেছি,সেটাও রিয়াক্টিভ ভ্যালু হতে হবে। **আমরা কম্পোনেন্টের ভিতরে শুধু সেই ভ্যারিয়েবল ই রাখবো যেগুলো কম্পোনেন্টের রেন্ডারিং এর সাথে সম্পর্কযুক্ত। এমন কোন ভ্যারিয়েবল যা আমাদের কম্পোনেন্টের রেন্ডারিং সাথে সম্পর্ক নেই, এবং া কখনো পরিবর্তন হউয়ার সম্ভাবনা নেই, সেগুলো আমরা সবসময় কম্পোনেন্ট এর বাইরে ডিক্লেয়ার করবো।**
51 |
52 | ### React verifies that you specified every reactive value as a dependency (রিয়াক্ট ভেরিফাই করা যে প্রতিটা রিয়াক্টিভ ভ্যালু ইফেক্টের ডিপেন্ডেন্সিতে এড করা হয়েছে।)
53 |
54 | আমরা প্রজেক্ট সেটআপ করার সময় রিয়াক্টের জন্য যেই `linter` টা সেটআপ করি,সে সবসময় আমাদের ওয়ার্ন করে যাতে সকল রিয়াক্টিভ ভ্যালু যা ইফেক্টের ভিতরে ব্যাবহার করা হয়েছে সেগুলো যাতে ইফেন্টের ডিপেন্ডেন্সিতে এড করা হয়।
55 |
56 | যদি কোন রিয়াক্টিভ ভ্যালু আমরা ইফেক্টের ভিতরে ব্যাবহার করি কিন্তু ডিপেন্ডেন্সিতে এড না করি, তাহলে `linter` আমাদের ওয়ার্নিং দিবে, আমরা কখনোই সেই ওয়ার্নিং টাকে সাপ্রেস করবোনা, বরং যেসব ভ্যালু ডিপেন্ডেন্সিতে এড করার জন্য `linter` সাজেস্ট করবে সেগুলো আমরা ডিপেন্ডেন্সিতে এড করে নিবো।
57 |
58 | আর যদি আমরা চাই যে, আমাদের কম্পোনেন্ট `re-Syncronize` না করুক,তাহলে আমরা রিয়াক্টিভ ভ্যালুগুলো কম্পোনেন্ট এর বাহিরে স্ট্যাটিক ভ্যালু হসেবে রাখতে পারি,যেগুলো কখনই চেঞ্জ হবেনা, এবং ইফেক্ট `re-Syncronize` হবেনা।
59 |
60 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/fatching-data.mdx:
--------------------------------------------------------------------------------
1 | ### Fetching data with effects
2 |
3 | যখন আমরা রিয়াক্টে ইফেক্টের মাধ্যমে কোন ডাটা `fetch` করবো তখন অবশ্যই আমাদেরকে ইফেক্টের ক্লিন-আপ ফাংশন ইমপ্লিমেন্ট করতে হবে এবং ডেভেলপমেন্ড মুডে আমরা যখনি ডাটা `fetch` করে স্টেট এ সেট করবো তখন যাতে দুইবার সেট না হয় সেজন্য ইফেক্টের ক্লিন-আপে প্রথমবার `setState` কে ইগনোর করতে হবে।
4 |
5 | ```jsx {3,9-11}
6 | const [data, setData] = useState([]);
7 | useEffect(() => {
8 | let ignore = false;
9 |
10 | async function startFatching() {
11 | const fetched = await fetch(`apiurl/${id}`);
12 | const json = await fetched.json();
13 |
14 | if (!ignore) {
15 | setData(json);
16 | }
17 | }
18 |
19 | startFatching();
20 |
21 | return () => {
22 | ignore = true;
23 | };
24 | }, [id]);
25 | ```
26 |
27 | দেখেন এখানে আমরা ৩ নাম্বার লাইনে একটা ভ্যারিয়েবল রেখেছি `ignore` নামে এবং ৯-১১ নাম্বার লাইনে আমরা স্টেট আপডেট করার আগে চেক করেছি যে `ignore` এর ভ্যালু `true` কিনা, যদি `true` না হয়,সেখেত্রে আমরা স্টেট আপডেট করেছি।
28 |
29 | এখন চলুন এই প্যাটার্নটা আরেকটু ভালো করে বুঝি,
30 |
31 | আমরা জানি ডেভেলপমেন্ট মুডে প্রতিটা কম্পোনেন্ট দুইবার করে রান হয়, মানে হলো `mount --> unmount --> remount`.
32 |
33 | তাই প্রথমবার যখন আমাদের কম্পোনেন্ট মাউন্ট হয়েছে তখন আমাদের ইফেক্ট রান হয়েছে এবং সেখানে `ignore` এর ভ্যালু `false` পেয়েছে, এবং তারের পরের লাইনেই আমাদের ডাটা `fatching` এর জন্য একটা `asynchronous` ফাংশন `startFatching()` কল হয়েছে, `asynchronous` ফাংশনটার ক্লোজারের মধ্যে `ignore` ভ্যারিয়েবল এর ভ্যালু `false` নিয়ে `Web API` এর মধ্যে তার ডাটা `fatching` এর কাজ করছে।
34 |
35 | এর পরে আমাদের এফেক্টের আর কোন কাজ নাই, তাই সে দ্বিতীয়বার রান হউয়ার জন্য কম্পোনেন্টকে `unmount` করতে যাবে এমন সময় দেখে একটা ক্লিন-আপ ফাংশন লেখা হয়েছে ইফেক্টের মধ্যে, তাই সে ক্লিন-আপ ফাংশনটা রান করবে, এবং ক্লিন-আপের মধ্যে `ignore` ভ্যারিয়েবল এর ভ্যালু `true` করে দেয়া হয়েছে,
36 |
37 | এই সময়ের মধ্যে যখন `startFatching()` ফাংশনটা তার কাজ শেষ করে ফিরে আসবে এবং স্টেট-আপডেট করতে যাবে তখন সে দেখবে তার ক্লোজারের মধ্যে থাকা `ignore` ভ্যারিয়েবল এর ভ্যালু `true` হয়ে গিয়েছে। তখন সে আর কোন কাজ করবেনা।
38 |
39 | এরই মধ্যে যখন কম্পোনেন্ট `remount` হবে তখন আবার পুরো কম্পোনেন্ট নতুন করে রান হবে, এবং তখন `ignore` ভ্যারিয়েবল এর ভ্যালু `false` পাবে, আর `startFatching()` ফাংশনটা কল হবে, এবারে কিন্তু কম্পোনেট আর `unmount` হবেনা, তাই ক্লিন-আপ ফাংশনও কল হবেনা আর `ignore` ভ্যারিয়েবল এর ভ্যালুও চেঞ্জ হবেনা। তখন `startFatching()` ফাংশনটা তার কাজ শেষ করে যখন ডাটা নিয়ে ফিরত আসবে তখনও সে `ignore` ভ্যারিয়েবল এর ভ্যালু `false` পাবে, আর তাই স্টেট আপডেট করে দিবে।
40 |
41 | এই প্যাটার্নে করলে আমাদের ডেভেলপমেন্ট মুড এবং প্রোডাকশন মুড দুইটাতে সেফ। দুইবার আমাদের স্টেট আপডেট হবেনা।
42 |
43 | যদিও ইফেক্টের মাধ্যমে এভাবে ডাটা ফেচ করাটা বেস্ট এপ্রোচ না, আমরা রিয়াক্ট এপ্লিকেশনে ডাটা ফেচিং এর জন্য [React Query](https://tanstack.com/query/latest), [useSWR](https://swr.vercel.app/), [rtkQuery](https://redux-toolkit.js.org/rtk-query/overview) ইত্যাদি চাইলে ব্যবাহার করতে পারি। অথবা আমরা যদি কোন ফ্রেমওয়ার্ক ব্যবাহার করি তাহলে সেখানে বিল্ট-ইন ডাটা ফেচিং মেকানিজম পেয়ে যাবো।
44 |
45 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/flushing-state-updates-synchronously.mdx:
--------------------------------------------------------------------------------
1 | এটা আরেকটা `escap hatch`। আমরা জানি যে রিয়াক্ট তার State গুলুকে ব্যাচ করে আপডেট করে এবং পরের রেন্ডারে গিয়ে আপডেটেড ভ্যালু পাওয়া যায়।
2 |
3 | কিন্তু আমরা যদি চাই যে স্টেট আপডেডকে আমরা Syncronously করবো এবং স্টেট আপডেট হয়ে যাওয়ার পর নিচের লাইন এক্সিকিউট হবে তাহলে আমরা `flushSync` ব্যাবহার করতে পারি। এটি `react-dom` একটি মেথড। এটা স্টেট আপডেট না হওয়া পর্যন্ত নিচের লাইনের এক্সিকিউশন বন্ধ রাখে এবং রিয়াক্টকে জানায় যে আগে স্টেট আপডেট করো তারপর নিচের লাইনগুলো এক্সিকিউট করো।
4 |
5 | তাহলে আমরা যেই স্টেট আপডেটকে ফোর্স করে আগে স্টেট আপডেট করে তারপর নিচের লাইনে যেতে বলছি সেই স্টেট আপডেটের `setter function ` কে `flushSync` মেথড দিয়ে তার একটা কলব্যাক এ দিয়ে দিতে হবে।
6 |
7 | ```jsx
8 | import { flushSync } from "react-dom";
9 |
10 | flushSync(() => {
11 | setTodos([...todos, newTodo]);
12 | });
13 | ```
14 |
15 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/forwarding-refs.mdx:
--------------------------------------------------------------------------------
1 | import { Steps } from "nextra/components";
2 |
3 | ### Accessing another component’s DOM nodes
4 |
5 | সাধারণত আমরা যখন কোন `HTML ELEMENT`কে `ref` দিয়ে ধরতে চাই, আমরা সেটা করতে পারি, এবং আমরা `ref.current`এর মধ্যে তার ভ্যালুটা পাই। কিন্তু আমরা যদি আমদের কোন কাস্টম কম্পোনেন্ট `(eg: )` কে সরাসরি ধরতে চাই, তখন আমরা সেটা পারবোনা। এবং তখন যদি আমরা কনসলে `ref` এর `current` ভ্যালু দেখি আমরা তাতে `null` পাবো।
6 |
7 | চলুন একটা উদাহরণের মাধ্যমে এই প্রব্লেমটা বুঝা যাক,
8 |
9 | ```jsx
10 | import { useRef } from "react";
11 |
12 | function MyInput(props) {
13 | return ;
14 | }
15 |
16 | export default function MyForm() {
17 | const inputRef = useRef(null);
18 |
19 | function handleClick() {
20 | inputRef.current.focus();
21 | }
22 |
23 | return (
24 | <>
25 |
26 | Focus the input
27 | >
28 | );
29 | }
30 | ```
31 |
32 | এখানে আমাদের দুইটা কম্পোনেন্ট আছে যার একটি হলো `` যাতে শুধুমাত্র একটি ইনপুট ট্যাগ আছে, আরেকটি হলো প্যারেন্ট কম্পোনেন্ট , এখানে একটি বাটন আছে এবং আমরা চাইছি এই বাটনে `onClick`এ আমরা আমাদের যেই কাস্টম কম্পোনেন্ট `` এর ভিতরের ইনপুট ট্যাগ এ ফোকাস করবো। কিন্তু আমরা যদি এখন আউটপুট দেখি এবং বাটনে ক্লিক করি তাহলে দেখবো যে ইনপুট ট্যাগটা ফোকাস হচ্ছেনা।
33 |
34 | তার কারণ হলো রিয়াক্ট বাই ডিফল্ট কোন কম্পোনেন্ট এর রেফারেন্স অন্য কম্পোনেন্টে শেয়ার করেনা এমনকি সেটা সেই কম্পোনেন্টের নিজের চাইল্ড কম্পোনেন্ট হলেও না।
35 |
36 | কিন্তু আমরা যদি এই বিহেবিয়ারটাকে চেঞ্জ করতে চাই এবং সত্যিই চাই যে আমরা আমাদের কাস্টম কম্পোনেন্টের কোন Node কে আমরা বাহিরের কোন কম্পোনেন্টে এক্সেস দিবো তাহলে আমদেরকে সেই কাস্টম কম্পোনেন্টস থেকে রেফারেন্স টাকে ফরওয়ার্ড করে দিতে হবে React এর `forwardRef` API ব্যাবহার করে।
37 |
38 | সেজন্য আমাদের কে দুইটা স্টেপ ফলো করতে হবে।
39 |
40 |
41 | ### প্যারেন্ট কম্পোনেন্ট থেকে `ref` কে প্রপ্স এর মতো করে পাস করতে হবে ।
42 |
43 | ```jsx {12}
44 |
45 | import { useRef } from "react";
46 |
47 | export default function MyForm() {
48 | const inputRef = useRef(null);
49 |
50 | function handleClick() {
51 | inputRef.current.focus();
52 | }
53 |
54 | return (
55 | <>
56 |
57 | Focus the input
58 | >
59 | );
60 |
61 | }
62 |
63 | ```
64 |
65 | ### চাইল্ড কম্পোনেন্ট থেকে কম্পোনেন্টটাকে `forwardRef` (এটা একটা Higer Order Function) ব্যাবহার করে `ref` সহ কম্পোনেন্ট কে ফরওয়ার্ড করে দিতে হবে।
66 |
67 | এক্ষেত্রে আমরা আমাদের পুরো কম্পোনেন্ট টাকে `forwardRef` দিয়ে wrap করে দিতে হবে এবং প্যারেন্ট কম্পোনেন্ট থেকে পাস করা `ref` আমরা কম্পোনেন্টের সেকেন্ড প্যারামিটারে ধরতে পারি এবং সেটা কম্পোনেন্টের যেই নোডের এক্সেস চাই সেটাতে সেট করতে হবে।
68 |
69 | ```jsx {12}
70 |
71 | import { forwordRef } from "react";
72 |
73 | const MyInput = forwardRef((props,ref)=> { return });
74 |
75 | export default MyInput;
76 |
77 | ```
78 |
79 |
80 |
81 | এবার যদি আমরা আউটপুট দেখি এবং বাটনে ক্লিক করি, আমরা দেখবো এটা কাজ করছে। স্বাভাবিক ভাবে কম্পোনেন্ট গুলো তাদের Node এর রেফারেন্স বাইরে শেয়ার করেনা কারণ এতে কম্পোনেন্ট আন-এক্সপেক্টেড আচরণ করতে পারে, তাই এটাই ডিফল্ট বিহেবিয়ার, আমরা এটাকে পরিবর্তন করতে চাইলে উপরের স্টেপগুলো ফলো করে করতে পারি।
82 |
83 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/handling-effects-firing-twice.mdx:
--------------------------------------------------------------------------------
1 | ### How to handle the Effect firing twice in development?
2 |
3 | রিয়াক্ট ইন্টেনশনালি প্রতিটা কম্পোনেন্টকে দুইবার করে রান করে যাতে আমরা সহজেই বুঝতে পারি যে কোডে কোন বাগ রয়েছে কিনা, তাই ডেভেলপমেন্ট মুডে আমরা যখনি দেখবো যে আমাদের কম্পোনেন্ট দুইবার করে রান হয়েছে তখন আমরা এটা ভাববোনা যে, **কিভাবে আমাদের কম্পোনেন্ট একবার রান করবো বরং এটা ভাববো যে কিভাবে আমাদের ইফেক্টগুলোকে ঠিক ভাবে করতে পারি যাতে আমাদের কম্পোনেন্ট দুইবার মাউন্ট হলেও যেন ইফেক্ট ঠিকভাবে কাজ করে?**
4 |
5 | সাধারণভাবেই এটার উত্তর হলো, ইফেক্টের ক্লিন-আপ ফাংশনের ইমপ্লিমেন্ট করা। আমরা যদি সঠিকভাবে ক্লিন-আপ ফাংশন ইমপ্লিমেন্ট করতে পারি, তাহলে আমদের কম্পোনেন্ট দুইবার করে মাউন্ট হলেও সঠিকভাবে কাজ করবে।
6 |
7 | ### Don’t use refs to prevent Effects from firing
8 |
9 | একটা সাধারণ ভুল যেটা অনেকেই করে তা হলো `ref` এর মাধ্যমে ইফেক্টকে দুইবার করে রান হওয়া বন্ধ করে।
10 |
11 | ```jsx
12 | const connectionRef = useRef(null);
13 | useEffect(() => {
14 | // ❌ This wont fix the bug!!!
15 | if (!connectionRef.current) {
16 | connectionRef.current = createConnection();
17 | connectionRef.current.connect();
18 | }
19 | }, []);
20 | ```
21 |
22 | এটা করলে হয়তো ডেভেলপমেন্ট মোডে আপনি দেখতে পারেন যে আপনার কানেকশন একবার হয়ছে,কিন্তু এতে কিন্তু বাগ ফিক্স হয়না। যখন ইউজার নেভিগেট করে অন্য পেজে চলে যাবে এবং ফিরে আসলে আবার নতুন করে কানেকশন হবে, কিন্তু পুর্বের কানেকশন কিন্তু ক্লোজ করা হয়নি। তাই এটা মেমরি লিক করবে।
23 |
24 | তাই এটা ফিক্স করার জন্য অবশ্যই ক্লিন-আপ ফাংশন ইমপ্লিমেন্ট করা লাগবে।
25 |
26 | নিচে আমরা কয়েকটা কমন প্যাটার্নের উদাহরণ দেখবো যাতে আমরা বুঝতে পারি যে কখন আমাদের ক্লিন-আপ ফাংশন লেখা লাগবে আর কখন লাগবেনা।
27 |
28 | #### Controlling non-React widgets
29 |
30 | যখন আমরা কোন UI এলিমেন্ট এড করবো যা আমাদের রিয়াক্টে লেখা নয়, উদাহরণ স্বরূপ যদি আমরা একটা ইমেজ এড করি এবং তার একটা জুমলেভেল সেট করে দেই ইফেক্ট দিয়ে তাহলে আমাদের ক্লিন-আপ ফাংশনের কোন দরকার নেই, কেননা কম্পোনেন্ট যতবার মাউণ্ট হউক না কেন, একই কপোনেন্টে বার বার একই ভ্যালু পাবে। তাই এখানে ক্লিন-আপের কোন দরকার নেই।
31 |
32 | ```jsx
33 | useEffect(() => {
34 | const map = mapRef.current;
35 | map.setZoomLevel(zoomLevel);
36 | }, [zoomLevel]);
37 | ```
38 |
39 | আবার কিছু কিছু API আছে যেগুলা একসাথে দুইবার রান হলে ইরর দেয়, যেমন HTML এর `dialog` ট্যাগ এর একটা বিল্ট-ইন মেথড আছে `showModal` নামে। এখানে যদি দুইবার `showModal` কল হয় তাহলে ইরর দিতে পারে, তাই এখানে ক্লিন-আপ করতে হবে।
40 |
41 | ```jsx
42 | useEffect(() => {
43 | const dialog = dialogRef.current;
44 | dialog.showModal();
45 | return () => dialog.close();
46 | }, []);
47 | ```
48 |
49 | #### Subscribing to events
50 |
51 | যখনি আমরা ইফেক্টের ভিতরে কোন ইভেন্ট লিসেনার এড করবো সেটা অবশ্যই আমদের ক্লিন-আপ করা লাগবে।
52 |
53 | ```jsx
54 | useEffect(() => {
55 | function handleScroll(e) {
56 | console.log(window.scrollX, window.scrollY);
57 | }
58 | window.addEventListener("scroll", handleScroll);
59 | return () => window.removeEventListener("scroll", handleScroll);
60 | }, []);
61 | ```
62 |
63 | #### Triggering animations
64 |
65 | যখন আমরা ইফেক্টের ভিতরে কোন কম্পোনেন্টে এনিমেশন এড করবো তখন অবশ্যই ক্লিন-আপ এড করা লাগবে, যাতে কম্পোনেন্ট আনমাউন্ট হলে এনিমেশন ও রিসেট হয়, নাহলে এটা ইউজারের এক্সপেরিয়ন্স কে নষ্ট করতে পারে।
66 |
67 | ```jsx
68 | useEffect(() => {
69 | const node = ref.current;
70 | node.style.opacity = 1; // Trigger the animation
71 | return () => {
72 | node.style.opacity = 0; // Reset to the initial value
73 | };
74 | }, []);
75 | ```
76 |
77 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/manipulating-dom-with-refs.mdx:
--------------------------------------------------------------------------------
1 | import { Steps } from "nextra/components";
2 |
3 | রিয়াক্ট অটোমেটিক ভাবে DOM কে আপডেট করতে থাকে, তাই আমদের ম্যনুয়ালি DOM কে মডিফাই করা দরকার হয়না, কিন্তু আমাদের এমন এমন কিছু ইউজকেস আসতে পারে যখন আমদের বাধ্য হয়ে DOM মেনিপুলেট করা লাগে, যেমনঃ কোন এলিমেন্টে ফোকাস করা, স্ক্রল করে কোন এলিমেন্টের পজিশনে যাওয়া অথবা সাইজ পরিমাপ করা। রেয়াক্টে এসব করার জন্য কোন বিল্ট-ইন মেথড নেই, তাই এসব করার জন্য আমরা `useRef` ব্যবহার করে সরাসরি DOM মডিফাই করতে পারি।
4 |
5 | চলুন দেখে নেই কিভাবে আমরা `useRef` ব্যবহার করে DOM মেনিপুলেট করতে পারি,
6 |
7 |
8 | ### Import useref from react
9 |
10 | সর্বপ্রথম আমদেরকে রিয়াক্ট থেকে `useRef`কে ইম্পোর্ট করতে হবে।
11 |
12 | ```jsx
13 | import { useState } from "react";
14 | ```
15 |
16 | ### declare a ref inside your component:
17 |
18 | কম্পোনেন্টের ভিতর `ref` কে ডিক্লেয়ার করে ইনিশিয়াল করতে হবে।
19 |
20 | ```jsx
21 | const myRef = useRef(null);
22 | ```
23 |
24 | ### pass your ref as the `ref` attribute to the JSX tag
25 |
26 | এবারে আমরা যেই DOM node কে মেনিপুলেট করতে চাই সেই JSX ট্যাগ এ Attraibute এর মতো করে `ref` কে ব্যবহার করবো।
27 |
28 | ```jsx
29 |
30 | Change Text
31 | ```
32 |
33 | ### modify the dom node in event handler
34 |
35 | এবারে আমদের ওই DOM NODE যেসব মেনিপুলেশন করা দরকার তা করতে পারবো event handler এর মধ্যমে।
36 |
37 | ```jsx
38 | function handleChangeText() {
39 | myRef.innerText = "This is a text passed by the ref";
40 | }
41 | ```
42 |
43 |
44 |
45 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/removing-effect-dependecies.mdx:
--------------------------------------------------------------------------------
1 | ### Removing Effect Dependencies
2 |
3 | যখনি আপনি কোন ইফেক্ট ডিক্লেয়ার করবেন,তখন `linter` অটোমেটিক ভেরিফাই করবে যে আপনি সকল রিয়াক্টিভ ভ্যালু তার ডিপেন্ডেন্সি অ্যারেতে এড করেছেন, কিন্তু কখনো কখনো যদি আপনি অপ্রয়োজনীয় ডিপেন্ডেন্সি এড করেন, এটা আপনার এপ্লিকেশনে বাগ সৃষ্টি করতে পারে ।
4 |
5 | এই লেসনে আমরা জানবো কিভাবে আমরা ইফেক্টের ডিপেন্ডেন্সি থেকে অপ্রয়োজনীয় ডিপেন্ডেন্সি বাদ দিতে পারি।
6 |
7 | #### Dependencies should match the code
8 |
9 | যখনি কোন ইফেক্ট লিখবেন, আপনি ইফেক্টের মাধ্যমে কি করতে চান তার শুধু স্টার্ট আর স্টপ লিখবেন, তারপর যদি আপনি ইফেক্টর ডিপেন্ডেন্সি ইম্পটি রাখলে `linter` আপনাকে প্রয়োজনীয় ডিপেন্ডেন্সিগুলো অটো সাজেস্ট করবে। আপনাকে শুধু সেই সাজেশন অনুযায়ী ডিপেন্ডেন্সিগুলো ডিপেন্ডেন্সি অ্যারেতে লিখে দিতে হবে।
10 |
11 | অর্থাৎ আপনাকে ইফেক্টের ডিপেন্ডেন্সি নিয়ে কোন চিন্তা করতে হবেনা, প্রয়োজনীয় ডিপেন্ডেন্সিগুলো `linter`ই আপনাকে বলে দিবে।
12 |
13 | #### To remove a dependency, prove that it’s not a dependency
14 |
15 | যেহেতু আপনাকে ইফেক্টের ডিপেন্ডেন্সিগুলো আপনাকে সিলেক্ট করতে হবেনা, প্রয়োজনীয় ডিপেন্ডেন্সিগুলো `linter`ই আপনাকে বলে দিবে। তাই যদি এমন হয় যে এমন কোন ডিপেন্ডেন্সি `linter` আপনাকে সাজেস্ট করছে ডিপেন্ডেন্সিতে এড করতে কিন্তু আপনি সিওর জানেন যে সেটা কখনো চেঞ্জ হবেনা, আর তাই আপনি সেটা ডিপেন্ডেন্সিতে দিতে চান না, তাহলে রিয়াক্টকে এটা কোডের মাধ্যমে বুঝাবেন যে এটা কখনো চেঞ্জ হবেনা। কিন্তু আপনি কিন্তু এমন ক্ষেত্রে কখনই `linter` কে সাপ্রেস করবেন না।
16 |
17 | ধরুন আপানার কোড এমন ,
18 |
19 | ```jsx
20 | const serverUrl = "https://localhost:1234";
21 |
22 | function ChatRoom({ roomId }) {
23 | // This is a reactive value
24 | useEffect(() => {
25 | const connection = createConnection(serverUrl, roomId); // This Effect reads that reactive value
26 | connection.connect();
27 | return () => connection.disconnect();
28 | }, [roomId]); // ✅ So you must specify that reactive value as a dependency of your Effect
29 | // ...
30 | }
31 | ```
32 |
33 | এক্ষত্রে `linter` আপনাকে সাজেস্ট করবে `roomId` কে ডিপেন্ডেন্সিতে এড করার জন্য। কিন্তু আপনি জানেন যে `roomId` কখনোই চেঞ্জ হবেনা। আর তাই আপনি হয়তো `roomId` কে ডিপেন্ডেন্সি থেকে বাদ দিলেন,
34 |
35 | ```jsx
36 | const serverUrl = "https://localhost:1234";
37 |
38 | function ChatRoom({ roomId }) {
39 | useEffect(() => {
40 | const connection = createConnection(serverUrl, roomId);
41 | connection.connect();
42 | return () => connection.disconnect();
43 | }, []); // 🔴 React Hook useEffect has a missing dependency: 'roomId'
44 | // ...
45 | }
46 | ```
47 |
48 | তখনি দেখবেন `linter` আপনাকে ওয়ার্নিং দেবে, আর তাই আপনি হয়তো ওয়ার্নিং থেকে বাচার জন্য `linter` কে এভাবে সাপ্রেস করে দিলেন।
49 |
50 | ```jsx
51 | const serverUrl = "https://localhost:1234";
52 |
53 | function ChatRoom({ roomId }) {
54 | useEffect(() => {
55 | const connection = createConnection(serverUrl, roomId);
56 | connection.connect();
57 | return () => connection.disconnect();
58 | // eslint-ignore-next-line react-hooks/exhaustive-deps
59 | }, []);
60 | // ...
61 | }
62 | ```
63 |
64 | এটা কখনই করবেন না, কারণ এতে আপনার কম্পোনেন্টে বাগ তৈরি হবে, এবং পরে আর কখনই এই কম্পোনেন্টে `linter` সাজেশন দিবেনা, আর তাই হয়তো আপনি কোন প্রয়োজনীয় ডিপেন্ডেন্সি মিস করে যেতে পারেন, এতে আপনার কম্পনেন্টের বিহেবিয়ার চেঞ্জ হয়ে যাবে। তাই আপনি যদি একদম শিওর হন যে, `roomId` কখনই চেঞ্জ হবেনা,তাহলে আপনাকে রিয়াক্টকে বুঝাতে হবে যে `roomId` কখনই চেঞ্জ হবেনা। আর এটা করার জন্য আপনি `roomId` কে কম্পোনেন্টের বাহিরে নিয়ে স্ট্যাটিক ভাবে লিখে রাখতে পারেন।
65 |
66 | ```jsx
67 | const serverUrl = "https://localhost:1234";
68 | const roomId = "general";
69 |
70 | function ChatRoom() {
71 | useEffect(() => {
72 | const connection = createConnection(serverUrl, roomId);
73 | connection.connect();
74 | return () => connection.disconnect();
75 | }, []);
76 | // ...
77 | }
78 | ```
79 |
80 | মনে রাখবেন ডিপেন্ডেন্সি থেকে কোন কিছু বাদ দিতে চাইলে কখনওই `linter` কে সাপ্রেস করবেন না । বরং আপনি কোড চেঞ্জ করবেন। কোড অনুযায়ী ডিপেন্ডেন্সি ম্যাচ করবে।
81 |
82 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/seperating-events-from-effects.mdx:
--------------------------------------------------------------------------------
1 | ### Separating Events from Effects
2 |
3 | ইউজার যখন কোন ইন্টারেকশন করে তখন মূলত ইভেন্ট হ্যান্ডেলার রান হয়, যদি সেম ইন্টারেকশন আরেকবার করে তাহলে আরেকবার ইভেন্ট-হ্যান্ডেলার রি-রান হয়, কিন্তু ইফেক্ট শুধু তখনই রি-রান হয় যখন তার ডিপেন্ডেন্সি অ্যারেতে থাকা কোন ভ্যালু আগের রেন্ডার থেকে পরের রেন্ডারে চেঞ্জ হয়।
4 |
5 | কখনো কখনো হয়তো আমরা দুইটা মিলিয়েই ব্যাবহার করবো,কিন্তু এই লেসনে আমরা শিখবো কিভাবে আমরা ইফেক্ট থেকে ইভেন্টগুলোকে আলাদা করবো।
6 |
7 | #### Choosing between event handlers and Effects (কখন ইফেক্ট ব্যাবহার করবো আর কখন ইভেন্ট হ্যন্ডেলার ব্যাবহার করবো ?)
8 |
9 | মনে করুন আপনি একটা চ্যাটরুম কম্পনেন্ট বানাচ্ছেন, এখন এক্ষেত্রে দুইটা রিকুয়ারমেন্ট আছে,
10 |
11 | 1. আপনার কম্পোনেন্টকে অটোমেটিক ভাবে চ্যাটরুম সার্ভারের সাথে কানেক্টেড হতে হবে।
12 | 2. যখন আপনি `Send` বাটনে ক্লিক করবেন,সুধুমাত্র তখনি মেসেজ সেন্ট হতে হবে।
13 |
14 | এখন আপনি চিন্তা করেন কোনটা কোথায় রাখা উচিত।
15 |
16 | **অবশ্যই যেটা ক্লিক করার পর হবে সেটা হবে ইভেন্ট হ্যান্ডেলার, আর যেটা অটোমেটিক হবে সেটা হবে ইফেক্ট।**
17 |
18 | #### Reactive values and reactive logic (রিয়াক্টিভ ভ্যালু এবং রিয়াক্টিভ লজিক কি ?)
19 |
20 | ##### Reactive values
21 |
22 | সাধারণ ভাবে আমরা বলতে পারি যে, ইভেন্ট-হ্যান্ডেলারগুলো ট্রিগার হয় ম্যানুয়ালি,যেমন কোন বাটনে ক্লিক করার পর কোন কিছু হবে, এটাকে আমরা ইভেন্ট বলতে পারি। অন্যদিকে যদি কোনকিছু অটোমেটিক করার প্রয়োজন হয়, তখন সেই অটোমেটিক কাজগুলো হবে ইফেক্ট।
23 |
24 | প্রপ্স,স্টেট এবং ভ্যারিয়েবল যেগুলো কম্পোনেন্ট এর বডির ভিতরে ডিক্লেয়ার করা হয়েছে সেগুলো হলো রিয়াক্টিভ ভ্যালু।
25 |
26 | ```jsx /serverUrl/ /roomId/ /message/
27 | const serverUrl = "https://localhost:1234";
28 |
29 | function ChatRoom({ roomId }) {
30 | const [message, setMessage] = useState("");
31 |
32 | // ...
33 | }
34 | ```
35 |
36 | এই উদাহরণে `serverUrl` কোন রিয়াক্টিভ ভ্যালু নয়, কেননা এটা কম্পোনেন্ট এর রেন্ডারিং এর বাহিরে ডেক্লেয়ার করা একটা স্ট্যাটিক ভ্যালু। এটি কম্পোনেন্টের রি-রেন্ডারে কখনই চেঞ্জ হবেনা। কিন্তু `roomId`, আর `message` কিন্তু রিয়াক্টিভ ভ্যালু । কেননা `roomId` প্রপ্স হিসেবে এসেছে আর `message` হলো একটা স্টেট ভ্যারিয়েবল। তাই দুইটাই রিয়াক্টিভ ভ্যালু।
37 |
38 | ##### reactive logic
39 |
40 | - **Logic inside event handlers is not reactive** ইভেন্ট হ্যান্ডেলারের ভিতরে লিখা লজিকগুলো কখনো রিয়াক্টিভ না, কেননা এগুলো কখনো অটোমেটিক কোন কিছু করবেনা, একমাত্র কোন একশন ট্রিগার হলেই লজিকগুলো এক্সিকিউট হবে।
41 |
42 | - **Logic inside Effects is reactive** এফেক্টের ভিতরে লিখা লজিকগুলো রিয়াক্টিভ। কেননা যদি ইফেক্টের ডিপেন্ডেন্সি এরের ভিতরে কোন কিছু রে-রেন্ডারে চেঞ্জ হয়,তাহলে ইফেক্টের ভিতরের লজিকগুলো অটোমেটিক রান হয়।
43 |
44 | #### Extracting non-reactive logic out of Effects
45 |
46 | কখনো কখনো ইফেক্টের ভিতরে নন-রিয়াক্টিভ লজিক লিখতে হতে পারে। কিন্তু এতে করে আবার আমদের এপ্লিকেশনের বিহেবিয়ার চেঞ্জ হয়ে যেতে পারে, মানে যেটা আমরা অটোমেটিক চাইনা, সেটাও অটোমেটিক কল হয়ে যেতে পারে,
47 |
48 | এইরকম সিচুয়েশনে রিয়াক্টের একটা বিল্ট-ইন হুক যেটা `useEffectEvent` এখনো রিয়াক্টের স্টেবল ভার্সনে রিলিজ হয়নি,সেটা যখন স্টেবল ভার্সনের রিলিজ হবে তখন আমরা তা ব্যাবহার করতে পারবো। যেহেতু এটা এখনও স্টেবল ভার্সনের রিলিজ হয়নি, তাই এটার ডকুমেন্টেশন আমরা এখানে এড করছিনা। তবে আপনি চাইলে [এই লিঙ্কে ক্লিক করে `useEffectEvent` সম্পর্কে বিস্তারিত জানতে পারেন](https://react.dev/learn/separating-events-from-effects#declaring-an-effect-event)
49 |
50 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/the-lifecycle-of-an-effect.mdx:
--------------------------------------------------------------------------------
1 | ### The lifecycle of an Effect
2 |
3 | রিয়াক্টের প্রতিটা কম্পনেন্ট সেম লাইফ সাইকেলের ভিতর দিয়ে যায়,
4 |
5 | - **মাউন্টঃ** কম্পোনেন্ট প্রথমে মাউন্ট হয় এবং স্ক্রিনে ভিজিবল হয়।
6 | - **আপডেটঃ** প্রপ বা স্টেট চেঞ্জ এর উপর ভিত্ত করে কম্পোনেন্ট আপডেট হয়।
7 | - **আনমাউন্টঃ** যখন স্ক্রিন থেকে রিমোভ করা হয় বা ইউজার নেভিগেট করে অন্য পেজে যায় তখন কম্পোনেন্ট আনমাউণ্ট হয়।
8 |
9 | রিয়াক্টের কম্পোনেন্টের ক্ষেত্রে এভাবে ভাবলে ঠিক আছে, কিন্তু ইফেক্টের লাইফসাইকেল কিন্তু এভাবে নয়। প্রতিটা ইফেক্ট কম্পোনেন্টের লাইফসাইকেল থেকে আলাদা। ইফেক্ট কম্পোনেন্টের স্টেট বা প্রপ এর সাথে এক্সটারনাল সার্ভারের `Syncronize` করে থাকে, তাই যখনি আমাদের কোড চেঞ্জ হতে থাকে তখন `Syncronization` টাও একাধিকবার দরকার হয়।
10 |
11 | চলুন একটু উদাহরণের মাধ্যমে বুঝি,
12 |
13 | ধরে নেই আমাদের এই কোড একটা এক্সটারনাল চ্যাট সার্ভারের সাথে কানেক্ট করে।
14 |
15 | ```jsx
16 | const serverUrl = "https://localhost:1234";
17 |
18 | function ChatRoom({ roomId }) {
19 | useEffect(() => {
20 | const connection = createConnection(serverUrl, roomId);
21 | connection.connect();
22 | return () => {
23 | connection.disconnect();
24 | };
25 | }, [roomId]);
26 | // ...
27 | }
28 | ```
29 |
30 | এখানে ইফেক্টের বডিতে বলা হয়েছে কিভাবে চ্যাট সার্ভারের সাথে কানেকশন ঘটাবে,
31 |
32 | ```jsx {2-3}
33 | // ...
34 | const connection = createConnection(serverUrl, roomId);
35 | connection.connect();
36 | return () => {
37 | connection.disconnect();
38 | };
39 | // ...
40 | ```
41 |
42 | আর এখানে ক্লিন-আপের মধ্যে বলা হয়েছে কিভাবে কানেকশন স্টপ করবে,
43 |
44 | ```jsx {4-6}
45 | // ...
46 | const connection = createConnection(serverUrl, roomId);
47 | connection.connect();
48 | return () => {
49 | connection.disconnect();
50 | };
51 | // ...
52 | ```
53 |
54 | সাধারণভাবেই আপনি ভাবতে পারেন যে এখানে যখন কম্পোনেন্ট মাউট হবে তখন ইফেক্টের মাধ্যমে কানেশন স্টার্ট হবে এবং যদি কম্পোনেন্ট আনমাউন্ট হয় তাহলে কানেকশন স্টপ হয়ে যাবে।
55 |
56 | কিন্তু এখানেই কিন্তু সবকিছু শেষ না, আমদের কম্পোনেন্ট মাউন্ট থাকা অবস্থায় আমাদের আরও একাধিকবার সার্ভারের সাথে `Syncronization` দরকার হতে পারে।
57 |
58 | #### Why synchronization may need to happen more than once (কেন একাধিকবার `Syncronization` দরকার হবে ?)
59 |
60 | মনে করুন `ChatRoom` কম্পোনেন্ট তার প্রপ্স হিসেবে একটা `roomId` নেয় এবং যখনি `roomId` চেঞ্জ হয় তখনি কম্পোনেন্ট কে নতুন নতুন চ্যাটরুমের সাথে কানেক্টেড করতে হয়। ধরে নেন `roomId` গুলো ইউজার কোন সিলেক্ট অপশন থেকে সিলেক্ট করতে পারবে,
61 |
62 | এখন ধরুন প্রথমবার ইউজার সিলেক্ট অপশন থেকে `General` সিলেক্ট করলো এবং তাতে প্রথমে UI তে `General` চ্যাটরুম টা ভিজিবল হলো।
63 |
64 | ```jsx
65 | const serverUrl = "https://localhost:1234";
66 |
67 | function ChatRoom({ roomId /* "general" */ }) {
68 | // ...
69 | return
Welcome to the {roomId} room!
;
70 | }
71 | ```
72 |
73 | তারপর ইফেক্ট জেনারেল রুমের সাথে কানেকশন স্টার্ট করলো। এর মধ্যেই আবার ইউজার `Travel` চ্যাটরুম সিলেক্ট করলো এবং তাতে স্টেট চেঞ্জ হলো এবং প্রপ হিসেবে একটা নতুন `roomId` আসলো, এতে প্রথমে UI তে `Travel` চ্যাটরুম দেখানো হবে।
74 |
75 | কিন্তু এখনও কিন্তু আমাদের ইফেক্ট `General` চ্যাট সার্ভারের সাথেই কানেক্টেড হয়ে আছে, তাহলে এবার এখানে কিন্তু ইফেক্টকে `re-Syncronize` হতে হবে এবং `general` চ্যাট সার্ভার থেকে ডিসকানেন্ট হয়ে `Travel` চ্যাট সার্ভারের সাথে কানেক্ট হতে হবে।
76 |
77 | #### How React re-synchronizes your Effect (রিয়াক্ট কিভাবে ইফেক্ট কে `re-Syncronize` করে)
78 |
79 | ইফেক্ট তার ডিপেন্ডেন্সি হিসেবে একটা Array আকারে কিছু রিয়াক্টিভ ভ্যালু নেয়, যেগুলো চেঞ্জ হলে রিয়াক্ট নিজেই ডিসিশন নেয় তাকে কি করতে হবে। যখন স্টেট চেঞ্জ এর কারনে কম্পোনেন্ট রি-রেন্ডার হয় এবং নতুন ভ্যালু পায়, তখন কম্পোনেন্ট প্রথমে UI তে আপডেট হয়, তারপর ইফেক্ট রান হয়। ইফেক্ট রান হউয়ার আগে সে চেক করে তার ডীপেন্ডেসি Array-এর কোন ভ্যালু সেকেন্ড রেন্ডারে চেঞ্জ হয়েছে কিনা, যদি চেঞ্জ হয় তাহলে সে প্রথমে প্রথম রেন্ডারের `Syncronization` টা স্টপ করে দেয়, এবং তারপর আবার নতুন করে ইফেক্ট রান করে।
80 |
81 | ```jsx
82 | const serverUrl = "https://localhost:1234";
83 |
84 | function ChatRoom({ roomId }) {
85 | useEffect(() => {
86 | const connection = createConnection(serverUrl, roomId);
87 | connection.connect();
88 | return () => {
89 | connection.disconnect();
90 | };
91 | }, [roomId]);
92 | // ...
93 | }
94 | ```
95 |
96 | #### রিয়াক্টের ইফেক্টের লাইফসাইকেলের চিত্রঃ
97 |
98 | 
99 |
100 | ### Each Effect represents a separate synchronization process (আলাদা আলাদা ইফেক্ট আলাদা আলাদা `Syncronization` কে রিপ্রেজেন্ট করে)
101 |
102 | একই সাথে রিলেটেড ফিচারগুলো আমরা একটা ইফেক্টে ম্যানেজ করতে পারি, কিন্তু যদি এমন হয় যে আমাদের আলাদা আলাদা ফিচার ইমপ্লিমেন্ট করা লাগবে তাহলে আমরা আলাদা আলাদা ইফেক্টে সেগুলো ম্যানেজ করতে পারি।
103 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-4/useImperativeHandle.mdx:
--------------------------------------------------------------------------------
1 | import { Steps } from "nextra/components";
2 |
3 | **`forwardRef` ব্যাবহার করলে আমরা আমদের কম্পোনেন্ট এর সকল এক্সেস প্যারেন্ট কম্পোনেন্ট কে দিয়ে দেই ফরোয়ার্ড করে, কিন্তু আমরা যদি চাই যে না, আমরা `forwardRef` করে রেফারেন্স টা ফরোয়ার্ড করবো ঠিকই কিন্তু সেই সাথে আমরা এটাও বলে দিবো যে সেই রেফারেন্স নিয়ে প্যারেন্ট কম্পোনেন্ট ঠিক কি কি করতে পারবে, মানে হলো আমরা চাইল্ড থেকে প্যারেন্ট কম্পোনেন্ট এর এক্সেস টা লিমিটেড করে দিতে চাচ্ছি, যদি এমনটা করতে চাই তাহলে আমাদেরকে `useImperativeHandle` নামে রিয়াক্টের একটা বিল্ট-ইন হুক ব্যাবহার করতে হবে। আমরা নিচের স্টেপগুলো ফলো করে এটা করতে পারি।**
4 |
5 |
6 | ### চাইল্ড কম্পোনেন্টের ভিতর একটা `ref` নেয়া লাগবে সেই কম্পোনেন্টের NODE এ চাইল্ড কম্পোনেন্টের `ref` ব্যাবহার করা লাগবে।
7 |
8 | ```jsx {4,8}
9 | import { forwardRef, useRef } from "react";
10 |
11 | const MyInput = forwardRef((props, ref) => {
12 | const realInputRef = useRef(null);
13 | return (
14 |
18 | );
19 | });
20 | ```
21 |
22 | ### `useImperativeHandle` হুক এর মাধ্যমে বলে দিতে হবে আমরা কোন কোন বিষয়ের এক্সেস দিতে চাই।
23 |
24 | ```jsx {7-11}
25 | import { forwardRef, useRef, useImperativeHandle } from "react";
26 |
27 | const MyInput = forwardRef((props, ref) => {
28 | const realInputRef = useRef(null);
29 |
30 | // Only expose focus and nothing else
31 | useImperativeHandle(ref, () => ({
32 | focus() {
33 | realInputRef.current.focus();
34 | },
35 | }));
36 |
37 | return (
38 |
42 | );
43 | });
44 | ```
45 |
46 |
47 |
48 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-5/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "react-suspense-and-error-bounderies": "React Suspense and Error Bounderies",
3 | "react-lazy-load": "React Lazy Load"
4 | }
5 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-5/react-lazy-load.mdx:
--------------------------------------------------------------------------------
1 | **আমরা চেষ্টা করছি খুব দ্রুত পুরো ডকুমেন্টটিকে আপডেট করতে**
--------------------------------------------------------------------------------
/pages/reactive-accilarator/React-js/module-5/react-suspense-and-error-bounderies.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/React-js/module-5/react-suspense-and-error-bounderies.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/Tanstack-query/installation.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/Tanstack-query/installation.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "index": {
3 | "title": "Getting Started"
4 | },
5 | "javascript": "Vanilla Javascript",
6 | "git": "Git and Github Refresher",
7 | "frontend-focus-topic": "Frontend Focus Topic",
8 | "javascript-refresher": "Javascript Refresher",
9 | "React-js": "React Js",
10 | "react-router-dom": "React Router Dom",
11 | "Firebase": "Firebase",
12 | "tanstack-query": "Tanstack Query / React Query",
13 | "react-hook-form": "React Hook Form",
14 | "framer-motion": "Framer Motion",
15 | "nextjs": "Next Js",
16 | "tips-tricks": "Tips and Tricks"
17 | }
18 |
19 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/framer-motion.mdx:
--------------------------------------------------------------------------------
1 | **আমরা চেষ্টা করছি খুব দ্রুত পুরো ডকুমেন্টটিকে আপডেট করতে**
--------------------------------------------------------------------------------
/pages/reactive-accilarator/frontend-focus-topic.mdx:
--------------------------------------------------------------------------------
1 | That's great! Since you've already learned React and Next.js, you're off to a solid start. To become a well-rounded frontend developer, here are some key areas to focus on next:
2 |
3 | ### 1. **Advanced JavaScript**
4 | - Deepen your understanding of JavaScript (ES6+).
5 | - Learn about **asynchronous programming** (Promises, Async/Await).
6 | - Study **closures, event loops**, and **execution contexts**.
7 |
8 | ### 2. **State Management**
9 | - Learn advanced state management tools like **Redux**, **Recoil**, or **Zustand**.
10 | - Understand context API more deeply for managing local state.
11 |
12 | ### 3. **TypeScript**
13 | - Since many modern React/Next.js projects use TypeScript, learning this will make your code more robust and reduce bugs.
14 |
15 | ### 4. **CSS and Design Systems**
16 | - Explore **CSS frameworks** like **TailwindCSS**, **Material-UI**, or **Chakra UI**.
17 | - Learn about **CSS-in-JS** libraries like **Styled Components** and **Emotion**.
18 | - Study **responsive design** and grid systems (Flexbox, Grid).
19 | - Understand design systems and how to create or work with component libraries.
20 |
21 | ### 5. **Testing**
22 | - Learn to test your components using **Jest**, **React Testing Library**, or **Cypress**.
23 | - Understand the concepts of **unit testing**, **integration testing**, and **end-to-end testing**.
24 |
25 | ### 6. **Version Control & Collaboration**
26 | - Improve your understanding of **Git** and tools like **GitHub**, **GitLab**, or **Bitbucket**.
27 | - Learn about branching strategies, pull requests, and code reviews.
28 |
29 | ### 7. **Performance Optimization**
30 | - Learn about **code-splitting**, lazy loading, and optimizing images in React/Next.js.
31 | - Focus on **Lighthouse**, **PageSpeed Insights**, and tools for optimizing web performance.
32 |
33 | ### 8. **SEO for Frontend**
34 | - Dive deeper into **Next.js SEO** features.
35 | - Learn about **server-side rendering (SSR)**, **static site generation (SSG)**, and **dynamic routing**.
36 |
37 | ### 9. **Progressive Web Apps (PWA)**
38 | - Learn how to build PWAs, including service workers, caching strategies, and offline functionality.
39 |
40 | ### 10. **Build Tools**
41 | - Familiarize yourself with **Webpack**, **Babel**, **Vite**, or **Parcel**.
42 | - Understand **CI/CD pipelines** and how to automate testing, building, and deployment.
43 |
44 | ### 11. **Authentication and Security**
45 | - Explore **OAuth**, **JWT**, and integrating authentication systems (e.g., Firebase Auth, NextAuth).
46 | - Learn about web security essentials (XSS, CSRF, HTTPS, etc.).
47 |
48 | By working through these topics, you'll significantly enhance your frontend development skills and become more prepared for real-world projects.
49 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/git.mdx:
--------------------------------------------------------------------------------
1 | import { Callout, Steps } from "nextra/components";
2 |
3 | # গিট এবং গিটহাব
4 |
5 | ## গিট কি ?
6 |
7 | গিট হলো একটি `ভার্সন কনট্রোল` টুল।
8 |
9 | ভার্সন কনট্রোল কি ?
10 |
11 | ধরুন আপনি আপনার কম্পিউটার এ কোন ডকুমেন্ট লিখছেন,সেখানে হয়তো আজ কিছু লিখছেন আবার হয়তো অন্যদিন কিছু লিখছেন। এভাবে হয়তো আপনার কখনও মনে হলো যে আপনি গত দুইদিন যা লিখেছেন তা হয়তো সঠিক নয়, আপনি তা ডিলিট করে আবার দুই দিন আগে যা লিখেছেন সেই অবস্থায় ফিরত যেতে চান। এক্ষেত্র আপনাকে যেটা করা লাগবে তা হলো এই দুইদিনের সমস্ত লিখা মুছে ফেলতে হবে। এখন এই অবস্থায় আপনার যদি মনে না থাকে যে আপানর ঠিক কোন পর্যন্ত মুছা উচিত বা দুইদিন আগে ঠিক কতটুকু লেখা হয়েছিলো,তখন আপনি কি করবেন? ঠিক এই কাজটায় গিট হেল্প করে থাকে। গিট কোন ফাইলের প্রতিটা চেঞ্জেস গুলোকে মনিটরিং করে বা ট্র্যাক রাখে এবং প্রতিটা চেঞ্জেস গুলোকে ভার্সনাইজ করে। যাতে আপনি যেকোন সময় যেকোনো ভার্সনে সুইচ করতে পারেন ।
12 |
13 | ## গিটের কিছু প্রয়োজনীয় কমান্ড যা আমাদের গিটের লোকাল রিপজিটরিতে ফাইল ম্যানেজ করতে প্রয়োজন হবে।
14 |
15 | 1. **গিট ইনিশিয়ালাইজ করা**
16 |
17 | ```bash
18 | git init
19 | ```
20 |
21 | 2. **গিট এর স্ট্যাটাস চেক করা**
22 |
23 | ```bash
24 | git status
25 | ```
26 |
27 | 3. **ফাইলকে গিটের ট্রাক করার জন্য স্টেজ এ উঠানো**
28 |
29 | ```bash
30 | git add //For stage any specific file
31 | or
32 | git add --all // if you want to add all files
33 | or
34 | git add . // if you want to add all files in the current working directory
35 | ```
36 |
37 | 4. **কমিট করা**
38 |
39 | ```bash
40 | git commit -m ""
41 | ```
42 |
43 | 5. **গিট লগ চেক করা**
44 |
45 | ```bash
46 | git log
47 | or
48 | git log --oneline
49 | ```
50 |
51 | 6. **একটা কমিট থেকে অন্য কমিটের অবস্থায় ফিরে যাওয়া**
52 |
53 | ```bash
54 | git reset --hard
55 | ```
56 |
57 | 7. **গিটের প্রতিটা চেঞ্জের রেফারেন্স সহ লগ দেখার জন্য**
58 |
59 | ```bash
60 | git reflog
61 | ```
62 |
63 | 8. **গিটের ট্র্যাক থেকে কোন ফাইল রিমূভ করা**
64 |
65 | ```bash
66 | git rm
67 | ```
68 |
69 | 9. **ব্রাঞ্চ তৈরী করা**
70 |
71 | ```bash
72 | git branch
73 | ```
74 |
75 | 10. **ব্রাঞ্চ লিস্ট দেখা**
76 |
77 | ```bash
78 | git branch --list
79 | ```
80 |
81 | 11. **এক ব্রাঞ্চ থেকে অন্য ব্রাঞ্চ এ সুইচ করা**
82 |
83 | ```bash
84 | git switch
85 | ```
86 |
87 | 12. **এক ব্রাঞ্চের কোড অন্য ব্রাঞ্চে মার্জ করা**
88 |
89 |
90 | এক্ষেত্রে যেই ব্রাঞ্চে অন্য ব্রাঞ্চের কোড আনতে হবে,প্রথমে `git switch ` করে প্রথমে সেই ব্রাঞ্চে যেতে হবে। তারপর কমান্ড দিতে হবে।
91 |
92 |
93 | ```bash
94 | git merge
95 | ```
96 |
97 | 13. **গিট থেকে ব্রাঞ্চ ডিলিট করা**
98 |
99 | ```bash
100 | git branch -d
101 | ```
102 |
103 | 14. **ব্রাঞ্চ নেম পরিবর্তন করতে চাইলে**
104 |
105 | এক্ষেত্রে যেই ব্রাঞ্চের নাম পরিবর্তন করতে হবে আমাদেরকে প্রথমে `git switch ` করে প্রথমে সেই ব্রাঞ্চে যেতে হবে। তারপর কমান্ড দিতে হবে।
106 |
107 | ```bash
108 | git branch -m
109 | ```
110 |
111 | 15. **গিট স্ট্যাস করা (আনকমিটেড কাজ গিটের ড্রাফট এ সেভ রাখা)**
112 |
113 | ```bash
114 | git stash
115 | ```
116 |
117 | 16. **গিট স্ট্যাস লিস্ট চেক করা**
118 |
119 | ```bash
120 | git stash list
121 | ```
122 |
123 | 17. **গিটের স্ট্যাস এ কি কি সেভ রাখা হয়েছিল তা দেখতে**
124 |
125 | ```bash
126 | git stash show -p
127 | ```
128 |
129 | 18. **গিটের স্ট্যাস এপ্লাই করার জন্য**
130 |
131 | ```bash
132 | git stash apply
133 | or
134 | git stash pop
135 | ```
136 |
137 | 19. কোন ফাইল ভুলবশত গিটে এড করে ফেললে বা কমিট করার পর যদি মনে হয় ফাইলটা গিট থেকে ইগনোর করতে হবে তাহলে:
138 |
139 |
140 |
141 | ### ১ম স্টেপঃ
142 |
143 | একটা .gitignore ফাইল বানাতে হবে এবং তাতে উক্ত ফাইলের নাম এড করা লাগবে ।
144 |
145 | ### ২য় স্টেপঃ
146 |
147 | ```bash
148 | git rm --cached
149 | ```
150 |
151 |
152 |
153 | 20. গিটহাব বা রিমোট রিপোজিটরিতে ফাইল এড করা বা পুশ করার জন্যঃ
154 |
155 |
156 | ### ১ম স্টেপঃ
157 |
158 | ```bash
159 | git remote add
160 | ```
161 |
162 | example:
163 |
164 | `git remote add origin git@github.com:Deveripon/reactive-accelarator.git`
165 |
166 | ### ২য় স্টেপঃ
167 |
168 | ```bash
169 | git push -u
170 | ```
171 |
172 | example:
173 |
174 | `git push -u origin main`
175 |
176 |
177 |
178 | 21. রিমোট রিপোজিটরি থেকে পুল করা
179 |
180 | ```bash
181 | git pull
182 | ```
183 |
184 |
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/_meta.json:
--------------------------------------------------------------------------------
1 | {
2 | "setup": "Setup Environemnt and First Javascript Program",
3 | "variables": "Variables and Data Types"
4 |
5 | }
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/array-methods.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/array-methods.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/asyncronus.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/asyncronus.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/closures.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/closures.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/conditionals.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/conditionals.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/dom.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/dom.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/event-handlers.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/event-handlers.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/event-loops.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/event-loops.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/execution-context.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/execution-context.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/fetch.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/fetch.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/functions.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/functions.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/index.mdx:
--------------------------------------------------------------------------------
1 | আমরা এই সেকশনে জাভাস্ক্রিপ্টের ইন-ডেপথ টপিকগুলো নিয়ে আলোচনা করবো।
2 | এখানে আমরা আমাদের **Tapash Adhakari** দাদার [40 Days of JavaScript](https://youtube.com/playlist?list=PLIJrr73KDmRw2Fwwjt6cPC_tk5vcSICCu&si=cblrQhUh72FvJEg1) প্লেসিস্ট ফলো করে জাভাস্ক্রিপ্টের সকল টপিকগুলো নিয়ে আলোচনা করবো।
3 |
4 |
5 |
6 | আপনারা চাইলে [40 Days of JavaScript](https://youtube.com/playlist?list=PLIJrr73KDmRw2Fwwjt6cPC_tk5vcSICCu&si=cblrQhUh72FvJEg1)*** প্লেসিস্টটি ফলো করতে পারেন।
7 | এবং Tapash Adhakari দাদার [YouTube Channel](https://www.youtube.com/@TapashAdhakari) সাবস্ক্রাইব করতে পারেন।
8 | এবং Discord Server এ দাদার সাথে যুক্ত হতে পারেন [Discord Server](https://discord.gg/ux9BchWEW3)।
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/localstorage-sessionstorage.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/localstorage-sessionstorage.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/loops.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/loops.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/object-methods.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/object-methods.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/oop.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/oop.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/operators-expressions.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/operators-expressions.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/scopes-hoisting.mdx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Deveripon/reactive-accelarator/cca6bfc629189640173124b098d04b6131b31739/pages/reactive-accilarator/javascript/scopes-hoisting.mdx
--------------------------------------------------------------------------------
/pages/reactive-accilarator/javascript/setup.mdx:
--------------------------------------------------------------------------------
1 | ## Setting Up JavaScript - "JavaScript" in `html` file
2 |
3 | ### Where to put `
21 |
22 |
23 |