Node.js runtime: איך JavaScript רץ מחוץ לדפדפן

מה Node בעצם

Node.js היא תוכנה שמתקינים במחשב ושמריצה קובצי JavaScript. זה התיאור הפשוט ביותר, והוא מדויק. כשמקלידים node script.js, Node קורא את הקובץ, מעביר אותו למנוע V8 של Google (מנוע ה-JavaScript של Chrome) ומריץ אותו, עם ספרייה גדולה של APIs נוספים שמחוברים אליו בשביל דברים ש-V8 לא יודע לעשות לבד.

V8 יודע להריץ JavaScript. הוא לא יודע לפתוח קובץ, להאזין ל-TCP socket, להפעיל תהליך או לקרוא משתנה סביבה. Node מספק את כל זה, כתוב ב-C++, וחושף אותו לקוד ה-JavaScript שלכם כמודולים מובנים.

node --version
node script.js

אז Node הוא לא שפה. הוא גם לא framework. הוא runtime, סביבת ריצה: V8 ועוד ספרייה סטנדרטית ועוד מערכת מודולים ועוד event loop. זה כל הסיפור.

סקריפט ראשון

כל קובץ .js הוא תוכנית Node תקינה. בלי קוד שלד, בלי פונקציית main:

const name = "Rosa";
const now = new Date();

console.log(`Hello, ${name}`);
console.log(`It is ${now.toISOString()}`);

console.log עובד בדיוק כמו בדפדפן. Template literals, Date, מערכים, promises: כל יכולות השפה שאתם כבר מכירים מגיעות מ-V8 ומתנהגות באותה צורה. מה שמשתנה ב-Node הוא מה שזמין מסביב לשפה.

Globals שקיימים רק ב-Node

לדפדפן יש window, document, localStorage, fetch. ל-Node יש סט אחר של globals, שמותאם לסביבת ריצה בצד השרת:

console.log("Node version:", process.version);
console.log("Platform:", process.platform);
console.log("Working directory:", process.cwd());
console.log("Script path:", __filename);
console.log("Script directory:", __dirname);

• process הוא תהליך ה-Node שרץ כרגע. הוא מחזיק את משתני הסביבה (process.env), את הארגומנטים משורת הפקודה (process.argv), ומתודות ליציאה (process.exit(1)).
• __filename ו-__dirname נותנים את הנתיב המוחלט של הקובץ הנוכחי ושל התיקייה שלו. (במודולי ES הם לא קיימים, ומשתמשים במקומם ב-import.meta.url.)
• global הוא האובייקט העליון, המקבילה של window ב-Node.

אין document ואין window. אם מנסים להשתמש בהם מקבלים ReferenceError. זה בדרך כלל הרמז הראשון לכך שספרייה נכתבה לדפדפן ולא תרוץ ב-Node כמו שהיא.

ארגומנטים משורת הפקודה ומשתני סביבה

חלק גדול ממה שעושים עם Node, כלי CLI, סקריפטים של build ושרתים, צריך לקרוא ארגומנטים ומשתני סביבה. שניהם נמצאים על process:

// Pretend this was run as: node greet.js Rosa --loud
const args = process.argv.slice(2);
console.log("args:", args);

const name = args[0] ?? "friend";
const loud = args.includes("--loud");

const greeting = `Hello, ${name}`;
console.log(loud ? greeting.toUpperCase() : greeting);

console.log("NODE_ENV is:", process.env.NODE_ENV ?? "not set");

process.argv הוא מערך: שני הפריטים הראשונים הם הנתיב לקובץ ההרצה של Node והנתיב לסקריפט, כך שהארגומנטים האמיתיים מתחילים באינדקס 2. process.env הוא אובייקט רגיל של משתני סביבה, וקריאה של NODE_ENV, PORT או מפתחות API ממנו היא פרקטיקה מקובלת.

מודולים מובנים

Node מגיע עם ספרייה סטנדרטית שניגשים אליה דרך require (CommonJS) או import (ESM). שמות המודולים מתחילים ב-node: כדי שיהיה ברור שהם מובנים:

import { readFile, writeFile } from "node:fs/promises";
import { join } from "node:path";

const filePath = join(process.cwd(), "greeting.txt");

await writeFile(filePath, "hello from node\n");
const contents = await readFile(filePath, "utf8");

console.log("file says:", contents.trim());

אלה שתשתמשו בהם הכי הרבה:

