JavaScript Function Arguments

ஜாவாஸ்கிரிப்ட் செயல்பாடு வாதங்கள் மற்றும் அவற்றின் பண்புகள்

Parameters vs. Arguments

ஜாவாஸ்கிரிப்ட்டில், செயல்பாட்டு அளவுருக்கள் மற்றும் வாதங்கள் வெவ்வேறான கருத்துகள்:

அளவுருக்கள் வாதங்கள்
செயல்பாடு வரையறையில் பட்டியலிடப்பட்ட பெயர்கள் செயல்பாட்டிற்கு அனுப்பப்பட்டு, பெறப்பட்ட உண்மையான மதிப்புகள்
செயல்பாடு வரையறுக்கப்படும் போது குறிப்பிடப்படுகிறது செயல்பாடு அழைக்கப்படும் போது வழங்கப்படுகிறது
என்ன வகையான தரவு எதிர்பார்க்கப்படுகிறது என்பதை விவரிக்கிறது செயல்பாட்டிற்கு வழங்கப்படும் உண்மையான தரவு
function add(a, b) - இங்கே a மற்றும் b அளவுருக்கள் add(5, 3) - இங்கே 5 மற்றும் 3 வாதங்கள்

எடுத்துக்காட்டு

function multiply(a, b) {
    return a * b;
}

let result = multiply(4, 5);  // 20

மேலே உள்ள எடுத்துக்காட்டில்:

வாதம் 4 அளவுரு a க்கு ஒதுக்கப்படுகிறது.

வாதம் 5 அளவுரு b க்கு ஒதுக்கப்படுகிறது.

🎓 எளிய நினைவுகூர்வது:

  • அளவுருக்கள்: "இது எதைப் பெறுகிறது" (செயல்பாடு வரையறை)
  • வாதங்கள்: "நாம் இதை அனுப்புகிறோம்" (செயல்பாட்டு அழைப்பு)

The Arguments Object

ஜாவாஸ்கிரிப்ட் செயல்பாடுகள் arguments பொருள் என்று அழைக்கப்படும் ஒரு உள்ளமைக்கப்பட்ட பொருளைக் கொண்டுள்ளன.

arguments பொருள் செயல்பாடு அழைக்கப்பட்ட போது பயன்படுத்தப்பட்ட வாதங்களின் வரிசையைக் கொண்டுள்ளது.

எடுத்துக்காட்டு: அதிகபட்ச மதிப்பைக் கண்டறிதல்

x = findMax(1, 123, 500, 115, 44, 88);

function findMax() {
    let max = -Infinity;
    for (let i = 0; i < arguments.length; i++) {
        if (arguments[i] > max) {
            max = arguments[i];
        }
    }
    return max;
}

console.log(x);  // 500

எடுத்துக்காட்டு: அனைத்து உள்ளீட்டு மதிப்புகளையும் கூட்டுதல்

x = sumAll(1, 123, 500, 115, 44, 88);

function sumAll() {
    let sum = 0;
    for (let i = 0; i < arguments.length; i++) {
        sum += arguments[i];
    }
    return sum;
}

console.log(x);  // 871

📋 arguments பொருள் பண்புகள்:

  • arguments.length: கடந்து வந்த வாதங்களின் எண்ணிக்கை
  • arguments[0]: முதல் வாதம்
  • arguments[1]: இரண்டாவது வாதம், மற்றும் பல...
  • arguments.callee: தற்போதைய செயல்பாட்டைக் குறிக்கிறது

குறிப்பு: arguments பொருள் வரிசை போன்றது, ஆனால் உண்மையான வரிசை அல்ல. இது length பண்பு மற்றும் குறியீட்டு அணுகலைக் கொண்டுள்ளது.

⚠️ arguments பொருள் குறிப்பு:

ஒரு செயல்பாடு அதிக அளவு வாதங்களுடன் (அறிவிக்கப்பட்டதை விட அதிகமாக) அழைக்கப்பட்டால், இந்த வாதங்களை arguments பொருளைப் பயன்படுத்தி அணுகலாம்.

கவனம்: arguments பொருள் காலாவதியானது மற்றும் நவீன ஜாவாஸ்கிரிப்ட்டில் Rest parameters (...) பயன்படுத்த பரிந்துரைக்கப்படுகிறது.

வாதங்களின் வரிசை முக்கியமானது

வாதங்கள் அவை தோன்றும் வரிசையில் அளவுருக்களுக்கு ஒதுக்கப்படுகின்றன.

