מצב תצוגה
מספרים
טיפוסי נתונים
לכל משתנה בשפת Java Script יש טיפוס המגדיר אותו.
טיפוס-נתונים מתייחס לסוג המשתמש ולא למידע הקיים בתוכו. בשפת Java Script טיפוס הנתונים של המשתנה יכול להשתנות לאחר הצבה מה שהופך את השפה לשפה חלשת-טיפוס. חלשת-טיפוס היא היכול להגדיר את טיפוס המשתנה באופן דינאמי.
בשפות אחרון כגון C# ו-Java למשל ברגע שמשתנה הוגדר כמספר למשל הוא יישאר מספר לכל אורך חיי השימוש במשתנה.
האופרטור typeof
יעיל מאוד והוא מחזיר מחרוזת (טקסט – עוד על כך בפרק הבא) המכילה את שם הטיפוס, כמו בדוגמת הקוד הבאה:
javascript
let a;
console.log(typeof a);
a = 1;
console.log(typeof a);
הפלט יהיה
sh
undefined
number
הטיפוס undefined
הוא טיפוס נתונים (אשר די ייחודי לשפת Java Script) המייצג משתנה ללא טיפוס שיגדיר אותו. במקרה כאן בשורה הראשונה אומנם הגדרנו את המשתנה a
בעזרת מילת המפתח let
אך כיוון שלא הקצנו שום ערך למשתנה הוא יהיה ללא טיפוס מוגדר, על כן הוא קיבל את הטיפוס undefined
.
בפרק זה נכיר את שני סוגי המספרים תחת הטיפוס number
ומה ניתן לעשות איתם.
סוגי מספרים
בשפת Java Script ובשונה משפות אחרות הטיפוס המספרי כולל בתוכו גם מספרים שלמים וגם מספרים עם נקודה צפה. כך שני המשתנים הבאים יהיו מסוג number
.
javascript
let a = 2; // Integer number
let b = 3.14 // Float number
להקלת קריאה ניתן להגדיר מספרים ארוכים בשימוש עם תו הקו-תחתון _
. אין צורך שסימן הקו-תחתון יהיה בחלוקת אלפים, אלא ניתן למקמו היכן שרוצים.
javascript
let a = 1000000;
let b = 1_000_000;
let c = 1_00000_0
ניתן גם להגדיר מספרים עם האות e
וכל מספר אח"כ להגדרה כמה אפסים יתווספו למספר
javascript
let a = 1e10; // a = 10000000000;
מניפולציה במספרים ערך מספרי יכול להיות התוצאה של איזו סדרה של פעולות מתמטיות, כל הדוגמאות הבאות יציבו ערך מטיפוס number
במשתנים.
javascript
let a = 1;
let b = a *60;
let c = (1_333_5 + 16) * b;
let d = c – a;
console.log(a);
console.log(b);
console.log(c);
console.log(d);
בהקצאת המשתנה d
ניתן לראות שלאחר שהערכים הוצבו בתוך המשתנים, ניתן כמו להתייחס למשתנים כמו אל הערך הקיים בתוכם.
NaN – Infinity
ב-Java Script יש שני קבועים המייצגים ערכים מספרים והם NaN
ו-Infinity
.
NaN – ר"ת של Not a Number (שאינו מספר). ערך זה מוצב במשתנה מטיפוס number
כאשר הערך של פעולה חישובית כל שהיא אינה שווה למספר. Infinity
– אין סופי. ערך זה מוצב כאשר תוצאה של פעולה חישובית כל שהיא תהיה אין סופית, דוגמת חלוקת כל מספר באפס.
את שני הערכים ניתן להציב מראש במשתנה וכן הם יכולים להתקבל מתוצאה חישובית כמו בדוגמאות הבאות
javascript
let a = 10 / 'YES';
let b = 10 / 0;
console.log(a);
console.log(b);
בדוגמא הראשונה נעשה ניסיון לחלק מספר במחרוזת, התוצאה תהיה NaN. בדוגמה השנייה נעשה ניסיון לחלק את המספר 10 ב-0. התוצאה של פעולה כזו היא Infinity - אינסוף. חשוב לדעת הטיפוס של NaN
ושל Infinity
הוא Number
מתודות של מספרים
כל משתנה מטיפוס number
מגיע עם מספר מתודות שימושיות. מתודות הינן פונקציות הקשורות למשתנה ויותר נכון לאובייקט, עוד על כך בהמשך. לעת עתה יש לזכור שהדרך לגשת למתודה של משתנה הוא ע"י שימוש באופרטור הנקודה לאחר שם המשתנה .
ולאחריה תכתב שם המתודה.
לדוגמה נניח ויש משתנה בשם a
ששווה לערך 3.5
כדי להציג את הערך כ-3.500
יש להשתמש במתודה toFixed
ולכתוב את המספר 3 כארגומנט. ככה:
javascript
let a = 3.5;
a = a.toFixed(3);
console.log(a);
בדוגמה זו ניתן לראות ש:
- נעשה שימוש במתודה של המשתנה
a
. - המתודה נקרא
toFixed
והיא מחזירה את המספר כמספר עם נקודה צפה. - הארגומנט שהמתודה
toFixed
מקבלת ייקבע את מספר האפסים לאחר הנקודה. כלומר, את רמת הדיוק של המספר עם ערך של נקודה צפה.
עם זאת שהשימוש בהם הוא די נדיר אלו מתודות נוספת לשימוש על משתנים מספריים.
toString()
- מחזירה את המספר כמחרוזת.toExponential()
- מחזירה את הייצוג החזקתי של המספר.toPrecision()
- מחזירה את רמת ה-"דיוק" של המספר.
קטע הקוד הבא מריץ ומדגים את היכולת של שלושת המתודות הקודמות.
javascript
let a = 3.5;
let b = 100000000;
let c = 6504;
console.log(‘toString() Examples:’)
console.log(a.toString());
console.log(b.toString());
console.log(c.toString());
console.log(‘toExponential() Examples:’)
console.log(a.toExponential());
console.log(b.toExponential());
console.log(c.toExponential());
console.log(‘toPrecision() Examples:’)
console.log(a.toPrecision());
console.log(b.toPrecision());
console.log(c.toPrecision());
ניתן גם להריץ את כל המתודות של כל טיפוס על ערך של הטיפוס ללא הצורך שהוא יהיה מוצב לפני כן במשתנה, כך:
javascript
console.log(3.5.toFixed(3));
ניתוח – Parsing
ניתוח מעניק את היכולת לקבל ערך מספרי בוודאות ממשתנה שהתוכן והטיפוס שלו לא יודע. בנוסף ניתוח עוזר גם במקרים בו ערך המשתנה כן ידוע אבל ייתכן שהטיפוס אינו מספרי. שימוש בניתוח ממיר את הערך תמיד למספר.
הפונקציה parseInt
מקבלת כארגומנט את כל סוגי הערכים ומנסה להחזיר אותם כערך מספר שלם. לדוגמה:
javascript
console.log( parseInt(‘10’) );
console.log( parseInt(’10.55’) );
console.log( parseInt(‘-10BlaBla’) );
הפלט יהיה
sh
10
10
-10
בקריאה הראשונה הפונקציה קיבלה את המחרוזת 10
והחזירה 10 זה די ישר ולעניין.
בקריאה השנייה הפונקציה קיבלה מחרוזת עם התוכן 10.55
אך כיוון שהפונקציה parseInt
מנתחת רק מספרים שלמים הערך לאחר הנקודה נמחק והפונקציה החזירה 10 שוב.
בקריאה השלישית הפונקציה קיבלה מחרוזת המתחילה ב--10
ועם עוד קצת תווי אותיות כללים. הפונקציה ניקתה את כל התוכן הלא רלוונטי והחזירה -10.
הפונקציה parseFloat
פועלת אותו דבר רק שהיא מנסה להחזיר את הערך כמספר עם נקודה צפה. לדוגמה
javascript
console.log( parseFloat(‘10’) );
console.log( parseFloat(’10.55’) );
console.log( parseFloat(‘-10.4BlaBla’) );
כל זה טוב ויפה במקרים בהם הארגומנט שהועבר לפונקציה מכיל מספר, מה יקרה במקרים בהם הערך שסופק הוא לא ערך מספרי?
בכזה מקרה יגיע הערך המוכר NaN אשר יסמל שהערך שהתקבל אינו מספרי.
באלו מקרים יכול לחזור ערך לא מספרי?
- במקרה והארגומנט לא מכיל מספרים
- במקרה והארגומנט מכיל מספרים אך לא מתחיל עם מספר. בכזה מקרה למרות שיש ערך מספרי הפונקציה תחזיר NaN.
מחרוזות ומספרים יחד
נקודה אחרונה שחשוב לדעת בהקשר למספרים.
כאשר נריץ את קטע הקוד הבא המשתנה b
יהיה שווה 30.
javascript
let b = 10 + 10 + 10;
console.log(b);
מדובר בפעולה חשבונית די פשוטה. חיבור של שלושה עשרות מביא תוצאה של 30.
כל זה נכון במקרה וכל האופרנדים בין הארגומנטים הם מטיפוס number
. אך במקרה ואחד מהארגומנטים יהיה מחרוזת כמו בדוגמה הבאה, מה אמורה להיות התוצאה?
javascript
let b = 10 + ‘10’ + 10;
console.log(b);
לכאורה גם בכזה מקרה התוצאה צריכה להיות 30, לא?
התוצאה בכזה מקרה תהיה 101010
למה? הסיבה היא שהאופרטור +
משמש לשני דברים
חיבור בין מספרים. דוגמת
1 + 1
חיבור בין מחרוזות. דוגמת
’hellow’ + ‘world’
ובקדימות האופרטור של חיבור בין מחרוזות קודם לחיבור בין מספרים. כיוון שכך כל שאר פעולות החיבור מתבצעות מצד המחרוזות מה שמביא לתוצאה הסופית של הצמדת הערכים 10 + ‘10’ + 10
אחד ליד השני ולא חיבור הערכים שלהם.
בפרק דובר די הרבה על מחרוזות, מה הם ולמה הם נקראים כך? כל זה ועוד בפרק הבא