כיצד לעבוד עם מערכים ברובי

הקדמה

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

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

יצירת מערך

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

shark1 = "Hammerhead"
shark2 = "Great White"
shark3 = "Tiger"

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

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

sharks = ["Hammerhead", "Great White", "Tiger"]

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

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

print sharks

Output
["Hammerhead", "Great White", "Tiger"]

אם ברצונך ליצור מערך שבו כל ערך הוא מילה יחידה, ניתן להשתמש בתחביר %w{}, שיוצר מערך של מילים:

days = %w{Monday Tuesday Wednesday Thursday Friday Saturday Sunday}

זה שקול ליצירת המערך עם סוגריים מרובעים:

days =  ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]

אך שים לב ששיטת %w{} מאפשרת לך לדלג על גבי הציונים והפסיקים.

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

record = [
    "Sammy",
    null,
    7,
    [
        "another",
        "array",
    ]
]

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

גישה לפריטים במערכים

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

sharks = ["Hammerhead", "Great White", "Tiger"]

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

האיבר הראשון במערך הוא Hammerhead, שמאושר באינדקס 0. האיבר האחרון הוא Tiger, שמאושר באינדקס 2. המנייה מתחילה ב- 0 באינדקסים, מה שהולך נגד התחושה הטבעית להתחיל לספור מ-1, אז כדאי לשמור על זה בראש עד שזה יהיה טבעי.

אתה יכול לגלות כמה איברים יש במערך עם השיטה length:

sharks.length

Output
3

למרות שהאינדקסים של sharks מתחילים ב- 0 ונמשכים עד 2, נכס ה- length מחזיר את מספר האיברים במערך, שהוא 3. הוא לא מתעניין באינדקסים בכלל.

אם תרצה לגלות את מספר האינדקס של איבר ספציפי במערך, כמו Tiger, תשתמש בשיטת ה- index():

print sharks.index("Tiger")

Output
2

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

print sharks.index("Whale")

Output
nil

כדי לקבל את האיבר האחרון של מערך ב־Ruby, יש להשתמש באינדקס `-1`:

print sharks[-1]

Output
"Tiger"

רובי מספקת גם את השיטות first ו־last לקבלת האיברים הראשונים והאחרונים בלי להשתמש באינדקסים:

puts sharks.first
puts sharks.last

Output
"Hammerhead"
"Tiger"

ניסיון לגשת לאינדקס שלא קיים יחזיר `nil`:

sharks[10]

Output
nil

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

nested_array = [
    [
        "salmon",
        "halibut",
    ],
    [
        "coral",
        "reef",
    ]
]

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

print nested_array[1][0];

Output
coral

בדוגמה זו, גישת למערך בעמדה 1 של משתנה nested_array, המחזירה את המערך ["coral", "reef"]. לאחר מכן, גישת לאיברים בעמדה 0 של המערך הזה, שהיה "coral".

עכשיו נסתכל על איך להוסיף איברים למערך.

הוספת איברים למערך

יש לך שלושה איברים במערך sharks שלך, שמסומנים מ־0 עד 2:

sharks = ["Hammerhead", "Great White", "Tiger"]

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

sharks[3] = "Whale";

print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale"]

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

sharks[5] = "Sand";

print sharks;

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Sand"]

ניסיון לגשת לאלמנט הנוסף במערך יחזיר את ערכו, שיהיה nil:

sharks[4]

Output
nil

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

sharks.push("Thresher")
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher"]

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

sharks << "Bullhead"

