JavaScript Function Return

ஜாவாஸ்கிரிப்ட் செயல்பாடுகளிலிருந்து மதிப்புகளைத் திரும்பப் பெறுதல்

JavaScript Function Return

செயல்பாடுகளிலிருந்து மதிப்புகளைத் திரும்பப் பெறுதல்

ஒரு செயல்பாடு அதை அழைத்த குறியீட்டிற்கு ஒரு மதிப்பைத் திருப்பித் தரலாம்.

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

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

function sayHello() {
    return "Hello World";
}

let message = sayHello();
console.log(message);  // "Hello World"

🎯 return அறிக்கையின் நோக்கம்:

return அறிக்கை செயல்பாடுகளை பயனுள்ளதாக ஆக்குகிறது, ஏனெனில் அவை:

  • கணக்கீட்டு முடிவுகளைத் திருப்பித் தருகின்றன
  • தரவைச் செயலாக்கிய பின் வழங்குகின்றன
  • ஒரு செயல்பாட்டின் முடிவை தெரிவிக்கின்றன
  • மதிப்புகளை மாறிகளில் சேமிக்க அனுமதிக்கின்றன

The return Statement

ஜாவாஸ்கிரிப்ட் ஒரு return அறிக்கையை அடையும் போது, செயல்பாடு செயல்படுத்துவதை நிறுத்துகிறது.

return க்குப் பின் உள்ள மதிப்பு அழைப்பவருக்குத் திருப்பி அனுப்பப்படுகிறது.

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

function sayHello() {
    return "Hello World";
}

let message = sayHello();
console.log(message);  // "Hello World"

// மாறி message இப்போது திரும்பிய மதிப்பைக் கொண்டுள்ளது

⚡ return இன் உடனடி விளைவு:

return அறிக்கை உடனடியாக:

  1. செயல்பாட்டின் இயக்கத்தை நிறுத்துகிறது
  2. குறிப்பிட்ட மதிப்பை அழைப்பவருக்கு அனுப்புகிறது
  3. return க்குப் பின் எந்த குறியீடும் செயல்படுத்தப்படாது

கணக்கிடப்பட்ட மதிப்பைத் திருப்பித் தருதல்

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

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

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

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

// மற்றொரு கணக்கீட்டில் பயன்படுத்தவும்
let total = multiply(4, 5) + multiply(2, 3);
console.log(total);   // 26

திரும்பிய மதிப்பை ஒரு மதிப்பு எதிர்பார்க்கும் எந்த இடத்திலும் பயன்படுத்தலாம்.

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

function square(number) {
    return number * number;
}

function isEven(number) {
    return number % 2 === 0;
}

function getDiscountPrice(price, discountPercent) {
    return price - (price * discountPercent / 100);
}

// பயன்பாடு:
console.log(square(5));           // 25
console.log(isEven(4));           // true
console.log(getDiscountPrice(100, 20)); // 80

வெளிப்பாடுகளில் திரும்பிய மதிப்புகளைப் பயன்படுத்துதல்

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

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

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

let total = add(2, 3) * 10;
console.log(total);  // 50

// மேலும் சிக்கலான எடுத்துக்காட்டுகள்:
let result = add(add(2, 3), add(4, 5));
console.log(result);  // 14 (2+3=5, 4+5=9, 5+9=14)

let average = add(10, 20) / 2;
console.log(average); // 15

🔗 செயல்பாடுகளை இணைத்தல்:

செயல்பாடுகளை ஒன்றோடொன்று இணைக்கலாம், ஒன்றின் வெளியீட்டை மற்றொன்றின் உள்ளீடாகப் பயன்படுத்தலாம்:

function double(x) {
    return x * 2;
}

function addFive(x) {
    return x + 5;
}

// செயல்பாடுகளை இணைத்தல்
let result = addFive(double(10));
console.log(result);  // 25 (10*2=20, 20+5=25)

// அல்லது:
let result2 = double(addFive(10));
console.log(result2); // 30 (10+5=15, 15*2=30)

உரை அல்லது எண்களைத் திருப்பித் தருதல்

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

உரையைத் திருப்பித் தருதல்

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

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

function getGreeting(timeOfDay) {
    if (timeOfDay === "morning") {
        return "Good Morning";
    } else if (timeOfDay === "evening") {
        return "Good Evening";
    } else {
        return "Hello";
    }
}

console.log(getGreeting("morning"));  // "Good Morning"

எண்களைத் திருப்பித் தருதல்

function calculateTotal(price, quantity) {
    return price * quantity;
}

let total = calculateTotal(100, 3);
console.log(total);  // 300

function getRandomNumber() {
    return Math.random();
}

console.log(getRandomNumber());  // 0.123456... (சீரற்ற எண்)

function getMax(a, b) {
    if (a > b) {
        return a;
    } else {
        return b;
    }
}

