From 4d234cff887181bd1af697254cdb51e10858d582 Mon Sep 17 00:00:00 2001 From: Asim Kattum Thazha Date: Sat, 12 Aug 2023 22:44:02 +0530 Subject: [PATCH 1/2] feat(quickstart): quickstart phase 1 --- src/components/MDX/MDXComponents.tsx | 2 +- src/content/learn/index.md | 61 ++++++++++++++-------------- 2 files changed, 31 insertions(+), 32 deletions(-) diff --git a/src/components/MDX/MDXComponents.tsx b/src/components/MDX/MDXComponents.tsx index 8ddf371c9..2849f40bf 100644 --- a/src/components/MDX/MDXComponents.tsx +++ b/src/components/MDX/MDXComponents.tsx @@ -173,7 +173,7 @@ function YouWillLearn({ children: any; isChapter?: boolean; }) { - let title = isChapter ? 'In this chapter' : 'You will learn'; + let title = isChapter ? 'ഈ ചാപ്റ്ററിൽ' : 'ഈ ചാപ്റ്ററിൽ പഠിക്കുന്നത്'; return {children}; } diff --git a/src/content/learn/index.md b/src/content/learn/index.md index b57655bc4..835559ea6 100644 --- a/src/content/learn/index.md +++ b/src/content/learn/index.md @@ -1,29 +1,28 @@ --- -title: Quick Start +title: വേഗം തുടങ്ങാം --- -Welcome to the React documentation! This page will give you an introduction to the 80% of React concepts that you will use on a daily basis. +റീയാക്ട് ഡോക്യുമെന്റേഷനിലേക്ക് സ്വാഗതം! ദിവസേന ഒരാൾ ഉപയോഗിക്കാൻ സാധ്യത ഉള്ള 80% ആശയങ്ങളും ഈ ഒരു പേജിലൂടെ നിങ്ങൾക്ക് പഠിക്കാം. - -- How to create and nest components -- How to add markup and styles -- How to display data -- How to render conditions and lists -- How to respond to events and update the screen -- How to share data between components +- എങ്ങനെ componentകൾ ഉണ്ടാക്കാം? +- componentകളെ എങ്ങനെ style ചെയ്യാം? +- എങ്ങനെ componentൽ data കാണിക്കാം? +- conditionകളും listകളും എങ്ങനെ render ചെയ്യാം? +- events നടക്കുമ്പോൾ എങ്ങനെ സ്ക്രീനിൽ മാറ്റങ്ങൾ വരുത്താം? +- എങ്ങനെ രണ്ടു componentsനിടയിൽ data പങ്കിടാം? -## Creating and nesting components {/*components*/} +## എങ്ങനെ componentകൾ ഉണ്ടാക്കാം {/*components*/} -React apps are made out of *components*. A component is a piece of the UI (user interface) that has its own logic and appearance. A component can be as small as a button, or as large as an entire page. +നമ്മൾ ഒരു ബ്രൗസറിന്റെ സ്‌ക്രീനിൽ കാണുന്നതിനെ UI (User Interface) എന്ന് പറയാം. ഒരു ബട്ടൺ, അല്ലെങ്കിൽ ഒരു പേയ്മെന്റ് പേജ് ഒക്കെ ഒരു UIടെ ഭാഗമാണ്. സ്വന്തമായി യുക്തി(logic)യും രൂപവും ഉള്ള ഒരു UI (User Interface)ന്റെ ഒരു ഭാഗത്തെ നമുക്ക് React *component* എന്ന് വിളിക്കാം. എല്ലാ React അപ്ലിക്കേഷനുകളും components കൊണ്ട് നിർമിച്ചിരിക്കുന്നു. അതായത് ഒരു ബട്ടൺ, അല്ലെങ്കിൽ ഒരു മുഴുവൻ പേജ് ഒക്കെ നമുക്ക് component ആയിട്ട് ഉണ്ടാക്കാം. -React components are JavaScript functions that return markup: +ചുരുക്കി പറഞ്ഞാൽ "markup" return ചെയ്യുന്ന ഒരു javascript function ആണ് ഒരു React component: ```js function MyButton() { @@ -33,7 +32,7 @@ function MyButton() { } ``` -Now that you've declared `MyButton`, you can nest it into another component: +മുകളിൽ ഒരു `MyButton` component നിർവചിച്ചിരിക്കുന്നു. ചിലപ്പോൾ ഈ component വേറൊരു componentന്റെ ഉള്ളിൽ ഉപയോഗിക്കേണ്ടി വരും: ```js {5} export default function MyApp() { @@ -46,9 +45,9 @@ export default function MyApp() { } ``` -Notice that `` starts with a capital letter. That's how you know it's a React component. React component names must always start with a capital letter, while HTML tags must be lowercase. +`` ഒരു ക്യാപിറ്റൽ ലെറ്റർ വെച്ചു സ്റ്റാർട്ട് ചെയ്യുന്നത് ശ്രദ്ധിച്ചോ? എല്ലാ React componentsഉം അങ്ങനെ ആണ് തുടങ്ങുക. componentകൾ എല്ലാം ക്യാപിറ്റൽ ലെറ്റർ വെച്ചു തുടങ്ങും, അതുപോലെ HTML ടാഗുകൾ ലോവർ കേസും ആയിരിക്കും. -Have a look at the result: +മുകളിലെ കോഡ് താഴെ ഉള്ളത് പോലെ ആണ് ഒരു ബ്രൗസറിൽ കാണുക. ഒരു ബ്രൗസറിൽ React കാണിക്കുന്നതിനെ നമുക്കു React render ചെയ്യുക എന്നും പറയാം. അതായത് താഴെ ഇടത് ഭാഗത്തുള്ള കോഡ് React വലത് ഭാഗത്തു render ചെയ്തിരിക്കുന്നു @@ -73,13 +72,14 @@ export default function MyApp() { -The `export default` keywords specify the main component in the file. If you're not familiar with some piece of JavaScript syntax, [MDN](https://developer.mozilla.org/en-US/docs/web/javascript/reference/statements/export) and [javascript.info](https://javascript.info/import-export) have great references. +നമ്മുടെ കോഡിൽ `export default` എന്ന ഭാഗം ശ്രദ്ധിച്ചോ? അങ്ങനെ ആണ് നമ്മൾ ഒരു ഫയലിലെ മെയിൻ componentനെ export ചെയ്യുക. ഈ export ഭാഗം കൂടുതൽ മനസ്സിലാക്കാൻ, [MDN](https://developer.mozilla.org/en-US/docs/web/javascript/reference/statements/export) അതുപോലെ [javascript.info](https://javascript.info/import-export) ലിങ്കുകൾ ഉപയോഗിക്കാം. ഒരു component export ചെയ്താൽ മാത്രമേ നമുക്ക് മറ്റു ഫയലുകളിൽ ഉപയോഗിക്കാൻ കഴിയുകയുള്ളു. + +## JSX ഉപയോഗിച്ചു markup എഴുതുമ്പോൾ {/*writing-markup-with-jsx*/} -## Writing markup with JSX {/*writing-markup-with-jsx*/} +നമ്മുടെ componentലെ (`MyApp`) കാണാൻ HTML പോലെ ഉള്ള markup ശ്രദ്ധിച്ചോ? അതിനെ JSX എന്ന് പറയുന്നു. ഒരു React Componentനു JSX വേണം എന്ന് നിർബന്ധമില്ല, എങ്കിലും ഒരു വിധ എല്ലാ പ്രൊജെക്ടുകളും എളുപ്പത്തിൽ component എഴുതാൻ JSX ഉപയോഗിക്കുന്നു. ഈ പേജിൽ പറയുന്ന എല്ലാ [ടൂൾസും](/learn/installation) വേറെ ഒന്നും ചെയ്യാതെ തന്നെ JSX സപ്പോർട്ട് ചെയ്യും. -The markup syntax you've seen above is called *JSX*. It is optional, but most React projects use JSX for its convenience. All of the [tools we recommend for local development](/learn/installation) support JSX out of the box. -JSX is stricter than HTML. You have to close tags like `
`. Your component also can't return multiple JSX tags. You have to wrap them into a shared parent, like a `
...
` or an empty `<>...` wrapper: +റൂൾസിന്റെ കാര്യത്തിൽ HTML വെച്ച് നോക്കുമ്പോൾ JSX കുറച്ചു കൂടെ കര്‍ശനമാണ്. `
` പോലുള്ള റ്റാഗുകൾ കറക്റ്റ് ക്ലോസ് ചെയ്യണം, തന്നെയുമല്ല, ഒരു component ഒന്നിൽ കൂടുതൽ JSX റ്റാഗുകൾ return ചെയ്യരുത്. അങ്ങനെ ചെയ്യണമെങ്കിൽ എല്ലാ ടാഗുകളും ഒരു പാരന്റ് ടാഗിൽ പൊതിഞ്ഞു return ചെയ്യണം. ഉദാഹരണത്തിന് ഒരു `
...
` അല്ലെങ്കിൽ ഒരു `<>...` വെച്ചു പൊതിഞ്ഞാലേ നമ്മുടെ JSX ശെരി ആവുകയുള്ളൂ: ```js {3,6} function AboutPage() { @@ -92,17 +92,17 @@ function AboutPage() { } ``` -If you have a lot of HTML to port to JSX, you can use an [online converter.](https://transform.tools/html-to-jsx) +നിങ്ങൾക്കു കുറെ അധികം HTML റ്റാഗ്സ് JSXലേക്ക് മാറ്റാൻ ഉണ്ടെങ്കിൽ ഈ ഒരു [ഓൺലൈൻ കൺവെർട്ടർ](https://transform.tools/html-to-jsx) ഉപയോഗിക്കാം -## Adding styles {/*adding-styles*/} +## componentകളെ എങ്ങനെ style ചെയ്യാം? {/*adding-styles*/} -In React, you specify a CSS class with `className`. It works the same way as the HTML [`class`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class) attribute: +React componentൽ ഒരു CSS ക്ലാസിനു വേണ്ടി നമ്മൾ `className` ഉപയോഗിക്കണം. HTMLൽ ഉള്ള [`class`](https://developer.mozilla.org/en-US/docs/Web/HTML/Global_attributes/class) ടാഗും React `className` ടാഗും ഒരുപോലെ ആണ് വർക്ക് ചെയ്യുക. ```js ``` -Then you write the CSS rules for it in a separate CSS file: +ശേഷം വേണ്ട CSS വേറെ ഒരു ഫൈലിൽ എഴുതുക ```css /* In your CSS */ @@ -111,12 +111,11 @@ Then you write the CSS rules for it in a separate CSS file: } ``` -React does not prescribe how you add CSS files. In the simplest case, you'll add a [``](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link) tag to your HTML. If you use a build tool or a framework, consult its documentation to learn how to add a CSS file to your project. - -## Displaying data {/*displaying-data*/} +ഇതിനു ശേഷം എങ്ങനെ ആണ് നമ്മൾ ഈ CSS ഫയൽ പ്രോജെക്ടിൽ ആഡ് ചെയ്യുന്നത് എന്നതിന് Reactനു പ്രത്യേക റൂൾ ഒന്നുമില്ല. വേണമെങ്കിൽ നേരിട്ട് ഒരു [`link`](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/link) HTMLൽ കൊടുക്കാം. ഇനി നിങ്ങൾ ഒരു ബിൽഡ് ടൂലോ ഫ്രെയിംവർക്കോ ഉപയോഗിച്ചു CSS ആഡ് ചെയ്താലും ഇത് വർക്ക് ചെയ്യും. -JSX lets you put markup into JavaScript. Curly braces let you "escape back" into JavaScript so that you can embed some variable from your code and display it to the user. For example, this will display `user.name`: +## എങ്ങനെ componentൽ data കാണിക്കാം? {/*displaying-data*/} +JSX ഉപയോഗിച്ചപ്പോൾ നമുക്കു JavaScriptന്റെ ഉള്ളിൽ markup എഴുതാൻ സാധിച്ചു. JSXന്റെ ഉള്ളിൽ Curly braces ഉപയോഗിച്ചാൽ നമുക്ക് തിരിച്ചു JSXന്റെ ഉള്ളിൽ JavaScript റൺ ചെയ്യാം. താഴെ ഉള്ള example നോക്കൂ, നമ്മുടെ കോഡിലെ `user.name` എന്ന ഒരു വേരിയബിന്റെ വാല്യൂ, ഇങ്ങനെ കൊടുക്കുമ്പോൾ സ്‌ക്രീനിൽ render ചെയ്യും: ```js {3} return (

@@ -125,8 +124,7 @@ return ( ); ``` -You can also "escape into JavaScript" from JSX attributes, but you have to use curly braces *instead of* quotes. For example, `className="avatar"` passes the `"avatar"` string as the CSS class, but `src={user.imageUrl}` reads the JavaScript `user.imageUrl` variable value, and then passes that value as the `src` attribute: - +ഇനി നമുക്ക് JSXന്റെ ഏതേലും attributes ആണ് ഇങ്ങനെ മാറ്റേണ്ടതെങ്കിലും ഈ "Curly braces" തന്നെ ഉപയോഗിക്കാം. ഉദാഹരണത്തിന്, `className="avatar"` എന്നത് `"avatar"` എന്ന വാചകം (string) CSS ക്ലാസ്സായി കൈമാറുന്നു, എന്നാൽ `src={user.imageUrl}` എന്നത് `user.imageUrl`ന്റെ വാല്യൂ എടുത്ത് ആ വാല്യൂ ആണ് CSS ക്ലാസ്സായിട്ടു കൊടുക്കുക: ```js {3,4} return ( @@ -177,7 +175,8 @@ export default function Profile() { -In the above example, `style={{}}` is not a special syntax, but a regular `{}` object inside the `style={ }` JSX curly braces. You can use the `style` attribute when your styles depend on JavaScript variables. + +മുകളിൽ, `style={{}}` എന്നത് ഒരു സ്പെഷ്യൽ syntax ഒന്നുമല്ല. ഒരു സാധാരണ object `{}` നേരത്തെ പറഞ്ഞ Curly bracesന്റെ (`style={ }`) ഉള്ളിൽ വന്നതാണ്. ഇവിടെ നമ്മൾക്കു കൊടുക്കേണ്ട styles, JavaScript വേരിയബിളിൽ നിന്ന് വന്നപ്പോൾ നമ്മൾ Curly braces ഉപയോഗിച്ചു എന്ന് മാത്രം. ## Conditional rendering {/*conditional-rendering*/} From 2fde24bea178f76c7c66005f63608b6e096aa5bb Mon Sep 17 00:00:00 2001 From: Asim Kattum Thazha Date: Tue, 19 Sep 2023 12:41:28 +0530 Subject: [PATCH 2/2] feat(quickstart): complete quickstart page --- src/content/learn/index.md | 101 ++++++++++++++++++++++--------------- 1 file changed, 59 insertions(+), 42 deletions(-) diff --git a/src/content/learn/index.md b/src/content/learn/index.md index 835559ea6..40a4a267b 100644 --- a/src/content/learn/index.md +++ b/src/content/learn/index.md @@ -1,5 +1,5 @@ --- -title: വേഗം തുടങ്ങാം +title: ആമുഖം --- @@ -178,9 +178,9 @@ export default function Profile() { മുകളിൽ, `style={{}}` എന്നത് ഒരു സ്പെഷ്യൽ syntax ഒന്നുമല്ല. ഒരു സാധാരണ object `{}` നേരത്തെ പറഞ്ഞ Curly bracesന്റെ (`style={ }`) ഉള്ളിൽ വന്നതാണ്. ഇവിടെ നമ്മൾക്കു കൊടുക്കേണ്ട styles, JavaScript വേരിയബിളിൽ നിന്ന് വന്നപ്പോൾ നമ്മൾ Curly braces ഉപയോഗിച്ചു എന്ന് മാത്രം. -## Conditional rendering {/*conditional-rendering*/} +## condition എങ്ങനെ render ചെയ്യാം? {/*conditional-rendering*/} -In React, there is no special syntax for writing conditions. Instead, you'll use the same techniques as you use when writing regular JavaScript code. For example, you can use an [`if`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else) statement to conditionally include JSX: +React-ൽ, conditions എഴുതാൻ ഒരു പ്രത്യേക syntax ഒന്നുമില്ല. നമ്മൾ സാധാരണ JavaScript കോഡിൽ എഴുതുന്നത് പോലെ React-ലും എഴുതാം. ഉദാഹരണത്തിന്, ഒരു [`if`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else) സ്റ്റേറ്റ്മെന്റ് JSX-ന്റെ ഉള്ളിൽ നേരിട്ട് ഉപയോഗിക്കാം: ```js let content; @@ -196,7 +196,7 @@ return ( ); ``` -If you prefer more compact code, you can use the [conditional `?` operator.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) Unlike `if`, it works inside JSX: +കോഡ് കുറച്ചു കൂടെ ചെറുതാക്കണമെങ്കിൽ `if`നു പകരം [conditional `?` operator.](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator) ഉപയോഗിക്കാവുന്നതാണ്. ഇത് JSX-ന്റെ ഉള്ളിൽ നേരിട്ട് എഴുതാനും പറ്റും: ```js
@@ -208,7 +208,7 @@ If you prefer more compact code, you can use the [conditional `?` operator.](htt
``` -When you don't need the `else` branch, you can also use a shorter [logical `&&` syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND#short-circuit_evaluation): +ഇനി `else` ബ്രാഞ്ച് വേണ്ടെങ്കിൽ നമുക്ക് കുറച്ചു കൂടെ ഹ്രസ്വമായ [logical `&&` syntax](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND#short-circuit_evaluation) ഉപയോഗിക്കാം: ```js
@@ -216,13 +216,13 @@ When you don't need the `else` branch, you can also use a shorter [logical `&&`
``` -All of these approaches also work for conditionally specifying attributes. If you're unfamiliar with some of this JavaScript syntax, you can start by always using `if...else`. +മുകളിൽ പറഞ്ഞ എല്ലാ വഴികളും attributesനും ബാധകമാണ്. ഈ പുതിയ syntax മനസ്സിലായില്ലെങ്കിൽ, എപ്പോഴും `if...else` ഉപയോഗിക്കാം. -## Rendering lists {/*rendering-lists*/} +## list എങ്ങനെ render ചെയ്യാം? {/*rendering-lists*/} -You will rely on JavaScript features like [`for` loop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for) and the [array `map()` function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) to render lists of components. +condition പോലെ തന്നെ, list render ചെയ്യാനും React-നു പ്രത്യേക syntax ഇല്ല. JavaScript-ന്റെ ഭാഗമായ [`for` loop](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for) അതുപോലെ [array `map()` function](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) ഉപയോഗിച്ച് നമുക്ക് component-ന്റെ list-കൾ render ചെയ്യാം. -For example, let's say you have an array of products: +ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ഒരു കുറെ പ്രോഡക്ടസ് ഉണ്ടെന്നു സങ്കല്പിക്കുക. (array of products): ```js const products = [ @@ -232,7 +232,7 @@ const products = [ ]; ``` -Inside your component, use the `map()` function to transform an array of products into an array of `
  • ` items: +നമ്മുടെ componentന്റെ ഉള്ളിൽ ഒരു `map()` function ഉപയോഗിച്ചാൽ, ഈ array of productsനെ നമുക്ക് ഒരു array of `
  • ` ഐറ്റംസ് ആക്കി മാറ്റാം: ```js const listItems = products.map(product => @@ -246,7 +246,7 @@ return ( ); ``` -Notice how `
  • ` has a `key` attribute. For each item in a list, you should pass a string or a number that uniquely identifies that item among its siblings. Usually, a key should be coming from your data, such as a database ID. React uses your keys to know what happened if you later insert, delete, or reorder the items. + `
  • `ക്കു ഒരു `key` attribute കൊടുത്തത് ശ്രദ്ധിച്ചോ? ഒരു ലിസ്റ്റിലെ എല്ലാ ഐറ്റത്തിനും നമ്മൾ അതിനെ വ്യക്തമായി വേർതിരിക്കാൻ പറ്റിയ ഒരു `key` കൊടുക്കണം. അത് ഒരു string അല്ലെങ്കിൽ ഒരു number ആവാം. ഈ `key` വെച്ചാണ് React ഐറ്റംസിനു എന്തെങ്കിലും മാറ്റങ്ങൾ വന്നിട്ടുണ്ടോ എന്ന് മനസ്സിലാക്കുന്നത്. പറ്റുമെങ്കിൽ ഈ `key` നിങ്ങളുടെ ഡാറ്റയിൽ നിന്ന് തന്നെ വരണം. (Ex: `database ID`). ഒരു ലിസ്റ്റിൽ ഒരു `key` ഒരു പ്രാവശ്യം മാത്രമേ വരാൻ പാടുള്ളൂ. @@ -277,9 +277,9 @@ export default function ShoppingList() { -## Responding to events {/*responding-to-events*/} +## events നടക്കുമ്പോൾ എങ്ങനെ പ്രതികരിക്കാം? {/*responding-to-events*/} -You can respond to events by declaring *event handler* functions inside your components: +വ്യത്യസ്ത eventകൾ നടക്കുമ്പോൾ componentന്റെ ഉള്ളിൽ *event handler* functions വെച്ചു നമുക്ക് പ്രതികരിക്കാം: ```js {2-4,7} function MyButton() { @@ -295,19 +295,20 @@ function MyButton() { } ``` -Notice how `onClick={handleClick}` has no parentheses at the end! Do not _call_ the event handler function: you only need to *pass it down*. React will call your event handler when the user clicks the button. -## Updating the screen {/*updating-the-screen*/} +`onClick={handleClick}` എന്ന ഭാഗത്തു Parenthesis ഇല്ലാത്തത് ശ്രദ്ധിച്ചോ? നമ്മൾ ഒരിക്കലും event handler function നേരിട്ട് വിളിക്കരുത്. ഇവിടെ `onClick` നു നമ്മൾ `handleClick` *pass down* ആണ് ചെയ്യുന്നത്. React ആണ് യൂസർ ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുമ്പോൾ ആ `handleClick` വിളിക്കുക. -Often, you'll want your component to "remember" some information and display it. For example, maybe you want to count the number of times a button is clicked. To do this, add *state* to your component. +## സ്ക്രീൻ അപ്ഡേറ്റ് ചെയ്യാൻ {/*updating-the-screen*/} -First, import [`useState`](/reference/react/useState) from React: +പലപ്പോഴും നമ്മുടെ component ചില കാര്യങ്ങൾ ഓർത്തിരിക്കേണ്ട ആവശ്യം നമുക്ക് വരും. ഉദാഹരണത്തിന്, എത്ര പ്രാവശ്യം ഒരു ബട്ടണിൽ യൂസർ ക്ലിക്ക് ചെയ്തു എന്ന് നമുക്ക് അറിയണം എന്ന് വെക്കുക, അങ്ങനെ ചെയ്യാൻ നമുക്ക് Reactന്റെ state എന്ന ആശയം ഉപയോഗിക്കണം. + +ആദ്യമായി നമ്മൾ `useState` നമ്മുടെ component-ലേക്ക് import ചെയ്യണം: ```js import { useState } from 'react'; ``` -Now you can declare a *state variable* inside your component: +ഇനി നമുക്ക് ഒരു *state variable* ഡിക്ലയർ ചെയ്യാം: ```js function MyButton() { @@ -315,9 +316,9 @@ function MyButton() { // ... ``` -You’ll get two things from `useState`: the current state (`count`), and the function that lets you update it (`setCount`). You can give them any names, but the convention is to write `[something, setSomething]`. +രണ്ടു കാര്യങ്ങളാണ് നമുക്ക് `useState`-ൽ നിന്നും തിരിച്ചു ലഭിക്കുക. ഇപ്പോഴുള്ള അവസ്ഥ (React-ന്റെ വാക്കുകളിൽ state), കൂടെ ആ state മാറ്റാനുള്ള ഒരു function. മുകളിലെ ഉദാഹരണത്തിൽ `count` ആണ് state. അതുപോലെ `setCount` ആണ് state മാറ്റാനുള്ള function. നമുക്ക് എന്ത് പേര് വേണമെങ്കിലും ഇതിനു കൊടുക്കാം, എങ്കിലും `[something, setSomething]` എന്ന രീതിയിലാണ് നമ്മൾ അത് എഴുതേണ്ടത്. -The first time the button is displayed, `count` will be `0` because you passed `0` to `useState()`. When you want to change state, call `setCount()` and pass the new value to it. Clicking this button will increment the counter: +ആദ്യ തവണ button render ചെയ്യപ്പെട്ടപ്പോൾ, `count`-ന്റെ വാല്യൂ `0` ആയിരിക്കും, കാരണം നമ്മൾ `0` എന്നാണ് `useState` ന്റെ ഘടകം ആയിട്ട് കൊടുത്തത്. `useState(0)` എന്ന് കണ്ടില്ലേ? ഇനി ആ വാല്യൂ നമുക്ക് മാറ്റണമെങ്കിൽ, നമ്മൾ `setCount`-നു പുതിയ വാല്യൂ വെച്ച് വിളിച്ചാൽ മതി. താഴത്തെ ഉദാഹരണത്തിൽ, button ക്ലിക്ക് ചെയ്യപ്പെടുമ്പോൾ, `count` വാല്യൂ കൂടിക്കൊണ്ടിരിക്കും: ```js {5} function MyButton() { @@ -335,9 +336,10 @@ function MyButton() { } ``` -React will call your component function again. This time, `count` will be `1`. Then it will be `2`. And so on. +യൂസർ ഓരോ വട്ടവും button ക്ലിക്ക് ചെയ്യുമ്പോൾ React `handleClick` വിളിക്കുകയും, ആദ്യമുള്ള `0` മാറി `1` ആവുകയും, രണ്ടാമത്തെ ക്ലിക്കിൽ `2` ആവുകയും അങ്ങനെ ഓരോ ക്ലിക്കും `count`-നെ കൂട്ടിക്കൊണ്ടിരിക്കും . + -If you render the same component multiple times, each will get its own state. Click each button separately: +ഇനി നമ്മൾ ഇതേ component രണ്ടു സ്ഥലങ്ങളിൽ render ചെയ്താലോ? ഓരോന്നിനും അതിന്റെതായ `state` ലഭിക്കും. അതായത് വ്യത്യസ്‌തമായ സ്ഥലങ്ങളിലെ componentsനു വ്യത്യസ്ത `state` ആയിരിക്കും എന്നർത്ഥം. താഴെ ഉള്ള ഓരോ ബട്ടണും വേറെ വേറെ ക്ലിക്ക് ചെയ്തു നോക്കൂ @@ -378,59 +380,60 @@ button { -Notice how each button "remembers" its own `count` state and doesn't affect other buttons. +ഓരോ componentഉം സ്വന്തമായിട്ടുള്ള `count` "ഓർത്തിരിക്കുന്നത്" ശ്രദ്ധിച്ചോ? -## Using Hooks {/*using-hooks*/} +## Hooks ഉപയോഗിക്കുന്ന വിധം {/*using-hooks*/} -Functions starting with `use` are called *Hooks*. `useState` is a built-in Hook provided by React. You can find other built-in Hooks in the [API reference.](/reference/react) You can also write your own Hooks by combining the existing ones. +`use` എന്ന് വെച്ച് തുടങ്ങുന്ന function ആണ് *Hooks*. `useState` React തന്നെ തരുന്ന ഒരു Hook ആണ്. `useState` പോലെ React തരുന്ന Hooksനെ അറിയാൻ [API reference.](/reference/react) നോക്കാം. അതുപോലെ നമുക്ക് സ്വന്തമായി Hooks നിർമിക്കാനും സാധിക്കും. -Hooks are more restrictive than other functions. You can only call Hooks *at the top* of your components (or other Hooks). If you want to use `useState` in a condition or a loop, extract a new component and put it there. +Hooks ഒരു function ആണെന്ന് പറഞ്ഞല്ലോ. എന്നാൽ മറ്റു functionsനേക്കാൾ കൂടുതൽ റൂളുകൾ Hooksനുണ്ട്. Hooks എപ്പോഴും *component-ന്റെ തുടക്കത്തിൽ* ആയിരിക്കണം. ഉദാഹരണത്തിന് ഒരു condition-ന്റെ ഉള്ളിലോ loop-ന്റെ ഉള്ളിലോ `useState` hook ഉപയോഗിക്കാൻ പറ്റില്ല. അങ്ങനെ ഉപയോഗിക്കാൻ നമ്മൾ പുതിയൊരു component ഉണ്ടാക്കി അതിന്റെ ഉള്ളിൽ `useState` എഴുതണം. -## Sharing data between components {/*sharing-data-between-components*/} +## എങ്ങനെ രണ്ടു componentsനിടയിൽ data പങ്കിടാം? {/*sharing-data-between-components*/} -In the previous example, each `MyButton` had its own independent `count`, and when each button was clicked, only the `count` for the button clicked changed: +നമ്മൾ നേരത്തെ കണ്ട example ഓർമ ഉണ്ടോ? അതിൽ ഓരോ `MyButton` component-നും സ്വന്തമായി ഒരു `count` ഉണ്ടായിരുന്നു അല്ലെ? ഓരോ ബട്ടണും ക്ലിക്ക് ചെയ്തപ്പോൾ ആ ബട്ടണിന്റെ മാത്രം `count` മാറി. അതായത് താഴെ ചിത്രത്തിൽ പറയുന്ന പോലെ: -Initially, each `MyButton`'s `count` state is `0` +ആദ്യം രണ്ടു `MyButton`-ന്റെ `count` state `0` ആയിരുന്നു -The first `MyButton` updates its `count` to `1` +ക്ലിക്കിൽ ആദ്യത്തെ `MyButton`-ന്റെ `count` മാത്രം `1` ആയി മാറി -However, often you'll need components to *share data and always update together*. +ചിലപ്പോൾ നമുക്ക് രണ്ടു componentഉം ഒരു *ഡാറ്റ പങ്കിടേണ്ട ആവശ്യം* വരും. എന്നിട്ട് ആ ഡാറ്റ മാറുമ്പോൾ രണ്ടു component *ഒരുമിച്ച് അപ്ഡേറ്റ് ചെയ്യുകയും വേണം*. -To make both `MyButton` components display the same `count` and update together, you need to move the state from the individual buttons "upwards" to the closest component containing all of them. +രണ്ടു `MyButton`ഉം ഒരേ `count` കാണിക്കാനും ഒരുമിച്ച് അപ്ഡേറ്റ് ചെയ്യാനും, നമ്മുടെ stateനെ ഓരോ button-ൽ നിന്നും പുറത്തു കൊണ്ട് പോയി "മുകളിലോട്ട്" അയക്കണം. നമുക്ക് വേണ്ട രണ്ടു componentഉം പൊതുവായിട്ടുള്ള ഒരു parent component-ലേക്ക് അയച്ചാൽ നമുക്ക് ഒരു `count` സ്റ്റേറ്റ് മാത്രമേ ഉണ്ടാവൂ. -In this example, it is `MyApp`: +നമ്മുടെ ഉദാഹരണത്തിൽ, അത് `` component ആണ്: -Initially, `MyApp`'s `count` state is `0` and is passed down to both children +ആദ്യം `MyApp`-ന്റെ `count` state `0` ആണ്. അത് താഴെ രണ്ടു childrenഉം കൊടുക്കുന്നു -On click, `MyApp` updates its `count` state to `1` and passes it down to both children + +ക്ലിക്കിൽ `MyApp` തന്റെ `count` state, `1` ആക്കി മാറ്റുന്നു. പുതിയ `count` താഴെ 2 childrenഉം കൊടുക്കുന്നു. -Now when you click either button, the `count` in `MyApp` will change, which will change both of the counts in `MyButton`. Here's how you can express this in code. +ഇപ്പോൾ യൂസർ ഏത് ബട്ടൺ ക്ലിക്ക് ചെയ്താലും `MyApp`-ലെ `count` ആണ് മാറുന്നത്, ആ മാറ്റമാണ് രണ്ടു `MyButton`ലെ `count` മാറ്റുന്നത്. ഇത് ഇനി എങ്ങനെ കോഡിൽ വരുത്താം എന്ന് നോക്കാം -First, *move the state up* from `MyButton` into `MyApp`: +ആദ്യം `MyButton`-ലെ state-നെ *മുകളിലോട്ട്, `MyApp`ലേക്ക്, കൊണ്ട് പോവാം*: ```js {2-6,18} export default function MyApp() { @@ -455,7 +458,8 @@ function MyButton() { ``` -Then, *pass the state down* from `MyApp` to each `MyButton`, together with the shared click handler. You can pass information to `MyButton` using the JSX curly braces, just like you previously did with built-in tags like ``: + +എന്നിട്ട് ഇപ്പോൾ കൊണ്ട് പോയ stateന്റെ ഡീറ്റെയിൽസ് മുകളിലെ `MyApp`-ൽ നിന്നും, താഴെ ഉള്ള രണ്ടു `MyButton`-നു കൊടുക്കാം. നമ്മൾ നേരത്തെ പഠിച്ച Curly Braces ഇതിനു വേണ്ടി ഉപയോഗിക്കാം: ```js {11-12} export default function MyApp() { @@ -475,9 +479,9 @@ export default function MyApp() { } ``` -The information you pass down like this is called _props_. Now the `MyApp` component contains the `count` state and the `handleClick` event handler, and *passes both of them down as props* to each of the buttons. +ഇങ്ങനെ നമ്മൾ ഇപ്പോൾ താഴേക്കു കൊടുക്കുന്ന ഇൻഫോർമേഷനെ _props_ എന്നാണ് വിളിക്കുക. ഇപ്പൊ `MyApp` componentനു `count` എന്ന state-ഉം `handleClick` എന്ന event handler-ഉം ഉണ്ട്. ഈ *രണ്ടുമാണ് താഴേക്ക് props ആയിട്ടു അയച്ചു* കൊടുക്കുന്നത്. -Finally, change `MyButton` to *read* the props you have passed from its parent component: +അവസാനമായി, നമ്മുടെ `MyButton` ഈ props *വായിക്കാൻ* പ്രാപ്തമാക്കിയാൽ നമ്മുടെ ജോലി കഴിഞ്ഞു ```js {1,3} function MyButton({ count, onClick }) { @@ -490,6 +494,19 @@ function MyButton({ count, onClick }) { ``` When you click the button, the `onClick` handler fires. Each button's `onClick` prop was set to the `handleClick` function inside `MyApp`, so the code inside of it runs. That code calls `setCount(count + 1)`, incrementing the `count` state variable. The new `count` value is passed as a prop to each button, so they all show the new value. This is called "lifting state up". By moving state up, you've shared it between components. +ents. + +ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുമ്പോൾ താഴെ പറയുന്നത് പോലെ നടക്കും: +- ബട്ടണിന്റെ `onClick` handler വിളിക്കപ്പെടും +- ബട്ടണിന്റെ `onClick`, `MyApp`ന്റെ `handleClick` ആയിട്ടാണ് സെറ്റ് ചെയ്തിട്ടുള്ളത്. അതിന്റെ ഉള്ളിലെ കോഡ് റൺ ആവും. +- `handleClick`ന്റെ ഉള്ളിൽ `setCount(count + 1)` വിളിക്കപ്പെടും. +- `count`ന്റെ വാല്യൂ കുടും +- പുതിയ `count` , prop ആയിട്ട് താഴെ ഉള്ള 2 ബട്ടണിനും കൊടുക്കും. +- രണ്ടു ബട്ടണും പുതിയ `count` വാല്യൂ render ചെയ്യും. + +ഇങ്ങനെ മുകളിലോട്ട് സ്റ്റേറ്റ് കൊണ്ടുപോവുന്നതിനെ ""lifting state up" എന്ന് പറയാം. നമ്മൾ സ്റ്റേറ്റ് ലിഫ്റ്റ് ചെയ്തപ്പോൾ രണ്ടു component-നും state ഷെയർ ചെയ്യാൻ പറ്റി. + + @@ -532,6 +549,6 @@ button { ## Next Steps {/*next-steps*/} -By now, you know the basics of how to write React code! +React-ന്റെ അടിസ്‌ഥാന പാഠങ്ങൾ മനസ്സിലാക്കാൻ നിങ്ങൾക്കു പറ്റി എന്ന് വിചാരിക്കുന്നു. -Check out the [Tutorial](/learn/tutorial-tic-tac-toe) to put them into practice and build your first mini-app with React. +അടുത്തതായി, ഈ [Tutorial](/learn/tutorial-tic-tac-toe)-ലൂടെ പഠിച്ചതൊക്കെ വെച്ച് ഒരു React മിനി ആപ്പ് ഉണ്ടാക്കാൻ നോക്കാം. \ No newline at end of file