Invoking JavaScript Functions

JavaScript செயல்பாடுகளை அழைத்தலைக் கற்றுக்கொள்ளுங்கள்

ஒரு செயல்பாட்டை அழைத்தல்

ஒரு JavaScript செயல்பாடு அது அழைக்கப்படும் போது இயங்கும் (invoked என்றும் அழைக்கப்படுகிறது).

ஒரு செயல்பாட்டை அழைக்க, பெயரைத் தொடர்ந்து அடைப்புக்குறிகளை எழுதவும், எ.கா. name().

"ஏதோ ஒன்று" செயல்பாட்டை அழைக்கும் போது செயல்பாட்டிற்குள் உள்ள குறியீடு செயல்படுத்தப்படும்.

செயல்பாட்டை வரையறுக்கவும்

குறியீட்டை எழுதவும்

செயல்பாட்டை அழைக்கவும்

functionName() பயன்படுத்தவும்

குறியீடு இயங்கும்

செயல்பாட்டின் உள்ளீடு செயல்படுத்தப்படுகிறது

முடிவு வழங்கப்படுகிறது

மதிப்பு திரும்ப அனுப்பப்படுகிறது

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

கீழே உள்ள செயல்பாடு "Hello World" என்ற உரையை வழங்குகிறது. ஆனால் நீங்கள் அதை அழைக்கும் முன்பு இது இயங்காது.

எடுத்துக்காட்டு 1: வரையறை

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

எடுத்துக்காட்டு 2: அழைப்பு

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

sayHello();  // செயல்பாட்டை அழைக்கிறது

📝 குறிப்பு:

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

திரும்பிய மதிப்பைப் பயன்படுத்துதல்

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

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

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

let greeting = sayHello();
// 'greeting' மாறி இப்போது "Hello World" ஐக் கொண்டுள்ளது

முடிவைக் காட்சிப்படுத்துதல்

நீங்கள் திரும்பிய மதிப்பை பல வழிகளில் காட்சிப்படுத்தலாம், எடுத்துக்காட்டாக console.log() அல்லது HTML பயன்படுத்தி.

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

// console.log() உடன்:
function sayHello() {
  return "Hello World";
}

console.log(sayHello());  // கன்சோலில் "Hello World" ஐக் காட்டுகிறது
<p id="demo"></p>

<script>
function sayHello() {
  return "Hello World";
}

// HTML உடன்:
document.getElementById("demo").innerHTML = sayHello();
</script>

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

உங்களுக்கு தேவைப்படும் போதெல்லாம் நீங்கள் அதே செயல்பாட்டை அழைக்கலாம்.

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

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

let a = sayHello();  // முதல் அழைப்பு
let b = sayHello();  // இரண்டாவது அழைப்பு
let c = sayHello();  // மூன்றாவது அழைப்பு

// a, b, c அனைத்தும் "Hello World" ஐக் கொண்டுள்ளன

செயல்பாட்டு அழைப்பு ஓட்டம்:

1. sayHello() அழைக்கப்படுகிறது
2. செயல்பாட்டு உடல் இயங்குகிறது
3. "Hello World" திரும்ப அனுப்பப்படுகிறது
4. மதிப்பு மாறியில் சேமிக்கப்படுகிறது
5. மீண்டும் அழைக்கப்படலாம்...

செயல்பாட்டு அழைப்பு

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

"ஏதோ ஒன்று" செயல்பாட்டை அழைக்கும் போது செயல்பாட்டிற்குள் உள்ள குறியீடு செயல்படுத்தப்படும்:

JavaScript குறியீட்டிலிருந்து

அழைக்கப்படும் போது

myFunction();

ஒரு நிகழ்வு நிகழும் போது

(ஒரு பயனர் ஒரு பொத்தானைக் கிளிக் செய்கிறார்)

onclick="myFunction()"

தானாகவே

(சுய அழைக்கப்பட்டது)

(function(){})();

💬 சொற்களஞ்சியம்:

invoke என்ற சொல்லைப் பயன்படுத்துவது பொதுவானது, ஏனெனில் ஒரு செயல்பாட்டை அழைக்காமலேயே அழைக்க முடியும். பின்வரும் சொற்களையும் பயன்படுத்துவது பொதுவானது:

  • ஒரு செயல்பாட்டை அழைக்கவும் (call a function)
  • ஒரு செயல்பாட்டை அழைக்கவும் (call upon a function)
  • ஒரு செயல்பாட்டைத் தொடங்கவும் (start a function)
  • ஒரு செயல்பாட்டைச் செயல்படுத்தவும் (execute a function)

செயல்பாடுகள் () உடன் அழைக்கப்படுகின்றன

() ஆபரேட்டர் ஒரு செயல்பாட்டை அழைக்கிறது.

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

toCelsius() செயல்பாட்டை அழைக்கிறது:

// பாரன்ஹீட்டை செல்சியஸாக மாற்றவும்:
function toCelsius(fahrenheit) {
  return (5/9) * (fahrenheit-32);
}

// toCelsius() செயல்பாட்டை அழைக்கவும்
let value = toCelsius(77);
// மதிப்பு இப்போது 25 ஆகும்

() இல்லாமல் ஒரு செயல்பாட்டை அணுகுவது, செயல்பாட்டின் முடிவை அல்ல, செயல்பாட்டையே வழங்குகிறது:

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

let value = toCelsius;  // செயல்பாட்டை மட்டுமே ஒதுக்குகிறது
// 'value' இப்போது toCelsius செயல்பாட்டைக் கொண்டுள்ளது

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

  • toCelsius செயல்பாட்டையே குறிக்கிறது
  • toCelsius(77) செயல்பாட்டின் முடிவைக் குறிக்கிறது

செயல்பாட்டை அழைத்தல் vs குறிப்பிடுதல்

இது ஒரு முக்கியமான வேறுபாடு:

குறிப்பிடுதல்

sayHello செயல்பாட்டையே குறிக்கிறது

இது செயல்பாட்டை வழங்குகிறது

let text = sayHello;
// 'text' செயல்பாடு

அழைத்தல்

sayHello() செயல்பாட்டின் முடிவைக் குறிக்கிறது

இது முடிவை வழங்குகிறது

let text = sayHello();
// 'text' "Hello World"

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

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

let text = sayHello;  // செயல்பாட்டை மட்டுமே ஒதுக்குகிறது
// 'text' இப்போது செயல்பாட்டைக் கொண்டுள்ளது

📝 குறிப்பு:

மேலே உள்ள எடுத்துக்காட்டில், text செயல்பாட்டையே வழங்குகிறது:

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

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

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

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

// மற்றொரு செயல்பாட்டிலிருந்து அழைக்கவும்:
function sayHello() {
  return "Hello World";
}

function showHello() {
  document.getElementById("demo").innerHTML = sayHello();
}
<p id="demo"></p>
<button onclick="showHello()">Click Me</button>

<script>
function sayHello() {
  return "Hello World";
}

function showHello() {
  document.getElementById("demo").innerHTML = sayHello();
}
</script>

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

அடைப்புக்குறிகளை மறந்து விடுதல்

sayHello என்று எழுதுவது செயல்பாட்டை இயக்காது. நீங்கள் sayHello() பயன்படுத்த வேண்டும்.

வெளியீட்டை எதிர்பார்த்தல்

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

திரும்புவதை எதிர்பார்த்தல்

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

பயிற்சி

sayHello மற்றும் sayHello() இடையே உள்ள வேறுபாடு என்ன?

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

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

Function Parameters

செயல்பாடு அளவுருக்களைக் கற்றுக்கொள்ளுங்கள்