console.log(getMax(10, 20));  // 20

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

  • எண்கள்: கணக்கீட்டு முடிவுகள்
  • சரங்கள்: உரை தகவல்
  • பூலியன்: true/false முடிவுகள்
  • வரிசைகள்: தரவுகளின் தொகுப்புகள்
  • பொருள்கள்: கட்டமைக்கப்பட்ட தரவு
  • செயல்பாடுகள்: உயர்-வரிசை செயல்பாடுகள்

ஒரு செயல்பாட்டிலிருந்து திரும்புவது செயல்படுத்தலை நிறுத்துகிறது

return க்குப் பிறகு எழுதப்பட்ட குறியீடு செயல்படுத்தப்படாது.

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

function testReturn() {
    return "Done";
    console.log("This will never run");  // இது இயங்காது
    let x = 10;                         // இது இயங்காது
    return "Also done";                 // இது இயங்காது
}

let result = testReturn();
console.log(result);  // "Done"

⚠️ குறிப்பு:

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

இது தொகுப்பிகள் மற்றும் IDE களால் பொதுவாக ஒரு எச்சரிக்கையாகக் காட்டப்படும்.

எச்சரிக்கை உதாரணம்:

function calculate(x) {
    let result = x * 2;
    return result;
    // பின்வரும் கோடுகள் எப்போதும் இயங்காது:
    console.log("Calculation complete");  // இறந்த குறியீடு
    let extra = result + 10;             // இறந்த குறியீடு
}

console.log(calculate(5));  // 10

return இல்லாத செயல்பாடுகள்

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

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

function noReturn() {
    let x = 10;
    // எந்த return அறிக்கையும் இல்லை
}

let result = noReturn();
console.log(result);  // undefined
console.log(typeof result);  // "undefined"

function logMessage(message) {
    console.log(message);
    // return இல்லை
}

let logged = logMessage("Hello");
console.log(logged);  // undefined (console.log வெளியீட்டைத் திருப்பித் தராது)

ℹ️ console.log() vs return:

இந்த இரண்டுக்கும் இடையே உள்ள வேறுபாட்டைப் புரிந்துகொள்வது முக்கியம்:

  • console.log(): கன்சோலுக்கு வெளியீட்டைக் காட்டுகிறது, ஆனால் மதிப்பைத் திருப்பித் தராது
  • return: ஒரு மதிப்பைத் திருப்பித் தருகிறது, ஆனால் கன்சோலுக்கு காட்டாது
function showOnly() {
    console.log("Hello");  // கன்சோலில் காட்டுகிறது
}

function returnOnly() {
    return "Hello";        // மதிப்பைத் திருப்பித் தருகிறது
}

let a = showOnly();  // a = undefined
let b = returnOnly(); // b = "Hello"

மதிப்புகளை முன்கூட்டியே திருப்பித் தருதல்

நீங்கள் ஒரு நிபந்தனையின் அடிப்படையில், ஒரு செயல்பாட்டை முன்கூட்டியே நிறுத்த return ஐப் பயன்படுத்தலாம்.

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

function checkAge(age) {
    if (age < 18) {
        return "Too young";
    }
    return "Access granted";
}

console.log(checkAge(15));  // "Too young"
console.log(checkAge(25));  // "Access granted"

// மேலும் சிக்கலான எடுத்துக்காட்டு:
function getGrade(score) {
    if (score >= 90) {
        return "A";
    }
    if (score >= 80) {
        return "B";
    }
    if (score >= 70) {
        return "C";
    }
    if (score >= 60) {
        return "D";
    }
    return "F";
}

console.log(getGrade(95));  // "A"
console.log(getGrade(65));  // "D"
console.log(getGrade(45));  // "F"

🚦 முன்கூட்டியே வெளியேறுவதன் நன்மைகள்:

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

HTML க்கு மதிப்புகளைத் திருப்பித் தருதல்

திரும்பிய செயல்பாட்டு மதிப்புகள் பெரும்பாலும் HTML உள்ளடக்கத்தைப் புதுப்பிக்கப் பயன்படுத்தப்படுகின்றன.

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

<!-- HTML -->
<p id="demo"></p>

<script>
// JavaScript
function toCelsius(fahrenheit) {
    return (5 / 9) * (fahrenheit - 32);
}

// செயல்பாட்டு மதிப்பை HTML இல் காட்டவும்
document.getElementById("demo").innerHTML = toCelsius(77);
</script>

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

function getCurrentTime() {
    let now = new Date();
    return now.toLocaleTimeString();
}

function createGreeting(name) {
    return "Welcome, " + name + "!";
}

// HTML உறுப்புகளைப் புதுப்பித்தல்
document.getElementById("time").innerHTML = getCurrentTime();
document.getElementById("greeting").innerHTML = createGreeting("John");

// கணக்கீட்டு மதிப்புகளைக் காட்டுதல்
function calculateTotal(items) {
    let total = 0;
    for (let item of items) {
        total += item.price;
    }
    return total;
}

