மாறிகள்

நிரலாக்கத்தை உண்மையிலேயே புரிந்துகொள்வதற்கான முதல் படி இயற்கணிதத்தை திரும்பிப் பார்ப்பதாகும். நீங்கள் பள்ளியில் அதை நினைவு வைத்திருந்தால், இயற்கணிதம் பின்வருவனவற்றை போன்ற சொற்களை எழுதுவதுடன் தொடங்குகிறது.

3 + 5 = 8

நீங்கள் ஒரு தெரியாத அளவை அறிமுகப்படுத்தும்போது கணக்கீடுகளை செய்யத் தொடங்குகிறீர்கள், எடுத்துக்காட்டாக, கீழே x:

3 + x = 8

அவற்றை மாற்றி x ஐ தீர்மானிக்கலாம்:

x = 8 - 3
-> x = 5

நீங்கள் ஒன்றுக்கு மேற்பட்டவற்றை அறிமுகப்படுத்தும்போது உங்கள் சொற்களை மிகவும் நெகிழ்வானதாக ஆக்குகிறீர்கள் - நீங்கள் மாறிகளை பயன்படுத்துகிறீர்கள்:

x + y = 8

x மற்றும் y இன் மதிப்புகளை மாற்றலாம் மற்றும் சூத்திரம் இன்னும் உண்மையாக இருக்கலாம்:

x = 4
y = 4

அல்லது

x = 3
y = 5

நிரலாக்க மொழிகளுக்கும் அதே உண்மை. நிரலாக்கத்தில், மாறிகள் மாறும் மதிப்புகளுக்கான கொள்கலன்கள். மாறிகள் அனைத்து வகையான மதிப்புகளையும் கணக்கீடுகளின் முடிவுகளையும் வைத்திருக்கலாம். மாறிகளுக்கு name மற்றும் value ஆகியவை சமமான அடையாளத்தால் (=) பிரிக்கப்பட்டிருக்கும். இருப்பினும், வெவ்வேறு நிரலாக்க மொழிகளுக்கு மாறி பெயர்களாக என்ன பயன்படுத்தலாம் என்பதில் அவற்றின் சொந்த வரம்புகள் மற்றும் கட்டுப்பாடுகள் இருப்பதை மனதில் கொள்வது முக்கியம். ஏனென்றால் சில வார்த்தைகள் மொழிக்குள் குறிப்பிட்ட செயல்பாடுகள் அல்லது செயல்பாட்டிற்காக ஒதுக்கப்படலாம்.

Javascript இல் இது எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம். பின்வரும் குறியீடு இரண்டு மாறிகளை வரையறுக்கிறது, இரண்டையும் கூட்டுவதன் முடிவை கணக்கிடுகிறது, மற்றும் இந்த முடிவை மூன்றாவது மாறியின் மதிப்பாக வரையறுக்கிறது.

let x = 5;
let y = 6;
let result = x + y;

மாறிகளுக்கு பெயரிடும் போது பின்பற்ற வேண்டிய சில வழிகாட்டுதல்கள் உள்ளன. அவை:

• மாறி பெயர்கள் ஒரு எழுத்தில், அடிக்கோடு (_), அல்லது டாலர் அடையாளத்தில் ($) தொடங்க வேண்டும்.
• முதல் எழுத்திற்கு பிறகு, எழுத்துகள், எண்கள், அடிக்கோடுகள், அல்லது டாலர் அடையாளங்களை பயன்படுத்தலாம்.
• JavaScript பெரிய மற்றும் சிறிய எழுத்துகளை வேறுபடுத்துகிறது (case-sensitive), எனவே myVariable, MyVariable, மற்றும் MYVARIABLE அனைத்தும் தனித்தனி மாறிகள்.
• உங்கள் குறியீட்டை படிக்க மற்றும் பராமரிக்க எளிதாக ஆக்க, அவற்றின் நோக்கத்தை துல்லியமாக பிரதிபலிக்கும் விவரணமான மாறி பெயர்களை பயன்படுத்துவது பரிந்துரைக்கப்படுகிறது.

let x = 20;

assert(x == 20);

ECMAScript 2015 அல்லது ES2015 E6 என்றும் அழைக்கப்படுகிறது, இது 2009 க்கு பிறகு JavaScript நிரலாக்க மொழிக்கான குறிப்பிடத்தக்க புதுப்பிப்பாகும். ES6 இல் மாறிகளை அறிவிக்க மூன்று வழிகள் உள்ளன.

var x = 5;
const y = 'Test';
let z = true;

அறிவிப்பின் வகைகள் scope ஐ பொறுத்தது. Block scope ஐப் பொறுட்படுத்தாமல் ஒரு செயல்பாடு முழுவதும் உலகளாவிய அல்லது உள்ளூர் மட்டத்தில் மாறியை வரையறுக்கும் var முக்கியசொல்லைப் போலல்லாமல், let நீங்கள் பயன்படுத்தும் block, அறிக்கை அல்லது வெளிப்பாட்டிற்கு மட்டுப்படுத்தப்பட்ட scope உடைய மாறிகளை அறிவிக்க அனுமதிக்கிறது. எடுத்துக்காட்டாக:

function varTest(){
    var x=1;
    if(true){
        var x=2; // அதே மாறி
        console.log(x); //2
    }
    console.log(x); //2
}

function letTest(){
    let x=1;
    if(true){
        let x=2;
        console.log(x); // 2
    }
    console.log(x); // 1
}

const மாறிகள் மாற்ற முடியாதவை, அதாவது அவற்றை மீண்டும் ஒதுக்க அனுமதிக்கப்படவில்லை.

const x = "hi!";
x = "bye"; // இது பிழையை ஏற்படுத்தும்