המרת טיפוסים - casting, coercion

טיפוסים בסיסיים בג'אווה סקריפט

ל-JavaScript יש כמה טיפוסים בסיסיים (Data Types), כל אחד משרת מטרות שונות בתכנות. להלן הטיפוסים העיקריים:

מספר (Numeric):

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

let num = 10; // Integer
let floatNum = 3.14; // Floating-point number

מחרוזת (String):

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

let str = "Hello, World!";

בוליאן (Boolean):

הטיפוס הבוליאני מייצג ערכים לוגיים אמיתיים ושקריים (true / false). בוליאנים משמשים לפעולות לוגיות, תנאים וביטויים בוליאניים.

let isLogged = true;
let hasPermission = false;

לא מוגדר (Undefined):

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

let undefinedVar;
console.log(undefinedVar); // Output: undefined

Null:

הטיפוס null מייצג היעדר מכוון של ערך אובייקט כלשהו. Null משמש לעתים קרובות, כדי לציין שמשתנה אינו מצביע על אף אובייקט.

let nullVar = null;

אובייקט (Object):

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

let person = { firstName: "John", lastName: "Doe", age: 30 };

סימבול (Symbol):

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

const key = Symbol("description");
let obj = { [key]: "value" };

המרת נתונים בצורה מפורשת - Casting

כעת, לאחר שהכרנו את הטיפוסים הבסיסיים של JavaScript, נצלול לתוך המושגים של Casting ו-Coercion.

Casting היא המרה מפורשת (Explicit Conversion) של ערך מטיפוס נתונים אחד לאחר, בדרך כלל תוך שימוש בפונקציות או אופרטורים מובנים של המרה.

דוגמה:

let str = "123";
let num = Number(str); // Explicitly convert string to number
console.log(num); // Output: 123 (number)

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

המרת נתונים בצורה לא מפורשת - Coercion

Coercion היא המרה לא מפורשת (Implicit Conversion) של ערך מטיפוס נתונים אחד לאחר, המתבצעת על ידי JavaScript באופן אוטומטי במהלך פעולות או השוואות.

JavaScript מבצע Coercion, כלומר כופה המרה, של מחרוזות למספרים, בעת ביצוע פעולות אריתמטיות.

דוגמה:

let str = "10";
let num = str * 2; // Implicitly convert string to number
console.log(num); // Output: 20 (number)

ניתן לראות בשורה השניה שבדוגמה, שביצענו הכפלה של str, שהוא משתנה מטיפוס מחרוזת, בערך המספרי 2. כיוון שלא ניתן לבצע פעולות אריתמטיות שמשלבות מחרוזות ומספרים יחד, הערך שבמשתנה str, שהוא המחרוזת "10", עבר המרה בצורה לא מפורשת (כלומר מבלי שהשתמשנו בפונקציה כלשהי עבור ההמרה הזו) לערך 10, שהוא ערך מספרי, ובוצעה הכפלה של 10 ב-2 לקבלת התוצאה המספרית 20.

JavaScript מבצע Coercion, כלומר כופה המרה, לבוליאנים בהקשרים לוגיים, כגון הצהרות אם (if) או אופרטורים לוגיים.

דוגמה:

let value = "Hello";
if (value) {
    console.log("Value is truthy"); // Executes because non-empty strings are truthy
}

בדוגמה זו, ערך המשתנה value הוא מחרוזת שאינה ריקה, ולכן, הוא מומר לערך true. מחרוזות ריקות מומרות לערך false.

פונקציות המרה ב-JavaScript

JavaScript מספק מספר פונקציות מובנות להמרת ערכים מסוג אחד לאחר. נחקור כמה מפונקציות ההמרה הנפוצות:

הפונקציה toString ממירה ערך למחרוזת.

דוגמה:

let num = 10;
let str = num.toString();
console.log(str); // Output: "10" (string)

הפונקציה parseInt מקבלת כפרמטר מחרוזת ומחזירה מספר שלם.

דוגמה:

let str = "10";
let num = parseInt(str);
console.log(num); // Output: 10 (number)

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

דוגמה:

let binaryStr = "1010";
let decimalNum = parseInt(binaryStr, 2); // Convert binary string to decimal number
console.log(decimalNum); // Output: 10 (number)

הפונקציה parseFloat מקבלת כפרמטר מחרוזת ומחזירה מספר עם נקודה צפה (כלומר שבר עשרוני).

דוגמה:

let str = "3.14";
let num = parseFloat(str);
console.log(num); // Output: 3.14 (number)

הפונקציה Number ממירה ערך למספר.

דוגמה:

let str = "10";
let num = Number(str);
console.log(num); // Output: 10 (number)

הפונקציה Boolean ממירה ערך לבוליאן.

דוגמה:

let value = "Hello";
let bool = Boolean(value);
console.log(bool); // Output: true (boolean)

שיטות עבודה מומלצות כדי להמנע מבאגים

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

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

דוגמה:

let invalidStr = "abc123";

// Attempting to parse the invalid string using parseInt()
let num = parseInt(invalidStr);

if (isNaN(num)) {
    console.log("Invalid input provided."); // Output: "Invalid input provided."
} else {
    console.log("Parsed number:", num);
}

בדוגמה זו, יש לנו מחרוזת לא חוקית "abc123" שלא ניתן להמיר למספר שלם באמצעות parseInt. הפונקציה parseInt תחזיר את NaN (Not a Number) כאשר תסופק עם קלט לא חוקי. כדי לטפל בתרחיש זה, אנו משתמשים בפונקציה isNaN, כדי לבדוק אם התוצאה של parseInt היא NaN. אם זה NaN, נחזיר הודעה המציינת שסופק קלט לא חוקי. אחרת, נמשיך עם המספר שהומר. כך נבטיח שהקוד שלנו מטפל בצורה נאותה במקרים של קלט לא חוקי ומונע התנהגות בלתי צפויה.

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

דוגמה:

let invalidStr = "abc123";

// Attempting to parse the invalid string using parseInt()
let num = parseInt(invalidStr);

// Combining parseInt() with a default value to handle conversion failure
let parsedNum = isNaN(num) ? 0 : num;

console.log("Parsed number:", parsedNum); // Output: Parsed number: 0

בדוגמה זו, שוב יש לנו מחרוזת לא חוקית "abc123" שלא ניתן להמיר למספר שלם באמצעות parseInt. אנו מנסים לנתח את המחרוזת, ואם התוצאה היא NaN, דבר שמצביע על המרה שנכשלה, נשתמש באופרטור הטרינרי (אם ... אז ... בפורמט a ? b : c), כדי להקצות ערך ברירת מחדל של 0 ל-parsedNum. כך נבטיח שגם אם ההמרה נכשלת, יש לנו ערך מספרי תקין לשימוש בקוד שלנו, ונמנע בעיות פוטנציאליות הנגרמות על ידי NaN.

המר במפורש ערכים לסוג הרצוי לפני ביצוע השוואות, כדי למנוע תוצאות בלתי צפויות.

דוגמה:

let str = "10";
let num = 10;
if (Number(str) === num) {
    console.log("Equal"); // Output: "Equal"
}

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

דוגמה:

let num = 10;
let str = "10";
if (num === str) {
    console.log("Equal"); // Does not execute because of strict equality
}