آموزش معرفی و بررسی

نحوه استفاده از تاریخ و زمان در Go

07 فوریه

معرفی

نرم افزار به گونه ای طراحی شده است که انجام کار را آسان تر می کند، و برای بسیاری از افراد، شامل تعامل با تاریخ و زمان می شود. مقادیر تاریخ و زمان در همه جا در نرم افزار مدرن نشان داده می شود. به عنوان مثال، پیگیری زمان نیاز خودرو به خدمات و اطلاع دادن به مالک، پیگیری تغییرات در پایگاه داده برای ایجاد گزارش حسابرسی، یا فقط مقایسه یک زمان با زمان دیگر برای تعیین مدت زمان طول کشیده یک فرآیند. بنابراین، بازیابی زمان جاری، دستکاری مقادیر زمان برای استخراج اطلاعات از آنها و نمایش آنها به کاربران در قالبی قابل فهم از ویژگی های ضروری یک برنامه کاربردی است.

در این آموزش، شما یک برنامه Go ایجاد می‌کنید تا زمان محلی فعلی رایانه خود را دریافت کنید، سپس آن را با فرمتی که برای مردم راحت‌تر خوانده شود، روی صفحه چاپ کنید. در مرحله بعد، رشته ای را برای استخراج اطلاعات تاریخ و زمان تفسیر می کنید. شما همچنین مقادیر تاریخ و زمان را بین دو منطقه زمانی ترجمه می‌کنید، همچنین مقادیر زمانی را برای تعیین فاصله بین دو زمان اضافه یا کم می‌کنید.

پیش نیازها

Go نسخه 1.16 یا بالاتر نصب شده است، که می توانید با دنبال کردن سری ما، نحوه نصب و راه اندازی یک محیط برنامه نویسی محلی برای Go، این کار را انجام دهید.

دریافت زمان فعلی

در این بخش، زمان فعلی را با استفاده از بسته زمانی Go دریافت خواهید کرد. بسته زمانی در کتابخانه استاندارد Go انواع توابع مربوط به تاریخ و زمان را ارائه می‌کند و می‌تواند برای نمایش یک نقطه خاص در زمان با استفاده از نوع time.Time استفاده شود. علاوه بر زمان و تاریخ، می‌تواند اطلاعاتی در مورد منطقه زمانی که تاریخ و زمان نمایش داده شده در آن قرار دارد نیز در خود جای دهد.

برای شروع ایجاد برنامه ای برای کاوش بسته زمانی، باید یک دایرکتوری برای فایل ها ایجاد کنید. این دایرکتوری را می توان در هر جایی که می خواهید در رایانه خود ایجاد کرد، اما بسیاری از توسعه دهندگان تمایل دارند برای پروژه های خود دایرکتوری داشته باشند. در این آموزش از دایرکتوری به نام پروژه ها استفاده می کنید.

دایرکتوری پروژه ها را بسازید و به آن بروید:

mkdir projects

cd projects

هنگامی که فهرست پروژه خود را ایجاد کردید، یک فایل main.go را با استفاده از nano یا ویرایشگر دلخواه خود باز کنید:

nano main.go

در فایل main.go، یک تابع اصلی اضافه کنید که زمان جاری را دریافت کرده و آن را چاپ می کند:

projects/datetime/main.go
package main

import (
	"fmt"
	"time"
)

func main() {
	currentTime := time.Now()
	fmt.Println("The time is", currentTime)
}

در این برنامه تابع time.Now از بسته زمان برای دریافت زمان محلی فعلی به عنوان مقدار time.Time استفاده می شود و سپس آن را در متغیر currentTime ذخیره می کند. هنگامی که در متغیر ذخیره شد، تابع fmt.Println، CurrentTime را با استفاده از فرمت خروجی رشته پیش فرض time.Time روی صفحه چاپ می کند.

برنامه را با استفاده از go run با فایل main.go اجرا کنید:

go run main.go

خروجی که تاریخ و زمان فعلی شما را نشان می دهد مشابه این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT m=+0.000066626

خروجی تاریخ و زمان فعلی شما را نشان می دهد که با مثال متفاوت است. علاوه بر این، منطقه زمانی که مشاهده می کنید (-0500 CDT در این خروجی) احتمالاً متفاوت خواهد بود، زیرا time.Now() زمان را در منطقه زمانی محلی برمی گرداند.

همچنین ممکن است متوجه یک مقدار m= در خروجی خود شوید. این مقدار ساعت یکنواخت است و به صورت داخلی توسط Go هنگام اندازه گیری تفاوت در زمان استفاده می شود. ساعت یکنواخت برای جبران هرگونه تغییر احتمالی در تاریخ و زمان ساعت سیستم کامپیوتر در حین اجرای برنامه طراحی شده است. با استفاده از ساعت یکنواخت، یک مقدار time.Now در مقایسه با زمان. اکنون مقدار پنج دقیقه بعد همچنان به نتیجه صحیح ختم می شود (فاصله پنج دقیقه)، حتی اگر ساعت سیستم برای رایانه یک ساعت به جلو تغییر کند. یا در طی آن فاصله پنج دقیقه ای به عقب برگردید. برای کد یا مثال‌های موجود در این آموزش، نیازی به درک کامل آن ندارید، اما اگر می‌خواهید درباره ساعت‌های یکنواخت و نحوه استفاده Go از آن‌ها بیشتر بدانید، بخش ساعت‌های یکنواخت در مستندات بسته زمانی جزئیات بیشتری را ارائه می‌دهد.

اکنون، در حالی که زمان فعلی نمایش داده شده است، ممکن است برای کاربران مفید نباشد. ممکن است فرمت مورد نظر شما نباشد، یا ممکن است قسمت‌های بیشتری از تاریخ یا ساعت را شامل شود که می‌خواهید نمایش دهید.

خوشبختانه، نوع time.Time شامل روش های مختلفی برای به دست آوردن قسمت های خاصی از تاریخ یا ساعت مورد نظر شما است. به عنوان مثال، اگر فقط می‌خواهید بخش سال متغیر currentTime را بدانید، می‌توانید از روش Year استفاده کنید یا ساعت جاری را با استفاده از روش Hour دریافت کنید.

