streamalism.org

1. הקדמה

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

במדריך זה נראה כיצד להשתמש בתכונת התצוגה המקדימה של JDK 13/14 של גושי טקסט.

2. שימוש

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

דוגמה למחרוזת = "" "טקסט לדוגמה" "";

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

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

בתוצאה חוּט, הכניסה (הבסיס) והקו החדש הראשון אינם כלולים. אנו נסתכל על מסירת הכניסה בחלק הבא.

3. הזחה

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

שקול בלוק טקסט המכיל קצת HTML:

מחרוזת ציבורית getBlockOfHtml () {return "" "טקסט לדוגמה" ""; }

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

@Test בטל שניתןAnOldStyleMultilineString_whenComparing_thenEqualsTextBlock () {מחרוזת צפויה = "\ n" + "\ n" + "\ n" + "טקסט לדוגמא \ n" + "\ n" + ""; assertThat (subject.getBlockOfHtml ()). isEqualTo (צפוי); } @Test בטל givenAnOldStyleString_whenComparing_thenEqualsTextBlock () {String צפוי = "\ n \ n \ n טקסט לדוגמא \ n \ n"; assertThat (subject.getBlockOfHtml ()) .isEqualTo (צפוי); }

כאשר אנו זקוקים לכניסה מפורשתנוכל להשתמש בפחות הזחה לשורה שאינה ריקה (או לשורה האחרונה):

מחרוזת ציבורית getNonStandardIndent () {return "" "Indent" ""; } @Test בטל שניתןAnIndentedString_thenMatchesIndentedOldStyle () {assertThat (subject.getNonStandardIndent ()) .isEqualTo ("כניסה \ n"); }

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

4. בריחה

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

מחרוזת ציבורית getTextWithEscapes () {return "" "כיף עם \ n רווח לבן \ t \ r ושאר בריחות \" "" "";}

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

כמו כן, שים לב שגם אם לקובץ מקור יש סיומות של Windows (\ r \ n), גושי הטקסט יסתיימו רק עם שורות חדשות (\ n). אם אנו זקוקים להחזרת כרכרה (\ r) כדי להיות נוכחים, עלינו להוסיף אותם במפורש לגוש הטקסט:

מחרוזת ציבורית getTextWithCarriageReturns () {return "" "מופרד עם הכרכרה מחזירה" ""; } @Test בטל givenATextWithCarriageReturns_thenItContainsBoth () {assertThat (subject.getTextWithCarriageReturns ()) .isEqualTo ("מופרד עם \ r \ n מחזירה מרכבה"); }

5. עיצוב

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

מחרוזת ציבורית getFormattedText (פרמטר מחרוזת) {return "" "פרמטר כלשהו:% s" "". format (פרמטר); }

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

6. רצפי בריחה חדשים בג'אווה 14

התצוגה המקדימה השנייה של התכונה Blocks Text מוסיפה שני רצפי בריחה נוספים.

6.1. מסופי קו נמלטים

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

מחרוזת ציבורית getIgnoredNewLines () {return "" "זו בדיקה ארוכה שנראית \ יש קו חדש אך למעשה לא" ""; }

למעשה זה חוּט מילולי פשוט יהיה שווה ללא הפרעה רגילה חוּט:

@Test void givenAStringWithEscapedNewLines_thenTheResultHasNoNewLines () {String expected = "זו בדיקה ארוכה שנראית שיש לה קו חדש אך למעשה אין"; assertThat (subject.getIgnoredNewLines ()) .isEqualTo (צפוי); }

6.2. בריחה מחללים

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

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

מחרוזת ציבורית getEscapedSpaces () {return "" "שורה 1 ······· שורה 2 ······ \ s" ""; } @Test בטל שניתן AStringWithEscapesSpaces_thenTheResultHasLinesEndingWithSpaces () {מחרוזת צפויה = "שורה 1 \ n קו 2 \ n"; assertThat (subject.getEscapedSpaces ()) .isEqualTo (צפוי); } 

הערה: החללים בדוגמה שלמעלה מוחלפים בסמל '·' כדי להפוך אותם לגלויים.

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

7. מסקנה

במדריך קצר זה, בחנו את התכונה Java Blocks Text. זה אולי לא מחליף משחק, אבל זה עוזר לנו לכתוב קוד טוב וקריא יותר, וזה בדרך כלל דבר טוב.

כמו תמיד, קוד המקור המלא של המאמר זמין באתר GitHub.