எடுத்துக்காட்டு

function subtract(a, b) {
    return a - b;
}

let x1 = subtract(10, 5);   // 5
let x2 = subtract(5, 10);   // -5

console.log(x1);  // 5
console.log(x2);  // -5

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

🔢 நினைவில் கொள்ள:

  • முதல் வாதம் முதல் அளவுருவிற்கு செல்லும்
  • இரண்டாவது வாதம் இரண்டாவது அளவுருவிற்கு செல்லும்
  • மூன்றாவது வாதம் மூன்றாவது அளவுருவிற்கு செல்லும், மற்றும் பல...

இது "நிலை அடிப்படையிலான வாதங்கள்" என்று அழைக்கப்படுகிறது.

வாதங்கள் மாறிகளாக இருக்கலாம்

வாதங்கள் மதிப்புகளாக இருக்க வேண்டியதில்லை. அவை மாறிகளாகவும் இருக்கலாம்.

எடுத்துக்காட்டு

let x = 5;
let y = 6;

function multiply(a, b) {
    return a * b;
}

let result = multiply(x, y);
console.log(result);  // 30

மேலும் எடுத்துக்காட்டுகள்:

let firstName = "John";
let lastName = "Doe";
let age = 30;

function createUser(name, surname, userAge) {
    return {
        name: name,
        surname: surname,
        age: userAge
    };
}

let user = createUser(firstName, lastName, age);
console.log(user);  // {name: "John", surname: "Doe", age: 30}

💡 மாறிகள் வாதங்களாக:

மாறிகளை வாதங்களாகப் பயன்படுத்துவது:

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

வாத விதிகள்

ஜாவாஸ்கிரிப்ட் செயல்பாடு வரையறைகள் வாதங்களுக்கான தரவு வகைகளைக் குறிப்பிடாது.

வகை சோதனை இல்லை

ஜாவாஸ்கிரிப்ட் செயல்பாடுகள் அனுப்பப்பட்ட வாதங்களில் வகை சோதனை செய்யாது.

function add(a, b) {
    return a + b;
}

// எண்களுடன்
console.log(add(5, 3));      // 8
// சரங்களுடன் (இணைக்கப்படும்)
console.log(add("5", "3"));  // "53"
// கலவையுடன்
console.log(add(5, "3"));    // "53"

வாதங்களின் எண்ணிக்கை சோதனை இல்லை

ஜாவாஸ்கிரிப்ட் செயல்பாடுகள் பெறப்பட்ட வாதங்களின் எண்ணிக்கையை சோதிக்காது.

function multiply(a, b) {
    return a * b;
}

// அதிக வாதங்கள்
console.log(multiply(2, 3, 4));  // 6 (முதல் இரண்டு மட்டுமே பயன்படுத்தப்படுகின்றன)
// குறைவான வாதங்கள்
console.log(multiply(2));        // NaN (b என்பது undefined)

தவறான வாதங்கள்

தவறான வாதங்கள் தவறான பதில்களைத் திருப்பித் தரும்:

எடுத்துக்காட்டு

function toCelsius(fahrenheit) {
    return (5/9) * (fahrenheit - 32);
}

// தவறான வகை
let value = toCelsius("John");
console.log(value);  // NaN

// வாதங்கள் இல்லாமல்
let value2 = toCelsius();
console.log(value2);  // NaN

⚠️ தவறான வாதங்களின் விளைவுகள்:

  • தவறான வகைகள்: எண்ணுக்குப் பதிலாக சரம் → NaN
  • வாதங்களை மறந்துவிடுதல்: அளவுரு undefined ஆகிறது
  • தவறான வரிசை: தவறான அளவுருக்களுக்கு வாதங்கள் செல்லும்
  • அதிகமான வாதங்கள்: கூடுதல் வாதங்கள் புறக்கணிக்கப்படும்

விடுபட்ட வாதங்கள்

ஒரு செயல்பாடு அளவுருக்களை விட குறைவான வாதங்களுடன் அழைக்கப்பட்டால், விடுபட்ட மதிப்புகள் undefined ஆகின்றன.

எடுத்துக்காட்டு

function multiply(a, b) {
    console.log("a:", a);  // 4
    console.log("b:", b);  // undefined
    return a * b;
}

let result = multiply(4);
console.log(result);  // NaN (4 * undefined = NaN)

ℹ️ குறிப்பு:

