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

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

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

חבילת המיתרים

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

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

יְבוּא"מחרוזות"

מחפש מחרוזות משנה

ה מחרוזות החבילה מספקת שלוש פונקציות לחיפוש מחרוזות משנה: ה מכיל פונקציה, ה מכיל כל פונקציה, ואת מכילRune פוּנקצִיָה.

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

instagram viewer
מכילRune הפונקציה בודקת אם המחרוזת מכילה רונה (תו Unicode).

יְבוּא (
"fmt"
"מחרוזות"
)
funcרָאשִׁי() {
 aString := "שלום עולם!"
 מחרוזת משנה := "עוֹלָם"
 תווים := "איי"
 aRune := 'או'
 fmt. Println (מחרוזות. מכיל (aString, substring)) // פלט: נכון
 fmt. Println (מחרוזות. מכיל כל (aString, תווים)) // פלט: נכון
 fmt. Println (מחרוזות. ContainsRune (aString, aRune)) // פלט: נכון
}

אתה יכול לאחזר את האינדקס של מחרוזת משנה עם ה אינדקס, IndexAny, IndexByte, ו IndexFunc פונקציות. ה אינדקס הפונקציה מחזירה את האינדקס של מחרוזת משנה, אם היא מופיעה במחרוזת נתונה אחרת. ה IndexAny הפונקציה מחזירה את האינדקס של המופע הראשון של נקודת קוד Unicode אוֹ -1 אם אף אחת מהדמויות לא נוכחת.

יְבוּא (
"fmt"
"מחרוזות"
)
funcרָאשִׁי() {
 aString := "שלום עולם!"
 מחרוזת משנה := "עוֹלָם"
 תווים := "וורלד"
 byteCharacter := בייט('או')
 aRune := רונה('או')


 fmt. Println (מחרוזות. אינדקס (aString, substring)) // פלט: 7
 fmt. Println (מחרוזות. IndexAny (aString, תווים)) // פלט: 7
 fmt. Println (מחרוזות. IndexByte (aString, byteCharacter)) // פלט: 4
 f := func(ר רונה)bool {
לַחֲזוֹר r == 'או'
 }

 fmt. Println (מחרוזות. IndexFunc (aString, f)) // פלט: 4
 fmt. Println (מחרוזות. IndexRune (aString, aRune)) // פלט: 4
}

IndexByte מחזירה את האינדקס של המופע הראשון של תו ה-byte במחרוזת או -1. ה IndexFunc function מחזירה את האינדקס למחרוזת של נקודת Unicode הראשונה שעונה על פונקציה נתונה. סוף - סוף, ה IndexRune הפונקציה מחזירה את האינדקס של המופע הראשון של נקודת הקוד Unicode של הרונה.

החלפת מחרוזות משנה ב-Go

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

יְבוּא (
"fmt"
"מחרוזות"
)
funcרָאשִׁי() {
 theString := "זו מחרוזת בדיקה שיש לשנות."
 fmt. Println (מחרוזות. החלף (המחרוזת, "הוא", "היה", 1))
 fmt. Println (מחרוזות. החלף (המחרוזת, "הוא", "היה", -1))
 fmt. Println (מחרוזות. ReplaceAll (המחרוזת, "הוא", "היה"))
}

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

פיצול וחיבור מיתרים

ה מחרוזות החבילה מכילה את לְפַצֵל, SplitAfter, SplitAfterN, ו SplitN פונקציות לפיצול מחרוזות המחזירות פרוסה מהמחרוזות.

ה לְפַצֵל השיטה מתפצלת על ידי מפריד מוגדר. דומה ל לְפַצֵל שיטה, ה SplitAfter השיטה מפצלת את המחרוזת, אך היא כוללת את המפריד בתוצאות שלה.

יְבוּא (
"fmt"
"מחרוזות"
)
funcרָאשִׁי() {
 s := "זו מחרוזת בדיקה שיש לפצל."
 fmt. Println (מחרוזות. פיצול (ים, " "))
 fmt. Println (מחרוזות. SplitAfter (s, " "))
 fmt. Println (מחרוזות. SplitAfterN(s, " ", 3))
 fmt. Println (מחרוזות. SplitN(s, " ", 3))
}

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

אתה יכול לחבר מחרוזות עם לְהִצְטַרֵף פונקציה מה מחרוזות חֲבִילָה. ה לְהִצְטַרֵף הפונקציה תופסת פרוסה ומפריד.

