מחרוזות ​

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

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

בתכנות (Strings – סטרינגז) מחרוזות הינן שורה של אותיות אחת אחר השנייה, מחרוזות מורכבות מהרבה "חרוזים" והם האותיות.

ציור של מחרוזת עם אותיות

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

אז מהן מחרוזות?

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

בקטע הקוד הערך 'hello world' שהינו ערך מחרוזת מוקצה למשתנה a.

let a = 'hello world';
console.log(a);

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

console.log("hello world");

אז מתי משתמשים בגרש ומתי בגרשיים? ​

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

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

console.log('hello wor'ld');

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

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

console.log("hello wor'ld");

את הסוג השלישי הנקרא "כתיבת תבנית" נכיר בסוף הפרק.

פעולות במחרוזות ​

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

console.log('hello' + 'world');

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

let a = 'hello' + 'world';
console.log(a);

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

let a = 'hello' + 'world';
console.log(a.length);

לשפת Java Script יש מתודות רבות תחת משתנים מטיפוס string נכיר את השימושיים מביניהם.

המתודה slice() ​

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

1. התחלה – מהיכן להתחיל את פעולת החיתוך
2. סוף – עד היכן יש לבצע את החיתוך

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

let a  = 'Hello World';
console.log( a.slice(4, 9)); 

הפלט יהיה

"o Wor”

כיוון שפעולת החיתוך תתחיל מהתו החמישי כיוון שמתחילים מהספרה 0 אז הספרה 4 מסמלת את האות החמישית.

המתודה replace() ​

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

let a  = 'Hello Hello Hello';
console.log( a.replace('Hello', 'Bye') );

נשים לב שהמתודה החליפה רק את ה-hello הראשון במקרה ונרצה להחליף את כל "המופעים" של המחרוזת נשתמש בפונקציה replaceAll()

המתודה replaceAll() ​

זהה לגמרי למתודה replace() חוץ מהבדל אחד. המתודה תחליף את כל הפעמים בהם מופיעה המחרוזת בחדשה.

let a  = 'Hello Hello Hello';
console.log( a.replaceAll('Hello', 'Bye') );

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

let a  = 'Hey Hello Hello Hello';
console.log( a.indexOf('Hello') );

במקרה כאן אנו מחפשים את המחרוזת Hello (ניתן גם לחפש תו אחד בלבד) והפלט הוא 4. גם כאן המספור מתחיל מ-0 כך שהתוצאה בעצם אומרת שהמחרוזת נמצאה בתו החמישי.

אם כן מה קורה כאשר המחרוזת היא התו הראשון? בכזה מקרה המתודה תחזיר 0.

let a  = 'Hey Hello Hello Hello';
console.log( a.indexOf('Hey') );

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

let a  = 'Hey Hello Hello Hello';
console.log( a.indexOf('Bey') );

המתודה lastIndexOf() ​

המתודה זהה למתודה indexOf רק שהערך שהיא מחזירה מייצג את מיקום המופע האחרון של המחרוזת.

let a  = 'Hey Hello Hello Hello';
console.log( a.lastIndexOf('Hello') );

התוצאה כאן תהיה 16 שהוא התו ה-17 במחרוזת.

המתודה includes() ​

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

let a  = 'Hey Hello Hello Hello';
console.log( a.includes('Hello') );
console.log( a.includes('Bello') );

הפלט יהיה

true
false

הערך true - אמת חזר נכון כיוון שהערך Hello אכן קיים בתוך המחרוזת. הערך false – שקר חזר כיוון שהערך Bello לא קיים במחרוזת.

המתודה startsWith() ​

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

let a  = 'Hey Hello Hello Hello';
console.log( a.startsWith('Hello') );

התשובה שתחזור תהיה false כיוון שהמשתנה a לא מתחיל עם הערך Hello.

המתודה endsWith() ​

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

let a  = 'Hey Hello Hello Hello';
console.log( a.endsWith('Hello') );

התשובה שתחזור תהיה true כיוון שהמשתנה a כן מסתיים עם הערך Hello.

חילוץ ​

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

console.log('hello wor'ld');

שפת Java Script מציעה כלי נוסף להתמודדות עם תווים כאלה וכמה אחרים ע"י שימוש ב-Escaping – חילוץ. כך את הקוד הקודם נכתוב בצורה הבאה

console.log('hello wor\'ld')

התו המיוחד לוכסן \ מסמל לשפת Java Script להתעלם מהתו הבא בצורתו הרגילה. כיוון שכך המחרוזת תחשב לשלמה.

במקרה ויש צורך לכתוב את סימן הלוכסן עצמו יש להשתמש בלוכסן כפול.

console.log('example: \\')

מחרוזת תבנית ​

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

הדרך המסורתית לחיבור מחרוזות הוא בעזרת אופרטור החיבור + בדרך הבאה:

let username  = 'Israel';
console.log( 'Welcome ' + username + ', Nice seeing you.');

שפת Java Script תדע להחליף את המשתנה username בשם המשתמש ולייצר את המחרוזת החדשה השלמה

"Welcome Israel, Nice seeing you."

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

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

let username  = `Israel`;
console.log( `Welcome ` + username + `, Nice seeing you.`);

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

let username  = 'Israel';
console.log( `Welcome ${username}, Nice seeing you.`);

הצבנו את המשתנה username בתוך הביטוי בצורה הבאה ${username} ונחסך הצורך להשתמש באופרטור הפלוס, לזכור לפתוח גרשיים ולסגור אותם. קלי קלות.

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

consloe.log('aefaef
            
            aefaefe');

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

consloe.log('aefaef\
           
            aefaefe');

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

consloe.log(`aefaef
           
            aefaefe`);

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