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

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

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

אז מה המשמעות של מניפולציה של זמן ותאריך, וכיצד ניתן לתפעל זמן ותאריך ב-Go?

מהי מניפולציה של זמן ותאריך?

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

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

מניפולציה של זמן ותאריך יכולה לכלול:

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

כדי להתחיל לתפעל זמן ותאריך ביישומי Go, ייבא את ה זְמַן חבילה לצד שאר החבילות שבהן אתה משתמש.

יְבוּא (
"fmt"
"זְמַן"
)

כיצד לקבל את השעה והתאריך הנוכחיים ב-Go

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

כדי לקבל את השעה והתאריך בזמן המקומי שלך או באזור זמן או מיקום ספציפיים, אתה יכול להשתמש ב- זְמַן. עַכשָׁיו() ו זְמַן. LoadLocation() פונקציות:

func רָאשִׁי(){
// קבל את השעה והתאריך הנוכחיים בזמן מקומי
 myTime := ime. עַכשָׁיו()
 fmt. Println("שעה נוכחית ב ", הזמן שלי. מקום(), " הוא: ", הזמן שלי)
// דרך נוספת לקבל זמן מקומי
 מיקום, _ := זמן. LoadLocation("מְקוֹמִי") // או זמן. LoadLocation("")
 fmt. Println("שעה נוכחית ב ", מקום, " הוא: ", זמן. Now().In (מיקום))
// מיקום אחר
 מיקום, _ = זמן. LoadLocation("אמריקה/ניו_יורק")
 fmt. Println("שעה נוכחית ב ", מקום, " הוא: ", הזמן שלי. ב (מיקום))
// קבל את השעה הנוכחית באזור זמן הררי (MST)
 מיקום, _ = זמן. LoadLocation("MST")
 fmt. Println("שעה נוכחית ב ", מקום, " הוא: ", הזמן שלי. ב (מיקום))
}

הפעלת התוכנית למעלה עם לך להפעיל את filename.go מייצר את הפלט הבא במסוף:

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

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

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

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

אתה יכול להשתמש ב תַאֲרִיך() פונקציה כדי לקבל את היום, החודש והשנה, ואת שָׁעוֹן() פונקציה כדי לקבל את השעה, הדקה והשניות. לדוגמה:

funcרָאשִׁי() {
 myTime := זמן. עַכשָׁיו();
 שנה, חודש, יום := myTime. תַאֲרִיך()
 fmt. Println("שנה :", שנה)
 fmt. Println("חודש :", חודש)
 fmt. Println("יום :", יום)
שעה, דקות, שניות := myTime. שָׁעוֹן() 
 fmt. Println("שעה :", שעה) 
 fmt. Println("דקה :", min) 
 fmt. Println("שניות :", שניות)
}

הפלט ממחיש את החלקים השונים של חותמת הזמן:

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

funcרָאשִׁי() {
 myTime := זמן. עַכשָׁיו()
// קבל כל יחידה משנה עד ננו-שנייה
 fmt. Println("Year :", myTime. שָׁנָה())
 fmt. Println("חודש :", myTime. חוֹדֶשׁ())
 fmt. Println("Day :", myTime. יְוֹם())
 fmt. Println("שעה :", myTime. שָׁעָה())
 fmt. Println("דקה :", myTime. דַקָה())
 fmt. Println("שניות :", myTime. שְׁנִיָה())
 fmt. Println("Nanosecond :", myTime. ננו-שנייה())
}

כפי שהפלט ממחיש, זה גם נותן לך גישה לננו-שניות:

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

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

