streamalism.org

1. סקירה כללית

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

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

2. שיפור מיתר

זה כנראה טוב להתחיל בהצהרה שמכיוון ש- Groovy מבוסס על Java, יש בו את כל Java חוּט יכולות כמו שרשור, ממשק ה- API של המחרוזת והיתרונות הטבועים במאגר המתמיד של מחרוזת בגלל זה.

בואו נראה תחילה כיצד גרובי מרחיב כמה מהיסודות הללו.

2.1. שרשור מיתרים

שרשור מיתרים הוא רק שילוב של שני מיתרים:

def first = 'first' def second = "second" def concatenation = first + second assertEquals ('firstsecond', שרשור)

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

2.2. אינטרפולציה מיתרים

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

def name = "Kacper" def result = "שלום $ {name}!" assertEquals ("Hello Kacper!", result.toString ())

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

2.3. GString

אבל מוסתר בדוגמה זו קמטוט קטן - למה אנחנו מתקשרים toString ()?

בעצם, תוֹצָאָה לא מהסוג חוּט, גם אם זה נראה ככה.

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

במילים פשוטות, אם עשינו:

assertEquals ("שלום קספר!", תוצאה)

זה קורא assertEquals (Object, Object), ואנחנו מקבלים:

java.lang.AssertionError: צפוי: java.lang.String אבל היה: org.codehaus.groovy.runtime.GStringImpl צפוי: java.lang.String בפועל: org.codehaus.groovy.runtime.GStringImpl

3. מחרוזת עם ציטוט יחיד

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

def לדוגמא = 'שלום עולם'

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

במקום:

def hardToRead = "קספר אוהב \" שר הטבעות \ ""

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

def easyToRead = 'קספר אוהב את' שר הטבעות ''

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

4. מחרוזת משולשת עם ציטוט יחיד

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

לדוגמא, נניח שיש לנו כאלה ג'סון לייצג כמחרוזת:

{"name": "John", "age": 20, "birthDate": null}

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

במקום זאת, בואו נשתמש במחרוזת משולשת עם ציטוט יחיד:

def jsonContent = '' '{"name": "John", "age": 20, "birthDate": null}' ''

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

יש עדיין אתגר אחד שעליו להתגבר.

בדרך כלל לקריאות קוד אנו מכניסים את הקוד שלנו:

def triple = "" קו ראשון בשורה ראשונה ""

אבל מחרוזות משולשות של ציטוט יחיד משמרות את החלל הלבן. משמעות הדבר היא שהמחרוזת הנ"ל היא באמת:

(קו חדש) קו ראשון (קו חדש) שורה שניה (קו חדש)

לֹא:

כמו שאולי התכוונו.

הישאר מכוון לראות כיצד אנו נפטרים מהם.

4.1. דמות Newline

בואו נאשר זאת המחרוזת הקודמת שלנו מתחילה בתו חדש:

assertTrue (triple.startsWith ("\ n"))

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

def triple = '' \ קו ראשון בשורה ראשונה '' '

עכשיו, לפחות יש לנו:

בעיה אחת למטה, עוד אחת ללכת.

4.2. הפשיט את כניסת הקוד

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

ממשק ה- API של Groovy String נחלץ להצלה!

כדי להסיר רווחים מובילים בכל שורה במחרוזת שלנו, אנו יכולים להשתמש באחת משיטות ברירת המחדל של Groovy, מחרוזת # stripIndent ():

def triple = '' '\ קו ראשון בשורה השנייה' ''. stripIndent () assertEquals ("שורה ראשונה \ n שניה שורה", משולש)

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

4.3. הזחה יחסית

עלינו לזכור זאת stripIndent לא נקרא stripWhitespace.

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

אז בואו נשנה את הכניסה לא מעט בשבילנו לְשַׁלֵשׁ מִשְׁתַנֶה:

class TripleSingleQuotedString {@Test void 'triple single citation with multiline string with line last with only whitespaces' () {def triple = '' \ firstline line \ '' '.stripIndent () // ... use triple}}

הַדפָּסָה לְשַׁלֵשׁ היה מראה לנו:

שורה ראשונה שורה שנייה

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

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

4.4. רצועה עם stripMargin ()

לקבלת שליטה רבה יותר, אנו יכולים לומר ל- Groovy היכן להתחיל את הקו באמצעות המקש | ו stripMargin:

def triple = '' \ | קו ראשון | קו שני ''. stripMargin ()

אשר יציג:

שורה ראשונה שורה שנייה

הצינור קובע היכן קו המיתר הזה באמת מתחיל.

כמו כן, אנו יכולים להעביר א אופי אוֹ CharSequence כטיעון ל stripMargin עם אופי התיחום המותאם אישית שלנו.

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

4.5. בריחה מדמויות מיוחדות

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

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

לדוגמה:

def specialCharacters = "" שלום \ "ג'ון \". זוהי נטייה לאחור - \ \ n שורה שניה מתחילה כאן '' '

יביא ל:

שלום ג'ון'. זוהי נטייה לאחור - \ השורה השנייה מתחילה כאן

יש כמה שאנחנו צריכים לזכור, כלומר:

• \ t - טבלה
• \ n - שורה חדשה
• \ b - מקש לחזור אחורה
• \ r - החזרת כרכרה
• \\ - נטייה אחורית
• \ f - טופס הזנה
• \' - ציטוט יחיד

5. מחרוזת עם ציטוט כפול

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

5.1.GString והערכה עצלנית

אנו יכולים לשלב מחרוזת עם ציטוט כפול על ידי ביטויים סביב ${} או עם $ לביטויים מנוקדים.

הערכתה עצלהעם זאת - הוא לא יומר לא חוּט עד שהוא מועבר לשיטה הדורשת א חוּט:

def string = "example" def stringWithExpression = "example $ {2}" assertTrue (string string of String) assertTrue (stringWithExpression instance of GString) assertTrue (stringWithExpression.toString () instance of String)

5.2. מציין מיקום עם התייחסות למשתנה

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

def name = "John" def helloName = "שלום $ name!" assertEquals ("שלום ג'ון!", helloName.toString ())

5.2. מציין מיקום עם ביטוי

אבל, אנחנו יכולים גם לתת לזה ביטויים:

def result = "result is $ {2 * 2}" assertEquals ("result is 4", result.toString ())

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

5.3. מצייני מקום עם מפעיל הנקודות

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

def person = [name: 'John'] def myNameIs = "אני $ person.name, ואתה?" assertEquals ("אני ג'ון ואתה?", myNameIs.toString ())

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

אבל אם נקרא ישירות לשיטה, נצטרך להשתמש בה ${}בגלל הסוגריים:

def name = 'John' def result = "שם רישיות: $ {name.toUpperCase ()}". toString () assertEquals ("שם רישיות: JOHN", תוצאה)

5.4. hashCode ב GString ו חוּט

מיתרים אינטרפולציה הם בהחלט מתנה משמים בהשוואה לרגיל java.util. מיתר, אבל הם נבדלים בצורה חשובה.

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

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

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

def string = "2 + 2 is 4" def gstring = "2 + 2 is $ {4}" assertTrue (string.hashCode ()! = gstring.hashCode ())

לפיכך, לעולם אל לנו להשתמש GString כמפתח ב- מַפָּה!

6. מחרוזת משולשת עם ציטוט כפול

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

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

def name = "John" def multiLine = "" "אני $ name." זה ציטוט מתוך 'מלחמה ושלום' "" ""

שימו לב לכך לא היינו צריכים לברוח ממרכאות בודדות או כפולות!

7. מחרוזת סלאשי

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

דפוס def = "\ d {1,3} \ s \ w + \ s \ w + \\ w +"

ברור שזה בלגן.

כדי לעזור בזה, Groovy תומך ב- regex באופן מקורי באמצעות מחרוזות סלאשיות:

תבנית def = / \ d {3} \ s \ w + \ s \ w + \ w + / assertTrue ("3 עכברים עיוורים \ גברים". התאמות (תבנית))

מיתרים סלאשיים עשוי להיות אינטרפולציה ורב-קו:

def name = 'John' def example = / Dear ([A-Z] +), Love, $ name /

כמובן שעלינו לברוח מקושי קדימה:

דפוס def = /.*foobar.*\/hello.*/ 

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

// if ('' == //) {// println ("אני לא יכול לקמפל") //}

8. מחרוזת דולר סלאשי

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

נניח שיש לנו דפוס regex: [0-3]+/[0-3]+. זה מועמד טוב למחרוזת סלאשית של דולר מכיוון שבמחרוזת סלאשית נצטרך לכתוב: [0-3]+//[0-3]+.

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

אנחנו לא צריכים לברוח $ פנימה GString מציין מיקום.

לדוגמה:

def name = "John" def dollarSlashy = $ / שלום $ name !, אני יכול להראות לך סימן $ או סימן דולר נמלט: $$ שני החלקים עובדים: \ או /, אבל אנחנו עדיין יכולים לברוח ממנו: $ / יש לנו כדי להימלט ממתיחות פתיחה וסגירה: - $$$ / - $ / $$ / $ 

היה פלט:

שלום ג 'ון !, אני יכול להראות לך סימן $ או סימן דולר נמלט: $ שני החלקים עובדים: \ או /, אבל אנחנו עדיין יכולים לברוח ממנו: / עלינו לברוח ממתיחת פתיחה וסגירה: - $ / - / $

9. אופי

מי שמכיר את Java כבר תהה מה גרובי עשה עם תווים מכיוון שהוא משתמש במרכאות בודדות עבור מחרוזות.

בעצם, קִצבִּי אין אופי מפורש מילולי.

יש שלוש דרכים להכין קִצבִּי מחרוזת דמות ממשית:

• שימוש מפורש במילת המפתח 'char' בעת הכרזה על משתנה
• באמצעות אופרטור 'כמו'
• על ידי ליהוק ל"צ'אר "

בואו נסתכל על כולם:

char a = 'A' char b = 'B' כמו char char c = (char) 'C' assertTrue (a instance of Character) assertTrue (b instance of Character) assertTrue (c instance of Character)

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

10. סיכום

ברור שזה היה הרבה, אז בואו נסכם במהירות כמה נקודות מפתח:

• מחרוזות שנוצרו עם ציטוט יחיד (') אינן תומכות באינטרפולציה
• מחרוזות ציטוטים כפולות משולשות ומשולשות יכולות להיות מרובות שורות
• מחרוזות מרובות שורות מכילות תווים רווחים לבנים עקב הכנסת קוד
• קו נטוי (\) משמש כדי לברוח מתווים מיוחדים בכל סוג, למעט מחרוזת סלאש של דולר, שם עלינו להשתמש בדולר ($) כדי לברוח

11. מסקנה

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

ניתן למצוא את כל הקטעים האלה ב- Github.

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