טיפוסים פרימיטיביים ב-JavaScript: שבעת הערכים הבסיסיים

שבעה פרימיטיבים וכל השאר

JavaScript מחלקת ערכים לשני מחנות. בצד אחד, שבעה טיפוסים פרימיטיביים: ערכים פשוטים שלא ניתן לשנות. בצד השני, אובייקטים: כל מה שמורכב, ניתן לשינוי או ניתן לקריאה. זו כל מערכת הטיפוסים ברמת הערכים.

שבעת הפרימיטיבים:

console.log(typeof "hello");     // string
console.log(typeof 42);          // number
console.log(typeof 42n);         // bigint
console.log(typeof true);        // boolean
console.log(typeof undefined);   // undefined
console.log(typeof Symbol("x")); // symbol
console.log(typeof null);        // object  ← historical bug

כל מה שלא ברשימה הזו, מערכים, פונקציות, תאריכים, ביטויים רגולריים ו-{} רגיל, הוא אובייקט. typeof נותן את הטיפוס בזמן ריצה, ותשימו לב לפגם המפורסם בשורה האחרונה. typeof null מחזיר 'object' מאז 1995 ולעולם לא יתוקן; יותר מדי קוד קיים מסתמך עליו.

פרימיטיב הוא ערך, לא מכל

המודל המחשבתי שהכי עוזר: פרימיטיב הוא הערך שלו. המספר 3 הוא לא קופסה שמחזיקה 3, הוא פשוט 3. שני משתנים שמחזיקים 3 מחזיקים את אותו ערך, ולא שני עותקים שמצביעים על משהו משותף:

const a = 3;
const b = 3;

console.log(a === b);   // true - same value
console.log(a === 3);   // true

const x = { n: 3 };
const y = { n: 3 };

console.log(x === y);   // false - different objects

פרימיטיבים מושווים לפי ערך. אובייקטים מושווים לפי הפניה. ההבחנה הזו לבדה עומדת מאחורי הרבה רגעים של "למה זה false?" בהמשך, במיוחד כשמשווים מערכים או אובייקטים עם ===.

פרימיטיבים אינם ניתנים לשינוי

אי אפשר לשנות פרימיטיב. כל פעולה שנראית כמו שינוי בעצם מייצרת ערך חדש:

let name = "ada";
name.toUpperCase();     // returns "ADA"
console.log(name);      // "ada" - unchanged

name = name.toUpperCase();
console.log(name);      // "ADA" - variable now points at a different string

הקריאה הראשונה בונה מחרוזת חדשה וזורקת אותה, כי שום דבר לא תפס את הערך המוחזר. השנייה מבצעת השמה מחדש ל-name. ה-"ada" המקורי מעולם לא השתנה, והוא גם לא יכול היה להשתנות. אותו דבר עם מספרים: x + 1 מייצר מספר חדש ולא משנה את x.

זו הסיבה ש-const על מחרוזת או מספר הוא בטוח באמת. הערך לא יכול להשתנות, ו-const מונע השמה מחדש למשתנה.

Number, BigInt, ולמה יש שניים

ה-number של JavaScript הוא מספר נקודה צפה של 64 ביט. זה אומר חישובים מהירים ותקרה: מספרים שלמים מדויקים רק עד Number.MAX_SAFE_INTEGER (2^53 - 1):

console.log(Number.MAX_SAFE_INTEGER);         // 9007199254740991
console.log(Number.MAX_SAFE_INTEGER + 1);     // 9007199254740992
console.log(Number.MAX_SAFE_INTEGER + 2);     // 9007199254740992 ← wrong

מעבר לסף הזה, מספרים שלמים מתחילים להתנגש. bigint קיים בשביל מספרים שלמים שצריכים להישאר מדויקים בכל גודל. כותבים אותו עם הסיומת n:

const big = 9007199254740993n;
console.log(big + 1n);          // 9007199254740994n

// console.log(big + 1);        // TypeError - can't mix bigint and number

אי אפשר לערבב bigint ו-number בחישובים, כי כך הייתם מאבדים את כל הטעם של הדיוק הנוסף. השתמשו ב-bigint כשאתם עובדים עם מזהים ממסד נתונים, חותמות זמן בננו-שניות או קריפטוגרפיה. חישובים רגילים נשארים עם number.

גם מחרוזות הן פרימיטיבים

מחרוזת ב-JavaScript היא פרימיטיב, לא אובייקט, למרות שיש לה מתודות כמו .length, .slice ו-.toUpperCase:

const greeting = "hello";

console.log(greeting.length);          // 5
console.log(greeting.toUpperCase());   // "HELLO"
console.log(typeof greeting);          // "string"

מאחורי הקלעים, כשקוראים למתודה על מחרוזת, JavaScript עוטפת אותה לרגע באובייקט String כדי שקריאת המתודה תעבוד, ואז זורקת את העטיפה. לא צריך לחשוב על העטיפה הזו, רק לדעת שמחרוזות מתנהגות כמו ערכים (לא ניתנות לשינוי ומושוות לפי ערך) למרות שיש להן אוסף עשיר של מתודות.

