Variables & Operators in Javascript

3 Variables

Javascript-ல் உள்ள variable-ஆனது முதல் நிலைத் தரவு வகைகளான(primitive data types) எண்கள், எழுத்துக்கள் மற்றும் ‘true’ , ‘false’ என்பது போன்ற Boolean மதிப்புகளை சேமிக்கும் வல்லமை கொண்டது. மேலும் Null மற்றும் undefined என்பது போன்ற பிற நிலைத் தரவு வகைகளையும் இது ஆதரிக்கும்.

Variable Declaration & Initialization

Javascript-ல் உள்ள ஒரு variable-ஆனது எழுத்துக்கள், எண்கள் மற்றும் தசம எண்கள் போன்ற அனைத்து விதமான தரவுகளையும் தானாகவே அடையாளம் கண்டு கொள்ளும். பிற மொழிகளில் குறிப்பிடுவது போன்று int, flot, string என்றெல்லாம் வெளிப்படையாகச் சொல்லத் தேவையில்லை.

உதாரணம்:
 

<html>
   <body>
      <script type = "text/javascript">
         <!--
	    var salary;
	    salary="25000.00";
	    var age = 29, name='Nithya';
            document.write(salary,"<br/>",name,"-",age)
         //-->
      </script>
   </body>
</html>

ஏதோ ஒரு குறிப்பிட்ட மதிப்பினைத்(25000.00) தாங்கப் போகும் ஒரு பொதுவான வார்த்தைக்கு(salary) variable என்று பெயர். எனவே எந்த வார்த்தையை நாம் variable-ஆகப் பயன்படுத்தப் போகிறோம் என்பதை முன்கூட்டியே அறிவிக்க வேண்டும். இதுவே ‘variable declaration’ எனப்படும்(var salary). அவ்வாறு அறிவிக்கப்பட்ட variable-க்கு எந்த மதிப்பினை வழங்கப் போகிறோம் என்பதைக் குறிப்பிடும் செயலுக்கு ‘variable initialization’ என்று பெயர்(salary=”25000.00). ஒரு variable-ஐ அறிவிக்கும்போதே அதற்கான மதிப்பினையும் வழங்கலாம் (var age=29). மேலும் ஒன்றுக்கும் மேற்பட்ட variable-களை ஒரே நேரத்தில் நம்மால் அறிவிக்கவும், மதிப்புகளை வழங்கவும் முடியும் (var age = 29, name=’Nithya’;).

document.write() என்பது அதன் அடைப்புக்குறிக்குள் கொடுக்கப்படும் விஷயங்களை வெளியிட உதவும். இங்கு அடைப்புக்குறிக்குள் (salary,”<br/>”,name,”-“,age) என்று கொடுக்கப்பட்டிருப்பதால், salary-ன் மதிப்பும், <br/> tag-ஆனது cursor-ஐ அடுத்த வரிக்கு அனுப்பி name-ன் மதிப்பையும், Hyphen எனும் குறியீட்டையும், age-ன் மதிப்பையும் வெளிப்படுத்தியுள்ளது.

எனவே இதன் Output பின்வருமாறு அமையும்:

Local vs Global Variables

அடுத்தபடியாக ஒரே variable-க்கு வெவ்வேறு வகையான மதிப்புகளை அதன் எல்லையைப் பொறுத்து நம்மால் வரையறுக்க முடியும். பின்வரும் உதாரணத்தில் salary எனும் variable-க்கு ஒரு மதிப்பினை (25000.00) அளித்துள்ளோம். பின்னர் அதே variable- ஐ ஒரு function-க்குள் பயன்படுத்தி, வேறு ஒரு மதிப்பினை (50000.00) அளித்துள்ளோம். இவ்வாறு ஒரு சிறிய எல்லையான function-க்குள் வரையறுக்கப்படும் variable-ன் மதிப்பு அதன் எல்லைக்குள்ளேயே முடிந்து விடும். இதனை நாம் “Local variables” (salary=50000.00) என்று கூறுவோம். எந்த ஒரு தனி எல்லைக்குள்ளும் இல்லாமல் பொதுவாக காணப்படுபவை “Global variables” (salary=25000.00) ஆகும்.