Output
["Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

כדי להוסיף אלמנט להתחלת המערך, השתמשו בשיטת unshift():

sharks.unshift("Angel")
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", nil, "Whale", "Thresher", "Bullhead"]

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

הסרת אלמנטים ממערכים

כדי להסיר אלמנט ספציפי ממערך, השתמש בשיטות delete או delete_at. במערך sharks שיצרתם אלמנט מערך nil קודם. עכשיו תימחקו אותו.

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

print sharks.index(nil)

Output
4

לאחר מכן, השתמשו ב-delete_at כדי להסיר את האלמנט באינדקס 4 ולהדפיס את המערך:

sharks.delete_at(4)
print sharks

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Whale", "Thresher", "Bullhead"]

השיטה delete מסירה אלמנטים ממערך שתואמים את הערך שאתה מעביר. השתמש בה כדי להסיר את Whale מהמערך:

sharks.delete("Whale")
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher", "Bullhead"]

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

השיטה pop תסיר את האלמנט האחרון במערך:

sharks.pop
print sharks;

Output
["Angel", "Hammerhead", "Great White", "Tiger", "Thresher"]

Bullhead הוסר כאלמנט האחרון של המערך. כדי להסיר את האלמנט הראשון של המערך, השתמש בשיטה shift:

sharks.shift
print sharks

Output
["Hammerhead", "Great White", "Tiger", "Thresher"]

הפעם, Angel הוסר מההתחלה של המערך.

על ידי שימוש ב־pop ו־shift, אתה יכול להסיר אלמנטים מההתחלה ומהסוף של מערכים. שימוש ב־pop מומלץ בכל מקום שזה אפשרי, מאחר ששאר הפריטים במערך שומרים על מספרי האינדקסים המקוריים שלהם.

השיטות delete_at, pop, ו־shift משנות את המערך המקורי ומחזירות את האלמנט שנמחק::

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
deleted_at_element = sharks.delete_at(1)
popped_element = sharks.pop

puts "Deleted_at element: #{deleted_at_element}"
puts "Popped element: #{popped_element}"

puts "Remaining array: #{sharks}"

Output
Deleted_at element: Great White
Popped element: Whale
Remaining array: ["Hammerhead", "Tiger"]

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

שינוי אלמנטים קיימים במערכים

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

נתון מערך חדש של צוללות, עם "פטיש ראש" באינדקס 0, תחליפו את "פטיש ראש" ב- "מלאך":

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks[0] = "Angel"
print sharks;

Output
["Angel", "Great White", "Tiger", "Whale"]

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

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

עובר על מערכים

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

רובי מספקת את התחביר for..in:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
for shark in sharks do
  puts shark
end

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

לא תראה for..in בהרבה מקרים. מערכי רובי הם אובייקטים, והם מספקים את השיטה each לעבוד עם אלמנטים. שיטת each פועלת באופן דומה ל-for..in, אך יש לה תחביר שונה:

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each do |shark|
  puts shark
end

השיטה each משתמשת בתחביר שתראה הרבה בתכנות ב־Ruby. היא מקבלת בתור ארגומנט בלוק של Ruby. בלוק הוא קטע קוד שישופץ מאוחר יותר בהקשר של השיטה. במקרה זה, הקוד הוא puts shark. המילה המפתח shark, העטופה בתווים של צינור (|), היא המשתנה המקומי שמייצג את האלמנט במערך אליו הבלוק יגיע. Ruby משייכת את האלמנט למשתנה זה ומבצעת את הקוד בבלוק. שיטת each מחזירה את התהליך הזה עבור כל אלמנט במערך:

Output
Hammerhead
Great White
Tiger
Whale

כאשר הבלוק הוא שורה בודדת, לרוב אתה רואה מפתחי Ruby מחליפים את המילים do ו־end עם סוגריים מסולסלים וצמצום ההצהרה כולה לשורה בודדת:

...
sharks.each {|shark| puts shark }

זה יוצר את אותם תוצאות אבל משתמש בפחות שורות קוד.

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

sharks = ["Hammerhead", "Great White", "Tiger", "Whale"]
sharks.each_with_index do |shark, index|
  puts "The index is #{index}"
  puts "The value is #{shark}"
end

עבור כל אלמנט במערך, Ruby משייכת את האלמנט למשתנה shark, ומשייכת את האינדקס הנוכחי למשתנה index. אתה יכול להתייחס לשני המשתנים הללו בבלוק.

Output
The index is 0
The value is Hammerhead
The index is 1
The value is Great White
The index is 2
The value is Tiger
The index is 3
The value is Whale

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

סיכום

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

למד עוד על סוגי נתונים אחרים ב־Ruby על ידי קריאה במדריך הבנת סוגי נתונים ב־Ruby.