Node.js என்றால் என்ன, அது எதற்கு நல்லது?

Question

Accepted Answer

**Node.js** என்பது ஒரு runtime ஆகும், இது உங்களை JavaScript ஐ **பிரவுசருக்கு வெளியே** — சேவகங்கள், CLIs, மற்றும் கருவிகளில் இயக்க அனுமதிக்கிறது. இது Chrome இன் **V8** engine இல் கட்டமைக்கப்பட்டுள்ளது மற்றும் ஸ்கேலேபிள் நெட்வொர்க் பயன்பாடுகளுக்காக வடிவமைக்கப்பட்ட non-blocking, event-driven I/O மாதிரியைச் சேர்க்கிறது।

## மைய கருத்து: single-threaded, non-blocking I/O

```js
const fs = require("fs");

// non-blocking: the read happens in the background; the callback fires when done
fs.readFile("big.txt", "utf8", (err, data) => {
  console.log("file read complete");
});
console.log("this prints FIRST — the read didn't block");
```

Node உங்கள் JS ஐ ஒரு முதன்மை thread இல் இயக்குகிறது ஆனால் I/O (file, network, DB) ஐ கணினிக்கு மாற்றுகிறது மற்றும் இயக்கத்தைத் தொடர்கிறது. I/O முடிந்தபின், ஒரு callback இயக்கப்படுகிறது. இதுவே ஒரு Node process **ஆயிரக்கணக்கான concurrent connections** ஐ ஒரு request க்கு ஒரு thread இல்லாமல் கையாள முடியும் என்பதாகும்।

## Node எதற்கு நல்லது

```text
✓ APIs & web servers (REST, GraphQL) — I/O-bound, many concurrent requests
✓ Real-time apps (chat, live updates) — WebSockets, event-driven model fits well
✓ Microservices — lightweight, fast startup
✓ CLIs & build tools (the entire npm/Vite/webpack ecosystem)
✓ Streaming (video, large files) via streams
```

## அது என்ன சிறந்தது அல்ல

```text
✗ CPU-heavy work (image processing, big computations) — blocks the single thread
  → offload to worker threads, a queue, or another service
```

இது உங்கள் JS க்கு single-threaded ஆகிறது என்பதால், கனமான CPU வேலை எல்லாவற்றையும் தடுக்கிறது — Node **I/O-bound** கொழுவ்ப்புகளுக்கு ஒளிர்கிறது, CPU-bound வற்றுக்கு அல்ல।

## எங்கே JavaScript எல்லாக்குமாக முக்கியமானது

```text
Same language front-end and back-end → shared code/types, one skill set,
huge npm ecosystem (the largest package registry).
```

## இது ஏன் முக்கியம்

Node.js JavaScript ஐ சேவகத்திற்கு கொணர்ந்தது மற்றும் non-blocking, event-driven மாதிரியை பிரபலப்படுத்தியது, இது **I/O-heavy, high-concurrency** பயன்பாடுகளுக்கு சிறந்தமாகிறது (APIs, real-time, microservices).

க்கி இது ஸ்கேல் செய்கிறது (async I/O ஒரு single thread இல்) மற்றும் *அது எங்கே முறிகிறது* (CPU-bound வேலை) என்பதை புரிந்துகொள்வது நன்கு பயன்படுத்துவதற்கான அடிப்படையாகும் — இது பெரும்பாலான நவீன JavaScript back-ends மற்றும் கருவிகளின் முதுகெலும்பாகும்।