<html>
   <body onload = checkscope();>
      <script type="text/javascript">
         <!--
	    var salary=25000.00;
            document.write(salary);
            function checkscope( ) 
	    {
               var salary = "50000.00";  
               document.write(salary);
            }
         //-->
      </script>
   </body>
</html>

இங்கு document.write() மூலம் salary-ன் மதிப்பினை வெளிப்படுத்துமாறு function-க்கு உள்ளேயும், வெளியேயும் கொடுத்துள்ளோம். ஆனால் function-க்கு உள்ளே உள்ள வரி மட்டும் செயல்படுத்தப்பட்டு 50000.00 எனும் மதிப்பினை வெளிப்படுத்தியுள்ளது. எப்போதும் ஒரே variable இருமுறை பயன்படுத்தப்பட்டிருப்பின், local-ஆக அமைக்கப்பட்ட variable-ன் மதிப்பே முதன்மை பெரும்.

எனவே இதன் Output பின்வருமாறு அமையும்:

Reserved Words

ஒரு சில வார்த்தைகளை (eg: export, final, long) நம்மால் variable-ஆக அறிவிக்க முடியாது. ஏனென்றால் இது போன்ற வார்த்தைகளுக்கு என்னென்ன மதிப்புகள் என்பதை javascript-ஐ உருவாக்கியவர்களே நியமித்து விட்டனர். அவையே ‘Reserved Keywords’ எனப்படும். இதன் பட்டியல் பின்வருமாறு:

abstract

boolean

break

byte

case

catch

char

class

const

continue

debugger

default

delete

do

double

else

enum

export

extends

false

final

finally

float

for

function

goto

if

implements

import

in

instanceof

int

interface

long

native

new

null

package

private

protected

public

return

short

static

super

switch

synchronized

this

throw

throws

transient

true

try

typeof

var

void

volatile

while

with

4 Operators

Operator என்றால் இயக்குபவர் என்று பொருள். கொடுக்கப்பட்ட மதிப்புகளைப் பெற்றுக்கொண்டு, அதன் மீது ஒருசில செயல்பாடுகளை செலுத்தி, நமக்கு வேண்டிய தகவல்களை வெளிப்படுத்தும் வேலையை செய்பவருக்கு operator என்று பெயர். Javascript-ல் arithmetic, comparison, logical, conditional, typeof, assignment போன்ற பல்வேறு வகையான operators உள்ளன.

கீழ்க்காணும் program-ல் அனைத்து வகை operator- களின் செயல்பாடுகளும் ஒரு சேரக் கொடுக்கப்பட்டுள்ளது.

<html>
   <body>   
      <script type="text/javascript">
         <!--
	    var a = 100;
            var b = 40;
         
            document.write("Arithmetic - "); 
            document.write(a%b);
            document.write("<br />");
            
            document.write("Comparison - ");
            document.write(a<b);
            document.write("<br />");
            
            document.write("Logical - ");
            document.write(((b<=100)&&(a>=100)));
            document.write("<br />");            
          
            document.write("Conditional - ");
            document.write((a > b) ? a : b);
            document.write("<br />");

            document.write("typeof - ");
            document.write(typeof a=="string" ? "The value is string" : "The value is not a string");
            document.write("<br />");

            document.write("Assignment - ");
            document.write((a -= b));
            document.write("<br />");
         //-->
      </script>
   </body>
</html>

இதன் Output பின்வருமாறு:

இப்போது மேற்கண்ட program- க்கான விளக்கத்தையும், ஒவ்வொரு வகை operator-ன் கீழும் வரும் அனைத்து விதமான குறியீடுகளின் செயல்பாடுகளையும் பின்வருமாறு காணலாம். மேற்கண்ட அதே program-ல் document.write() எனும் வரியை மட்டும் கீழே கொடுக்கப்பட்டுள்ளவாறு மாற்றி மாற்றி இயக்கி பார்க்கவும்.

Arithmetic Operators