גרשיים בודדים, גרשיים כפולים ו-backticks יוצרים כולם את אותו טיפוס. backticks מאפשרים בנוסף שילוב ערכים ומחרוזות מרובות שורות, והדף הבא מסביר אותם.

null מול undefined

שני פרימיטיבים אומרים "אין ערך", והם לא ניתנים להחלפה זה בזה.

undefined הוא מה שמקבלים כשמשהו מעולם לא קיבל ערך: משתנה שהוצהר ולא הוגדר, ארגומנט חסר לפונקציה, מאפיין שלא קיים:

let x;
console.log(x);               // undefined

function greet(name) {
    console.log(name);
}
greet();                      // undefined

const user = { name: "Rosa" };
console.log(user.email);      // undefined

null הוא מה ש_אתם_ כותבים כשאתם רוצים לומר "ריק בכוונה":

let selectedItem = null;      // nothing selected yet, but we meant to say so

selectedItem = { id: 42 };
console.log(selectedItem);

המוסכמה הכללית: undefined הוא הדרך של השפה לומר "אין כאן כלום", null הוא הדרך של המתכנת. שניהם falsy, שניהם נכשלים בהשוואה לערכים רגילים, ולכל אחד מהם יש דף משלו בהמשך.

Symbol: ייחודי מעצם הגדרתו

symbol הוא הפרימיטיב שהכי פחות משתמשים בו. כל symbol שיוצרים הוא ייחודי, גם אם שניים נבנו מאותו תיאור:

const a = Symbol("id");
const b = Symbol("id");

console.log(a === b);         // false
console.log(a.description);   // "id"

const user = {};
user[a] = "first value";
user[b] = "second value";

console.log(user[a]);         // "first value"
console.log(user[b]);         // "second value"

symbols שימושיים כמפתחות של אובייקטים שלא יכולים להתנגש במפתחות קיימים: ספרייה יכולה להצמיד מטא-דאטה לאובייקטים שלכם עם symbol ולהיות בטוחה ששום קוד אחר לא ידרוס אותה. תפגשו אותם שוב סביב איטרטורים ו-symbols מוכרים כמו Symbol.iterator.

בדיקת טיפוסים בזמן ריצה

typeof מטפל ברוב המקרים. זכרו את המוזרויות האלה:

console.log(typeof "abc");        // "string"
console.log(typeof 42);           // "number"
console.log(typeof 42n);          // "bigint"
console.log(typeof true);         // "boolean"
console.log(typeof undefined);    // "undefined"
console.log(typeof Symbol());     // "symbol"

console.log(typeof null);         // "object"   ← quirk
console.log(typeof [1, 2]);       // "object"
console.log(typeof function(){}); // "function" ← also quirk, but useful

עבור null, השוו ישירות: value === null. עבור מערכים, השתמשו ב-Array.isArray(value). לשאלה "האם זה פרימיטיב כלשהו?" אין פונקציה מובנית אחת, אבל הביטוי המקובל ברור מספיק:

function isPrimitive(value) {
    return value === null || (typeof value !== "object" && typeof value !== "function");
}

console.log(isPrimitive("hello"));   // true
console.log(isPrimitive(42));        // true
console.log(isPrimitive(null));      // true
console.log(isPrimitive({}));        // false
console.log(isPrimitive([1, 2]));    // false

פרימיטיבים מול אובייקטים: המלכודת של השמה

עוד דבר אחד ששווה לראות לפני שממשיכים. מכיוון שפרימיטיבים הם ערכים ואובייקטים הם הפניות, השמה מתנהגת אחרת:

let a = 10;
let b = a;
b = 20;
console.log(a);          // 10 - unaffected

let x = { n: 10 };
let y = x;
y.n = 20;
console.log(x.n);        // 20 - same object

עם פרימיטיבים, b = a מעתיק את הערך. עם אובייקטים, y = x מעתיק את ההפניה: שני השמות מצביעים על אותו אובייקט. שינוי דרך שם אחד משפיע על השני. זה המקור הגדול ביותר לבאגים מסוג "רגע, למה זה השתנה?" ב-JavaScript.

מה לקחת מכאן

• שבעה פרימיטיבים: string, number, bigint, boolean, null, undefined, symbol. כל השאר הוא אובייקט.
• פרימיטיבים אינם ניתנים לשינוי ומושווים לפי ערך; אובייקטים ניתנים לשינוי ומושווים לפי הפניה.
• typeof מגלה את הטיפוס בזמן ריצה, עם שתי מוזרויות ששווה לזכור: typeof null === "object" ו-typeof function === "function".
• number הוא מספר נקודה צפה של 64 ביט עם תקרת בטיחות למספרים שלמים; bigint קיים בשביל מספרים שלמים מדויקים מעבר לתקרה הזו.

הבא בתור: מחרוזות ו-Template Literals

מחרוזות הן הפרימיטיב שתעבדו איתו הכי הרבה, ו-template literals (המחרוזות עם backticks) הופכים את בנייתן לקלה: שילוב ערכים, טקסט מרובה שורות ו-tagged templates. זה הדף הבא.