فایل main.go خود را دوباره باز کنید و چند روش time.Time را به خروجی خود اضافه کنید تا ببینید چه چیزی تولید می کنند:

projects/datetime/main.go
...

func main() {
	currentTime := time.Now()
	fmt.Println("The time is", currentTime)
	
	fmt.Println("The year is", currentTime.Year())
	fmt.Println("The month is", currentTime.Month())
	fmt.Println("The day is", currentTime.Day())
	fmt.Println("The hour is", currentTime.Hour())
	fmt.Println("The minute is", currentTime.Hour())
	fmt.Println("The second is", currentTime.Second())
}

سپس با استفاده از go run دوباره برنامه خود را اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT m=+0.000066626
The year is 2021
The month is August
The day is 15
The hour is 14
The minute is 14
The second is 45

مانند خروجی قبلی، تاریخ و زمان فعلی شما با مثال متفاوت خواهد بود، اما قالب باید مشابه باشد. این بار در خروجی، تاریخ و زمان کامل را مانند قبل می بینید، اما فهرستی از سال، ماه، روز ماه، ساعت، دقیقه و ثانیه نیز دارید. توجه داشته باشید که به جای چاپ ماه به عنوان یک عدد (مانند تاریخ کامل)، به عنوان رشته انگلیسی اوت ظاهر می شود. این به این دلیل است که روش Month ماه را به‌عنوان یک زمان برمی‌گرداند. نوع ماه به‌جای یک عدد، و آن نوع برای چاپ نام کامل انگلیسی زمانی که به صورت رشته‌ای چاپ می‌شود طراحی شده است.

اکنون، فایل main.go را دوباره در برنامه خود به‌روزرسانی کنید و خروجی‌های تابع مختلف را با یک فراخوانی تابع به fmt.Printf جایگزین کنید، بنابراین می‌توانید تاریخ و زمان فعلی را در قالبی نزدیک‌تر به آنچه می‌خواهید نمایش دهید چاپ کنید. یک کاربر:

projects/datetime/main.go
...

func main() {
	currentTime := time.Now()
	fmt.Println("The time is", currentTime)
	
	fmt.Printf("%d-%d-%d %d:%d:%d\n",
		currentTime.Year(),
		currentTime.Month(),
		currentTime.Day(),
		currentTime.Hour(),
		currentTime.Hour(),
		currentTime.Second())
}

هنگامی که به روز رسانی های خود را در فایل main.go ذخیره کردید، آن را با استفاده از دستور go run مانند قبل اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT m=+0.000066626
2021-8-15 14:14:45

این بار ممکن است خروجی شما به چیزی که می‌خواهید نزدیک‌تر باشد، اما هنوز چند چیز وجود دارد که می‌توان در مورد خروجی اصلاح کرد. ماه اکنون دوباره در قالب عددی نمایش داده می‌شود، زیرا قالب fmt.Printf از %d برای نشان دادن زمان استفاده می‌کند. نوع ماه باید از یک عدد استفاده کند نه رشته، اما فقط به صورت تک رقمی نشان داده می‌شود. اگر می‌خواهید دو رقم نمایش داده شود، می‌توانید فرمت fmt.Printf را برای گفتن آن تغییر دهید، اما اگر بخواهید به جای زمان ۲۴ ساعته همانطور که در خروجی بالا نشان داده شده است، یک زمان ۱۲ ساعته را نیز نشان دهید، چطور؟ با استفاده از روش fmt.Printf، شما باید برای محاسبه آن، ریاضی خود را انجام دهید. چاپ تاریخ و زمان با استفاده از fmt.Printf امکان پذیر است، اما همانطور که می بینید، در نهایت می تواند دست و پا گیر شود. با انجام این کار، می‌توانید برای هر قسمتی که می‌خواهید نمایش دهید تعداد زیادی خط داشته باشید، یا باید تعدادی از محاسبات خود را برای تعیین اینکه چه چیزی را نمایش دهید انجام دهید.

در این قسمت برنامه جدیدی برای دریافت زمان فعلی با استفاده از time.Now ایجاد کردید. هنگامی که زمان فعلی را داشتید، سپس از عملکردهای مختلفی مانند سال و ساعت در زمان. نوع زمان برای چاپ اطلاعات مربوط به زمان فعلی استفاده کردید. با این حال، نمایش آن در یک قالب سفارشی شروع به کار زیادی کرد. برای آسان‌تر کردن این نوع کار رایج، بسیاری از زبان‌های برنامه‌نویسی، از جمله Go، روش خاصی را برای قالب‌بندی تاریخ‌ها و زمان‌ها ارائه می‌کنند، مشابه روشی که fmt.Printf می‌تواند برای قالب‌بندی یک رشته استفاده شود.

چاپ و قالب بندی تاریخ های خاص

علاوه بر سال، ساعت و سایر روش‌های مرتبط با داده که نوع time.Time ارائه می‌کند، روشی به نام Format را نیز ارائه می‌کند. متد Format به شما امکان می‌دهد یک رشته طرح‌بندی، شبیه به فرمت fmt.Printf یا fmt.Sprintf ارائه دهید، که به روش Format می‌گوید که چگونه می‌خواهید تاریخ و زمان چاپ شود. در این بخش، خروجی زمانی را که در بخش گذشته اضافه کرده‌اید، تکرار می‌کنید، اما به روشی بسیار مختصرتر با استفاده از روش Format.

با این حال، قبل از استفاده از روش Format، اگر هر بار که برنامه را اجرا می‌کنید تغییری نمی‌کند، بهتر است ببینید که چگونه Format بر خروجی یک تاریخ و زمان تأثیر می‌گذارد. تا به حال، شما زمان فعلی را با استفاده از زمان دریافت می‌کردید. اکنون، بنابراین هر بار که آن را اجرا می‌کردید، عدد متفاوتی نشان داده می‌شد. بسته Go time یک تابع مفید دیگر را ارائه می دهد، تابع time.Date، که به شما امکان می دهد تاریخ و زمان خاصی را برای نمایش زمان تعیین کنید.

