הבנת סוגי נתונים ברובי

הקדמה

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

דרך אחת לחשוב על סוגי נתונים היא לשקול את סוגי הנתונים השונים שאנו משתמשים בהם בעולם האמיתי. לדוגמה, אנו משתמשים במספרים שלמים (0, 1, 2, …), מספרים שלמים (…, -1, 0, 1, …), ומספרים אי־רציונליים (π).

בדרך כלל, במתמטיקה אנו יכולים לשלב מספרים מסוגים שונים ולקבל תשובה כלשהי. לדוגמה, יתכן שנרצה להוסיף 5 ל־π:

5 + π

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

5 + π = 5 + 3.14 = 8.14

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

sky + 8

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

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

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

נתחיל על ידי הבנת כיצד לעבוד עם מספרים שלמים ב-Ruby.

מספרים שלמים

כמו במתמטיקה, מספרים שלמים בתכנות מחשב הם מספרים שלמים שיכולים להיות חיוביים, שליליים או 0 (…, -1, 0, 1, …). מספר שלם ידוע גם בשם int.

ניתן להדפיס מספר שלם כך:

print -25

Output
-25

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

my_int = -25
print my_int

Output
-25

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

sum = 116 - 68
print sum

Output
48

כאשר אנו כותבים מספרים גדולים, אנו נוטים להשתמש בפסיקים כדי להפוך אותם לקריאה קלה יותר. לדוגמה, אנו נכתוב 1,000,000 עבור "אחד מיליון". אין באפשרותך להשתמש בפסיקים בקוד שלך, אך Ruby מאפשרת לך להשתמש בתו המקווקו (_) כדי להפוך את המספרים הגדולים לקריאים יותר.

נסה את זה בעצמך:

large_number = 1_234_567
print large_number

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

Output
1234567

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

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

מספרים עשרוניים

A floating-point number or a float represents a real number. Real numbers can be either a rational or an irrational number; numbers that contain a fractional part, such as 9.0 or -116.42. In other words, a float in a Ruby program is a number that contains a decimal point.

אתה יכול להדפיס מספרים עשרוניים ב-Ruby בדיוק כמו שאתה מדפיס מספרים שלמים:

print 17.3

Output
17.3

בנוסף, אתה יכול להגדיר משתנה ולהקצות לו מספר עשרוני:

my_float = 17.3
print my_float

Output
17.3

וכמו שקורה עם מספרים שלמים, אתה יכול לעשות חישובים עם מספרים עשרוניים ב-Ruby גם:

sum = 564.0 + 365.24
print sum

Output
929.24

אם תוסיף מספר עשרוני למספר שלם ב-Ruby, תקבל מספר עשרוני:

sum = 564 + 365.24
print sum

Output
929.24

Ruby תתייחס לכל מספר שנכתב ללא נקודה עשרונית כמספר שלם (כמו 138) ולכל מספר שנכתב עם נקודה עשרונית כמספר עשרוני (כמו 138.0).

הבא, בואו נביט בבוליאנים ב-Ruby.

סוגי נתונים בוליאניים

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

הרבה פעולות במתמטיקה נותנות לנו תשובות שמעריכות או לאמת או לשקר:

• גדול מ
• 500 > 100 true
• 1 > 5 false
• קטן מ
• 200 < 400 true
• 4 < 2 false
• שווה
• 5 = 5 true
• 500 = 400 false

כמו עם מספרים, אפשר לאחסן ערך true או false במשתנה:

result = 5 > 8

אפשר להדפיס אז ערך בוליאני באמצעות שימוש בפונקציית print():

print result

מאחר ש־5 אינו גדול מ־8, תראה את התוצאה הבאה:

Output
false

ככל שתכתוב יותר תוכניות ב־Ruby, תתמצא יותר מוכר עם איך בוליאנים פועלים וכיצד פעולות ופונקציות שונות שמעריכות לאמת או לשקר יכולות לשנות את קור התוכנית.

בואו נמשיך ונסקור איך לעבוד עם טקסט בתוכניות שלנו.

מחרוזות