இதன் கீழ் வரும் கூட்டல், கழிதல், பெருக்கல், வகுத்தல் என்னென்ன செய்யும் என்பது உங்களுக்கே தெரியும். இதனுடன் சேர்த்து Modulus (%), Increment( ++), Decrement (–) எனும் 3 வகை குறியீடுகள் உள்ளன. % என்பது இரண்டு எண்களை வகுத்தல் கிடைக்கும் மீதியை வெளிப்படுத்தும். ++ என்பது கொடுக்கப்பட்ட எண்ணுடன் ஒரு எண்ணைக் கூட்டியும், — என்பது கொடுக்கப்பட்ட எண்ணுடன் ஒரு எண்ணைக் கழித்தும் வெளிப்படுத்தும்.

Comparison Operators

இரண்டு எண்களை ஒப்பிட்டு அவற்றுக்குள் எது பெரியது(>), சிறியது(<), சமமானது(==), சமமில்லாதது(!=), என்பது போன்ற தகவல்களை வெளிப்படுத்த உதவும். (>=) என்பது சமமானது அல்லது பெரியது என்றும், (<=) என்பது சமமானது அல்லது சிறியது என்றும் பொருள்படும். இதன் வெளிப்பாடு எப்போதும் உண்மை(true), பொய்(false) எனும் இரண்டு மதிப்புகளையே பெற்றிருக்கும்.

Logical (or Relational) Operators

இது உண்மை, பொய் எனும் 2 மதிப்புகளை ஒப்பீடு செய்யப் பயன்படுகிறது. && ஒப்பிடப்படுகின்ற அனைத்தும் உண்மை என்பதை வெளிப்படுத்தினால் மட்டுமே, இதுவும் உண்மை என்பதை வெளிப்படுத்தும். !! ஒப்பிடப்படுபவைகளில் ஏதேனும் ஒன்றின் வெளிப்பாடு உண்மை என்று இருந்தால் கூட இதுவும் உண்மை என்பதை வெளிப்படுத்தி விடும். ! என்பது வெளிப்படும் விடை உண்மையாக இருப்பின் பொய் என்றும், பொய்யாக இருப்பின் உண்மை என்றும் மாற்றி வெளிப்படுத்தும்.

Assignment Operators

= என்பது வலப்புறம் இருக்கும் மதிப்பினை, இடப்புறம் உள்ள variable-க்கு வழங்கிவிடும். b=40 என்று ஒரு variable காணப்படின், a=b எனக் கொடுக்கும்போது,  a-ன் மதிப்பு 40 என மாறிவிடும். பின்னர் a+=b எனக் கொடுக்கும்போது, ஏற்கனவே a-ல் உள்ள 40 எனும் மதிப்பு, b-ல் உள்ள 40-வுடன் கூட்டப்பட்டு a-ன் மதிப்பு 80 என மாறிவிடும். a-=b எனக் கொடுக்கும்போது 80-லிருந்து 40 கழிக்கப்பட்டு மீண்டும் a-ன் மதிப்பு 40-க்கே வந்துவிடும். இப்போது பின்வரும் உதாரணத்தைப் பார்த்தால் உங்களாலேயே புரிந்து கொள்ள முடியும்.

Miscellaneous Operator

Conditional (or ternary) Operators (a > b) ? a : b என்பது ஒரு சோதனையை செய்து, அதன் வெளீிப்பாடு உண்மை என இருப்பின், ?-க்கு அடுத்து உள்ள மதிப்பினையும், பொய் என இருப்பின் அந்த மதிப்பிற்கு அடுத்து உள்ள மதிப்பினையும் வெளிப்படுத்தும்.

(typeof a==”string” ? “xxx”: “yyy”); என்பது ஒரு variable-ல் உள்ள மதிப்பின் வகையை சோதனையை செய்து, அதன் வெளீிப்பாடு உண்மை என இருப்பின், ?-க்கு அடுத்து உள்ள மதிப்பினையும், பொய் என இருப்பின் அந்த மதிப்பிற்கு அடுத்து உள்ள மதிப்பினையும் வெளிப்படுத்தும்.. அதாவது ஒரு variable-ஆனது “number”, “string”, “Boolean”, “object”, “function”, “undefined” போன்ற data வகைகளுடன் ஒப்பிடப்படுகிறது.

Leave a Comment

Your email address will not be published. Required fields are marked *