برای شروع استفاده از time.Date به جای time.Now در برنامه خود، فایل main.go را دوباره باز کنید و آن را به روز کنید تا جایگزین time.Now با time.Date شود:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.Local)
	fmt.Println("The time is", theTime)
}

پارامترهای تابع time.Date شامل سال، ماه، روز ماه، ساعت، دقیقه و ثانیه از تاریخ و زمانی است که می‌خواهید زمان. زمان برای آن تعیین کنید. اولین پارامتر از دو پارامتر آخر برای نانوثانیه ها محاسبه می شود و آخرین پارامتر منطقه زمانی برای ایجاد زمان است. استفاده از مناطق زمانی خود بعداً در این آموزش پوشش داده شده است.

پس از ذخیره به روز رسانی ها، برنامه خود را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT

خروجی‌ای که می‌بینید اکنون باید به خروجی بالا نزدیک‌تر باشد، زیرا هنگام اجرای برنامه از تاریخ و زمان محلی خاصی به جای تاریخ فعلی استفاده می‌کنید. (بسته به منطقه زمانی که رایانه شما روی آن تنظیم شده است، منطقه زمانی ممکن است متفاوت نشان داده شود.) فرمت خروجی همچنان شبیه آنچه قبلا دیده اید به نظر می رسد زیرا هنوز از فرمت زمان پیش فرض استفاده می کند. اکنون که یک تاریخ و زمان استاندارد برای کار با آن دارید، می توانید از آن برای شروع به تغییر نحوه قالب بندی زمان هنگام نمایش با استفاده از روش Format استفاده کنید.

سفارشی کردن رشته های تاریخ با استفاده از روش قالب

بسیاری از زبان‌های برنامه‌نویسی دیگر روشی مشابه برای قالب‌بندی تاریخ‌ها و زمان‌ها برای نمایش دارند، اما روشی که Go طرح‌بندی آن فرمت‌ها را می‌سازد ممکن است کمی متفاوت از آنچه شما به آن عادت کرده‌اید، باشد، اگر از آن‌ها در زبان‌های دیگر استفاده کرده باشید. در زبان‌های دیگر، قالب‌بندی تاریخ از سبکی مشابه نحوه عملکرد Printf در Go استفاده می‌کند، با یک کاراکتر % و به دنبال آن یک حرف نشان‌دهنده بخشی از تاریخ یا زمان برای درج. به عنوان مثال، یک سال 4 رقمی ممکن است با %Y نشان داده شود. اما در Go، این بخش‌های تاریخ یا زمان با کاراکترهایی نشان داده می‌شوند که تاریخ خاصی را نشان می‌دهند. برای گنجاندن یک سال 4 رقمی در قالب تاریخ Go، در واقع باید سال 2006 را در خود رشته قرار دهید. مزیت این نوع چیدمان این است که آنچه در کد می بینید در واقع نشان دهنده چیزی است که در خروجی خواهید دید. وقتی بتوانید نمایشی از خروجی خود را مشاهده کنید، بررسی مجدد اینکه قالب شما با آنچه به دنبال آن هستید مطابقت دارد آسان تر می شود و همچنین درک خروجی برنامه را برای سایر توسعه دهندگان بدون اجرای برنامه آسان تر می کند. اول برنامه

تاریخ خاصی که Go برای طرح‌بندی تاریخ و زمان در قالب‌بندی رشته استفاده می‌کند، 01/02 03:04:05 06 -0700 است. اگر به هر جزء تاریخ و زمان نگاه کنید، خواهید دید که برای هر قسمت یک عدد افزایش می یابد. ماه اول در 01 می آید، پس از آن روز ماه در 02، سپس ساعت در 03، دقیقه در 04، دوم در 05، سال در 06 (یا 2006) و، در نهایت، منطقه زمانی در 07. به خاطر سپردن این ترتیب، ایجاد قالب‌های تاریخ و زمان را در آینده آسان‌تر می‌کند. نمونه‌هایی از گزینه‌های موجود برای قالب‌بندی را نیز می‌توانید در اسناد بسته زمانی Go پیدا کنید.

اکنون، از این روش جدید Format برای تکرار و پاکسازی قالب تاریخی که در بخش آخر چاپ کرده اید استفاده کنید. برای نمایش به چندین خط و فراخوانی تابع نیاز داشت و استفاده از روش Format باید کپی کردن آن را بسیار ساده تر و تمیزتر کند.

فایل main.go را باز کنید و یک تماس جدید fmt.Println اضافه کنید و آن را با تاریخ فرمت شده با استفاده از روش Format به Time ارسال کنید:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.Local)
	fmt.Println("The time is", theTime)

	fmt.Println(theTime.Format("2006-1-2 15:4:5"))
}

اگر به طرح مورد استفاده برای قالب نگاه کنید، خواهید دید که از همان زمان از بالا برای تعیین نحوه قالب بندی تاریخ و زمان استفاده می کند (2 ژانویه 2006). نکته ای که باید به آن توجه کرد این است که ساعت به جای 03 مانند مثال قبلی از 15 استفاده می کند. این نشان می دهد که شما می خواهید ساعت به جای 12 ساعت در قالب 24 ساعته نمایش داده شود.

برای دیدن خروجی از این فرمت جدید، برنامه خود را ذخیره کرده و با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT
2021-8-15 14:30:45

خروجی ای که اکنون می بینید مشابه خروجی انتهای بخش قبلی خواهد بود، اما انجام آن بسیار ساده تر بود. تنها چیزی که نیاز داشتید یک خط کد و یک رشته طرح بندی بود. تابع Format بقیه کارها را برای شما انجام می دهد.

