מחרוזות ב-R: paste, sprintf, gsub, substr ועוד

יצירת מחרוזות ב-R

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

name <- "Ada"
motto <- 'said "make it work" twice'
escaped <- "or escape \"quotes\" with a backslash"

cat(motto, "\n")
cat(escaped, "\n")

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

ועכשיו הטעות שכל מתחיל ב-R עושה בדיוק פעם אחת: לשאול מחרוזת מה האורך שלה עם length().

s <- "hello"
cat(nchar(s), "\n")
cat(length(s), "\n")

nchar() סופרת תווים: 5. length() סופרת איברים של וקטור, ומחרוזת בודדת היא וקטור של איבר אחד, ולכן היא אומרת 1. ב-R הכול וקטור, כולל טקסט, וכל הפונקציות בעמוד הזה עובדות בשקט איבר אחר איבר על וקטורים שלמים של תווים. זו תכונה, ברגע שמפסיקים להיות מופתעים ממנה.

חיבור מחרוזות: paste() ו-paste0()

אין ב-R + למחרוזות. חיבור נעשה עם paste(), שמחברת את הארגומנטים שלה עם רווח כברירת מחדל, ועם paste0(), שמחברת בלי כלום:

cat(paste("data", "science"), "\n")
cat(paste("data", "science", sep = "-"), "\n")
cat(paste0("file_", "2026"), "\n")

מכיוון ש-paste וקטורית, מתן וקטור לה בונה הרבה מחרוזות בבת אחת: כך מייצרים שמות קבצים, תוויות ומזהים בשורה אחת:

print(paste0("file_", 1:3))

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

words <- c("ready", "set", "go")
cat(paste(words, collapse = "... "), "\n")

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

עיצוב עם sprintf()

כשצריך מספרים מעוצבים בתוך טקסט, מספר קבוע של ספרות אחרי הנקודה, רוחב מרופד, paste() נגמרת ו-sprintf() נכנסת לתמונה. היא משתמשת בקודי עיצוב בסגנון C: %s למחרוזות, %d למספרים שלמים, %f לשברים עשרוניים:

cat(sprintf("%s scored %d points (%.1f%%)\n", "Rosa", 87, 92.5))
cat(sprintf("%.3f\n", pi))
cat(sprintf("invoice %05d\n", 42))

%.1f פירושו "ספרה אחת אחרי הנקודה", %.3f שלוש, ו-%05d מרפד לחמש ספרות עם אפסים. %% כפול מפיק סימן אחוז מילולי. גם sprintf() וקטורית, כך שהיא יכולה לעצב עמודה שלמה של ערכים בקריאה אחת. ראו קלט ופלט לדפוס הדיווח של sprintf() יחד עם cat().

שינוי אותיות וחיתוך: toupper(), tolower(), substr()

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

s <- "Programming in R"
cat(toupper(s), "\n")
cat(tolower(s), "\n")

tolower() מצדיקה את קיומה בנרמול של נתונים מבולגנים לפני השוואה: "Yes", "YES" ו-"yes" הופכים כולם לאותו ערך.

substr(x, start, stop) שולפת קטע לפי מיקום התו, בספירה מ-1 (ב-R האינדקסים מתחילים מ-1 בכל מקום):

s <- "Programming in R"
cat(substr(s, 1, 11), "\n")
cat(substr(s, 16, 16), "\n")

שתי נקודות הקצה כלולות: המיקומים 1 עד 11 נותנים "Programming".

חיפוש והחלפה: sub(), gsub() ו-grepl()

sub() מחליפה את המופע הראשון של תבנית; gsub() ("global substitute") מחליפה את כולם:

s <- "good code, good tests, good docs"
cat(sub("good", "great", s), "\n")
cat(gsub("good", "great", s), "\n")

פרט קריטי אחד: התבנית היא ביטוי רגולרי כברירת מחדל, לא טקסט מילולי. לתווי regex כמו ., *, ( ו-? יש משמעויות מיוחדות: . חשופה מתאימה לכל תו. כשמתכוונים לטקסט המילולי, העבירו fixed = TRUE:

cat(gsub(".", "-", "a.b.c", fixed = TRUE), "\n")
cat(gsub(".", "-", "a.b.c"), "\n")

השורה הראשונה נותנת a-b-c; השנייה נותנת -----, כי בתור regex ה-. התאימה לכל תו ותו. עד שלומדים regex, הפכו את fixed = TRUE לברירת המחדל שלכם ואף פעם לא תיפגעו.

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

files <- c("report.csv", "notes.txt", "data.csv")
print(grepl(".csv", files, fixed = TRUE))
print(files[grepl(".csv", files, fixed = TRUE)])

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

פיצול וקיצוץ: strsplit() ו-trimws()

strsplit() חותכת מחרוזת לחלקים לפי מפריד. המוזרות היחידה שלה: היא מחזירה רשימה, כי היא יכולה לפצל הרבה מחרוזות בבת אחת. למחרוזת בודדת, קחו את האיבר הראשון עם [[1]]:

parts <- strsplit("2026-08-07", "-")[[1]]
print(parts)
cat("year:", parts[1], "\n")

ו-trimws() מסירה את הרווחים שנתונים מהעולם האמיתי תמיד מגיעים עטופים בהם:

raw <- "   padded input   "
cat("[", trimws(raw), "]\n", sep = "")

כברירת מחדל היא מקצצת את שני הקצוות; which = "left" או "right" מקצצים צד אחד בלבד (השמות מתייחסים לתחילת המחרוזת ולסופה).

החלופה stringr

כל מה שלמעלה הוא R בסיסית: תמיד זמינה, בלי התקנה. החבילה stringr של ה-tidyverse עוטפת את אותן פעולות בשיטת שמות עקבית של str_*, כשהמחרוזת היא תמיד הארגומנט הראשון, ואנשים רבים מוצאים את זה קל יותר לזכירה (ראו חבילות להתקנה):

library(stringr)

str_detect(files, "csv")            # like grepl(), data first
str_replace_all(s, "good", "great") # like gsub(), arguments reordered
str_length("hello")                 # like nchar()

כדאי להכיר את פונקציות המחרוזות של R הבסיסית בכל מקרה: תפגשו אותן בכל סקריפט, בכל תשובה ב-Stack Overflow ובכל הודעת שגיאה שנכתבה אי פעם. למדו קודם את השמות הבסיסיים; עברו ל-stringr כשסדרי הארגומנטים הלא עקביים יתחילו להציק לכם.

מה לקחת מכאן

• מחרוזות משתמשות במירכאות כפולות לפי המוסכמה; nchar() סופרת תווים, length() סופרת איברים של וקטור.
• חברו עם paste() / paste0(); sep מדביק ארגומנטים, collapse מדביק וקטור למחרוזת אחת.
• sprintf() מטפלת בפלט מעוצב: %s, %d, %.2f.
• sub() מחליפה את ההתאמה הראשונה, gsub() את כל ההתאמות, grepl() בודקת התאמות: כולן regex כברירת מחדל, אז העבירו fixed = TRUE לטקסט מילולי.
• strsplit() מחזירה רשימה (קחו [[1]]); trimws() מנקה קלט מרופד.

הבא בתור: הכנסת טקסט לתוכניות שלכם והוצאתו מהן. הדפסה עם print() ו-cat(), וקריאת קלט מהמשתמש.