ஒரு ஜாவாஸ்கிரிப்ட் செயல்பாடு அளவுரு மதிப்புகள் (வாதங்கள்) மீது எந்த சோதனையையும் செய்யாது.

இயல்புநிலை அளவுருக்கள்

ஒரு செயல்பாடு விடுபட்ட வாதங்களுடன் (அறிவிக்கப்பட்டதை விட குறைவாக) அழைக்கப்பட்டால், விடுபட்ட மதிப்புகள் undefined ஆக அமைக்கப்படுகின்றன.

சில நேரங்களில் இது ஏற்றுக்கொள்ளப்படும், ஆனால் சில நேரங்களில் அளவுருவுக்கு இயல்புநிலை மதிப்பை ஒதுக்குவது நல்லது:

ES5 வழி (பழைய முறை)

function myFunction(x, y) {
    if (y === undefined) {
        y = 2;
    }
    return x + y;
}

console.log(myFunction(5));     // 7 (y இயல்புநிலை 2)
console.log(myFunction(5, 3));  // 8 (y = 3)

ES6 வழி (நவீன முறை)

function myFunction(x, y = 10) {
    return x + y;
}

console.log(myFunction(5));     // 15 (y இயல்புநிலை 10)
console.log(myFunction(5, 20)); // 25 (y = 20)
console.log(myFunction(5, 0));  // 5  (y = 0)

💡 இயல்புநிலை அளவுரு மதிப்புகள்:

ECMAScript 2015 செயல்பாட்டு அளவுருக்கள் இயல்புநிலை மதிப்புகளைக் கொண்டிருக்க அனுமதிக்கிறது.

  • வாதம் வழங்கப்படவில்லை அல்லது undefined ஆக இருந்தால், இயல்புநிலை மதிப்பு பயன்படுத்தப்படுகிறது.
  • இயல்புநிலை மதிப்புகள் எந்த வெளிப்பாடாகவும் இருக்கலாம், அல்லது மற்ற அளவுருக்களைக் கூட குறிப்பிடலாம்.

Function Rest Parameter

Rest parameter (...) ஒரு செயல்பாடு காலவரையின்றி பல வாதங்களை ஒரு வரிசையாக கையாள அனுமதிக்கிறது:

எடுத்துக்காட்டு

function sum(...args) {
    let sum = 0;
    for (let arg of args) sum += arg;
    return sum;
}

let x = sum(4, 9, 16, 25, 29, 100, 66, 77);
console.log(x);  // 326

மேலும் எடுத்துக்காட்டுகள்:

// சரங்களை இணைத்தல்
function concatenate(...strings) {
    return strings.join(' ');
}

console.log(concatenate("Hello", "World", "!"));  // "Hello World !"

// பல வாதங்களைக் கொண்டு வேலை செய்தல்
function createUser(name, age, ...hobbies) {
    return {
        name: name,
        age: age,
        hobbies: hobbies
    };
}

let user = createUser("John", 30, "Reading", "Gaming", "Coding");
console.log(user);
// {name: "John", age: 30, hobbies: ["Reading", "Gaming", "Coding"]}

🔄 Rest Parameter vs Arguments Object:

Rest Parameter (...args) Arguments Object
உண்மையான வரிசை வரிசை-போன்ற பொருள்
நவீன ES6 தொடரியல் பாரம்பரிய முறை
வரிசை முறைகளுடன் பயன்படுத்தலாம் (map, filter, etc.) வரிசை முறைகளை நேரடியாகப் பயன்படுத்த முடியாது
மீதமுள்ள அளவுருக்கள் மட்டுமே சேகரிக்கிறது அனைத்து வாதங்களையும் சேகரிக்கிறது

பரிந்துரை: நவீன குறியீட்டிற்கு Rest parameters பயன்படுத்தவும்.

வாதங்கள் மதிப்பின் மூலம் அனுப்பப்படுகின்றன

ஒரு செயல்பாட்டு அழைப்பில், அளவுருக்கள் செயல்பாட்டின் வாதங்கள்.

ஜாவாஸ்கிரிப்ட் வாதங்கள் மதிப்பின் மூலம் அனுப்பப்படுகின்றன: செயல்பாடு மதிப்புகளை மட்டுமே அறியும், வாதத்தின் இருப்பிடங்களை அறியாது.

எடுத்துக்காட்டு: பழமையான மதிப்புகள்