بسته به تاریخ یا زمانی که نمایش می‌دهید، استفاده از قالبی با طول متغیر مانند فرمتی که هنگام چاپ مستقیم اعداد با آن به پایان رسید، ممکن است برای خود، کاربران یا سایر کدهایی که سعی در خواندن مقدار دارند، خواندن آن دشوار باشد. استفاده از 1 برای قالب ماه باعث می شود که مارس به صورت 3 نمایش داده شود، در حالی که اکتبر از دو کاراکتر استفاده می کند و به صورت 10 نشان داده می شود. اکنون main.go را باز کنید و با طرح بندی ساختارمندتر، یک خط اضافی به برنامه خود اضافه کنید. در این چیدمان، یک پیشوند 0 روی کامپوننت ها قرار دهید و ساعت را برای استفاده از قالب 12 ساعته به روز کنید:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.Local)
	fmt.Println("The time is", theTime)

	fmt.Println(theTime.Format("2006-1-2 15:4:5"))
	fmt.Println(theTime.Format("2006-01-02 03:04:05 pm"))
}

پس از ذخیره کد خود، دوباره برنامه را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT
2021-8-15 14:30:45
2021-08-15 02:30:45 pm

خواهید دید که با افزودن یک پیشوند 0 به اعداد در رشته طرح بندی، 8 ماه در خروجی جدید به 08 تبدیل می شود تا با چیدمان مطابقت داشته باشد. ساعت که اکنون در قالب 12 ساعته است، پیشوند 0 خود را نیز دارد. با این حال، در پایان، آنچه در خروجی مشاهده می کنید، فرمتی را که در کد می بینید منعکس می کند، بنابراین در صورت نیاز، تغییر قالب آسان تر است.

بسیاری از اوقات، تاریخ‌های قالب‌بندی شده برای تفسیر برنامه‌های دیگر در نظر گرفته شده‌اند، و هر بار که می‌خواهید از آن‌ها استفاده کنید، ایجاد مجدد آن فرمت‌ها می‌تواند بار سنگینی باشد. در برخی موارد، می توانید از یک قالب از پیش تعریف شده استفاده کنید.

با استفاده از فرمت از پیش تعریف شده

بسیاری از قالب‌های تاریخ معمولاً مورد استفاده قرار می‌گیرند، مانند مهرهای زمانی برای پیام‌های گزارش، و ایجاد مجدد آن‌ها هر بار که می‌خواهید از آن‌ها استفاده کنید، ممکن است دردسرساز شود. برای برخی از این موارد، بسته زمانی شامل فرمت های از پیش تعریف شده ای است که می توانید استفاده کنید.

یکی از قالب‌های موجود و اغلب مورد استفاده، فرمت تعریف‌شده در RFC 3339 است. RFC سندی است که برای تعریف نحوه عملکرد استانداردها در اینترنت استفاده می‌شود و RFC‌های دیگر می‌توانند بر روی یکدیگر ایجاد کنند. یک RFC وجود دارد که نحوه عملکرد HTTP را تعریف می کند (RFC 2616)، برای مثال، و دیگرانی که در بالای آن برای تعریف بیشتر HTTP ساخته می شوند. بنابراین، در مورد RFC 3339، RFC یک قالب استاندارد برای استفاده برای مهرهای زمانی در اینترنت تعریف می‌کند. این قالب در سراسر اینترنت شناخته شده و به خوبی پشتیبانی می شود، بنابراین شانس دیدن آن در جای دیگر زیاد است.

هر یک از قالب‌های زمانی از پیش تعریف‌شده در بسته زمانی با یک رشته const به نام قالبی که نشان می‌دهند نشان داده می‌شوند. فرمت RFC 3339 دو فرمت در دسترس دارد، یکی به نام time.RFC3339 و دیگری به نام time.RFC3339Nano. تفاوت فرمت ها در این است که نسخه time.RFC3339Nano شامل نانوثانیه در فرمت است.

اکنون فایل main.go خود را دوباره باز کنید و برنامه خود را به روز کنید تا از فرمت time.RFC3339Nano برای خروجی آن استفاده کنید:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.Local)
	fmt.Println("The time is", theTime)
	
	fmt.Println(theTime.Format(time.RFC3339Nano))
}

از آنجایی که قالب‌های از پیش تعریف‌شده مقادیر رشته‌ای با قالب مورد نظر هستند، فقط باید قالبی را که معمولاً استفاده می‌کنید با یکی از آنها جایگزین کنید.

برای دیدن خروجی، برنامه خود را با go run دوباره اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT
2021-08-15T14:30:45.0000001-05:00

اگر بخواهید مقدار زمانی را به عنوان رشته در جایی ذخیره کنید، از فرمت RFC 3339 استفاده می شود. این می تواند توسط بسیاری از زبان های برنامه نویسی و برنامه های کاربردی دیگر خوانده شود، و به همان اندازه فشرده است که تاریخ و زمان می تواند در قالب رشته ای انعطاف پذیر باشد.

در این بخش، برنامه خود را به روز کردید تا از روش Format برای چاپ تاریخ و زمان استفاده کنید. استفاده از این طرح‌بندی انعطاف‌پذیر به کد شما اجازه می‌دهد شبیه به خروجی نهایی باشد. در نهایت، شما از یکی از رشته های چیدمان از پیش تعریف شده برای چاپ تاریخ و زمان با استفاده از قالبی که به خوبی پشتیبانی می شود استفاده کردید. در بخش بعدی، برنامه خود را به‌روزرسانی می‌کنید تا همان مقدار رشته را به یک مقدار time.Time تبدیل کنید که می‌توانید با آن کار کنید.

تجزیه تاریخ و زمان در رشته ها

اغلب هنگام توسعه برنامه‌ها، با تاریخ‌هایی مواجه می‌شوید که به‌عنوان مقادیر رشته‌ای نشان داده می‌شوند که باید به نحوی آن‌ها را تفسیر کنید. گاهی اوقات، شما باید قسمت تاریخ مقدار را بدانید، گاهی اوقات ممکن است نیاز به دانستن بخش زمانی داشته باشید، و برخی دیگر ممکن است به کل مقدار نیاز داشته باشید. بسته Go time علاوه بر استفاده از روش Format برای ایجاد مقادیر رشته ای از مقادیر time.Time، تابع time.Parse را برای تبدیل یک رشته به مقدار time.Time ارائه می دهد. تابع time.Parse شبیه به روش Format عمل می کند، به این صورت که طرح تاریخ و زمان مورد انتظار و همچنین مقدار رشته را به عنوان پارامتر می گیرد.

