מספרים ​

טיפוסי נתונים ​

לכל משתנה בשפת Java Script יש טיפוס המגדיר אותו.
טיפוס-נתונים מתייחס לסוג המשתמש ולא למידע הקיים בתוכו. בשפת Java Script טיפוס הנתונים של המשתנה יכול להשתנות לאחר הצבה מה שהופך את השפה לשפה חלשת-טיפוס. חלשת-טיפוס היא היכול להגדיר את טיפוס המשתנה באופן דינאמי.
בשפות אחרון כגון C# ו-Java למשל ברגע שמשתנה הוגדר כמספר למשל הוא יישאר מספר לכל אורך חיי השימוש במשתנה.
האופרטור typeof יעיל מאוד והוא מחזיר מחרוזת (טקסט – עוד על כך בפרק הבא) המכילה את שם הטיפוס, כמו בדוגמת הקוד הבאה:

let a;
console.log(typeof a);

a = 1; 
console.log(typeof a);

הפלט יהיה

undefined
number

הטיפוס undefined הוא טיפוס נתונים (אשר די ייחודי לשפת Java Script) המייצג משתנה ללא טיפוס שיגדיר אותו. במקרה כאן בשורה הראשונה אומנם הגדרנו את המשתנה a בעזרת מילת המפתח let אך כיוון שלא הקצנו שום ערך למשתנה הוא יהיה ללא טיפוס מוגדר, על כן הוא קיבל את הטיפוס undefined.

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

סוגי מספרים ​

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

let a = 2; // Integer number
let b = 3.14 // Float number

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

let a = 1000000;
let b = 1_000_000;
let c = 1_00000_0

ניתן גם להגדיר מספרים עם האות e וכל מספר אח"כ להגדרה כמה אפסים יתווספו למספר

let a =  1e10;  // a = 10000000000;

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

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

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

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

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 כארגומנט. ככה:

let a = 3.5;
a = a.toFixed(3);
console.log(a);

בדוגמה זו ניתן לראות ש:

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

עם זאת שהשימוש בהם הוא די נדיר אלו מתודות נוספת לשימוש על משתנים מספריים.

• toString() - מחזירה את המספר כמחרוזת.
• toExponential() - מחזירה את הייצוג החזקתי של המספר.
• toPrecision() - מחזירה את רמת ה-"דיוק" של המספר.

קטע הקוד הבא מריץ ומדגים את היכולת של שלושת המתודות הקודמות.

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());

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

console.log(3.5.toFixed(3));

ניתוח – Parsing ​

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

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

console.log( parseInt(‘10’) ); 
console.log( parseInt(’10.55’) ); 
console.log( parseInt(‘-10BlaBla’) ); 

הפלט יהיה

10
10
-10

בקריאה הראשונה הפונקציה קיבלה את המחרוזת 10 והחזירה 10 זה די ישר ולעניין.

בקריאה השנייה הפונקציה קיבלה מחרוזת עם התוכן 10.55 אך כיוון שהפונקציה parseInt מנתחת רק מספרים שלמים הערך לאחר הנקודה נמחק והפונקציה החזירה 10 שוב.

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

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

console.log( parseFloat(‘10’) ); 
console.log( parseFloat(’10.55’) ); 
console.log( parseFloat(‘-10.4BlaBla’) ); 

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

בכזה מקרה יגיע הערך המוכר NaN אשר יסמל שהערך שהתקבל אינו מספרי.

באלו מקרים יכול לחזור ערך לא מספרי?

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

מחרוזות ומספרים יחד ​

נקודה אחרונה שחשוב לדעת בהקשר למספרים.

כאשר נריץ את קטע הקוד הבא המשתנה b יהיה שווה 30.

let b = 10 + 10 + 10;
console.log(b);

מדובר בפעולה חשבונית די פשוטה. חיבור של שלושה עשרות מביא תוצאה של 30.

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

let b = 10 + ‘10’ + 10;
console.log(b);

לכאורה גם בכזה מקרה התוצאה צריכה להיות 30, לא?

התוצאה בכזה מקרה תהיה 101010

למה? הסיבה היא שהאופרטור + משמש לשני דברים

1. חיבור בין מספרים. דוגמת 1 + 1

2. חיבור בין מחרוזות. דוגמת ’hellow’ + ‘world’

ובקדימות האופרטור של חיבור בין מחרוזות קודם לחיבור בין מספרים. כיוון שכך כל שאר פעולות החיבור מתבצעות מצד המחרוזות מה שמביא לתוצאה הסופית של הצמדת הערכים 10 + ‘10’ + 10 אחד ליד השני ולא חיבור הערכים שלהם.

בפרק דובר די הרבה על מחרוזות, מה הם ולמה הם נקראים כך? כל זה ועוד בפרק הבא