• node:fs: קריאה וכתיבה של קבצים. השתמשו ב-node:fs/promises בשביל הגרסה עם async/await.
• node:path: חיבור, פענוח וניתוח של נתיבי קבצים בצורה שעובדת בכל מערכת הפעלה.
• node:http / node:https: בניית שרתי HTTP ושליחת בקשות.
• node:url: ניתוח ובנייה של כתובות URL.
• node:os: מידע על המחשב המארח.
• node:crypto: hashing, בתים אקראיים, הצפנה.

לא מתקינים את אלה. הם מגיעים עם Node. כל השאר מגיע מ-npm.

ה-event loop בקצרה

Node מריץ את ה-JavaScript שלכם על thread אחד, אבל מטפל בהרבה דברים במקביל. הטריק הוא ה-event loop. כשקוראים למשהו אסינכרוני, כמו קריאת קובץ, בקשת HTTP או טיימר, Node מעביר את העבודה עצמה למערכת ההפעלה (או ל-thread pool שלו) וממשיך לרוץ. כשהעבודה מסתיימת, callback נכנס לתור, והלולאה מריצה אותו כשהקוד הנוכחי מסיים.

console.log("1");

setTimeout(() => console.log("3 (after 0ms)"), 0);

Promise.resolve().then(() => console.log("2 (microtask)"));

console.log("4");

הסדר שמודפס הוא 1, 4, 2, 3. קוד סינכרוני רץ קודם. אחריו microtasks (promises שהסתיימו). אחריהם טיימרים. זו הסיבה שלולאה איטית שעמוסה בחישובים חוסמת את כל השרת: יש רק thread אחד בשביל הקוד שלכם. המקביליות של Node נוגעת ל-I/O, לא לחישוב.

שרת HTTP קטנטן

התמורה של כל זה היא ששרת web עובד נכנס בכמה שורות:

import { createServer } from "node:http";

const server = createServer((req, res) => {
    res.writeHead(200, { "Content-Type": "application/json" });
    res.end(JSON.stringify({ path: req.url, method: req.method }));
});

server.listen(3000, () => {
    console.log("מאזין בכתובת http://localhost:3000");
});

בלי framework, בלי תלויות. createServer מקבלת פונקציה שרצה על כל בקשה, ו-listen מפעילה את ה-event loop כדי לטפל בחיבורים נכנסים. אפליקציות אמיתיות משתמשות ב-Express או ב-Fastify מעל זה, אבל מתחת לפני השטח זה אותו מודול http מובנה.

Node מול הדפדפן

כדאי להגיד במפורש מה עובר ומה לא:

Node המודרני אימץ כמה APIs של דפדפן, כמו fetch, URL, AbortController ו-structuredClone, כך שהפער קטן יותר ממה שהיה. אבל ה-DOM לא מגיע ל-Node, ומערכת הקבצים לא מגיעה לדפדפן.

Node מול Deno מול Bun

Node הוא ברירת המחדל, אבל הוא כבר לא סביבת הריצה היחידה ל-JavaScript. Deno ו-Bun הן חלופות: Deno מהיוצר המקורי של Node, ו-Bun מצוות חדש יותר שמתמקד במהירות. הן מריצות JavaScript (ו-TypeScript, באופן מובנה), מגיעות עם כלים מובנים כמו test runners ו-bundlers, ושונות מ-Node באופן שבו הן מטפלות במודולים, בהרשאות ובהתקנת חבילות.

ללימוד JavaScript, Node הוא עדיין המקום שבו נמצאים התיעוד, המדריכים ומשרות העבודה. המושגים, event loop, מודולים ו-APIs מובנים, עוברים כמעט במלואם לסביבות הריצה האחרות. למדו קודם Node, ותכירו את האחרות כשפרויקט ידרוש אותן.

להריץ סקריפטים, מהר

כמה דרכים להריץ קוד בפועל תוך כדי עבודה:

# Run a file
node script.js

# Run a one-liner
node -e "console.log(2 ** 10)"

# Open the REPL (interactive prompt)
node

# Watch a file and re-run on save (Node 18.11+)
node --watch script.js

ה-REPL הוא דף טיוטה נוח כשרוצים לבדוק מה מתודה מחזירה בלי ליצור קובץ. --watch שימושי בזמן פיתוח: שומרים, ו-Node מריץ מחדש את הסקריפט אוטומטית.

הבא בתור: תפיסת שגיאות

להריץ קוד זה דבר אחד, ולטפל בו כשמשהו משתבש זה דבר אחר. קריאות קבצים נכשלות, בקשות HTTP נתקעות, פענוח JSON זורק שגיאות. הפרק הבא עוסק ב-try/catch, בסוגי שגיאות ובדפוסים להתמודדות עם דברים שנשברים, וזה, בתוכנית Node, קורה בסוף לכל דבר.