اکنون فایل main.go را در برنامه خود باز کنید و آن را به روز کنید تا از تابع time.Parse برای تجزیه یک timeString به متغیر time.Time استفاده کنید:

projects/datetime/main.go
...

func main() {
	timeString := "2021-08-15 02:30:45"
	theTime, err := time.Parse("2006-01-02 03:04:05", timeString)
	if err != nil {
		fmt.Println("Could not parse time:", err)
	}
	fmt.Println("The time is", theTime)
	
	fmt.Println(theTime.Format(time.RFC3339Nano))
}

برخلاف روش Format، متد time.Parse همچنین در صورتی که مقدار رشته ارسال شده با طرح ارائه شده به عنوان پارامتر اول مطابقت نداشته باشد، مقدار خطای احتمالی را برمی گرداند. اگر به چیدمان استفاده شده نگاه کنید، می بینید که چیدمان داده شده به time.Parse از همان 1 برای ماه، 2 برای روز ماه و غیره استفاده می کند که در متد Format استفاده می شود.

پس از ذخیره به روز رسانی های خود، می توانید برنامه به روز شده خود را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 02:30:45 +0000 UTC
2021-08-15T02:30:45Z

در این خروجی باید به چند نکته توجه کرد. یکی این که منطقه زمانی که از timeString تجزیه می‌شود از منطقه زمانی پیش‌فرض استفاده می‌کند که یک افست +0 است و به عنوان زمان جهانی هماهنگ (UTC) شناخته می‌شود. از آنجایی که نه مقدار زمان و نه چیدمان شامل منطقه زمانی نمی شود، تابع time.Parse نمی داند که با کدام منطقه زمانی مرتبط شود. اگر زمانی به آن نیاز داشتید، بسته زمانی شامل یک تابع time.ParseInLocation می‌شود تا بتوانید مکان مورد استفاده را ارائه دهید. بخش دیگری که باید به آن توجه کرد در خروجی RFC 3339 است. خروجی از طرح‌بندی نانو RFC3339 استفاده می‌کند، اما خروجی شامل هیچ نانوثانیه‌ای نمی‌شود. این به این دلیل است که تابع time.Parse هیچ نانوثانیه‌ای را تجزیه نمی‌کند، بنابراین مقدار روی پیش‌فرض 0 تنظیم می‌شود. وقتی نانوثانیه‌ها 0 هستند، فرمت time.RFC3339Nano شامل نانوثانیه‌ها در خروجی نمی‌شود.

متد time.Parse همچنین می‌تواند از هر یک از طرح‌بندی‌های زمانی از پیش تعریف‌شده ارائه شده در بسته زمان هنگام تجزیه یک مقدار رشته استفاده کند. برای مشاهده این موضوع در عمل، فایل main.go خود را باز کنید و مقدار timeString را به روز کنید تا با خروجی time.RFC3339Nano قبل از آن مطابقت داشته باشد و پارامتر time.Parse را برای مطابقت به روز کنید:

projects/datetime/main.go
...

func main() {
	timeString := "2021-08-15T14:30:45.0000001-05:00"
	theTime, err := time.Parse(time.RFC3339Nano, timeString)
	if err != nil {
		fmt.Println("Could not parse time:", err)
	}
	fmt.Println("The time is", theTime)
	
	fmt.Println(theTime.Format(time.RFC3339Nano))
}

هنگامی که کد را به روز کردید، می توانید برنامه خود را ذخیره کرده و با استفاده از go run دوباره اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT
2021-08-15T14:30:45.0000001-05:00

این بار، خروجی از روش Format نشان می دهد که time.Parse توانست هم منطقه زمانی و هم نانوثانیه های timeString را تجزیه کند.

در این بخش، از تابع time.Parse برای تجزیه یک مقدار رشته تاریخ و زمان فرمت شده دلخواه و همچنین یک طرح از پیش تعریف شده استفاده کردید. با این حال، تا کنون، با مناطق زمانی مختلفی که دیده‌اید تعاملی نداشته‌اید. مجموعه دیگری از ویژگی‌هایی که Go برای زمان ارائه می‌کند. نوع زمان، امکان تبدیل بین مناطق زمانی مختلف است، همانطور که در بخش بعدی خواهید دید.

کار با مناطق زمانی

هنگام توسعه یک برنامه با کاربران در سراسر جهان، یا حتی در چند منطقه زمانی، یک روش معمول این است که تاریخ ها و زمان ها را با استفاده از زمان جهانی هماهنگ (UTC) ذخیره کنید و سپس در صورت لزوم به زمان محلی کاربر تبدیل کنید. این اجازه می دهد تا داده ها در یک فرمت ثابت ذخیره شوند و محاسبات بین آنها را آسان تر می کند، زیرا تبدیل تنها زمانی لازم است که تاریخ و زمان را به کاربر نمایش دهد.

در بخش‌های قبلی این آموزش، برنامه‌ای ایجاد کردید که عمدتاً بر اساس زمان‌های منطقه زمانی محلی شما کار می‌کرد. برای صرفه جویی در زمان خود. مقادیر زمان به عنوان UTC، ابتدا باید آنها را به UTC تبدیل کنید. شما این کار را با استفاده از روش UTC انجام خواهید داد، که یک کپی از زمانی که آن را فراخوانی می کنید، اما در UTC را برمی گرداند.

اکنون، فایل main.go خود را باز کنید تا برنامه خود را به روز کنید تا از روش UTC در theTime برای برگرداندن نسخه UTC زمان استفاده کنید:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.Local)
	fmt.Println("The time is", theTime)
	fmt.Println(theTime.Format(time.RFC3339Nano))
	
	utcTime := theTime.UTC()
	fmt.Println("The UTC time is", utcTime)
	fmt.Println(utcTime.Format(time.RFC3339Nano))
}

این بار برنامه شما theTime را به‌عنوان زمان. مقدار زمان در منطقه زمانی محلی شما ایجاد می‌کند، آن را در دو قالب مختلف چاپ می‌کند، سپس از روش UTC برای ترجمه آن زمان از زمان محلی شما به زمان UTC استفاده می‌کند.

