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

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

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

תחילת העבודה עם תבנית ב-Go

ל-Go יש שתי חבילות תבניות בספרייה הרגילה: טקסט/תבנית ו html/תבנית. לחבילת הטקסט/תבנית יש פונקציונליות לניתוח קבצי טקסט, בעוד ש-html/תבנית מטפל ב-HTML. על ידי שימוש ב-html/תבנית אתה מוגן מפני התקפות סקריפטים בין-אתרים (XSS) מכיוון ש-Go בורח מהזנת נתונים במהלך העיבוד. זהו יתרון נוסף של תבנית על פני גישה ידנית.

מכיוון שחבילת התבנית היא חלק מהספרייה הסטנדרטית, לא תצטרך להתקין תלות כלשהי; רק לייבא את זה:

יְבוּא "html/תבנית"

התחל ב יצירת קובץ HTML לשימוש כתבנית עבור היישום שלך. אתה יכול להשתמש בתקן .html הרחבה או אחת מהן

instagram viewer
.gohtml אוֹ .tmpl, שניהם גם נפוצים. לא משנה באיזה הרחבה תשתמש, הפונקציונליות בתוך האפליקציה שלך תהיה זהה. עורכי טקסט מסוימים עשויים להחיל הדגשת תחביר שונה בהתאם להרחבות של התבניות שלך. הנה שלד בסיסי:

<!DOCTYPE html>
<html lang="he">
<רֹאשׁ>
<מטא תווים ="UTF-8">
<כותרת>מסמך</title>
</head>
<גוּף>
</body>
</html>

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

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

var tmplt *תבנית. תבנית

תצטרך ליצור שרת פשוט כדי לעבד ולהציג את התבניות שלך. הנה איך להפעיל שרת פשוט ב-Go באמצעות net/http חֲבִילָה:

funcrunServer() {
 http. HandleFunc("/home", handlePage)
 טעות := http. ListenAndServe("localhost:8080", אֶפֶס)
אם טעות != אֶפֶס {
 עֵץ. Fatalln("יש שגיאה בשרת:", err)
 }
}

אתה תתקשר ל runServer פונקציה מהפונקציה הראשית שלך כדי להפעיל את השרת. לשרת יש רק מסלול אחד, ה /home מסלול, שיציג את הדף שלך. ה handlePage פרמטר הוא השם של פונקציית מטפל שתציג את הדף שלך. ה ListenAndServe השיטה מתחילה את השרת להאזין ביציאה 8080 עַל localhost, כלומר המחשב שלך.

העברת משתנים לתבניות

צור מבנה גלובלי בשם חֲדָשׁוֹת:

סוּג חֲדָשׁוֹת struct {
 כּוֹתֶרֶת חוּט
 גוּף חוּט
}

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

{{ שם }}

איפה שֵׁם הוא השם של משתנה שהעברת לתבנית שלך. כאשר אתה מעבד את התבנית, היא תחליף את הערכים בסוגריים בנתונים מתאימים מקוד ה-Go שלך. מכיוון שהדוגמה הבאה תעביר מבנה, תשתמש בסימון נקודות כדי לגשת לשדות שלו:

<גוּף>
<h1>{{ .Headline }}</h1>
<ע> {{ .Body }} </p>
</body>

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

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

funchandlePage(כותב http. כותב תגובה, בקשה *http. בַּקָשָׁה) {
אם בַּקָשָׁה. שיטה == "קבל" {
 tmplt, _ = תבנית. ParseFiles("tutorial.html")
אירוע := חדשות{
 כותרת: "לmakeuseof.com יש הכל טכנולוגי",
 גוף: "בקר ב-MUO ל כל דבר שקשור לטכנולוגיה",
 }


טעות := tmplt. ביצוע (כותב, אירוע)
אם טעות != אֶפֶס {
לַחֲזוֹר
 }
 }
}

ה ParseFiles השיטה מנתחת את קובץ ה-HTML שאתה מציין. ה מִקרֶה המשתנה הוא המבנה המאותחל. ה לבצע השיטה תזריק את הנתונים שסופקו לעמוד האחרון, בהתאם למצייני המיקום בתבנית. ביצוע לוקח א כותב תגובה והנתונים, במקרה זה, המבנה.

להלן התוצאה מהפעלת השרת וביקור בדף:

שימוש במבני בקרה בתבניות

אתה יכול גם להשתמש במבני בקרה כמו הצהרות מותנות ולולאות בתבניות שלך.

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

    

     {{טווח .}}
  1. {{.}}
    2. 

     {{סוֹף}}

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

makeUseOfCategories := []חוּט{"הסבר על טכנולוגיה", "תכנות", "לינוקס",
 "Android", "iOS", "הרבה יותר..."}
טעות := tmplt. ביצוע (סופר, makeUseOfCategories)
אם טעות != אֶפֶס {
לַחֲזוֹר
}

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

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

סוּג TrueFalser struct {
 נכון bool
 Is False bool
 IsDefault bool
}

כדי להשתמש בתנאי, כלול את אם מילת מפתח בסוגריים כפולים לפני שם המשתנה לבדיקה. סיים את החסימה המותנית עם ה- סוֹף מילת מפתח בסוגריים:

{{if .IsTrue}}
<ע>מעריך פלט נכון ויהיה</p>
{{סוֹף}}
{{if .IsDefault}}
<ע>מעריך שקר וזכה'פלט t</p>
{{סוֹף}}
{{if .IsFalse}}
<ע>מעריך שקר וזכה'פלט t</p>
{{סוֹף}}

אתחול struct ב-Go מגדיר את הערכים ל-false בברירת המחדל, כך שאם לא אתחול שדה, הוא מוערך ל-false. באתחול ה-struct והעברת המשתנה כנתונים לתבנית, רק השדות שמעריכים כ-true גורמים להופעת פלט.

בחירה := TrueFalser {
 נכון: נָכוֹן,
 Is False: שֶׁקֶר,
}
טעות := tmplt. ביצוע (כותב, בחירה)

הפלט הסופי כולל פסקה בודדת בלבד מכיוון שרק השדה isTrue מוערך כ-true:

אינך צריך להשתמש בתבניות עבור יישומי הקצה שלך

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

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