JavaScript Function Parameters

அளவுருக்கள் (செயல்பாட்டு உள்ளீடு)

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

அளவுருக்கள் செயல்பாடு வரையறையில் அடைப்புக்குறிக்குள் பட்டியலிடப்பட்டுள்ளன.

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

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

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

🎯 அளவுருக்கள் ஏன் முக்கியமானவை:

அளவுருக்கள் செயல்பாடுகளை மிகவும் நெகிழ்வானதாகவும் மீண்டும் பயன்படுத்தக்கூடியதாகவும் ஆக்குகின்றன. அவை ஒரே செயல்பாட்டை வெவ்வேறு உள்ளீட்டு மதிப்புகளுடன் பயன்படுத்த அனுமதிக்கின்றன.

ஒரு அளவுரு கொண்ட செயல்பாடுகள்

ஒரு செயல்பாட்டில் ஒரு அளவுரு இருக்கலாம்.

எடுத்துக்காட்டு 1: வணக்கம் சொல்லுதல்

function sayHello(name) {
    return "Hello " + name;
}

let greeting = sayHello("John");
console.log(greeting);  // "Hello John"

let greeting2 = sayHello("Alice");
console.log(greeting2); // "Hello Alice"

எடுத்துக்காட்டு 2: வெப்பநிலை மாற்றம்

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

let value = toCelsius(77);
console.log(value);  // 25

let value2 = toCelsius(212);
console.log(value2); // 100

💡 நடைமுறை பயன்பாடு:

ஒற்றை அளவுரு செயல்பாடுகள் வெவ்வேறு உள்ளீட்டு மதிப்புகளுக்கு ஒரே மாற்றத்தைப் பயன்படுத்தும் எளிய செயல்பாடுகளுக்கு சிறந்தவை.

பல அளவுருக்கள் கொண்ட செயல்பாடுகள்

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

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

function fullName(firstName, lastName) {
    return firstName + " " + lastName;
}

let name = fullName("John", "Doe");
console.log(name);  // "John Doe"

let name2 = fullName("Jane", "Smith");
console.log(name2); // "Jane Smith"

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

// கணித செயல்பாடுகள்
function calculateArea(length, width) {
    return length * width;
}

let area = calculateArea(10, 5);
console.log(area);  // 50

// தனிப்பயன் செய்திகள்
function createMessage(greeting, name, punctuation) {
    return greeting + ", " + name + punctuation;
}

let message = createMessage("Hello", "World", "!");
console.log(message);  // "Hello, World!"

அளவுருக்கள் vs வாதங்கள்

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

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

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

// வரையறை: a மற்றும் b அளவுருக்கள்
function multiply(a, b) {
    return a * b;
}

// அழைப்பு: 4 மற்றும் 5 வாதங்கள்
let result = multiply(4, 5);

console.log(result);  // 20

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

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

அளவுருக்கள் வரையறையின் போது, வாதங்கள் அழைப்பின் போது.

அளவுரு விதிகள்

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

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

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

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();
console.log(value);  // NaN

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

⚠️ பொதுவான பிழைகள்:

வாதங்களை மறந்துவிடுதல்: toCelsius() - fahrenheit ஆனது undefined ஆகிறது
தவறான வரிசை: fullName("Doe", "John") - "Doe John" கொடுக்கிறது
தவறான வகைகள்: multiply("5", "3") - "53" கொடுக்கிறது, 8 அல்ல
அதிகமான வாதங்கள்: add(1, 2, 3) - 3 ஐ புறக்கணிக்கிறது

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

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

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

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

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)

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

செய்தி உருவாக்கம்

function greet(name, greeting = "Hello") {
    return greeting + ", " + name + "!";
}

console.log(greet("John"));           // "Hello, John!"
console.log(greet("Jane", "Hi"));     // "Hi, Jane!"
console.log(greet("Bob", "Welcome")); // "Welcome, Bob!"

கணிதக் கணக்கீடுகள்

function calculatePrice(quantity, price = 100, tax = 0.18) {
    let subtotal = quantity * price;
    let total = subtotal + (subtotal * tax);
    return total;
}

console.log(calculatePrice(2));        // 236 (இயல்புநிலை விலை மற்றும் வரி)
console.log(calculatePrice(2, 150));   // 354 (விலை = 150)
console.log(calculatePrice(2, 150, 0)); // 300 (வரி இல்லை)