برای دیدن خروجی برنامه، می توانید آن را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT
2021-08-15T14:30:45.0000001-05:00
The UTC time is 2021-08-15 19:30:45.0000001 +0000 UTC
2021-08-15T19:30:45.0000001Z

خروجی شما بسته به منطقه زمانی محلی شما متفاوت خواهد بود، اما در خروجی بالا، خواهید دید که اولین باری که چاپ می شود در CDT (زمان نوری مرکزی آمریکای شمالی) است که 5- ساعت از UTC فاصله دارد. هنگامی که متد UTC فراخوانی شد و زمان UTC چاپ شد، می توانید ببینید که ساعت در زمان از 14 به 19 می رسد، زیرا تبدیل زمان به UTC پنج ساعت اضافه می کند.

همچنین می‌توان یک زمان UTC را به زمان محلی با استفاده از روش محلی در یک زمان. زمان به همان روش تبدیل کرد. فایل main.go خود را دوباره باز کنید و آن را به روز کنید تا یک تماس به روش محلی در utcTime اضافه کنید تا آن را به منطقه زمانی محلی خود تبدیل کنید:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.Local)
	fmt.Println("The time is", theTime)
	fmt.Println(theTime.Format(time.RFC3339Nano))
	
	utcTime := theTime.UTC()
	fmt.Println("The UTC time is", utcTime)
	fmt.Println(utcTime.Format(time.RFC3339Nano))

	localTime := utcTime.Local()
	fmt.Println("The Local time is", localTime)
	fmt.Println(localTime.Format(time.RFC3339Nano))
}

هنگامی که فایل شما ذخیره شد، برنامه خود را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 -0500 CDT
2021-08-15T14:30:45.0000001-05:00
The UTC time is 2021-08-15 19:30:45.0000001 +0000 UTC
2021-08-15T19:30:45.0000001Z
The Local time is 2021-08-15 14:30:45.0000001 -0500 CDT
2021-08-15T14:30:45.0000001-05:00

خواهید دید که زمان UTC دوباره به منطقه زمانی محلی شما تبدیل شده است. در خروجی بالا، تبدیل UTC به CDT به این معنی است که پنج ساعت از UTC کم شده است و ساعت را از 19 به 14 تغییر می دهد.

در این بخش، شما برنامه خود را برای تبدیل تاریخ و زمان بین منطقه زمانی محلی خود و منطقه زمانی استاندارد UTC با استفاده از روش UTC به روز کردید، سپس دوباره با استفاده از روش محلی برگشتید.

هنگامی که مقادیر تاریخ و زمان خود را در دسترس قرار دادید، تعدادی ویژگی اضافی وجود دارد که بسته Go time ارائه می دهد که می تواند در برنامه های شما مفید باشد. یکی از این ویژگی ها تعیین این است که آیا زمان معین قبل یا بعد از دیگری است.

مقایسه دو بار

مقایسه دو تاریخ با یکدیگر، به دلیل همه متغیرهایی که باید در هنگام مقایسه آنها در نظر گرفته شوند، گاهی اوقات به طرز فریبنده ای دشوار است. به عنوان مثال، نیاز به در نظر گرفتن مناطق زمانی، یا این واقعیت که ماه ها تعداد روزهای متفاوتی از یکدیگر دارند. بسته زمان چند روش را برای آسان تر کردن این کار ارائه می دهد.

بسته زمان دو روش برای آسان‌تر کردن این مقایسه‌ها ارائه می‌کند: روش‌های قبل و بعد، که در نوع time.Time در دسترس هستند. این روش‌ها هر دو یک مقدار زمانی واحد را می‌پذیرند و بسته به اینکه زمانی که فراخوانی می‌شوند قبل یا بعد از زمان ارائه شده باشد، true یا false را برمی‌گردانند.

برای مشاهده نمونه ای از این توابع در عمل، فایل main.go خود را باز کنید و آن را به روز کنید تا شامل دو تاریخ مختلف باشد، سپس از قبل و بعد برای مقایسه آن تاریخ ها برای دیدن خروجی استفاده کنید:

projects/datetime/main.go
...

func main() {
	firstTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.UTC)
	fmt.Println("The first time is", firstTime)

	secondTime := time.Date(2021, 12, 25, 16, 40, 55, 200, time.UTC)
	fmt.Println("The second time is", secondTime)

	fmt.Println("First time before second?", firstTime.Before(secondTime))
	fmt.Println("First time after second?", firstTime.After(secondTime))

	fmt.Println("Second time before first?", secondTime.Before(firstTime))
	fmt.Println("Second time after first?", secondTime.After(firstTime))
}

هنگامی که فایل خود را به روز کردید، آن را ذخیره کرده و با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The first time is 2021-08-15 14:30:45.0000001 +0000 UTC
The second time is 2021-12-25 16:40:55.0000002 +0000 UTC
First time before second? true
First time after second? false
Second time before first? false
Second time after first? true

از آنجایی که کد از تاریخ های صریح در منطقه زمانی UTC استفاده می کند، خروجی شما باید با خروجی بالا مطابقت داشته باشد. خواهید دید که هنگام استفاده از روش Before در firstTime و ارائه آن secondTime برای مقایسه، این درست است که 2021-08-15 قبل از 2021-12-25 است. هنگام استفاده از روش After از firstTime و ارائه secondTime، اشتباه است که 2021-08-15 بعد از 2021-12-25 باشد. تغییر ترتیب فراخوانی متدها در secondTime، همانطور که انتظار می رود، نتایج مخالف را نشان می دهد.

روش دیگر برای مقایسه دو تاریخ و زمان با بسته زمانی، روش Sub است. متد Sub یک تاریخ را از تاریخ دیگر کم می کند و با استفاده از نوع جدیدی به نام time.Duration مقداری را برمی گرداند. بر خلاف یک مقدار time.Time، که یک نقطه مطلق در زمان را نشان می دهد، یک مقدار time.Duration نشان دهنده تفاوت در زمان است. به عنوان مثال، “در یک ساعت” مدت زمان خواهد بود زیرا به معنای چیزی متفاوت بر اساس زمان فعلی روز است، اما “در ظهر” یک زمان خاص و مطلق را نشان می دهد. Go از زمان استفاده می‌کند. نوع مدت زمان در تعدادی مکان، مانند زمانی که می‌خواهید مشخص کنید که یک تابع چه مدت باید قبل از بازگشت خطا منتظر بماند یا در اینجا، جایی که باید بدانید بین یک زمان و زمان دیگر چقدر زمان وجود دارد، استفاده می‌کند.