function changeValue(x) {
    x = 10;  // உள்ளூர் மாறியை மாற்றுகிறது
    console.log("Inside function:", x);  // 10
}

let num = 5;
console.log("Before:", num);  // 5
changeValue(num);
console.log("After:", num);   // 5 (மாறவில்லை!)

ஒரு செயல்பாடு ஒரு வாதத்தின் மதிப்பை மாற்றினால், அது அளவுருவின் அசல் மதிப்பை மாற்றாது.

வாதங்களில் மாற்றங்கள் செயல்பாட்டிற்கு வெளியே காணப்படவில்லை (பிரதிபலிக்கப்படவில்லை).

ℹ️ "மதிப்பின் மூலம்" என்பதன் பொருள்:

செயல்பாட்டிற்கு வாதத்தின் நகலை அனுப்புகிறது, அசல் அல்ல. எனவே, செயல்பாட்டிற்குள் மாற்றங்கள் அசல் மாறியைப் பாதிக்காது.

பொருள்கள் மேற்கோள் மூலம் அனுப்பப்படுகின்றன

ஜாவாஸ்கிரிப்ட்டில், பொருள் மேற்கோள்கள் மதிப்புகள்.

இதன் காரணமாக, பொருள்கள் மேற்கோள் மூலம் அனுப்பப்படுவது போல் செயல்படும்:

எடுத்துக்காட்டு: பொருள்கள்

function changeObject(obj) {
    obj.name = "Changed";  // பொருளின் பண்பை மாற்றுகிறது
    console.log("Inside function:", obj);  // {name: "Changed", age: 30}
}

let person = { name: "John", age: 30 };
console.log("Before:", person);  // {name: "John", age: 30}
changeObject(person);
console.log("After:", person);   // {name: "Changed", age: 30} (மாறிவிட்டது!)

ஒரு செயல்பாடு ஒரு பொருள் பண்பை மாற்றினால், அது அசல் மதிப்பை மாற்றுகிறது.

பொருள் பண்புகளில் மாற்றங்கள் செயல்பாட்டிற்கு வெளியே காணப்படுகின்றன (பிரதிபலிக்கப்படுகின்றன).

🔍 முக்கிய வேறுபாடு:

பழமையான மதிப்புகள் (மதிப்பின் மூலம்) பொருள்கள் (மேற்கோள் மூலம்)
எண்கள், சரங்கள், பூலியன் பொருள்கள், வரிசைகள், செயல்பாடுகள்
நகல் அனுப்பப்படுகிறது மேற்கோள் அனுப்பப்படுகிறது
செயல்பாட்டிற்குள் மாற்றங்கள் அசல் மாற்றாது செயல்பாட்டிற்குள் மாற்றங்கள் அசல் மாற்றும்
let x = 5; change(x); → x மாறாது let obj = {}; change(obj); → obj மாறும்

பொதுவான தவறுகள்

அளவுருக்கள் மற்றும் வாதங்களை குழப்புதல்

அளவுருக்கள் பெயர்கள். வாதங்கள் மதிப்புகள்.

// தவறான கருத்து:
function add(5, 3) { ... }  // தவறு! அளவுருக்கள் பெயர்களாக இருக்க வேண்டும்
// சரி:
function add(a, b) { ... }  // a, b அளவுருக்கள்
add(5, 3);                  // 5, 3 வாதங்கள்

வரிசையை மறந்துவிடுதல்

வாதங்கள் நிலை அடிப்படையில் ஒதுக்கப்படுகின்றன.

function createUser(name, age) {
    return { name: name, age: age };
}

// தவறு:
let user = createUser(30, "John");  // {name: 30, age: "John"}
// சரி:
let user = createUser("John", 30);  // {name: "John", age: 30}

விடுபட்ட வாதங்கள்

undefined ஐத் தவிர்ப்பதற்கு இயல்புநிலை மதிப்புகளைப் பயன்படுத்தவும்.

// தவறு:
function multiply(a, b) {
    return a * b;  // b undefined எனில் NaN
}

// சரி:
function multiply(a, b = 1) {
    return a * b;  // b வழங்கப்படவில்லை எனில் 1
}

console.log(multiply(5));  // 5 (b = 1)

செயல்பாடு வாதங்கள் பயிற்சி

ஜாவாஸ்கிரிப்டில், வாதங்கள் எவ்வாறு அனுப்பப்படுகின்றன (பழமையான மதிப்புகள் மற்றும் பொருள்களுக்கு)?