A string is a sequence of one or more characters, such as letters, numbers, and symbols. Strings primarily exist within either single quotes (') or double quotes (") in Ruby, so to create a string, enclose a sequence of characters in quotes, like this:

"This is a string in double quotes."

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

print "Hello, World!"

כמו עם סוגי נתונים אחרים, ניתן לאחסן מחרוזות במשתנים:

output = "Hello, World!"

ולהדפיס את המחרוזת על ידי קריאה למשתנה:

print output

Output
Hello, World!

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

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

מערכות

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

מערכות מוגדרות על ידי ציון ערכים בין סוגריים מרובעים [ ], מופרדים בפסיקים.

מערך של מספרים נראה כך:

[-3, -2, -1, 0, 1, 2, 3]

A array of floats looks like this:

[3.14, 9.23, 111.11, 312.12, 1.05]

הנה רשימת מחרוזות:

['shark', 'cuttlefish', 'squid', 'mantis shrimp']

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

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp']

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

print sea_creatures

['shark', 'cuttlefish', 'squid', 'mantis shrimp']

ניתן לגשת לאיברים בודדים במערך על ידי שימוש במספר אינדקס, החל מ־0.

puts sea_creatures[0]  # כריש
puts sea_creatures[2] # דיוני עקרב

כדי להדפיס את הערך האחרון, ניתן להשתמש באינדקס -1. Ruby מספקת גם את השיטות .first ו־.last לקבלת הערך הראשון והאחרון, בהתאמה:

puts sea_creatures.first # כריש
puts sea_creatures.last # שפנינית

מערכים ב־Ruby יכולים להכיל מגוון של סוגי נתונים. ניתן לאחסן מחרוזות, סמלים, ואפילו מערכים אחרים במערך:

record = [
:en,
"Sammy",
42,
[
"coral",
"reef"
]
]

מערכים ב־Ruby הם נשנים, מה שאומר שניתן להוסיף ערכים, להסיר ערכים, ואף לשנות ערכים במערך:

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

סמלים

A symbol is a special data type that acts like a label or an identifier in a Ruby program. Symbols are immutable, which means that they cannot be changed. A symbol looks like a variable declaration without a value. Here’s an example of a symbol:

:time_zone

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

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

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

אשכולות

A hash is a dictionary-like collection of keys and values. These key-value pairs provide a useful way to store and access data. Hashes are often used to hold data that are related, such as the information about a user. You define a hash like this:

{"first_name" => "Sammy", "last_name" => "Shark"}

אתה יכול להקצות אשכולות למשתנים כמו סוגי נתונים אחרים:

user = {"first_name" => "Sammy", "last_name" => "Shark"}

כדי לקבל ערכים מתוך המפתח user, אתה משתמש במפתח עבור הערך:

print user["first_name"] # "Sammy"
print user["last_name"] # "Shark"

אפשר להשתמש בסמלים כמפתחות במפתח שלך במקום מחרוזות:

user = {:first_name => "Sammy", :last_name => "Shark"}

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

כאשר אתה משתמש בסמלים כמפתחות, אתה משתמש בסמלים גם לקבלת הערכים:

print user[:first_name] # "Sammy"
print user[:last_name] # "Shark"

שומר על התרגום:

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

user = {first_name: "Sammy", last_name: "Shark"}

התחביר הזה דומה לתחביר המשמש ב-JavaScript ובשפות אחרות. תחביר זה מגדיר את המפתחות כסמלים, כך שתוכל לגשת לרשומות באמצעות
:first_name
ולא באמצעות המחרוזות
"first_name"
ולא
"last_name".

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

סוג דינמי

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

המשתנה
t
בדוגמה הבאה יכול להיות מוקצה לכל סוג נתונים שזמינים:

t = 42 # t is an Integer
t = "Sammy" # t is a String
t = :sammy # t is a Symbol
t = true # t is a boolean (true)
t # t is nil

עם שפות דינמיות, תוכל לש reuse משתנה קיים כדי להכיל סוגי נתונים שונים.

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

print "Please enter the length of the room: "
length = gets.chop

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

# המרת הכמות ל-Floating Point.
length = length.to_f

השיטה to_f ממירה את המחרוזת ל-mשבר. בנוסף, Ruby מספקת גם את השיטה to_i להמרת מחרוזות למספרים שלמים, ורוב האובייקטים יכולים להימר למחרוזת באמצעות השיטה to_s:

42.to_s # "42"
(42.5).to_s # "42.5"
["Sammy", "Shark"].to_s # "[\"Sammy\", \"Shark\"]"

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

print 5 + "5"

Output
TypeError: String can't be coerced into Integer

כמו גם קטע קוד זה:

print "5" + 5

Output
TypeError: no implicit conversion of Integer into String

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

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

זיהוי סוגי נתונים

ב-Ruby, כמעט כל דבר הוא אובייקט. Integer, float, array, symbol ו-hash הם כלם אובייקטים ב-Ruby, ולכולם יש שיטה בשם class שתגיד לך איזה סוג הם. גם ה-booleans true ו-false, והערך nil הם אובייקטים. נסה זאת לבד:

42.class # Integer
(42.2).class # Float
["Sammy", "Shark"].class # Array
true.class # TrueClass
nil.class # NilClass

בנוסף, אפשר להשתמש בשיטה שנקראת kind_of? כדי לוודא סוג מסוים של נתונים, כמו כן:

42.kind_of?(Integer) # true

זה מאוד שימושי כשיש לך משתנה ואתה רוצה לקבוע את סוגו:

# בקטע קוד...
sharks = ["Hammerhead", "Tiger", "Great White"]
...
# במקום אחר...

sharks.kind_of?(Hash) # false
sharks.kind_of?(Array) # true

אפשר גם להשתמש בזה כדי לוודא שנתונים שבאים ממקור חיצוני הם נכונים:

if data.kind_of? String
data = data.to_f
end

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

if data.is_a? String
data = data.to_f
end

בשימוש class, kind_of?, ו־is_a? יכולים לעזור לך לוודא שאתה עובד עם סוג הנתונים הנכון. כשתלמד עוד על רובי, תגלה דרכים נוספות להתמודד עם נתונים שאינם כוללים בדיקת סוג הנתונים באופן מפורש.

מסקנה

תשתמש במגוון רחב של סוגי נתונים בתוכניות ה־Ruby שלך. עכשיו יש לך הבנה טובה יותר של סוגי הנתונים העיקריים הזמינים בתוכניות ה־Ruby.

תסתכל על המדריכים הללו כדי להמשיך את החקירה שלך בסוגי הנתונים של רובי:

• איך לעבוד עם מחרוזות ב־Ruby
• איך לעבוד עם מערכים ב־Ruby
• איך להמיר סוגי נתונים ב־Ruby