Comparisons adding 'smart headers' ml translation

1-js/02-first-steps/09-comparison/article.md

@@ -1,4 +1,4 @@
-# താരതമ്യപ്പെടുത്തൽ
+# താരതമ്യം ചെയ്യൽ
 
 ഗണിതത്തിൽ സംഖ്യകളെ പരസ്പരം താരതമ്യം ചെയ്യുന്നത് എങ്ങനെയെന്ന് നമുക്കറിയാം.
 
@@ -34,7 +34,7 @@ alert( 2 != 1 ); // true (ശരി)
 let result = 5 > 4; // റിസൾട്ടിനെ 'result' എന്ന വേരിയബിളിൽ സുക്ഷിക്കുന്നു (assign ചെയ്യുന്നു)
 alert(result); // true
 ```
-## സ്ട്രിങ്ങുകളെ താരതമ്യം ചെയ്യൽ
+## സ്ട്രിങ്ങുകളെ താരതമ്യം ചെയ്യുമ്പോൾ
 
 ഒരു സ്ട്രിംഗ് മറ്റൊന്നിനെക്കാൾ വലുതാണോ എന്നറിയാൻ ജാവാസ്ക്രിപ്റ്റ് "ഡിക്ഷണറി ഓർഡർ" (lexicographical order) ആണ് ഉപയോഗിക്കുന്നത്.
 
@@ -67,12 +67,12 @@ alert( 'കാക്കപ്പെണ്ണ്' > 'കാക്ക' ); // true
 2. `l` യും `l` യും തുല്ല്യമാണ്.
 3. `o`, `e`യെക്കാൾ വലുതാണ്. താരതമ്യം ചെയ്യൽ ഇവിടെ നിർത്തുന്നു. ആദ്യത്തെ സ്ട്രിങ്ങാണ് വലുത്.
 
-```smart header="Not a real dictionary, but Unicode order"
+```smart header="ഒരു യഥാർത്ഥ ഡിക്ഷ്ണറി അല്ല, പക്ഷെ യൂനികോഡ് ഓർഡർ"
 മുകളിലത്തെ താരതമ്യ അൽഗൊരിതം ഒരു ഡിക്ഷ്ണറിയിലോ ഫോൺ ബുക്കിലോ വാക്കുകൾ ക്രമീകരിക്കുന്നതിന് ഏകദേശം തുല്ല്യമാണ്. എങ്കിലും അത് അതുപോലെത്തന്നെയല്ല.
 
 ഉദാഹരണത്തിന്, അക്ഷരം വലുതാണോ ചെറുതാണോ എന്നതിന് ഇതിൽ സ്വാധീനം ഉണ്ട്. അതായത് `"A"` യും `"a"` യും തുല്ല്യമല്ല. ഇതിൽ ഏതാണ് വലുത്? ചെറിയക്ഷരം `"a"`. അത് എന്തുകൊണ്ടോണെന്ന് വെച്ചാൽ ചെറിയക്ഷരങ്ങൾ ആണ് ജാവാസ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്ന ഇൻ്റേണൽ എൻകോഡിംഗ് ടേബിളിൽ(Unicode) മുകളിൽ വരുന്നത്. ഇതിനെക്കുറിച്ച് വിശദമായി നമ്മൾ <info:string> ചാപ്റ്ററിൽ പഠിക്കുന്നതാണ്.
 ```
-## വ്യത്യസ്ത ടൈപ്പുകളെ(Data types) തമ്മിൽ താരതമ്യം ചെയ്യൽ
+## വ്യത്യസ്ത ടൈപ്പുകളെ(Data types) തമ്മിൽ താരതമ്യം ചെയ്യുമ്പോൾ
 
 രണ്ട് വ്യത്യസ്ത വിഭാഗത്തിൽ പെട്ട വാല്യുകളെ തമ്മിൽ താരതമ്യം ചെയ്യുമ്പോൾ, ജാവാസ്ക്രിപ്റ്റ് അവയെ ആദ്യം ഒരു നമ്പറിലേക്ക് മാറ്റും.
 
@@ -92,7 +92,7 @@ alert( false == 0 ); // true
 ```
 ```
 
-````smart header="A funny consequence"
+````smart header="രസകരമായ അനന്തരഫലം"
 അതേ സമയം ഇതും സാധ്യമാണ്:
 
 - രണ്ട് വാല്യുകളും തുല്യമാവാം.
@@ -101,7 +101,7 @@ alert( false == 0 ); // true
 
 ഉദാഹരണത്തിന്:
 
-``` js run
+```js run
 let a = 0;
 alert( Boolean(a) ); // false
 
@@ -110,6 +110,8 @@ alert( Boolean(b) ); // true
 
 alert(a == b); // true!
 ```
+````
+
 ജാവാസ്ക്രിപ്റ്റിൻ്റെ ഭാഗത്തു നിന്നു നോക്കുമ്പോൾ ഈ റിസൾട്ട് സാധാരണമാണ്. ഒരു ഇക്വാലിറ്റി ചെക്ക് വാല്യുകളെ നേരിട്ട് നമ്പറിലേക്ക് മാറ്റുമ്പോൾ (അതായത് `"0"`, `0` ആയി മാറുന്നു), `Boolean` മറ്റു പല നിയമങ്ങളും അനുസരിച്ചാണ് ഇതു ചെയ്യുന്നത്.
 
 ## സ്ട്രിക്റ്റ് ഇക്വാലിറ്റി ഓപറേറ്റർ
@@ -141,7 +143,7 @@ alert( 0 === false ); // false, കാരണം വ്യത്യസ്ത ട
 
 സ്ട്രിക്റ്റ് ഇക്വാലിറ്റി ഓപറേറ്റർ എഴുതാൻ കുറച്ചധികം ഉണ്ടെങ്കിലും അവ താരതമ്യങ്ങളെ കൂടുതൽ വ്യക്തമാക്കുകയും തെറ്റുകൾ സംഭവിക്കാനുളള സാധ്യത കുറയ്ക്കുകയും ചെയ്യുന്നു.
 
-## nullഉം undefinedഉം താരതമ്യം ചെയ്യുമ്പോൾ
+## null, undefined - താരതമ്യം ചെയ്യുമ്പോൾ
 
 `null` ഉം `undefined` ഉം മറ്റു വാല്യുകളുമായി താരതമ്യം ചെയ്യുമ്പോൾ അപ്രതീക്ഷിതമായ പല സ്വഭാവങ്ങളും നമുക്ക് കാണാൻ സാധിക്കും.
 
@@ -161,7 +163,7 @@ alert( 0 === false ); // false, കാരണം വ്യത്യസ്ത ട
 : `null` ഉം `undefined` ഉം നമ്പറിലേക്ക് മാറ്റപ്പെടുന്നു: `null` `0` ആയും, `undefined` `NaN` ആയും മാറുന്നു.
 ഇനി നമുക്ക് ഈ നിയമങ്ങൾ ഉപയോഗിച്ചാൽ സംഭവിക്കുന്ന ചില രസകരമായ കാര്യങ്ങൾ കാണാം. അതിലും പ്രധാനമായി എങ്ങനെ ഇത്തരം കെണികളിൽ വീഴാതെ നോക്കാം എന്നും.
 
-### വിചിത്രമായ റിസൾട്ട്: null vs 0
+### അസാധാരണ റിസൾട്ടുകൾ: null vs 0
 
 `null`നെ പൂജ്യവുമായി താരതമ്യം ചെയ്യാം