ஜாவாஸ்கிரிப்ட் இயந்திரங்கள் (JavaScript Engines)

ஜாவாஸ்கிரிப்ட் இயந்திரம் என்பது ஜாவாஸ்கிரிப்ட் குறியீட்டைச் செயல்படுத்தும் ஒரு நிரல் அல்லது மொழிபெயர்ப்பாளர் (interpreter) ஆகும். மிகவும் பிரபலமான ஜாவாஸ்கிரிப்ட் இயந்திரங்கள் V8 (கூகுள் குரோம் மற்றும் Node.js இல் பயன்படுத்தப்படுகிறது), SpiderMonkey (பயர்பாக்ஸில் பயன்படுத்தப்படுகிறது) மற்றும் JavaScriptCore (சஃபாரியில் பயன்படுத்தப்படுகிறது).

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

ஜாவாஸ்கிரிப்ட் இயந்திரங்கள் ஜாவாஸ்கிரிப்ட் குறியீட்டைத் திறமையாகச் செயல்படுத்த பல முக்கிய பணிகளைச் செய்கின்றன:

பாகுபடுத்துதல் (Parsing): இயந்திரம் ஜாவாஸ்கிரிப்ட் குறியீட்டை Abstract Syntax Tree (AST) ஆகப் பாகுபடுத்துகிறது.
தொகுத்தல் (Compilation): AST பின்னர் பைட்கோடு (bytecode) அல்லது இயந்திர குறியீட்டாகத் தொகுக்கப்படுகிறது.
செயல்படுத்துதல் (Execution): தொகுக்கப்பட்ட குறியீடு இயந்திரத்தால் செயல்படுத்தப்படுகிறது.

ஜாவாஸ்கிரிப்ட் இயந்திரத்தின் பணிப்பாய்வுக்கு (Workflow) ஒரு எடுத்துக்காட்டு

ஒரு ஜாவாஸ்கிரிப்ட் இயந்திரத்தின் பணிப்பாய்வை விளக்குவதற்கான ஒரு எளிய எடுத்துக்காட்டு இங்கே:

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

console.log(add(2, 3)); // வெளியீடு: 5

பாகுபடுத்துதல் (Parsing)

இயந்திரம் முதலில் குறியீட்டை ஒரு AST ஆகப் பாகுபடுத்துகிறது. மேலே உள்ள குறியீட்டிற்கு, AST இதுபோல் இருக்கலாம்:

Program
 ├── FunctionDeclaration (add)
 │   ├── Identifier (a)
 │   ├── Identifier (b)
 │   └── BlockStatement
 │       └── ReturnStatement
 │           └── BinaryExpression (+)
 │               ├── Identifier (a)
 │               └── Identifier (b)
 └── ExpressionStatement
     └── CallExpression (console.log)
         └── CallExpression (add)
             ├── Literal (2)
             └── Literal (3)

தொகுத்தல் (Compilation)

AST பின்னர் பைட்கோடு அல்லது இயந்திர குறியீட்டாகத் தொகுக்கப்படுகிறது. இந்த படியானது செயல்திறனை (performance) மேம்படுத்துவதற்கான மேம்பாடுகளை (optimizations) உள்ளடக்கியது.

செயல்படுத்துதல் (Execution)

தொகுக்கப்பட்ட குறியீடு இயந்திரத்தால் செயல்படுத்தப்படுகிறது. இந்த வழக்கில், add செயல்பாடு 2 மற்றும் 3 வாதங்களுடன் (arguments) அழைக்கப்படுகிறது, மேலும் முடிவு 5 கன்சோலில் பதிவு செய்யப்படுகிறது.

Just-In-Time (JIT) Compilation

நவீன ஜாவாஸ்கிரிப்ட் இயந்திரங்கள் செயல்திறனை மேம்படுத்த Just-In-Time (JIT) தொகுப்பைப் பயன்படுத்துகின்றன. JIT தொகுப்பு என்பது செயல்படுத்துவதற்கு முன்பு அல்லாமல், இயக்க நேரத்தில் (runtime) குறியீட்டைத் தொகுப்பதை உள்ளடக்குகிறது. உண்மையான பயன்பாட்டு வடிவங்களின் (usage patterns) அடிப்படையில் குறியீட்டை மேம்படுத்த இது இயந்திரத்தை அனுமதிக்கிறது.

JIT தொகுப்பிற்கு ஒரு எடுத்துக்காட்டு

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

for (let i = 0; i < 1000000; i++) {
    multiply(2, 3);
}

இந்த எடுத்துக்காட்டில், multiply செயல்பாடு மீண்டும் மீண்டும் அழைக்கப்படுகிறது. ஒரு JIT கம்பைலர், ஒரு செயல்பாடு சூடான செயல்பாடு (hot function) (அதாவது, அடிக்கடி அழைக்கப்படுகிறது) என்பதைக் கண்டறிந்த பிறகு அந்தச் செயல்பாட்டை மேம்படுத்தலாம்.

குப்பை சேகரிப்பு (Garbage Collection)

ஜாவாஸ்கிரிப்ட் இயந்திரங்களில் நினைவகத்தை நிர்வகிக்கக் குப்பை சேகரிப்பான்களும் (garbage collectors) உள்ளன. குப்பை சேகரிப்பான் இனி பயன்பாட்டில் இல்லாத நினைவகத்தைத் தானாகவே விடுவித்து, நினைவக கசிவுகளைத் (memory leaks) தடுக்கிறது.

குப்பை சேகரிப்பிற்கு ஒரு எடுத்துக்காட்டு

function createObject() {
    return { name: "Object" };
}

let obj = createObject();
obj = null; // இந்த பொருள் (object) இப்போது குப்பை சேகரிப்பிற்குத் தகுதியானது

இந்த எடுத்துக்காட்டில், obj ஆனது null ஆக அமைக்கப்பட்ட பிறகு, createObject ஆல் உருவாக்கப்பட்ட பொருளானது குப்பை சேகரிப்பிற்குத் தகுதியுடையதாகிறது.

JavaScript இயந்திரம்