עבודה עם אזורי זמן שונים ב-Go

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

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

חבילת הזמן

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

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

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

יְבוּא"זְמַן"

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

חֲבִילָה רָאשִׁי
סוּג זְמַן מבנה {
// wall הוא זמן הקיר בפורמט המוחזר על ידי ה-runtime.nanotime()
// פונקציה.
 קִיר uint64





instagram viewer

// ext הוא קריאת השעון המונוטוני בפורמט המוחזר על ידי
// runtime.nanotime().
 שלוחה int64
// loc הוא מצביע למבנה המיקום המשויך לזמן זה.
 loc *מיקום
}
סוּג מקום מבנה {
// שם הוא שם אזור הזמן, כגון "UTC" או "PST".
 שֵׁם חוּט
// אזור מכיל מידע על קיצור אזור הזמן, היסט,
// וכלל עבור אזור זמן בודד במיקום.
 אזור []אזור
// tx מכיל מידע על מתי קיצור אזור הזמן או
// קיזוז שינויים עבור מיקום.
 tx []zoneTrans
// extension מכיל את השם של אזור זמן אב אם מיקום זה
// משתרע מאחד אחר.
 לְהַאֲרִיך חוּט
// cacheStart ו-cacheEnd הם חותמות זמן של יוניקס שמגדירות את הטווח
// שעבורו השדה cacheZone חוקי.
 cacheStart int64
 cacheEnd int64
// cacheZone מצביע על האזור התקף כרגע
// טווח מוגדר על ידי cacheStart ו-cacheEnd.
 cacheZone *אזור
}

שיטות רבות משתמשות ב-Time ו מקום מבנים, כולל שיטות אזור הזמן.

טוען מידע על אזור זמן

טעינת מידע על אזור זמן היא אחת הפעולות הבסיסיות בעבודה עם אזורי זמן. ה LoadLocation השיטה מספקת פונקציונליות לטעינת מידע על אזור זמן מה- מסד אזורי הזמן של IANA. ה LoadLocation השיטה לוקחת את שם אזור הזמן ומחזירה את פרטי המיקום ושגיאה לטיפול. ברגע שהוא טען את מידע אזור הזמן, הוא יוצר א זְמַן מופע struct המשויך לאזור הזמן.

יְבוּא (
"fmt"
"זְמַן"
)
funcרָאשִׁי() {
// טען את מיקום אזור הזמן עבור America/New_York
 loc, err := זמן. LoadLocation("אמריקה/ניו_יורק")
אם טעות != אֶפֶס {
 fmt. Println("שגיאה בטעינת מיקום:", טעות)
לַחֲזוֹר
 }
// קבל את השעה הנוכחית במיקום מסוים
 עכשיו := זמן. Now().In (loc)
 fmt. Println("שעה נוכחית בניו יורק:", עכשיו)
}

ה ב שיטת ה עַכשָׁיו הפונקציה תופסת מיקום ומדפיסה את הזמן שם:

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

יְבוּא (
"fmt"
"זְמַן"
)
funcרָאשִׁי() {
// קבל את השעה הנוכחית ב-UTC
 עכשיו := זמן. עכשיו().UTC()
// הגדר את אזור הזמן עבור לאגוס
 לאגוס := עכשיו. בזמן. FixedZone("WAT", 3600))
// הדפס את השעה הנוכחית בשני המיקומים
 fmt. Println("שעה נוכחית בלאגוס:", לגוס)
}

ה רָאשִׁי הפונקציה מדפיסה את השעה הנוכחית בלאגוס לקונסולה.

מדידת משך אזור זמן

חבילת הזמן מספקת את אֵזוֹר שיטה לאחזור הקיצור והקיזוז של אזור הזמן המשויך ל-a זְמַן. זְמַן ערך. שיטת ה-Zone מחזירה את המחרוזת המייצגת את הקיצור של אזור הזמן (למשל "EST" עבור "אמריקה/ניו_יורק") ומספר שלם המייצג את מספר השניות ממזרח ל-UTC.

יְבוּא (
"fmt"
"זְמַן"
)
funcרָאשִׁי() {
// טען את מיקום אזור הזמן עבור America/New_York
 loc, err := זמן. LoadLocation("אמריקה/ניו_יורק")
אם טעות != אֶפֶס {
 fmt. Println("שגיאה בטעינת מיקום:", טעות)
לַחֲזוֹר
 }
// קבל את השעה הנוכחית ב-UTC ואת המיקום שצוין
 t1 := זמן. עַכשָׁיו()
 t2 := t1.In (loc)
// קבל את ההיסט בשניות עבור כל אזור זמן 
//עבור אזורי הזמן
 _, offset1 := t1.Zone()
 _, offset2 := t2.Zone()
// חשב את משך השינוי באזור הזמן 
// בין UTC לאמריקה/ניו_יורק
 משך := offset2 - offset1
 fmt. Printf("משך השינוי של אזור הזמן" +
"בין UTC לניו יורק הוא: %d שניות", משך זמן)
}

בפונקציה הראשית, שיטת ה-Zone מודדת את משך המעבר של אזור הזמן בין שני אזורי זמן (זמן. ערכי זמן). ה t1 המשתנה הוא השעה הנוכחית ב-UTC, וה- t2 המשתנה הוא השעה הנוכחית באזור הזמן "אמריקה/ניו_יורק".

הפונקציה מדפיסה את מֶשֶׁך משתנה (ההבדל בהיסט בין אזורי הזמן) המייצג את שינוי אזור הזמן בשניות.

הערכת זמן בין אזורי זמן

אתה יכול להעריך זמן בין אזורי זמן אם אתה יודע את משך הזמן בין אזורי הזמן. אתה יכול להשתמש ב לְהוֹסִיף שיטת ה-In של זמנך. מופע מבנה זמן כדי להוסיף משך לזמן באזור זמן.

יְבוּא (
"עֵץ"
"זְמַן"// ייבא את חבילת הזמן
)
funcevaluateTime(זמן לא. זמן, משך זמן. מֶשֶׁך)זְמַן.זְמַן {
// טען את המיקום עבור אפריקה/לאגוס
 מיקום, טעות := זמן. LoadLocation("אפריקה/לגוס")
אם טעות != אֶפֶס {
 עֵץ. Println("אירעה שגיאה בטעינת המיקום")
 }

לַחֲזוֹר ט. ב (מיקום). הוסף (משך זמן)
}

ה evaluateTime הפונקציה לוקחת בזמן. מופע זמן ומשך סוג זְמַן. מֶשֶׁך, החזרת השעה באזור הזמן. הוא טוען את השעה הנוכחית ב"אפריקה/לגוס" ומוסיף משך זמן לשעה.

בצע מניפולציות של זמן ותאריך עם חבילת הזמן

חבילת הזמן מגוונת מאוד לעבודה עם זמנים ותאריכים. חבילת הזמן מספקת פונקציות כמו Unix() להמרת זמן לזמן Unix, Sleep() להשהיית goroutines ו-Format() לעיצוב ערכי זמן למחרוזת.