funcרָאשִׁי() {
// קבל רכיבים בודדים של הזמן משנה עד ננו-שנייה
// מתאריך מסוים
 yourTime := זמן. תַאֲרִיך(2020, 07, 1, 06, 32, 10, 0, זמן. UTC)
 fmt. Println("Year :", yourTime. שָׁנָה())
 fmt. Println("חודש :", yourTime. חוֹדֶשׁ())
 fmt. Println("Day :", yourTime. יְוֹם())
 fmt. Println("שעה :", yourTime. שָׁעָה())
 fmt. Println("דקה :", yourTime. דַקָה())
 fmt. Println("שניות :", yourTime. שְׁנִיָה())
 fmt. Println("Nanosecond :", yourTime. ננו-שנייה())
// באמצעות הפונקציה Clock() כדי לקבל שעה, דקה ושנייה
 yourHour, yourMin, yourSec := yourTime. שָׁעוֹן()
 fmt. Println("Hour :", yourHour)
 fmt. Println("Minute :", yourMin)
 fmt. Println("שניות :", yourSec)
// קבל זמן ותאריך ממחרוזת
 dateString := "2020-07-0106:32:10"
 פריסה := "2006-01-0215:04:05" // פורמט הפלט הרצוי
 yourTime, _ = זמן. ניתוח (פריסה, מחרוזת תאריך)
 fmt. Println("הזמן שלך הוא: ", הזמן שלך)
 fmt. Println("Year :", yourTime. שָׁנָה())
 fmt. Println("חודש :", yourTime. חוֹדֶשׁ())
 fmt. Println("Day :", yourTime. יְוֹם())
 fmt. Println("שעה :", yourTime. שָׁעָה())
 fmt. Println("דקה :", yourTime. דַקָה())
 fmt. Println("שניות :", yourTime. שְׁנִיָה())
}

קוד זה מייצר את הפלט הבא:

שים לב ש-Parse() משתמש UTC כברירת מחדל אם אינך מציין אזור זמן במחרוזת התאריך.

כיצד לבצע פעולות אריתמטיות עם תאריך ושעה

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

Go מאפשר לך להגדיר זְמַן. מֶשֶׁך ערכים עם כל יחידות הזמן מ זְמַן. שָׁעָה ל זְמַן. ננו-שנייה. אתה יכול להשתמש בערכים אלה כדי להוסיף או לגרוע זמן באמצעות לְהוֹסִיף(). יש גם א AddDate() פונקציה שלוקחת 3 פרמטרים: שנים, חודשים וימים לביצוע חיבור או חיסור.

הקוד הבא מדגים שימוש בפונקציות אלה:

funcרָאשִׁי() {
 curTime := זמן. עַכשָׁיו()
 curTime = curTime. הוסף זמן. שָׁעָה) // מוסיף שעה אחת
 fmt. Println("השעה הנוכחית היא: ", CurTime)
 מחר := curTime. הוסף זמן. שעה * 24)
 fmt. Println("השעה מחר היא: ", מחר)
 שבוע הבא := זמן קצר. הוסף זמן. שעה * 24 * 7)
 fmt. Println("הזמן הזה בשבוע הבא הוא: ", שבוע הבא)
// באמצעות AddDate (y, m, d)
 למחר הבא := curTime. AddDate(0, 0, 2)
 fmt. Println("הפעם הבאה מחר היא: ", מחר הבא)
 החודש הבא := זמן זמן. AddDate(0, 1, 0)
 fmt. Println("הזמן הזה בחודש הבא הוא: ", החודש הבא)
 fiveYearsAndOneMonthAfter := curTime. AddDate(5, 1, 0)
 fmt. Println("הפעם חמש שנים וחודש אחרי זה: ", fiveYearsAndOneMonthAfter)
}

מה שמייצר את הפלט הבא:

אתה יכול גם להחסיר זמן עם לְהוֹסִיף() ו AddDate() על ידי העברת פרמטרים שליליים. לדוגמה:

funcרָאשִׁי() {
 curTime := זמן. עַכשָׁיו()
// להפחית יום אחד באמצעות AddDate()
 אתמול := curTime. AddDate(0, 0, -1)
 fmt. Println("הזמן הזה אתמול היה: ", אתמול)
// להפחית חודש באמצעות Add()
 חודש אחרון := זמן זמן. הוסף זמן. שעה * -24 * 30)
 fmt. Println("הזמן הזה בחודש שעבר היה: ", בחודש האחרון)
}

