ஜாவாஸ்கிரிப்டில் செயல்பாடுகளுக்கான Hoisting ஐப் புரிந்துகொள்வது

Hoisting என்பது ஒரு ஜாவாஸ்கிரிப்ட் பொறிமுறையாகும், இதில் தொகுப்பு கட்டத்தின் (compile phase) போது மாறிகள் மற்றும் செயல்பாட்டு அறிவிப்புகள் (function declarations) அவற்றின் உள்ளடக்க நோக்கத்தின் (scope) உச்சிக்கு நகர்த்தப்படுகின்றன. குறியீட்டில் அறிவிக்கப்படுவதற்கு முன்பே செயல்பாடுகள் மற்றும் மாறிகளை நீங்கள் பயன்படுத்தலாம் என்பதே இதன் பொருள்.

செயல்பாட்டு Hoisting (Function Hoisting)

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

செயல்பாட்டு Hoisting க்கான எடுத்துக்காட்டு

செயல்பாட்டு hoisting ஐ விளக்குவதற்கான எடுத்துக்காட்டு இங்கே:

console.log(greet()); // Output: Hello, World!

function greet() {
    return "Hello, World!";
}

இந்த எடுத்துக்காட்டில், greet செயல்பாடு வரையறுக்கப்படுவதற்கு முன்பே அழைக்கப்படுகிறது, ஆனால் செயல்பாட்டு அறிவிப்பு நோக்கத்தின் உச்சிக்கு உயர்த்தப்படுவதால் இது செயல்படுகிறது.

செயல்பாட்டு வெளிப்பாடுகள் (Function Expressions) மற்றும் Hoisting

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

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

வித்தியாசத்தை விளக்குவதற்கான எடுத்துக்காட்டு இங்கே:

console.log(greet()); // Output: TypeError: greet is not a function

var greet = function() {
    return "Hello, World!";
};

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

let மற்றும் const உடன் Hoisting

let மற்றும் const உடன் அறிவிக்கப்பட்ட மாறிகளும் உயர்த்தப்படுகின்றன, ஆனால் அவை தொடங்கப்படுவதில்லை (initialized). அதாவது, அவற்றின் அறிவிப்புக்கு முன் அவற்றை அணுகுவது ReferenceError ஐ ஏற்படுத்துகிறது.

let மற்றும் const உடன் எடுத்துக்காட்டு

console.log(greet); // Output: ReferenceError: Cannot access 'greet' before initialization

let greet = function() {
    return "Hello, World!";
};

இந்த எடுத்துக்காட்டில், greet மாறி உயர்த்தப்படுகிறது, ஆனால் இது தொடங்கப்படவில்லை, இதன் அறிவிப்புக்கு முன் அணுகப்படும்போது ReferenceError ஏற்படுகிறது.

முடிவுரை

கணிக்கக்கூடிய மற்றும் பிழையற்ற ஜாவாஸ்கிரிப்ட் குறியீட்டை எழுதுவதற்கு hoisting ஐப் புரிந்துகொள்வது முக்கியமானது. செயல்பாட்டு அறிவிப்புகள் உயர்த்தப்படுகின்றன, அவை வரையறுக்கப்படுவதற்கு முன்பே அவற்றை அழைக்க அனுமதிக்கிறது, அதே சமயம் செயல்பாட்டு வெளிப்பாடுகள் உயர்த்தப்படுவதில்லை, அவை வரையறைக்கு முன் அழைக்கப்பட்டால் சாத்தியமான பிழைகளுக்கு வழிவகுக்கும். let மற்றும் const உடன் அறிவிக்கப்பட்ட மாறிகள் உயர்த்தப்படுகின்றன, ஆனால் தொடங்கப்படவில்லை, அவற்றின் அறிவிப்புக்கு முன் அணுகப்பட்டால் ReferenceError ஏற்படுகிறது.