اکنون فایل main.go خود را به روز کنید تا از روش Sub در مقادیر firstTime و secondTime استفاده کنید و نتایج را چاپ کنید:

projects/datetime/main.go
...

func main() {
	firstTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.UTC)
	fmt.Println("The first time is", firstTime)

	secondTime := time.Date(2021, 12, 25, 16, 40, 55, 200, time.UTC)
	fmt.Println("The second time is", secondTime)

	fmt.Println("Duration between first and second time is", firstTime.Sub(secondTime))
	fmt.Println("Duration between second and first time is", secondTime.Sub(firstTime))

فایل خود را ذخیره کنید و سپس با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The first time is 2021-08-15 14:30:45.0000001 +0000 UTC
The second time is 2021-12-25 16:40:55.0000002 +0000 UTC
Duration between first and second time is -3170h10m10.0000001s
Duration between second and first time is 3170h10m10.0000001s

خروجی بالا می گوید 3170 ساعت، 10 دقیقه، 10 ثانیه و 100 نانوثانیه بین این دو تاریخ وجود دارد و چند نکته در مورد خروجی وجود دارد. اولین مورد این است که مدت زمان بین بار اول و دوم یک مقدار منفی است. این می‌گوید که زمان دوم بعد از زمان اول است و شبیه به زمانی خواهد بود که 5 را از 0 کم کنید و 5- را دریافت کنید. دومین موردی که باید به آن توجه کرد این است که بزرگترین واحد اندازه گیری مدت زمان یک ساعت است، بنابراین آن را به روز یا ماه تقسیم نمی کند. از آنجایی که تعداد روزهای یک ماه یکسان نیست و یک “روز” می تواند در طول سوئیچ برای ساعت تابستانی معنای متفاوتی داشته باشد، یک ساعت دقیق ترین اندازه گیری است که نوسان ندارد.

در این بخش، برنامه خود را برای مقایسه دو بار با استفاده از سه روش مختلف به روز کردید. ابتدا از روش های قبل و بعد برای تعیین اینکه یک زمان قبل یا بعد از زمان دیگری است استفاده کردید، سپس از Sub استفاده کردید تا ببینید بین دو بار چقدر است. دریافت مدت زمان بین دو زمان تنها راهی نیست که بسته زمانی از زمان استفاده می‌کند، اما مدت زمان. همچنین می‌توانید از آن برای افزودن یا حذف زمان از مقدار زمان استفاده کنید، همانطور که در بخش بعدی خواهید دید.

اضافه یا تفریق زمان

هنگام نوشتن یک برنامه، یک عملیات رایج با استفاده از تاریخ و زمان، تعیین زمان گذشته یا آینده بر اساس زمان دیگر است. می‌توان از آن برای عملکرد استفاده کرد، مانند تعیین زمان تمدید اشتراک بعدی، یا اینکه مدت زمان مشخصی از بررسی مقداری گذشته است. در هر صورت، بسته Go time راهی برای مدیریت آن ارائه می دهد. برای پیدا کردن تاریخ دیگری بر اساس تاریخی که قبلاً می‌دانید، باید بتوانید زمان خود را تعیین کنید. مقادیر مدت زمان.

ایجاد یک مقدار time.Duration شبیه نحوه نوشتن مدت زمان روی کاغذ است، فقط با ضرب واحد زمان. به عنوان مثال، برای ایجاد زمان. مدت زمان برای نشان دادن یک ساعت، باید آن را با استفاده از مقدار time.Hour ضرب در تعداد ساعت‌هایی که می‌خواهید زمان را نشان دهید، تعریف کنید.

oneHour := 1 * time.Hour
twoHours := 2 * time.Hour
tenHours := 10 * time.Hour

اعلان واحدهای زمانی کوچکتر به روشی مشابه انجام می شود، به جز استفاده از time.minute، time.second و غیره:

tenMinutes := 10 * time.Minute
fiveSeconds := 5 * time.Second

همچنین می توان یک مدت زمان را به مدت زمان دیگر اضافه کرد تا مجموع مدت زمان ها بدست آید. برای اینکه این را در عمل ببینید، فایل main.go خود را باز کنید و آن را به روز کنید تا یک متغیر toAdd duration را اعلام کنید و مدت زمان های مختلف را به آن اضافه کنید:

projects/datetime/main.go
...

func main() {
	toAdd := 1 * time.Hour
	fmt.Println("1:", toAdd)

	toAdd += 1 * time.Minute
	fmt.Println("2:", toAdd)

	toAdd += 1 * time.Second
	fmt.Println("3:", toAdd)
}

پس از اتمام به روز رسانی، فایل را ذخیره کنید و برنامه خود را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
1: 1h0m0s
2: 1h1m0s
3: 1h1m1s

هنگامی که به خروجی نگاه می کنید، خواهید دید که اولین مدت چاپ یک ساعت است که مطابق با زمان 1 * ساعت در کد شما است. در مرحله بعد، 1 * time.Minute را به مقدار toAdd اضافه کردید، که به عنوان مقدار یک ساعت، یک دقیقه نشان داده می شود. در نهایت، 1 * time.Second را به toAdd اضافه کردید، که منجر به مقدار زمان. مدت زمان یک ساعت، یک دقیقه و یک ثانیه شد.

همچنین می توان با اضافه کردن مدت زمان ها در یک عبارت، یا کم کردن مدت زمان از دیگری را ترکیب کرد:

oneHourOneMinute := 1 * time.Hour + 1 * time.Minute
tenMinutes := 1 * time.Hour - 50 * time.Minute

بعد، فایل main.go خود را باز کنید و برنامه خود را به روز کنید تا از ترکیبی مانند این برای کم کردن یک دقیقه و یک ثانیه از toAdd استفاده کنید:

projects/datetime/main.go
...