💡 இயல்புநிலை மதிப்புகளின் நன்மைகள்:

நெகிழ்வுத்தன்மை: செயல்பாடுகளை குறைவான வாதங்களுடன் அழைக்க அனுமதிக்கிறது
பிழை குறைத்தல்: undefined மதிப்புகளிலிருந்து பிழைகளைத் தடுக்கிறது
தெளிவான குறியீடு: எதிர்பார்க்கப்படும் இயல்புநிலை மதிப்புகளை வெளிப்படுத்துகிறது
பின்னூட்டத்திறன்: பழைய ES5 குறியீட்டுடன் இணக்கமானது

அளவுரு சிறந்த நடைமுறைகள்

புரிந்துகொள்ளக்கூடிய அளவுருப் பெயர்களைப் பயன்படுத்தவும்

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

// மோசமானது:
function f(a, b) { ... }
// நன்றாக:
function calculateArea(width, height) { ... }

இயல்புநிலை மதிப்புகளை வழங்கவும்

செயல்பாடுகளை நம்பத்தகுந்ததாகவும் பிழை-எதிர்ப்பு சாதனமாகவும் ஆக்க இயல்புநிலை மதிப்புகளைப் பயன்படுத்தவும்.

function createUser(name, role = "user", active = true) {
    // ...
}

அளவுரு சரிபார்ப்பைச் செயல்படுத்தவும்

உள்ளீட்டு மதிப்புகள் செல்லுபடியாகுமா என்பதைச் சரிபார்க்க உள்ளமைக்கப்பட்ட செயல்பாடுகளைப் பயன்படுத்தவும்.

function calculatePrice(quantity, price) {
    if (typeof quantity !== 'number' || typeof price !== 'number') {
        throw new Error('Invalid input types');
    }
    return quantity * price;
}

தொகுதி அளவுருக்களைப் பயன்படுத்தவும்

பல தொடர்புடைய அளவுருக்கள் இருந்தால், அவற்றை ஒரு பொருளாகக் குழுவாக்குங்கள்.

// பல அளவுருக்கள்:
function createUser(name, age, email, role, active) { ... }
// பொருள் அளவுரு:
function createUser(userData) { ... }

செயல்பாடு அளவுருக்கள் பயிற்சி

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

❓ ஜாவாஸ்கிரிப்டில், செயல்பாடு அளவுருக்கள் மற்றும் வாதங்களுக்கு இடையே உள்ள வேறுபாடு என்ன?

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

✗ தவறு! இது உண்மையில் சரியான பதில். ஆனால் மேலே உள்ள விருப்பத்தில் "வாதங்கள்" மற்றும் "அளவுருக்கள்" இடமாற்றம் செய்யப்பட்டுள்ளன.

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

✓ சரி! அளவுருக்கள் என்பது செயல்பாடு வரையறுக்கப்படும் போது குறிப்பிடப்படும் மாறிகள். வாதங்கள் என்பது செயல்பாடு அழைக்கப்படும் போது அந்த அளவுருக்களுக்கு வழங்கப்படும் உண்மையான மதிப்புகள்.

அளவுருக்கள் எண்கள் மட்டுமே, வாதங்கள் எந்த வகையான மதிப்புகளும் இருக்கலாம்

✗ தவறு! ஜாவாஸ்கிரிப்ட் அளவுருக்கள் எந்த வகையான மதிப்புகளையும் ஏற்கும். அவை எண்கள் மட்டும் இல்லை.

அளவுருக்கள் திரும்பும் மதிப்புகள், வாதங்கள் உள்ளீட்டு மதிப்புகள்

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

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

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

// அளவுருக்கள்: a மற்றும் b (செயல்பாட்டு வரையறையில்)
function add(a, b) {
    return a + b;
}

// வாதங்கள்: 5 மற்றும் 3 (செயல்பாட்டு அழைப்பில்)
let result = add(5, 3);

console.log(result);  // 8

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

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

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

➡️ Function Return Values

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

return அறிக்கை
பல மதிப்புகளைத் திருப்பித் தருதல்
திரும்பும் மதிப்புகளைப் பயன்படுத்துதல்
void செயல்பாடுகள்

Function Return Values ஐ தொடர்ந்து படிக்கவும்