יְבוּא (
"fmt"
"מחרוזות"
)
funcרָאשִׁי() {
 fmt. Println (מחרוזות. לְהִצְטַרֵף([]חוּט{"שלום", "עוֹלָם"}, ":"))
// פלט: "שלום: עולם"
}

מארז מיתר מניפולציה

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

יְבוּא (
"fmt"
"מחרוזות"
)
funcרָאשִׁי() {
 s := "זו מחרוזת בדיקה."
 fmt. Println (מחרוזות. למטה (ים) // זו מחרוזת בדיקה.
 fmt. Println (מחרוזות. למעלה (ים) // זהו מחרוזת בדיקה.
 fmt. Println (מחרוזות. כותרת (ים) // זהו מחרוזת בדיקה.
}

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

בוני מחרוזות הם סוג המאפשר שרשור יעיל ב-Go. ה בתים. בַּלָם type הוא אחד מבוני המיתרים הנפוצים. ה בתים. בַּלָם השיטה מיישמת מאגר ניתן לגידול של בתים עם שיטות קריאה וכתיבה לפעולות, ומאפשרת הוספה יעילה של מחרוזת ללא צורך ביצירת עותקים חדשים, בניגוד ל- + המבצע וה לְהִצְטַרֵף פוּנקצִיָה.

יְבוּא (
"fmt"
"מחרוזות"
)
funcרָאשִׁי() {
var מחרוזות b. בּוֹנֶה


// כתוב כמה מחרוזות לבנאי
 ב. WriteString("זה")
 ב. WriteString("הוא")
 ב. WriteString("א")
 ב. WriteString("מבחן")
 ב. WriteString("חוּט.")


// קבלו את אורך הבנאי
 fmt. Println (ב. לן())


// המר את הבונה למחרוזת
 str := ב. חוּט()
 fmt. Println (str)


// אפס את הבנאי
 ב. אִתחוּל()


// כתוב עוד כמה מחרוזות לבונה
 ב. WriteString("זה")
 ב. WriteString("הוא")
 ב. WriteString("אחר")
 ב. WriteString("מבחן")
 ב. WriteString("חוּט.")


// קבלו את הקיבולת של הבנאי
 fmt. Println (ב. כובע())
// המר שוב את ה-Builder למחרוזת
 str = b. חוּט()
 fmt. Println (str)
}

ה רָאשִׁי הפונקציה מדגימה כיצד ניתן להשתמש ב- מחרוזות. בּוֹנֶה סוג לבניית מיתר יעיל. ה WriteString שיטת ה מחרוזות. בּוֹנֶה type מרחיב את רצף המחרוזות זה לזה, וה- לן השיטה מחזירה את אורך המחרוזת הבנויה.

ה חוּט השיטה ממירה את התוכן של הבונה למחרוזת, וה- אִתחוּל השיטה מאפסת את הבונה לבניית מחרוזת נוספת.

ה כובע השיטה מחזירה את הקיבולת של הבונה. זהו השטח הנוכחי ש-Go הקצתה למחרוזת.

כריתת מיתרים ב-Go

ה מחרוזות החבילה מספקת גם פונקציונליות לחיזור מיתרים ב- מְטוּפָּח, TrimLeft, TrimPrefix, TrimRight, TrimSpace, ו TrimSuffix פונקציות.

יְבוּא (
"מחרוזות"
"fmt"
)
funcרָאשִׁי() {
// המחרוזת המלאה
 s := "שלום עולם!"


// האלמנט עבור החיתוך
 קידומת := "שלום"
 סיומת := "עוֹלָם!"


// חותך מחרוזת לפי ערכת חיתוך שצוינה
 fmt. Println (מחרוזות. לחתוך (ים, "!"))


// חותך על ידי רווחים בתחילת המחרוזת ובסוף
 fmt. Println (מחרוזות. TrimSpace (ים)


// חותך מהמחרוזת השמאלית על ידי ערכת חיתוך שצוינה
 fmt. Println (מחרוזות. TrimLeft (s, "שלום"))


// חותך מהמחרוזת הימנית על ידי ערכת חיתוך שצוינה
 fmt. Println (מחרוזות. TrimRight (s, "עוֹלָם!"))


// חותך קידומת
 fmt. Println (מחרוזות. TrimPrefix (s, קידומת))
// חותך סיומת ספציפית
 fmt. Println (מחרוזות. TrimSuffix (s, סיומת))
}

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

אתה יכול לעצב מחרוזות ב-Go

ספריית התקן Go מספקת גם את חבילת fmt לעיצוב מחרוזת. חבילת fmt משתמשת בפעלי עיצוב בסגנון C לעיצוב מחרוזת יעיל ב-Go.