func main() {
	
	...
	
	toAdd += 1 * time.Second
	fmt.Println("3:", toAdd)
	
	toAdd -= 1*time.Minute + 1*time.Second
	fmt.Println("4:", toAdd)
}

پس از ذخیره کد خود، می توانید برنامه را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
1: 1h0m0s
2: 1h1m0s
3: 1h1m1s
4: 1h0m0s

خط چهارم جدید اضافه شده به خروجی کد جدیدی را که برای تفریق مجموع 1 * time.Minute و 1 * time اضافه کرده اید نشان می دهد.

استفاده از این مدت زمان‌ها که با متد Add of the time.Time جفت شده‌اند، به شما این امکان را می‌دهد که یک مقدار زمانی را که قبلاً دارید انتخاب کنید و زمان را در نقطه دلخواه دیگری قبل یا بعد از آن زمان تعیین کنید. برای مشاهده نمونه ای از این در حال اجرا، فایل main.go خود را باز کنید و آن را به روز کنید تا مقدار toAdd را روی 24 ساعت یا 24 * time.Hour تنظیم کنید. سپس، از روش افزودن روی مقدار time.Time استفاده کنید تا ببینید 24 ساعت پس از آن نقطه چه زمانی خواهد بود:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.UTC)
	fmt.Println("The time is", theTime)

	toAdd := 24 * time.Hour
	fmt.Println("Adding", toAdd)

	newTime := theTime.Add(toAdd)
	fmt.Println("The new time is", newTime)
}

پس از ذخیره فایل خود، برنامه خود را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 +0000 UTC
Adding 24h0m0s
The new time is 2021-08-16 14:30:45.0000001 +0000 UTC

با نگاهی به خروجی، خواهید دید که افزودن 24 ساعت به 2021-08-15 منجر به تاریخ جدید 2021-08-16 می شود.

برای کم کردن زمان، از روش افزودن نیز استفاده می‌کنید که کمی غیرمعمول است. از آنجایی که از روش Sub برای بدست آوردن اختلاف زمان بین دو تاریخ استفاده می شود، با استفاده از Add با مقدار منفی، زمان را از مقدار time.Time کم می کنید.

یک بار دیگر، برای مشاهده این مورد در برنامه خود، فایل main.go خود را باز کرده و آن را به روز کنید تا مقدار 24 ساعته toAdd را به مقدار منفی تغییر دهید:

projects/datetime/main.go
...

func main() {
	theTime := time.Date(2021, 8, 15, 14, 30, 45, 100, time.UTC)
	fmt.Println("The time is", theTime)

	toAdd := -24 * time.Hour
	fmt.Println("Adding", toAdd)

	newTime := theTime.Add(toAdd)
	fmt.Println("The new time is", newTime)
}

پس از ذخیره فایل خود، یک بار دیگر برنامه خود را با استفاده از go run اجرا کنید:

go run main.go

خروجی شبیه به این خواهد بود:

Output
The time is 2021-08-15 14:30:45.0000001 +0000 UTC
Adding -24h0m0s
The new time is 2021-08-14 14:30:45.0000001 +0000 UTC

این بار در خروجی خواهید دید که به جای اضافه کردن 24 ساعت به زمان اصلی، تاریخ جدید 24 ساعت قبل از زمان اصلی است.

در این بخش از time.Hour، time.Minute و time.Second برای ایجاد مقادیر time.Duration در درجات مختلف استفاده کردید. شما همچنین از مقادیر time.Duration با متد Add استفاده کردید تا یک مقدار time.Time جدید قبل و بعد از مقدار اصلی بدست آورید. با ترکیب زمان. اکنون، روش افزودن، و روش های قبل یا بعد، به عملکرد قدرتمند تاریخ و زمان برای برنامه های خود دسترسی خواهید داشت.

نتیجه

در این آموزش، شما از time.Now برای بازیابی یک مقدار time.Time برای زمان محلی فعلی در رایانه خود استفاده کردید، سپس از سال، ماه، ساعت و روش های دیگر برای دسترسی به اطلاعات خاصی در مورد آن زمان استفاده کردید. سپس، از روش Format برای چاپ زمان با استفاده از یک قالب سفارشی و یک قالب از پیش تعریف شده استفاده کردید. در مرحله بعد، از تابع time.Parse برای تفسیر مقدار رشته با زمان در آن و استخراج مقدار زمان از آن استفاده کردید. هنگامی که مقدار زمان را داشتید، از روش های UTC و Local برای ترجمه زمان بین UTC و منطقه زمانی محلی خود استفاده کردید. پس از آن، قبل از استفاده از روش افزودن برای یافتن زمان نسبت به مقدار زمانی متفاوت، از روش Sub برای بدست آوردن مدت زمان بین دو زمان مختلف استفاده کردید.

استفاده از توابع و روش‌های مختلفی که در این آموزش توضیح داده شده است، کمک زیادی به برنامه‌های شما می‌کند، اما بسته Go time در صورت علاقه، تعدادی ویژگی دیگر را نیز شامل می‌شود.

https://vpsgol.net/product/vps-germany/

https://vpsgol.net/product/vps-usa/

https://vpsgol.net/product/vps-france/

https://vpsgol.net/product/vps-canada/

https://vpsgol.net/product/vps-poland/

https://vpsgol.net/product/vps-netherlands/

https://vpsgol.net/product/vps-england/

برچسب ها:
, , , , , , ,
جدیدتر نحوه نصب Hadoop در حالت مستقل در اوبونتو 20.04
بازگشت به لیست
قدیمی تر نحوه راه اندازی یک سرور پخش ویدئو با استفاده از Nginx-RTMP در اوبونتو 20.04

نوشته های مشابه

24 ژانویه
آموزش معرفی و بررسی, دسته‌بندی نشده

نحوه راه اندازی یک سرور پخش ویدئو با استفاده از Nginx-RTMP در اوبونتو 20.04

معرفی موارد استفاده زیادی برای پخش ویدیو وجود دارد. ارائه دهندگان خدمات مانند Twitch برای مدیریت جنبه های اکتشاف وب و مدیریت جامعه جریا...

ادامه مطلب