הבנת המרת סוג וכפייה ב-JavaScript

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

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

מדוע המרת סוג וכפייה מתרחשת ב-JavaScript?

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

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

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

סוג כפייה

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

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

JavaScript כופה טיפוסים על סמך סוג הפעולה והאופרטור שבו אתה משתמש בפעולה.

כפייה עם מפעיל "+".

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

אם שני האופרנדים הם מספרים, ה-"+" המפעיל מבצע הוספה:

לתת מספר1 = 42;
לתת מספר 2 = 10;
לתת sum = num1 + num2; // חיבור
לְנַחֵם.log (sum); // 52

אם שני האופרנדים הם מחרוזות, ה-"+" האופרטור מבצע שרשור מחרוזות:

לתת str1 = "שלום";
לתת str2 = "עוֹלָם";
לתת תוצאה = str1 + " " + str2; // שרשרת מחרוזת
לְנַחֵם.log (תוצאה); // "שלום עולם"

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

// מספר ומחרוזת
לתת מספר = 42;
לתת str = "שלום";
// num נכפת למחרוזת ולאחר מכן משרשרת
לתת result_1 = num + str;
לְנַחֵם.log (result_1); // "42שלום"
// מחרוזת ובוליאנית
לתת bool = נָכוֹן;
// bool נכפה למחרוזת ולאחר מכן משרשרת
לתת result_2 = bool + str;
לְנַחֵם.log (result_2); // "trueHello"

כפייה עם המפעיל "-".

ב-JavaScript, ה"-" האופרטור משמש בעיקר לפעולות חיסור. כאשר אחד האופרנדים או שניהם בפעולה הכוללת את "-" האופרטור אינו מספר, JavaScript ינסה לכפות עליו מספר.

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

const מספר1 = 10;
const מספר 2 = 20;
const result_1 = num2 - num1; // חיסור
לְנַחֵם.log (result_1); // 10
const strNum = "10";
const strNum2 = "20";
const תוצאה = strNum2 - strNum; // הקלד כפייה למספרים, ואז חיסור
לְנַחֵם.log (result_1); // 10

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

// true נכפה ל-1, false נכפה ל-0
const boolNum = נָכוֹן;
const boolNum2 = שֶׁקֶר;
const result_1 = boolNum - boolNum2;
לְנַחֵם.log (result_1); // 1
// מערכים ריקים נאלצים ל-0
const arrNum = [];
const arrNum2 = [];
const result_2 = arrNum - arrNum2;
לְנַחֵם.log (result_2); // 0
// עצמים ריקים נאלצים ל-NaN
const objNum = {};
const result_3 = arrNum - objNum;
לְנַחֵם.log (result_3); // 0 - NaN = NaN

בדוגמה זו, JavaScript כופה ערכים בוליאניים נָכוֹן ו שֶׁקֶר לערכים המקבילים המספריים שלהם, 1 ו 0, בהתאמה. מערכים ריקים נאלצים 0, וחפצים ריקים נאלצים NaN.

כפייה עם מפעילי השוויון (==)/().

ב-JavaScript, אופרטורי השוויון (== ו ) להשוות ערכים לשוויון. עם זאת, הם מתנהגים אחרת בגלל כפייה מסוג.

ה "==אופרטור (שוויון רופף) מבצע כפיית סוג, כלומר מנסה להמיר אופרנדים לאותו סוג לפני השוואה:

"10" == 10; // נכון

בדוגמה זו, JavaScript כופה את המחרוזת "10" למספר 10, כך שהביטוי מוערך ל נָכוֹן.

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

"10"10; // שקר

בדוגמה זו, ההשוואה חוזרת שֶׁקֶר כי האופרנדים הם מסוגים שונים (מחרוזת ומספר).

אתה צריך בדרך כלל להשתמש ב אופרטור (שוויון קפדני) ב-JavaScript כדי למנוע התנהגות כפייה מסוג בלתי צפוי.

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

סוג המרה

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

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

הנה דוגמה באמצעות מספר() פוּנקצִיָה:

const numStr = "123";
const מספר = מספר(numStr); // ממירה מחרוזת למספר
לְנַחֵם.log (num); // 123

העברת מחרוזת שהיא מספר חוקי כארגומנט ל- מספר() הפונקציה תחזיר מספר. העברת מחרוזת שהיא מספר לא חוקי תחזור NaN.

הנה דוגמה באמצעות חוּט() פוּנקצִיָה:

const bool = נָכוֹן;
const str2 = חוּט(בול); // ממירה בוליאן למחרוזת
לְנַחֵם.log (str2); // "נכון"

העברת כל סוג נתונים לתוך פרט לסמל לתוך חוּט() הפונקציה תמיר את סוג הנתונים למחרוזת.

הנה דוגמה באמצעות בוליאנית() פוּנקצִיָה:

// המרת מחרוזת לבוליאנית (אמת: נכון, שקר: שקר)
const str = "שלום";
const bool2 = בוליאנית(str);
לְנַחֵם.log (bool2); // נכון

העברת ערכי אמת ל- בוליאנית() הפונקציה מחזירה את הערך הבוליאני "true" בעוד שהעברת ערכי שקר מחזירה את ה-"false" הבוליאני.

הנה דוגמה באמצעות ParseInt() ו ParseFloat() פוּנקצִיָה:

// המרת מחרוזת למספר שלם
const numStr = "123.00";
const מספר1 = parseInt(numStr);
לְנַחֵם.log (num1); // 123
// המרת מחרוזת למספר נקודה צפה
const floatStr = "3.14";
const מספר 2 = parseFloat(floatStr);
לְנַחֵם.log (num2); // 3.14

ה parseInt() הפונקציה מנתחת ארגומנט מחרוזת ומחזירה מספר שלם. ה parseFloat() הפונקציה ממירה מחרוזת למספר נקודה צפה.

מינוף סוג כפייה והמרה

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