איך לעבוד עם מחרוזות ב־Ruby

הקדמה

A string is a sequence of one or more characters that may consist of letters, numbers, or symbols.

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

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

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

יצירת והדפסת מחרוזות

מחרוזות קיימות בתוך גרשיים יחידים ' או גרשיים כפולים " ב-Ruby, כך שכדי ליצור מחרוזת, יש להקיף רצף של תווים באחד מהם:

'This is a string in single quotes.'

"This is a string in double quotes."

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

כדי להציג מחרוזת בתוכנית שלך, תוכל להשתמש בשיטת print:

print "Let's print out this string."

שיטת print מציגה את המחרוזת כפי שכתובה.

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

print 'This is the first string.'
print 'This is the second string.'
print 'This is the third string.'

שמור את הקובץ והרץ את התוכנית:

ruby print.rb

תראה את הפלט הבא:

Output
This is the first string.This is the second string.This is the third string.

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

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

puts 'This is the first string.'
puts 'This is the second string.'
puts 'This is the third string.'

הרץ את התוכנית שוב, ותראה את הפלט הבא:

Output
This is the first string.
This is the second string.
This is the third string.

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

שמירת מחרוזות במשתנים

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

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

my_string = 'This is my string'

לאחר מכן, כדי לאחזר את הערך, עליך להשתמש בשם המשתנה:

print my_string

כדי לבדוק זאת בעצמך, צור את הקובץ string_variables.rb בעורך שלך באמצעות הפקודה הבאה:

nano string_variables.rb

ואז הוסף את הקוד הבא:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts my_name
puts my_age

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

שמור את הקובץ בעזרת CTRL + X ואז y, ואז הרץ את התוכנית:

ruby string_variables.rb

תראה את הפלט הבא:

Output
Sammy the Shark
none of your business

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

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

שרשור מחרוזות

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

הנה דוגמה כיצד תבצעו שילוב של המחרוזות sammy ו־shark יחד:

"sammy" + "shark"

זה ייצור את הפלט הבא:

Output
sammyshark

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

"sammy " + "shark"

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

הנה דוגמה:

color = "Blue"
print "My favorite color is " + color

זה יצור את הפלט My favorite color is blue. שימו לב שהשארנו רווח אחרי המילה is במחרוזת כך שהפלט יכיל רווח בין המחרוזת לערך המשתנה בפלט.

באפשרותכם לשלב מספר מחרוזות יחד בדרך זו. צרו את הקובץ concatenation.rb והוסיפו את הקוד הבא:

my_name = "Sammy the Shark"
my_age = "none of your business"

puts "My name is " + my_name + " and my age is " + my_age + "."

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

בעת הפעלת התוכנית, תקבלו את הפלט הבא:

Output
My name is Sammy the Shark and my age is none of your business.

בתוך תוכנית זו, השתמשת בחיבור כדי להכניס משתנים למחרוזת זו.

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

my_name = "Sammy the Shark"
my_age = "none of your business"

# הקצאת מחרוזת מחוברת למשתנה
output = "My name is " + my_name + " and my age is " + my_age + "."

# הדפסת הפלט.
puts output

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

ודא שלא תשתמש באופרטור + בין שני סוגי נתונים שונים. לא ניתן לחבר מחרוזות ומספרים שלמים יחד, לדוגמה.

כדי לראות מה יקרה, צור תוכנית חדשה בשם strings_and_integers.rb עם התוכן הבא:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number

הפעם יש לנו את my_name שמחזיקה את המחרוזת Sammy the Shark ואת my_number שמחזיקה את המספר השלם 27. אנו יודעים ש- 27 אינו מחרוזת מכיוון שאין לו גרשיים מסביב. גם אין לו נקודה עשרונית, אז אנו יודעים שזהו מספר שלם.

אם תפעיל את התוכנית:

ruby strings_and_ints.rb

תראה את הודעת השגיאה הזו:

Output
strings_and_ints.rb:4:in `+': no implicit conversion of Integer into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

השגיאה no implicit conversion of Integer into String אומרת שברובי אפשר לאחד מחרוזת רק למחרוזת הקיימת.

strings_and_ints.rb:4:in `+': no implicit conversion of Fixnum into String (TypeError)
from strings_and_ints.rb:4:in `<main>'

אפשר לשנות את התוכנית שלנו ולהניח את המספר 27 בתוך מרכאות ("27") כך שהוא ייכתב כמחרוזת במקום כמספר שלם. או שנוכל להמיר את המספר למחרוזת כאשר אנו יוצרים את המחרוזת, כך:

my_name = "Sammy the Shark"
my_number = 27

print my_name + my_number.to_s

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

הרץ את התוכנית שוב ותראה Sammy the Shark27 מודפס למסך.

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

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

שימוש באינטרפולציה של מחרוזת

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

במקום לכתוב את זה:

"My name is " + my_name + "!"

אתה יכול לעשות את זה:

"My name is #{my_name}!"

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

נסה זאת. צור תוכנית חדשה בשם interpolation.rb והוסף את הקוד הבא:

my_name = "Sammy the Shark"
my_age = "none of your business"

output = "My name is #{my_name} and my age is #{my_age}."

puts output

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

אינטרפולציה של מחרוזת יש לה יתרון נוסף: היא יכולה להמיר ערכים מספריים למחרוזות באופן אוטומטי. זכור לתוכנית strings_and_integers.rb שלך? פתח שוב את הקובץ הזה בעורך שלך, אך שנה את השורה האחרונה כך שהיא נראית כמו הבאה:

my_name = "Sammy the Shark"
my_number = 27

# השתמש באינטרפולציה במקום בקיטוב
print "My name is #{my_name} and my favorite number is #{my_number}."

רובי ימיר באופן אוטומטי את my_number למחרוזת, והתוכנית שלך תדפיס את הפלט הבא כאשר תריץ אותה:

Output
My name is Sammy the Shark and my favorite number is 27.

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

מחרוזות מילוליות וערכי מחרוזת

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

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

זו מחרוזת מילולית:

"Sammy the Shark"

ערך המחרוזת יהיה Sammy the Shark.

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

התפלגות ציטוטים ומרכאות במחרוזות

כתובתך:

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

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

'This isn't what I wanted.'

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

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

"Sammy says, "Hello!""

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

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

אפשרות 1: השתמש בתחביר החלופי למחרוזות

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

במקום להגדיר את המחרוזת הזו עם גרש יחיד:

'This isn't what I wanted.'

הגדר אותה עם גרש כפול:

"This isn't what I wanted."

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

"Sammy says, "Hello!""

השתמש בגרש יחיד:

'Sammy says, "Hello!"'

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

"Sammy says, "I'm a happy shark!""

בדוגמה זו, הגרש הכפול הסוגר מזין את המחרוזת הראשונה, ולאחר מכן Ruby פוגשת באפוסטרופ ב- I'm, שמתחיל מחרוזת חדשה עם הערך m a happy shark!"". אך למחרוזת החדשה אין גרש יחיד תואם לסיוםה. ושימוש בגרש יחיד לסגור את המחרוזת מציג בעיה דומה:

'Sammy says, "I'm a happy shark!"'

הפעם האפוסטרופ ב- I'm מסיים את המחרוזת.

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

אפשרות 2: לברוח מתווים במחרוזות

התו השורה אחורית (\), המכונה לעיתים "תו בריח" במחרוזות, ימנע מ-Ruby לפרש את התו הבא במחרוזת ללא הפרשה.

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

"Sammy says, "I'm a happy shark!""

יש ליצור תוכנית Ruby חדשה בשם quoting.rb ולהוסיף את הקוד הבא לקובץ:

print "Sammy says, "I'm a happy shark!""

להפעיל את התוכנית:

ruby quoting.rb

ותקבלו את הפלט הבא:

Output
quoting.rb:1: syntax error, unexpected tCONSTANT, expecting end-of-input
print "Sammy says, "I'm a happy shark!""
^

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

print "Sammy says, \"I'm a happy shark!\""

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

Sammy says, "I'm a happy shark!"

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

ניתן להימנע מבריחת הגרשיים לחלוטין על ידי שימוש בתחביר שונה להגדרת מחרוזות.

אפשרות 3: שימוש בתחביר חלופי עבור מחרוזות

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

%$Sammy says, "I'm a happy shark!"$

תחביר זה יברח את המחרוזות המוטמעות באופן אוטומטי עבורך. המחרוזת הממשית נראית כך:

"Sammy says, \"I'm a happy shark!\""

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

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

%{Sammy says, "I'm a happy shark!"}

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

droplets = 5
print %{Sammy says, "I just created #{droplets} droplets!"}

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

droplets = 5
print %Q{Sammy says, "I just created #{droplets} droplets!"}

תחביר ה-%q{} פועל בדיוק כמו מחרוזות עם ציון יחיד:

%q{Sammy says, "I'm a happy shark!"}

תוכל לראות את תחבירי ה-%q וה-%Q בשימוש עם סוגריים או סוגריים מרובעים בכמה תכניות במקום של סוגריים מסולסלים.

כפי שתוכל לראות, יש המון דרכים ליצירת מחרוזות ב-Ruby. תבחר בשיטה אחת והשאר עם ההתאם. תגלה שתחבירי ה-%Q{} וה-%{} הם הנפוצים ביותר.

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

מחרוזות ארוכות ותווים חדשים

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

output = "This is\na string\nwith newlines"
puts output

תוכנית זו תייצר את הפלט הבא:

Output
This is
a string
with newlines

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

ראשית, ניתן להשתמש באופרטור הקיטוב (`.`) כדי לפצל את המחרוזת למספר שורות:

output = "This is a\n" +
"longer string\n" +
"with newlines."
puts output

זה פשוט מפצל שלושה מחרוזות יחד, דומה למה שכבר עשית.

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

output = "This is a
longer string
with newlines"
puts output

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

output = %{This is a
longer string
with newlines}
puts output

בשני הדוגמאות הללו, שים לב שאנו לא צריכים את התווים לירידה (`\n`). השיטה הזו שומרת על רווחי לבן, כולל כניסה ושורות חדשות.

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

Output
This is a
longer string
with newlines

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

output = %{This is a
longer string
with newlines
}

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

output = <<-END
This is a
longer string
with newlines
END

הסימנים <<-END ו־END מציינים את תחילת וסיום המסמך.

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

output = <<-END
This is a
longer string
with newlines
END

ידפיס עם שתי רווחים של הזחה.

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

output = <<~END
This is a
longer string
with newlines
and the code is indented
but the output is not.
END

זה יוצר את הפלט הבא:

Output
This is a
longer string
with newlines
and the code is indented
but the output is not.

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

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

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

שיכפול מחרוזת

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

להדפיס את Sammy תשע פעמים, יש להשתמש בקוד הבא:

print "Sammy" * 9

קוד זה יוצר את הפלט הבא:

Output
SammySammySammySammySammySammySammySammySammy

ניתן להשתמש בזה כדי ליצור אמנות ASCII יפהה. יש ליצור קובץ בשם banner.rb ולהוסיף את הקוד הבא:

puts "=" * 15
puts "| Hello World |"
puts "=" * 15

האם תוכל לתמונת איך התוכנית תייצר לפני הרצתה?

הפלט הוא:

Output
===============
| Hello World |
===============

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

מסקנה

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