let cartItems = [
    { name: "Book", price: 20 },
    { name: "Pen", price: 5 },
    { name: "Notebook", price: 15 }
];

document.getElementById("total").innerHTML = 
    "Total: $" + calculateTotal(cartItems);

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

return ஐ மறந்துவிடுதல்

return இல்லாத ஒரு செயல்பாடு undefined ஐத் திருப்பித் தரும்.

// தவறு:
function calculate(a, b) {
    a + b;  // return இல்லை
}
console.log(calculate(2, 3));  // undefined

// சரி:
function calculate(a, b) {
    return a + b;
}
console.log(calculate(2, 3));  // 5

return க்குப் பின் குறியீடு இயங்கும் என்று எதிர்பார்த்தல்

return க்குப் பின் உள்ள குறியீடு புறக்கணிக்கப்படும்.

// தவறு:
function process(x) {
    let result = x * 2;
    return result;
    console.log("Processing complete");  // இது இயங்காது
}

// சரி:
function process(x) {
    let result = x * 2;
    console.log("Processing complete");  // முதலில்
    return result;                       // பிறகு
}

console.log() ஐ return உடன் குழப்புதல்

console.log() வெளியீட்டைக் காட்டுகிறது ஆனால் மதிப்பைத் திருப்பித் தராது.

// தவறு:
function getMessage() {
    console.log("Hello");  // கன்சோலில் காட்டுகிறது
}
let msg = getMessage();    // msg = undefined

// சரி:
function getMessage() {
    return "Hello";        // மதிப்பைத் திருப்பித் தருகிறது
}
let msg = getMessage();    // msg = "Hello"

// அல்லது இரண்டும்:
function getMessage() {
    let message = "Hello";
    console.log(message);  // காட்டுகிறது
    return message;        // திருப்பித் தருகிறது
}

செயல்பாடு திரும்பும் மதிப்பு பயிற்சி

ஒரு செயல்பாட்டில் return அறிக்கை இல்லை என்றால் என்ன மதிப்பு திரும்பப் பெறப்படும்?

❓ ஒரு செயல்பாட்டில் return அறிக்கை இல்லை என்றால் என்ன மதிப்பு திரும்பப் பெறப்படும்?

null
✗ தவறு! null என்பது ஒரு முன்னரே தீர்மானிக்கப்பட்ட மதிப்பாகும், ஆனால் ஒரு செயல்பாடு return இல்லாமல் தானாகவே null ஐத் திருப்பித் தராது.
undefined
✓ சரி! ஒரு செயல்பாடு return அறிக்கை இல்லாமல் இருந்தால், அது தானாகவே undefined ஐத் திருப்பித் தரும். undefined என்பது ஒரு மதிப்பு வரையறுக்கப்படவில்லை என்பதைக் குறிக்கிறது.
0
✗ தவறு! 0 என்பது ஒரு செல்லுபடியாகும் எண் மதிப்பு, ஆனால் ஒரு செயல்பாடு தானாகவே 0 ஐத் திருப்பித் தராது. இது வெறுமனே return 0; என்று கூறும் செயல்பாட்டிற்கு மட்டுமே பொருந்தும்.
இது ஒரு பிழையை உருவாக்கும்
✗ தவறு! ஒரு செயல்பாடு return அறிக்கை இல்லாமல் இருப்பது பிழையல்ல. இது செல்லுபடியாகும் ஜாவாஸ்கிரிப்ட் ஆகும், மேலும் செயல்பாடு undefined ஐத் திருப்பித் தரும்.

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

ஜாவாஸ்கிரிப்ட்டில், ஒரு செயல்பாடு வெளிப்படையாக return அறிக்கையுடன் முடிவடையாவிட்டால், அது மறைமுகமாக undefined ஐத் திருப்பித் தரும்:

// வெளிப்படையான return இல்லை
function noReturn() {
    let x = 10;
    // return அறிக்கை இல்லை
}

let result = noReturn();
console.log(result);        // undefined
console.log(typeof result); // "undefined"

// வெற்று return அறிக்கை
function emptyReturn() {
    return;  // எந்த மதிப்பும் குறிப்பிடப்படவில்லை
}

let result2 = emptyReturn();
console.log(result2);       // undefined

// return உடன்
function withReturn() {
    return 42;
}

let result3 = withReturn();
console.log(result3);       // 42

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

  • undefined: மதிப்பு வரையறுக்கப்படவில்லை (இயல்புநிலை)
  • null: வேண்டுமென்றே வெற்று மதிப்பு
  • 0: ஒரு செல்லுபடியாகும் எண் மதிப்பு

செயல்பாடுகள் தானாகவே undefined ஐத் திருப்பித் தரும், null அல்லது 0 அல்ல.

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

➡️ Function Arguments

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

  • மீதமுள்ள அளவுருக்கள் (...args)
  • வாதங்கள் பொருள்
  • அளவுரு சிதைத்தல்
  • செயல்பாட்டு வாதங்களின் பண்புகள்