❓ ஜாவாஸ்கிரிப்டில், வாதங்கள் எவ்வாறு அனுப்பப்படுகின்றன?

பழமையான மதிப்புகள் மதிப்பின் மூலம், பொருள்கள் மேற்கோள் மூலம்
✓ சரி! ஜாவாஸ்கிரிப்ட் பழமையான மதிப்புகளை (எண்கள், சரங்கள், பூலியன்) மதிப்பின் மூலம் அனுப்புகிறது (நகல்), மேலும் பொருள்களை மேற்கோள் மூலம் அனுப்புகிறது (அதே நினைவக இருப்பிடத்திற்கான குறிப்பு).
அனைத்தும் மதிப்பின் மூலம் மட்டுமே
✗ தவறு! பொருள்கள் மதிப்பின் மூலம் அனுப்பப்படுகின்றன, ஆனால் அந்த மதிப்பு ஒரு மேற்கோள். இது "மேற்கோள் மதிப்பின் மூலம்" எனப்படுகிறது, ஆனால் நடைமுறையில் பொருள்கள் மாற்றப்படும்போது மேற்கோள் மூலம் போல் செயல்படுகின்றன.
அனைத்தும் மேற்கோள் மூலம் மட்டுமே
✗ தவறு! பழமையான மதிப்புகள் (எண்கள், சரங்கள், பூலியன்) மதிப்பின் மூலம் அனுப்பப்படுகின்றன. நீங்கள் ஒரு செயல்பாட்டிற்குள் ஒரு எண்ணை மாற்றினால், அசல் மாறி மாறாது.
எண்கள் மட்டுமே மதிப்பின் மூலம், மற்ற அனைத்தும் மேற்கோள் மூலம்
✗ தவறு! எண்கள், சரங்கள் மற்றும் பூலியன் அனைத்தும் மதிப்பின் மூலம் அனுப்பப்படுகின்றன. பொருள்கள் (வரிசைகள் உட்பட) மேற்கோள் மூலம் போல் செயல்படுகின்றன.

💡 தீர்வு விளக்கம்:

ஜாவாஸ்கிரிப்டில், வாதங்கள் அனுப்பும் முறை வாதத்தின் வகையைப் பொறுத்து மாறுபடும்:

// பழமையான மதிப்புகள்: மதிப்பின் மூலம்
function changePrimitive(x) {
    x = 10;  // நகலை மாற்றுகிறது
}

let num = 5;
changePrimitive(num);
console.log(num);  // 5 (மாறவில்லை!)

// பொருள்கள்: மேற்கோள் மூலம் போல்
function changeObject(obj) {
    obj.value = 10;  // அசல் பொருளை மாற்றுகிறது
}

let myObj = { value: 5 };
changeObject(myObj);
console.log(myObj.value);  // 10 (மாறிவிட்டது!)

மதிப்பின் மூலம் (பழமையான மதிப்புகள்):

  • எண்கள், சரங்கள், பூலியன்
  • செயல்பாட்டிற்கு நகல் அனுப்பப்படுகிறது
  • செயல்பாட்டிற்குள் மாற்றங்கள் அசல் மாற்றாது

மேற்கோள் மூலம் (பொருள்கள்):

  • பொருள்கள், வரிசைகள், செயல்பாடுகள்
  • செயல்பாட்டிற்கு மேற்கோள் (நினைவக முகவரி) அனுப்பப்படுகிறது
  • செயல்பாட்டிற்குள் மாற்றங்கள் அசல் மாற்றும்

தொழில்நுட்ப ரீதியாக: பொருள்கள் "மேற்கோள் மதிப்பின் மூலம்" அனுப்பப்படுகின்றன (மேற்கோளின் நகல்), ஆனால் நடைமுறையில் இது மேற்கோள் மூலம் போல் செயல்படுகிறது.

அடுத்த அத்தியாயம்

➡️ Function Expressions

அடுத்த பாடத்தில், செயல்பாட்டு வெளிப்பாடுகள் பற்றி கற்றுக்கொள்வோம் - செயல்பாடுகளை மாறிகளில் சேமிப்பதற்கான வழிகள்:

  • செயல்பாட்டு வெளிப்பாடுகள் vs அறிவிப்புகள்
  • அநாமதேய செயல்பாடுகள்
  • தலைக்கு மேலே உயர்த்துதல் (Hoisting)
  • IIFE (தானாக இயங்கும் செயல்பாடுகள்)