מייצר את הפלט הזה:

למרות שאתה יכול להשתמש לְהוֹסִיף() ו AddDate() כדי למצוא את ההבחנה בין תאריכים, ל-Go יש א תַת() פונקציה שעובדת קצת אחרת:

funcרָאשִׁי() {
 curTime = זמן. עַכשָׁיו()
 עבר := זמן. תַאֲרִיך(2022, זמן. דֵצֶמבֶּר, 25, 12, 0, 0, 0, זמן. UTC)
 הבדל := עבר. משנה (זמן זמן)
 fmt. Println("ההבדל בין עכשיו לעבר הוא: ", הבדל)
// קבל את ההבדל ביחידות שונות
 שנים := int(הבדל. שעה (ות() / 24 / 365)
 fmt. Println("שנים: ", שנים)
 חודשים := int(הבדל. שעה (ות() / 24 / 30)
 fmt. Println("חודשים: ", חודשים)
 ימים := int(הבדל. שעה (ות() / 24)
 fmt. Println("ימים: ", ימים)
 שעות := int(הבדל. שעה (ות())
 fmt. Println("שעות: ", שעות)
// הבדל. דקות(), הבדל. שניות(), הבדל. מיליסניות(), הבדל. ננו-שניות() גם מחזירות את היחידות שלהן
}

קוד זה מייצר את הפלט הבא:

כיצד לקבל זמן ותאריך בפורמטים שונים

אתה יכול גם לקבל פלטי זמן ותאריך במספר פורמטים באמצעות פוּרמָט() פוּנקצִיָה. להלן כמה סגנונות עיצוב נפוצים:

funcרָאשִׁי() {
 curTime = זמן. עַכשָׁיו()
// סגנונות עיצוב סטנדרטיים מובנים
 fmt. Println("השעה הנוכחית היא: ", CurTime)
 fmt. Println("הזמן הנוכחי בפורמט RFC3339 הוא: ", curTime. פורמט (זמן. RFC3339))
 fmt. Println("הזמן הנוכחי בפורמט RFC3339Nano הוא: ", curTime. פורמט (זמן. RFC3339Nano))
 fmt. Println("הזמן הנוכחי בפורמט RFC1123 הוא: ", curTime. פורמט (זמן. RFC1123))
 fmt. Println("הזמן הנוכחי בפורמט RFC1123Z הוא: ", curTime. פורמט (זמן. RFC1123Z))
 fmt. Println("הזמן הנוכחי בפורמט RFC822 הוא: ", curTime. פורמט (זמן. RFC822))
 fmt. Println("הזמן הנוכחי בפורמט RFC822Z הוא: ", curTime. פורמט (זמן. RFC822Z))
 fmt. Println("הזמן הנוכחי בפורמט RFC850 הוא: ", curTime. פורמט (זמן. RFC850))
 fmt. Println("הזמן הנוכחי בפורמט ANSIC הוא: ", curTime. פורמט (זמן. ANSIC))
 fmt. Println("השעה הנוכחית בפורמט יוניקס היא: ", curTime. פורמט (זמן. UnixDate))
// סגנונות עיצוב מותאמים אישית
// DD-MM-YYYY HH: MM: SS
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("02-01-200615:04:05"))
// MM-DD-YYYY HH: MM: SS
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("01-02-200615:04:05"))
// YYYY-MM-DD HH: MM: SS
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("2006-01-0215:04:05"))
// DD.MM.YYYY
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("02.01.2006"))
// DD/MM/YYYY
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("02/01/2006"))
// 1 בפברואר 2006
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("02 ינואר 2006"))
// 01 בפברואר 2006 יום שני
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("02 פברואר 2006 יוֹם שֵׁנִי"))
// 01 בפברואר 2006 יום שני 15:04:05
 fmt. Println("זמן נוכחי בפורמט מותאם אישית הוא: ", curTime. פוּרמָט("02 פברואר 2006 יום שני 15:04:05"))
}

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

מניפולציה של זמן ותאריך ב-Go

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

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

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