کتابخانه‌های استاندارد Go: بررسی بخش‌های ضروری

زبان برنامه‌نویسی Go، که اغلب با نام Golang شناخته می‌شود، از زمان معرفی خود توسط گوگل در سال ۲۰۰۹، به سرعت به یکی از محبوب‌ترین گزینه‌ها برای توسعه سیستم‌های مقیاس‌پذیر، هم‌روند و کارآمد تبدیل شده است. یکی از نقاط قوت اصلی Go که آن را از بسیاری از زبان‌های دیگر متمایز می‌کند، قدرت و جامعیت کتابخانه استاندارد (Standard Library) آن است. این کتابخانه، که همراه با هر نصب Go ارائه می‌شود، مجموعه‌ای غنی از پکیج‌ها را فراهم می‌کند که تقریباً برای هر نیاز توسعه‌ای، از دستکاری رشته‌ها و عملیات فایل گرفته تا ساخت سرورهای وب و مدیریت همزمانی، راه‌حل‌های توکار و بهینه ارائه می‌دهد. فلسفه طراحی Go بر سادگی، عملکرد و “باتری‌های همراه” (batteries included) تأکید دارد، و کتابخانه استاندارد تجلی بارز این فلسفه است. توسعه‌دهندگان Go می‌توانند با اطمینان خاطر بر روی پکیج‌های استاندارد تکیه کنند، زیرا آن‌ها به خوبی آزمایش شده، بهینه شده و توسط جامعه Go نگهداری می‌شوند. این رویکرد نه تنها زمان توسعه را کاهش می‌دهد، بلکه به سازگاری و قابلیت اطمینان کدها در سراسر اکوسیستم Go کمک شایانی می‌کند. در این مقاله جامع، ما به بررسی عمیق‌تر بخش‌های کلیدی و ضروری کتابخانه استاندارد Go خواهیم پرداخت و نحوه استفاده موثر از آن‌ها را برای ساخت برنامه‌های قدرتمند و مقیاس‌پذیر نشان خواهیم داد.

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

مقدمه: چرا کتابخانه استاندارد Go محوری است؟

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

فلسفه پشت کتابخانه استاندارد Go، سادگی و کارایی است. پکیج‌ها به گونه‌ای طراحی شده‌اند که وظایف خاصی را به بهترین نحو ممکن انجام دهند، بدون آنکه پیچیدگی‌های غیرضروری را به سیستم تحمیل کنند. این موضوع به ویژه در پکیج‌هایی مانند `net/http` و `sync` قابل مشاهده است، که ابزارهایی قدرتمند اما با رابط کاربری ساده برای توسعه‌دهندگان فراهم می‌کنند. علاوه بر این، بسیاری از پکیج‌ها در کتابخانه استاندارد Go، عملکردی را ارائه می‌دهند که در سایر زبان‌ها نیازمند کتابخانه‌های عظیم و پیچیده‌تر است. به عنوان مثال، قابلیت‌های همزمانی Go (با استفاده از goroutineها و channelها) به طور عمیقی در پکیج‌هایی مانند `sync` و `context` پشتیبانی می‌شوند و به توسعه‌دهندگان اجازه می‌دهند برنامه‌هایی با کارایی بالا و مقیاس‌پذیری فوق‌العاده بسازند بدون اینکه نگران پیچیدگی‌های مدیریت نخ‌ها و منابع مشترک باشند.

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

بخش‌های حیاتی برای ورودی/خروجی و دستکاری داده‌ها

هر برنامه کامپیوتری نیاز به تعامل با داده‌ها دارد، خواه این داده‌ها از ورودی کاربر باشند، از فایل‌ها خوانده شوند یا از طریق شبکه دریافت گردند. کتابخانه استاندارد Go ابزارهای قدرتمندی برای مدیریت ورودی/خروجی (I/O) و دستکاری داده‌ها فراهم می‌کند که پایه و اساس بسیاری از برنامه‌ها را تشکیل می‌دهند. پکیج‌های `fmt`, `io`, `bytes` و `strings` از جمله مهم‌ترین‌ها در این حوزه هستند.

پکیج `fmt`: قالب‌بندی و چاپ

پکیج `fmt` (به معنی format) یکی از پرکاربردترین پکیج‌ها در Go است که برای قالب‌بندی و چاپ ورودی/خروجی استفاده می‌شود. این پکیج شامل توابعی برای چاپ متون به کنسول، خواندن ورودی از کنسول و قالب‌بندی رشته‌ها است. توابع `Printf`, `Sprintf`, `Fprintf` و `Scanf`, `Sscanf`, `Fscanf` رایج‌ترین توابع آن هستند. `Printf` برای چاپ با فرمت به خروجی استاندارد، `Sprintf` برای قالب‌بندی یک رشته بدون چاپ، و `Fprintf` برای چاپ به یک `io.Writer` خاص استفاده می‌شوند. از طرف دیگر، توابع `Scanf` برای خواندن ورودی با فرمت از ورودی استاندارد، `Sscanf` از یک رشته و `Fscanf` از یک `io.Reader` استفاده می‌کنند.

package main

import (
	"fmt"
	"os"
)

func main() {
	// استفاده از Printf برای چاپ با فرمت به کنسول
	name := "Alice"
	age := 30
	fmt.Printf("Hello, my name is %s and I am %d years old.\n", name, age)

	// استفاده از Sprintf برای قالب‌بندی یک رشته
	message := fmt.Sprintf("User %s logged in at %s.", name, "2023-10-27 10:00:00")
	fmt.Println(message)

	// استفاده از Fprintf برای نوشتن به یک فایل (یا هر io.Writer دیگر)
	f, err := os.Create("log.txt")
	if err != nil {
		fmt.Println("Error creating file:", err)
		return
	}
	defer f.Close()
	fmt.Fprintf(f, "Log entry: %s\n", message)
	fmt.Println("Log written to log.txt")

	// استفاده از Scanf برای خواندن ورودی
	var inputName string
	var inputAge int
	fmt.Print("Enter your name and age: ")
	_, err = fmt.Scanf("%s %d", &inputName, &inputAge)
	if err != nil {
		fmt.Println("Error reading input:", err)
	} else {
		fmt.Printf("You entered: Name=%s, Age=%d\n", inputName, inputAge)
	}
}

پکیج `io`: رابط‌های ورودی/خروجی

پکیج `io` مجموعه‌ای از رابط‌ها (interfaces) را تعریف می‌کند که پایه و اساس تمام عملیات ورودی/خروجی در Go هستند. رابط‌های `Reader` و `Writer` از مهمترین این رابط‌ها هستند که به شما امکان می‌دهند با منابع مختلف (فایل‌ها، شبکه‌ها، حافظه) به روشی یکپارچه تعامل داشته باشید. این رابط‌ها امکان “polymorphism” را فراهم می‌کنند، به این معنی که می‌توانید توابعی بنویسید که هر نوع `Reader` یا `Writer` را بپذیرند، و این باعث افزایش قابلیت استفاده مجدد کد می‌شود.

package main

import (
	"fmt"
	"io"
	"os"
	"strings"
)

func main() {
	// Reader مثال: خواندن از یک رشته با strings.NewReader
	r := strings.NewReader("Hello, Go standard library!")
	buf := make([]byte, 10)
	for {
		n, err := r.Read(buf)
		fmt.Printf("Read %d bytes: %s\n", n, string(buf[:n]))
		if err == io.EOF {
			break
		}
		if err != nil {
			fmt.Println("Read error:", err)
			return
		}
	}

	// Writer مثال: نوشتن به os.Stdout
	fmt.Println("\nWriting to stdout:")
	_, err := io.WriteString(os.Stdout, "This is written directly to stdout.\n")
	if err != nil {
		fmt.Println("Write error:", err)
	}

	// io.Copy مثال: کپی کردن از یک Reader به یک Writer
	fmt.Println("\nCopying file content:")
	srcFile, err := os.Open("source.txt")
	if err != nil {
		// ایجاد فایل source.txt اگر وجود ندارد
		_ = os.WriteFile("source.txt", []byte("This is source content.\n"), 0644)
		srcFile, err = os.Open("source.txt")
		if err != nil {
			fmt.Println("Error opening source file:", err)
			return
		}
	}
	defer srcFile.Close()

	destFile, err := os.Create("destination.txt")
	if err != nil {
		fmt.Println("Error creating destination file:", err)
		return
	}
	defer destFile.Close()

	bytesCopied, err := io.Copy(destFile, srcFile)
	if err != nil {
		fmt.Println("Error copying:", err)
	} else {
		fmt.Printf("Copied %d bytes from source.txt to destination.txt\n", bytesCopied)
	}
}

این مثال‌ها نشان می‌دهند که چگونه با استفاده از رابط‌های `io.Reader` و `io.Writer` می‌توان عملیات I/O را به صورت انتزاعی انجام داد، که این امر قابلیت انعطاف‌پذیری و ماژولار بودن کد را به شدت افزایش می‌دهد.

پکیج `bytes` و `strings`: دستکاری کارآمد داده‌ها

پکیج‌های `bytes` و `strings` توابع و ابزارهایی برای دستکاری کارآمد `[]byte` (برش بایت‌ها) و `string` (رشته‌ها) فراهم می‌کنند. از آنجا که رشته‌ها در Go تغییرناپذیر هستند، توابع موجود در `strings` (مانند `Contains`, `Split`, `Join`, `Replace`) به طور معمول رشته‌های جدیدی را بازمی‌گردانند. پکیج `bytes` توابع مشابهی را برای برش بایت‌ها ارائه می‌دهد که اغلب در سناریوهایی که نیاز به عملکرد بالا و دستکاری مستقیم بایت‌ها است (مانند پروتکل‌های شبکه یا پردازش فایل‌های باینری) مفید هستند. `bytes.Buffer` یک پیاده‌سازی از `io.Reader` و `io.Writer` است که به شما اجازه می‌دهد بایت‌ها را در حافظه جمع‌آوری کرده و سپس آن‌ها را به عنوان یک برش بایت یا رشته بازیابی کنید؛ این ابزار به ویژه برای ساخت رشته‌ها به صورت پویا و کارآمد مفید است، زیرا از تخصیص حافظه مکرر جلوگیری می‌کند.

package main

import (
	"bytes"
	"fmt"
	"strings"
)

func main() {
	// استفاده از پکیج strings
	s := "Go programming language"
	fmt.Println("Original string:", s)
	fmt.Println("Contains 'Go'?", strings.Contains(s, "Go"))
	fmt.Println("Has prefix 'Go'?", strings.HasPrefix(s, "Go"))
	fmt.Println("Has suffix 'language'?", strings.HasSuffix(s, "language"))
	fmt.Println("Index of 'programming':", strings.Index(s, "programming"))

	parts := strings.Split(s, " ")
	fmt.Println("Split by space:", parts)

	joined := strings.Join(parts, "-")
	fmt.Println("Joined with hyphen:", joined)

	replaced := strings.ReplaceAll(s, "language", "development")
	fmt.Println("Replaced 'language':", replaced)

	// استفاده از پکیج bytes و bytes.Buffer
	var b bytes.Buffer
	b.WriteString("First part. ")
	b.WriteString("Second part. ")
	fmt.Fprintf(&b, "Number: %d. ", 123)
	fmt.Fprint(&b, "Last part.")

	fmt.Println("\nbytes.Buffer content:", b.String())

	// تبدیل bytes.Buffer به []byte
	byteSlice := b.Bytes()
	fmt.Printf("bytes.Buffer as []byte: %s\n", byteSlice)

	// عملیات روی []byte
	data := []byte("hello world")
	fmt.Println("Original byte slice:", string(data))
	fmt.Println("Contains 'world'?", bytes.Contains(data, []byte("world")))
	fmt.Println("Index of 'o':", bytes.IndexByte(data, 'o'))
}

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

پیمایش در دنیای شبکه با `net` و `net/http`

توسعه نرم‌افزارهای مدرن بدون قابلیت‌های شبکه تقریبا غیرممکن است. Go با کتابخانه استاندارد شبکه قدرتمند خود، `net` و به ویژه `net/http`، ساخت برنامه‌های شبکه، از جمله وب‌سرورها، کلاینت‌های HTTP، و سرویس‌های مبتنی بر پروتکل‌های TCP/UDP را بسیار آسان و کارآمد کرده است. این پکیج‌ها سنگ بنای بسیاری از میکرو سرویس‌ها، APIها و برنامه‌های وب Go هستند.

پکیج `net`: پایه و اساس شبکه

پکیج `net` پایه و اساس تمام عملیات شبکه در Go را فراهم می‌کند. این پکیج شامل انواع داده‌ها و توابعی برای کار با آدرس‌های IP، اتصالات TCP/UDP، و حل DNS است. اگرچه بیشتر توسعه‌دهندگان برای ساخت برنامه‌های وب از `net/http` استفاده می‌کنند، اما `net` زمانی ضروری است که نیاز به کنترل دقیق‌تر بر پروتکل‌های شبکه پایین‌تر دارید، یا برای ساخت کلاینت‌ها/سرورهای سفارشی TCP/UDP.

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
	// Resolve a hostname
	addrs, err := net.LookupHost("google.com")
	if err != nil {
		fmt.Println("Error looking up host:", err)
		return
	}
	fmt.Println("IP addresses for google.com:", addrs)

	// Connect to a TCP server (e.g., a simple echo server)
	// For this example, you might need a simple echo server running on localhost:8080
	// Example echo server (run in a separate goroutine or process):
	// go func() {
	//     ln, _ := net.Listen("tcp", ":8080")
	//     defer ln.Close()
	//     for {
	//         conn, _ := ln.Accept()
	//         go func(c net.Conn) {
	//             defer c.Close()
	//             io.Copy(c, c)
	//         }(conn)
	//     }
	// }()

	conn, err := net.DialTimeout("tcp", "localhost:8080", 2*time.Second)
	if err != nil {
		fmt.Println("Error connecting to TCP server:", err)
		fmt.Println("Please make sure a TCP server is running on localhost:8080 for this example.")
		// We'll proceed without connecting to avoid crashing for the main purpose of this example.
	} else {
		defer conn.Close()
		fmt.Println("\nSuccessfully connected to TCP server on localhost:8080")
		_, err := conn.Write([]byte("Hello TCP server!\n"))
		if err != nil {
			fmt.Println("Error writing to TCP server:", err)
		} else {
			buf := make([]byte, 1024)
			n, err := conn.Read(buf)
			if err != nil {
				fmt.Println("Error reading from TCP server:", err)
			} else {
				fmt.Printf("Received from TCP server: %s", string(buf[:n]))
			}
		}
	}
}

پکیج `net/http`: ساخت وب‌سرورها و کلاینت‌ها

پکیج `net/http` بدون شک یکی از قدرتمندترین و پرکاربردترین پکیج‌ها در کتابخانه استاندارد Go است. این پکیج ابزارهای کاملی برای ساخت سرورهای وب و کلاینت‌های HTTP فراهم می‌کند. استفاده از آن بسیار ساده است و به توسعه‌دهندگان اجازه می‌دهد در کمترین زمان، APIها و وب‌سرویس‌های قابل اعتماد و با کارایی بالا بسازند.

ساخت یک وب‌سرور ساده

برای ساخت یک وب‌سرور، کافیست توابعی را به عنوان handler برای مسیرهای مختلف ثبت کنید و سپس سرور را اجرا کنید. هر handler تابعی است که دو آرگومان `http.ResponseWriter` و `*http.Request` را دریافت می‌کند. `http.ResponseWriter` برای ارسال پاسخ به کلاینت استفاده می‌شود و `*http.Request` شامل جزئیات درخواست ورودی است.

package main

import (
	"fmt"
	"net/http"
	"time" // For demonstration of graceful shutdown
)

// Handler برای مسیر اصلی
func homeHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Welcome to the Home Page! Path: %s", r.URL.Path)
}

// Handler برای مسیر /hello
func helloHandler(w http.ResponseWriter, r *http.Request) {
	name := r.URL.Query().Get("name")
	if name == "" {
		name = "Guest"
	}
	fmt.Fprintf(w, "Hello, %s!", name)
}

// Handler برای مسیر /api/users
func apiUsersHandler(w http.ResponseWriter, r *http.Request) {
	if r.Method != http.MethodGet {
		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
		return
	}
	w.Header().Set("Content-Type", "application/json")
	fmt.Fprintln(w, `{"users": ["Alice", "Bob", "Charlie"]}`)
}

func main() {
	// ثبت handlerها برای مسیرهای مختلف
	http.HandleFunc("/", homeHandler)
	http.HandleFunc("/hello", helloHandler)
	http.HandleFunc("/api/users", apiUsersHandler)

	// تنظیم یک سرور HTTP با تنظیمات سفارشی
	server := &http.Server{
		Addr:         ":8080",
		ReadTimeout:  10 * time.Second,
		WriteTimeout: 10 * time.Second,
		IdleTimeout:  120 * time.Second,
		// Handler:      nil, // اگر nil باشد، از DefaultServeMux استفاده می کند
	}

	fmt.Println("Server starting on :8080...")
	// شروع گوش دادن به درخواست‌ها
	// Blocks until server stops or an error occurs
	if err := server.ListenAndServe(); err != http.ErrServerClosed {
		fmt.Printf("Server failed to start: %v\n", err)
	}
	fmt.Println("Server stopped.")
}

این کد یک وب‌سرور را روی پورت 8080 راه‌اندازی می‌کند. با مراجعه به `http://localhost:8080/`، `http://localhost:8080/hello?name=GoDev` و `http://localhost:8080/api/users` می‌توانید خروجی‌های مختلف را مشاهده کنید. استفاده از `http.Server` به شما امکان می‌دهد تا جزئیات بیشتری از جمله زمان‌بندی (timeouts) را برای سرور خود تنظیم کنید، که برای سرویس‌های Production حیاتی است.

ساخت یک کلاینت HTTP

`net/http` همچنین ساخت کلاینت‌های HTTP را برای ارسال درخواست به وب‌سرویس‌های دیگر آسان می‌کند. `http.Client` ابزاری برای این کار است که به شما امکان می‌دهد درخواست‌های GET, POST و غیره را ارسال کنید و پاسخ‌ها را دریافت کنید. می‌توانید تنظیماتی مانند زمان‌بندی و تغییر مسیر (redirects) را برای کلاینت خود پیکربندی کنید.

package main

import (
	"bytes"
	"fmt"
	"io"
	"net/http"
	"time"
)

func main() {
	// ساخت یک http.Client سفارشی
	client := &http.Client{
		Timeout: 5 * time.Second, // تنظیم زمان‌بندی برای درخواست
	}

	// ارسال درخواست GET
	resp, err := client.Get("https://jsonplaceholder.typicode.com/posts/1")
	if err != nil {
		fmt.Println("Error making GET request:", err)
		return
	}
	defer resp.Body.Close()

	fmt.Printf("GET Request Status: %s\n", resp.Status)
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading GET response body:", err)
		return
	}
	fmt.Println("GET Response Body:\n", string(body))

	// ارسال درخواست POST با JSON
	postData := []byte(`{"title": "foo", "body": "bar", "userId": 1}`)
	resp, err = client.Post("https://jsonplaceholder.typicode.com/posts", "application/json", bytes.NewBuffer(postData))
	if err != nil {
		fmt.Println("Error making POST request:", err)
		return
	}
	defer resp.Body.Close()

	fmt.Printf("\nPOST Request Status: %s\n", resp.Status)
	body, err = io.ReadAll(resp.Body)
	if err != nil {
		fmt.Println("Error reading POST response body:", err)
		return
	}
	fmt.Println("POST Response Body:\n", string(body))
}

این قابلیت‌های داخلی `net/http` Go را به انتخابی عالی برای توسعه هر نوع برنامه شبکه، از APIهای RESTful گرفته تا وب‌سایت‌های کامل، تبدیل کرده است. سادگی استفاده، کارایی بالا و توانایی مدیریت همزمانی به صورت بومی، آن را به ابزاری قدرتمند برای توسعه‌دهندگان Go تبدیل می‌کند.

همزمانی و مدیریت منابع: `sync` و `context`

یکی از ویژگی‌های برجسته Go، پشتیبانی قوی و توکار آن از همزمانی (concurrency) است که به توسعه‌دهندگان امکان می‌دهد برنامه‌هایی با کارایی بالا و واکنش‌گرا بسازند. این قابلیت از طریق Goroutineها و Channelها ارائه می‌شود، اما برای مدیریت صحیح منابع مشترک و کنترل جریان اجرا در برنامه‌های هم‌روند، پکیج‌های `sync` و `context` ضروری هستند. این پکیج‌ها ابزارهایی برای هماهنگ‌سازی Goroutineها، جلوگیری از شرایط رقابتی (race conditions) و مدیریت طول عمر عملیات‌ها فراهم می‌کنند.

پکیج `sync`: هماهنگ‌سازی Goroutineها

پکیج `sync` ابزارهای همزمانی اساسی را فراهم می‌کند که از جمله مهم‌ترین آن‌ها می‌توان به `Mutex` (Mutual Exclusion), `RWMutex` (Read-Write Mutex), `WaitGroup` و `Once` اشاره کرد. این ابزارها برای کنترل دسترسی به منابع مشترک و هماهنگ‌سازی عملیات بین Goroutineها حیاتی هستند.

`sync.Mutex`: حفاظت از منابع مشترک

`sync.Mutex` یک قفل انحصاری است که اطمینان می‌دهد تنها یک Goroutine در یک زمان می‌تواند به یک بخش حیاتی (critical section) از کد دسترسی داشته باشد. این امر برای جلوگیری از شرایط رقابتی هنگام دسترسی به داده‌های مشترک ضروری است.

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	balance int
	mu      sync.Mutex // Mutex برای حفاظت از balance
)

func deposit(amount int) {
	mu.Lock()   // قفل کردن Mutex
	defer mu.Unlock() // باز کردن قفل پس از اتمام تابع
	balance += amount
}

func withdraw(amount int) {
	mu.Lock()
	defer mu.Unlock()
	if balance >= amount {
		balance -= amount
	} else {
		fmt.Println("Insufficient funds!")
	}
}

func main() {
	balance = 100 // شروع با 100
	var wg sync.WaitGroup

	// 1000 واریز 10 واحدی به صورت همزمان
	for i := 0; i < 1000; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			deposit(10)
		}()
	}

	// 500 برداشت 5 واحدی به صورت همزمان
	for i := 0; i < 500; i++ {
		wg.Add(1)
		go func() {
			defer wg.Done()
			withdraw(5)
		}()
	}

	wg.Wait() // انتظار برای اتمام تمام Goroutineها
	fmt.Printf("Final balance: %d\n", balance) // انتظار برای 1000*10 = 10000 + 100 = 10100 - 500*5 = 2500 -> 7600
}

در این مثال، بدون `Mutex`، `balance` ممکن بود به دلیل شرایط رقابتی به مقدار نادرستی برسد. `Mutex` اطمینان می‌دهد که عملیات `deposit` و `withdraw` اتمیک هستند.

`sync.RWMutex`: قفل خواندن/نوشتن

`sync.RWMutex` یک قفل خواندن/نوشتن است که امکان دسترسی همزمان چند Goroutine برای خواندن را می‌دهد، اما تنها یک Goroutine می‌تواند برای نوشتن دسترسی داشته باشد. این قفل در سناریوهایی که خواندن بسیار بیشتر از نوشتن اتفاق می‌افتد، عملکرد بهتری نسبت به `Mutex` سنتی ارائه می‌دهد.

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	data  map[string]string
	rwMu  sync.RWMutex // RWMutex
	readCount int
)

func init() {
	data = make(map[string]string)
	data["key1"] = "value1"
	data["key2"] = "value2"
}

func readData(key string) {
	rwMu.RLock() // قفل خواندن
	defer rwMu.RUnlock()
	readCount++
	time.Sleep(50 * time.Millisecond) // شبیه‌سازی کار
	fmt.Printf("Read key '%s': %s (reads: %d)\n", key, data[key], readCount)
}

func writeData(key, value string) {
	rwMu.Lock() // قفل نوشتن
	defer rwMu.Unlock()
	data[key] = value
	fmt.Printf("Wrote key '%s' with value '%s'\n", key, value)
}

func main() {
	var wg sync.WaitGroup

	// شروع 10 Goroutine برای خواندن
	for i := 0; i < 10; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			readData(fmt.Sprintf("key%d", (id%2)+1)) // خواندن key1 یا key2
		}(i)
	}

	// شروع 2 Goroutine برای نوشتن
	wg.Add(1)
	go func() {
		defer wg.Done()
		writeData("key3", "newValue3")
	}()

	wg.Add(1)
	go func() {
		defer wg.Done()
		writeData("key1", "updatedValue1")
	}()

	wg.Wait()
	fmt.Println("All operations completed.")
	fmt.Println("Final data:", data)
}

`sync.WaitGroup`: انتظار برای اتمام گروهی از Goroutineها

`sync.WaitGroup` به شما امکان می‌دهد تا منتظر بمانید تا مجموعه‌ای از Goroutineها عملیات خود را به پایان برسانند. این ابزار برای هماهنگ‌سازی شروع و پایان وظایف هم‌روند بسیار مفید است.

package main

import (
	"fmt"
	"sync"
	"time"
)

func worker(id int, wg *sync.WaitGroup) {
	defer wg.Done() // کاهش شمارنده WaitGroup هنگام خروج از تابع
	fmt.Printf("Worker %d starting...\n", id)
	time.Sleep(time.Duration(id) * 100 * time.Millisecond) // شبیه‌سازی کار
	fmt.Printf("Worker %d finished.\n", id)
}

func main() {
	var wg sync.WaitGroup
	numWorkers := 5

	for i := 1; i <= numWorkers; i++ {
		wg.Add(1) // افزایش شمارنده WaitGroup
		go worker(i, &wg)
	}

	fmt.Println("Main: All workers launched, waiting for them to complete...")
	wg.Wait() // منتظر ماندن تا شمارنده به صفر برسد
	fmt.Println("Main: All workers completed.")
}

`sync.Once`: اجرای تنها یک بار

`sync.Once` تضمین می‌کند که یک عملیات خاص (مثلاً مقداردهی اولیه یک منبع) تنها یک بار اجرا شود، حتی اگر چندین Goroutine به صورت همزمان آن را فراخوانی کنند. این برای مقداردهی اولیه Lazy یا اطمینان از مقداردهی اولیه یک باره مفید است.

package main

import (
	"fmt"
	"sync"
	"time"
)

var (
	once     sync.Once
	configLoaded bool
)

func loadConfig() {
	// این تابع تنها یک بار اجرا خواهد شد
	fmt.Println("Loading configuration (this should only happen once)...")
	time.Sleep(time.Second) // شبیه‌سازی بارگذاری
	configLoaded = true
	fmt.Println("Configuration loaded.")
}

func main() {
	var wg sync.WaitGroup

	for i := 0; i < 5; i++ {
		wg.Add(1)
		go func(id int) {
			defer wg.Done()
			fmt.Printf("Goroutine %d trying to load config...\n", id)
			once.Do(loadConfig) // فراخوانی تابع loadConfig تنها یک بار توسط sync.Once
			fmt.Printf("Goroutine %d finished config check. Config loaded: %t\n", id, configLoaded)
		}(i)
	}

	wg.Wait()
	fmt.Println("All goroutines completed their attempts to load config.")
}

پکیج `context`: مدیریت طول عمر عملیات‌ها و لغو

پکیج `context` (که در Go 1.7 معرفی شد) برای مدیریت طول عمر عملیات‌های هم‌روند، انتقال داده‌های درخواست‌محور (request-scoped data) و سیگنالینگ لغو (cancellation) و زمان‌بندی (deadlines) در درخت فراخوانی Goroutineها طراحی شده است. این پکیج به ویژه در سرویس‌های شبکه و میکرو سرویس‌ها که نیاز به مدیریت درخواست‌های طولانی‌مدت و آبشاری (cascading) دارند، بسیار مهم است.

یک `Context` می‌تواند توسط تابع والد ایجاد شود و سپس به توابع فرزند یا Goroutineهای جدید منتقل شود. زمانی که `Context` لغو می‌شود (به دلیل انقضای زمان‌بندی، لغو دستی، یا خطای والد)، تمام `Goroutine`هایی که آن `Context` را گوش می‌دهند، از این لغو مطلع می‌شوند و می‌توانند عملیات خود را متوقف کنند.

package main

import (
	"context"
	"fmt"
	"time"
)

func longRunningOperation(ctx context.Context, id int) {
	fmt.Printf("Worker %d: Starting long running operation...\n", id)
	select {
	case <-time.After(5 * time.Second): // شبیه‌سازی کار طولانی
		fmt.Printf("Worker %d: Operation completed successfully.\n", id)
	case <-ctx.Done(): // گوش دادن به سیگنال لغو از Context
		fmt.Printf("Worker %d: Operation cancelled. Error: %v\n", id, ctx.Err())
	}
}

func main() {
	// مثال 1: Context با زمان‌بندی (Timeout)
	fmt.Println("--- Example 1: Context with Timeout ---")
	ctxTimeout, cancelTimeout := context.WithTimeout(context.Background(), 3*time.Second)
	defer cancelTimeout() // همیشه cancel را فراخوانی کنید تا منابع آزاد شوند

	go longRunningOperation(ctxTimeout, 1)

	select {
	case <-ctxTimeout.Done():
		fmt.Println("Main: Context Timeout expired or cancelled.", ctxTimeout.Err())
	case <-time.After(6 * time.Second): // منتظر ماندن بیشتر از timeout worker
		fmt.Println("Main: Waited too long for worker 1.")
	}
	time.Sleep(1 * time.Second) // Wait a bit for goroutine output

	// مثال 2: Context با لغو دستی
	fmt.Println("\n--- Example 2: Context with Manual Cancellation ---")
	ctxCancel, cancelCancel := context.WithCancel(context.Background())
	go longRunningOperation(ctxCancel, 2)

	time.Sleep(2 * time.Second) // صبر برای شروع کار
	fmt.Println("Main: Cancelling operation for Worker 2...")
	cancelCancel() // لغو دستی Context

	select {
	case <-ctxCancel.Done():
		fmt.Println("Main: Context Cancelled.", ctxCancel.Err())
	case <-time.After(3 * time.Second):
		fmt.Println("Main: Waited too long for worker 2 to cancel.")
	}
	time.Sleep(1 * time.Second) // Wait a bit for goroutine output

	// مثال 3: انتقال داده با Context
	fmt.Println("\n--- Example 3: Context with Value ---")
	ctxValue := context.WithValue(context.Background(), "userID", 123)
	ctxValue = context.WithValue(ctxValue, "traceID", "abc-123")

	processRequest(ctxValue)
}

func processRequest(ctx context.Context) {
	userID := ctx.Value("userID")
	traceID := ctx.Value("traceID")
	fmt.Printf("Processing request for UserID: %v, TraceID: %v\n", userID, traceID)

	// این Context می تواند به توابع/goroutine های پایین تر پاس داده شود.
	// مثلاً یک تابع برای دسترسی به دیتابیس
	go func(c context.Context) {
		dbUser := c.Value("userID")
		dbTrace := c.Value("traceID")
		fmt.Printf("  DB Operation: Accessing data for UserID: %v, TraceID: %v\n", dbUser, dbTrace)
	}(ctx)

	time.Sleep(50 * time.Millisecond) // Allow goroutine to run
}

پکیج `context` به دلیل اهمیت آن در ساخت برنامه‌های هم‌روند و توزیع شده Go، به یک استاندارد داکتو (de facto) تبدیل شده است. استفاده صحیح از `sync` و `context` نه تنها به شما کمک می‌کند تا برنامه‌هایی ایمن‌تر در برابر شرایط رقابتی بنویسید، بلکه مدیریت پیچیدگی‌های همزمانی را در پروژه‌های بزرگ‌تر نیز آسان‌تر می‌کند.

تعامل با سیستم عامل و فایل‌ها: قدرت `os` و `path/filepath`

بسیاری از برنامه‌ها نیاز به تعامل با سیستم عامل زیرین خود دارند، از جمله دسترسی به فایل‌ها و دایرکتوری‌ها، کار با متغیرهای محیطی، و مدیریت فرآیندها. کتابخانه استاندارد Go، پکیج‌های `os` و `path/filepath` را برای انجام این وظایف به صورت کراس‌پلتفرم و کارآمد ارائه می‌دهد.

پکیج `os`: عملیات سیستم عامل

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

عملیات فایل و دایرکتوری

`os.Open`, `os.Create`, `os.ReadFile`, `os.WriteFile`, `os.Stat`, `os.Remove`, `os.MkdirAll` و `os.Rename` از پرکاربردترین توابع برای تعامل با فایل‌ها و دایرکتوری‌ها هستند.

package main

import (
	"fmt"
	"os"
	"path/filepath"
)

func main() {
	// ایجاد و نوشتن در یک فایل
	fileName := "example.txt"
	content := []byte("Hello, Go OS package!\nThis is a test file.")
	err := os.WriteFile(fileName, content, 0644) // 0644 مجوزهای فایل (rw-r--r--)
	if err != nil {
		fmt.Printf("Error writing file: %v\n", err)
		return
	}
	fmt.Printf("File '%s' created and written successfully.\n", fileName)

	// خواندن از یک فایل
	readContent, err := os.ReadFile(fileName)
	if err != nil {
		fmt.Printf("Error reading file: %v\n", err)
		return
	}
	fmt.Printf("Content of '%s':\n%s\n", fileName, string(readContent))

	// اطلاعات فایل
	fileInfo, err := os.Stat(fileName)
	if err != nil {
		fmt.Printf("Error getting file info: %v\n", err)
		return
	}
	fmt.Printf("File Name: %s, Size: %d bytes, Is Directory: %t, Last Modified: %v\n",
		fileInfo.Name(), fileInfo.Size(), fileInfo.IsDir(), fileInfo.ModTime())

	// ایجاد یک دایرکتوری (و دایرکتوری‌های والد در صورت نیاز)
	dirName := "temp_dir/nested_dir"
	err = os.MkdirAll(dirName, 0755) // 0755 مجوزهای دایرکتوری (rwxr-xr-x)
	if err != nil {
		fmt.Printf("Error creating directory: %v\n", err)
		return
	}
	fmt.Printf("Directory '%s' created successfully.\n", dirName)

	// تغییر نام فایل
	newFileName := "renamed_example.txt"
	err = os.Rename(fileName, newFileName)
	if err != nil {
		fmt.Printf("Error renaming file: %v\n", err)
		return
	}
	fmt.Printf("File renamed from '%s' to '%s'.\n", fileName, newFileName)

	// حذف فایل و دایرکتوری
	// defer os.Remove(newFileName) // برای پاکسازی پس از اتمام برنامه
	// defer os.RemoveAll("temp_dir") // برای پاکسازی دایرکتوری و محتویات آن
	fmt.Println("Cleanup tasks deferred.")

	// کار با متغیرهای محیطی
	os.Setenv("MY_GO_VAR", "Hello_Env!")
	envVar := os.Getenv("MY_GO_VAR")
	fmt.Printf("Environment variable MY_GO_VAR: %s\n", envVar)

	// آرگومان‌های خط فرمان
	fmt.Println("Command line arguments:", os.Args)
	if len(os.Args) > 1 {
		fmt.Printf("First argument: %s\n", os.Args[1])
	}
}

پکیج `path/filepath`: عملیات مسیر فایل

در حالی که پکیج `os` به عملیات‌های فایل سیستم می‌پردازد، پکیج `path/filepath` برای دستکاری و تجزیه مسیرهای فایل به صورت کراس‌پلتفرم طراحی شده است. این پکیج شامل توابعی برای پیوستن مسیرها، استخراج نام دایرکتوری یا نام فایل از یک مسیر، پاکسازی مسیرها و بررسی اینکه یک مسیر مطلق است یا نسبی می‌باشد. استفاده از `path/filepath` به جای رشته‌سازی دستی مسیرها، تضمین می‌کند که کد شما روی سیستم‌عامل‌های مختلف به درستی کار می‌کند، زیرا کاراکتر جداکننده مسیر (مثلاً `/` در یونیکس و `\` در ویندوز) به صورت خودکار مدیریت می‌شود.

package main

import (
	"fmt"
	"path/filepath"
	"os"
)

func main() {
	// پیوستن مسیرها
	fullPath := filepath.Join("dir1", "dir2", "file.txt")
	fmt.Printf("Joined path: %s\n", fullPath)

	// جدا کردن دایرکتوری و نام فایل
	dir, file := filepath.Split(fullPath)
	fmt.Printf("Split path -> Dir: '%s', File: '%s'\n", dir, file)

	// دریافت نام دایرکتوری اصلی
	baseDir := filepath.Dir(fullPath)
	fmt.Printf("Base directory: %s\n", baseDir)

	// دریافت نام فایل (base)
	baseFile := filepath.Base(fullPath)
	fmt.Printf("Base file name: %s\n", baseFile)

	// پاکسازی مسیر (حذف /./ و /../ و تبدیل // به /)
	cleanedPath := filepath.Clean("/a/./b/../c")
	fmt.Printf("Cleaned path '/a/./b/../c': %s\n", cleanedPath)

	// تشخیص مسیر مطلق
	absPath, err := filepath.Abs("relative/path/to/file.go")
	if err != nil {
		fmt.Println("Error getting absolute path:", err)
	} else {
		fmt.Printf("Absolute path for 'relative/path/to/file.go': %s\n", absPath)
	}

	// تشخیص آیا یک مسیر مطلق است
	fmt.Printf("Is '/usr/local/bin' absolute? %t\n", filepath.IsAbs("/usr/local/bin"))
	fmt.Printf("Is 'relative/path' absolute? %t\n", filepath.IsAbs("relative/path"))

	// یافتن مسیر اجرایی فعلی
	exePath, err := os.Executable()
	if err != nil {
		fmt.Println("Error getting executable path:", err)
	} else {
		fmt.Printf("Current executable path: %s\n", exePath)
		fmt.Printf("Executable directory: %s\n", filepath.Dir(exePath))
	}
}

با استفاده از پکیج‌های `os` و `path/filepath`، توسعه‌دهندگان Go می‌توانند به راحتی با فایل سیستم و سیستم عامل تعامل داشته باشند، برنامه‌هایی بنویسند که به صورت پایدار و قابل حمل در محیط‌های مختلف کار کنند.

سریال‌سازی و قالب‌بندی داده‌ها: `encoding` و `time`

در دنیای برنامه‌نویسی مدرن، تبادل و ذخیره داده‌ها به فرمت‌های استاندارد، امری حیاتی است. Go مجموعه‌ای از پکیج‌های `encoding` را برای کار با فرمت‌های مختلف سریال‌سازی داده‌ها (مانند JSON، XML، Gob، Base64) فراهم می‌کند. علاوه بر این، پکیج `time` ابزارهای جامعی برای کار با زمان و تاریخ ارائه می‌دهد که در هر برنامه‌ای که نیاز به مدیریت رویدادهای زمانی دارد، ضروری است.

پکیج `encoding`: فرمت‌های داده

پکیج `encoding` شامل زیرپکیج‌های متعددی برای کدگذاری و رمزگشایی داده‌ها به فرمت‌های مختلف است. `encoding/json` و `encoding/xml` برای تبادل داده‌های ساختاریافته، و `encoding/base64` برای انتقال داده‌های باینری از طریق کانال‌های متنی، از پرکاربردترین‌ها هستند.

`encoding/json`: کار با JSON

JSON (JavaScript Object Notation) رایج‌ترین فرمت برای تبادل داده در وب است. پکیج `encoding/json` در Go به شما امکان می‌دهد تا به راحتی ساختارهای داده Go را به JSON تبدیل کنید (marshal) و JSON را به ساختارهای Go بازگردانید (unmarshal). این پکیج از قابلیت تگ‌های ساختار (struct tags) برای کنترل نحوه نگاشت فیلدها به JSON پشتیبانی می‌کند.

package main

import (
	"encoding/json"
	"fmt"
)

type User struct {
	ID        int    `json:"id"`
	Username  string `json:"username"`
	Email     string `json:"email,omitempty"` // omitempty: اگر مقدار خالی باشد، در JSON ظاهر نمی‌شود
	IsActive  bool   `json:"is_active"`
	CreatedAt string `json:"created_at,omitempty"` // For demonstration, better to use time.Time
}

func main() {
	// Marshal: تبدیل ساختار Go به JSON
	user1 := User{
		ID:        1,
		Username:  "johndoe",
		Email:     "john.doe@example.com",
		IsActive:  true,
		CreatedAt: "2023-01-15T10:00:00Z",
	}

	jsonData, err := json.MarshalIndent(user1, "", "  ") // MarshalIndent برای خروجی خوانا
	if err != nil {
		fmt.Println("Error marshalling user1:", err)
		return
	}
	fmt.Println("User 1 JSON:\n", string(jsonData))

	user2 := User{
		ID:       2,
		Username: "janedoe",
		IsActive: false, // Email is empty, so omitempty will omit it
	}
	jsonData2, err := json.MarshalIndent(user2, "", "  ")
	if err != nil {
		fmt.Println("Error marshalling user2:", err)
		return
	}
	fmt.Println("\nUser 2 JSON (with omitempty):\n", string(jsonData2))

	// Unmarshal: تبدیل JSON به ساختار Go
	jsonString := `
	{
		"id": 3,
		"username": "alice",
		"email": "alice@example.com",
		"is_active": true
	}`
	var user3 User
	err = json.Unmarshal([]byte(jsonString), &user3)
	if err != nil {
		fmt.Println("Error unmarshalling JSON:", err)
		return
	}
	fmt.Printf("\nUnmarshalled User 3: %+v\n", user3)

	// Unmarshal به map[string]interface{}
	jsonMapString := `{"name": "Bob", "age": 25, "city": "New York"}`
	var dataMap map[string]interface{}
	err = json.Unmarshal([]byte(jsonMapString), &dataMap)
	if err != nil {
		fmt.Println("Error unmarshalling to map:", err)
		return
		}
	fmt.Println("\nUnmarshalled to map:", dataMap)
	fmt.Printf("Name from map: %s, Age from map: %.0f\n", dataMap["name"], dataMap["age"])
}

`encoding/xml`: کار با XML

با وجود شیوع JSON، XML همچنان در برخی سیستم‌های قدیمی‌تر یا در برخی پروتکل‌ها (مانند SOAP) استفاده می‌شود. پکیج `encoding/xml` قابلیت‌های مشابهی را برای marshal و unmarshal کردن داده‌ها به/از XML فراهم می‌کند.

package main

import (
	"encoding/xml"
	"fmt"
)

type Book struct {
	XMLName    xml.Name `xml:"book"`
	Title      string   `xml:"title"`
	Author     string   `xml:"author"`
	Year       int      `xml:"year"`
	Categories []string `xml:"category"` // فهرست از تگ‌های category
}

func main() {
	// Marshal: تبدیل ساختار Go به XML
	book := Book{
		Title:  "The Go Programming Language",
		Author: "Alan A. A. Donovan and Brian W. Kernighan",
		Year:   2015,
		Categories: []string{"Programming", "Go", "Computer Science"},
	}

	xmlData, err := xml.MarshalIndent(book, "", "  ")
	if err != nil {
		fmt.Println("Error marshalling XML:", err)
		return
	}
	fmt.Println("Book XML:\n", string(xml.Header) + string(xmlData))

	// Unmarshal: تبدیل XML به ساختار Go
	xmlString := `
	
		
		The Go Authors
		2009
		Idiomatic Go
		Best Practices
	`
	var unmarshalledBook Book
	err = xml.Unmarshal([]byte(xmlString), &unmarshalledBook)
	if err != nil {
		fmt.Println("Error unmarshalling XML:", err)
		return
	}
	fmt.Printf("\nUnmarshalled Book: %+v\n", unmarshalledBook)
}

`encoding/base64`: کدگذاری/رمزگشایی Base64

Base64 یک کدگذاری است که داده‌های باینری را به یک فرمت ASCII تبدیل می‌کند تا بتوان آنها را به راحتی از طریق کانال‌های متنی (مانند ایمیل یا URL) انتقال داد. این پکیج برای این منظور مفید است.

package main

import (
	"encoding/base64"
	"fmt"
)

func main() {
	data := "Hello, Go Base64 Encoding!"
	encoded := base64.StdEncoding.EncodeToString([]byte(data))
	fmt.Printf("Original: '%s'\n", data)
	fmt.Printf("Encoded Base64: '%s'\n", encoded)

	decoded, err := base64.StdEncoding.DecodeString(encoded)
	if err != nil {
		fmt.Println("Error decoding Base64:", err)
		return
	}
	fmt.Printf("Decoded: '%s'\n", string(decoded))

	// مثال با یک URL-safe encoding
	url := "https://example.com/?param=value with spaces"
	encodedURL := base64.URLEncoding.EncodeToString([]byte(url))
	fmt.Printf("\nOriginal URL: '%s'\n", url)
	fmt.Printf("Encoded URL-safe Base64: '%s'\n", encodedURL)
}

پکیج `time`: مدیریت زمان و تاریخ

پکیج `time` ابزارهای جامع و قدرتمندی برای کار با زمان و تاریخ در Go ارائه می‌دهد. این پکیج شامل انواع `Time` (برای نمایش یک لحظه خاص در زمان) و `Duration` (برای نمایش یک بازه زمانی) است، همراه با توابعی برای قالب‌بندی، تجزیه و عملیات ریاضی بر روی زمان.

package main

import (
	"fmt"
	"time"
)

func main() {
	// زمان فعلی
	now := time.Now()
	fmt.Println("Current time:", now)

	// قالب‌بندی زمان
	// از layout های ثابت Go استفاده کنید تا مطمئن شوید که قالب‌بندی در هر مکانی کار می‌کند.
	// 2006-01-02 15:04:05.999999999 -0700 MST
	fmt.Println("Formatted (YYYY-MM-DD):", now.Format("2006-01-02"))
	fmt.Println("Formatted (RFC3339):", now.Format(time.RFC3339))
	fmt.Println("Formatted (Custom):", now.Format("Monday, 02 January 2006 15:04:05 MST"))

	// تجزیه (parsing) یک رشته زمان
	timeStr := "2023-10-27T14:30:00Z"
	parsedTime, err := time.Parse(time.RFC3339, timeStr)
	if err != nil {
		fmt.Println("Error parsing time:", err)
		return
	}
	fmt.Println("Parsed time:", parsedTime)

	// عملیات زمانی: افزودن و کسر زمان
	future := now.Add(24 * time.Hour)
	fmt.Println("24 hours from now:", future)

	past := now.Add(-5 * time.Minute)
	fmt.Println("5 minutes ago:", past)

	duration := future.Sub(now) // محاسبه مدت زمان بین دو زمان
	fmt.Println("Duration between now and future:", duration)

	// ایجاد یک زمان خاص
	customTime := time.Date(2024, time.January, 1, 0, 0, 0, 0, time.UTC)
	fmt.Println("Custom time (UTC):", customTime)

	// مقایسه زمان‌ها
	fmt.Printf("Is 'now' after 'past'? %t\n", now.After(past))
	fmt.Printf("Is 'now' before 'future'? %t\n", now.Before(future))
}

ترکیب پکیج‌های `encoding` و `time` به توسعه‌دهندگان Go امکان می‌دهد تا داده‌ها را به راحتی سریال‌سازی و دیسریال‌سازی کنند و با دقت و قابلیت اطمینان بالا، عملیات‌های مبتنی بر زمان را در برنامه‌های خود مدیریت کنند.

تست‌نویسی و خطایابی: بنیان کیفیت نرم‌افزار

کیفیت نرم‌افزار، مقیاس‌پذیری و قابلیت نگهداری آن به شدت به تست‌نویسی صحیح و ابزارهای خطایابی بستگی دارد. Go با پکیج `testing` خود، یک فریم‌ورک تست‌نویسی داخلی و قدرتمند را فراهم می‌کند که به توسعه‌دهندگان امکان می‌دهد به راحتی تست‌های واحد (unit tests)، تست‌های عملکرد (benchmarks) و تست‌های نمونه (examples) را بنویسند. علاوه بر این، رویکرد Go به مدیریت خطا (error handling) از طریق پکیج `errors` و همچنین ابزارهای خطایابی، به تولید نرم‌افزاری پایدارتر کمک می‌کند.

پکیج `testing`: تست‌نویسی در Go

پکیج `testing` ستون فقرات استراتژی تست Go است. برخلاف بسیاری از زبان‌ها که نیازمند فریم‌ورک‌های تست شخص ثالث هستند، Go یک راه‌حل توکار را ارائه می‌دهد که به سادگی قابل استفاده است و به طور عمیقی با ابزارهای Go ادغام شده است. توابع تست در Go با پیشوند `Test` شروع می‌شوند و یک آرگومان از نوع `*testing.T` را می‌پذیرند. فایل‌های تست باید در همان دایرکتوری کدهای منبع قرار گیرند و نام آن‌ها با `_test.go` به پایان برسد.

تست‌های واحد (Unit Tests)

تست‌های واحد برای اعتبارسنجی کوچکترین واحدهای کد (توابع یا متدها) طراحی شده‌اند. از `*testing.T` برای گزارش خطاها (`t.Error`, `t.Errorf`), شکست‌ها (`t.Fail`, `t.Fatalf`) و سایر ابزارهای کمکی استفاده می‌شود.

// calc.go
package main

// Add دو عدد صحیح را با هم جمع می‌کند.
func Add(a, b int) int {
	return a + b
}

// Subtract دو عدد صحیح را از هم کم می‌کند.
func Subtract(a, b int) int {
	return a - b
}

// calc_test.go
package main

import "testing"

func TestAdd(t *testing.T) {
	result := Add(2, 3)
	expected := 5
	if result != expected {
		t.Errorf("Add(2, 3) failed, expected %d, got %d", expected, result)
	}

	result = Add(-1, 1)
	expected = 0
	if result != expected {
		t.Errorf("Add(-1, 1) failed, expected %d, got %d", expected, result)
	}
}

func TestSubtract(t *testing.T) {
	tests := []struct {
		a, b     int
		expected int
	}{
		{5, 2, 3},
		{10, 7, 3},
		{-5, -2, -3},
		{0, 0, 0},
	}

	for _, test := range tests {
		result := Subtract(test.a, test.b)
		if result != test.expected {
			t.Errorf("Subtract(%d, %d) failed, expected %d, got %d", test.a, test.b, test.expected, result)
		}
	}
}

// برای اجرای تست‌ها: go test ./... در ترمینال

این ساختار تست، الگوهای رایج برای تست‌نویسی در Go را نشان می‌دهد: استفاده از `t.Errorf` برای گزارش خطا و استفاده از جداول تست (test tables) برای پوشش موارد ورودی مختلف.

تست‌های عملکرد (Benchmarks)

تست‌های عملکرد برای اندازه‌گیری کارایی کد استفاده می‌شوند. توابع benchmark با پیشوند `Benchmark` شروع می‌شوند و یک آرگومان از نوع `*testing.B` را می‌پذیرند. `b.N` تعداد دفعاتی است که عملیات باید اجرا شود تا به نتایج آماری معنی‌داری برسد.

// string_ops.go
package main

import "strings"

// ConcatStrings دو رشته را با استفاده از اپراتور + به هم می‌چسباند.
func ConcatStrings(s1, s2 string) string {
	return s1 + s2
}

// JoinStrings دو رشته را با استفاده از strings.Join به هم می‌چسباند.
func JoinStrings(s1, s2 string) string {
	return strings.Join([]string{s1, s2}, "")
}

// string_ops_test.go
package main

import "testing"

func BenchmarkConcatStrings(b *testing.B) {
	s1 := "hello"
	s2 := "world"
	for i := 0; i < b.N; i++ {
		_ = ConcatStrings(s1, s2)
	}
}

func BenchmarkJoinStrings(b *testing.B) {
	s1 := "hello"
	s2 := "world"
	for i := 0; i < b.N; i++ {
		_ = JoinStrings(s1, s2)
	}
}

// برای اجرای تست‌های عملکرد: go test -bench=. ./... در ترمینال

خروجی `go test -bench` اطلاعات مفیدی در مورد سرعت اجرای عملیات‌ها ارائه می‌دهد که برای بهینه‌سازی عملکرد کد بسیار ارزشمند است.

پکیج `errors`: مدیریت خطاها

Go رویکردی متفاوت نسبت به مدیریت خطاها نسبت به زبان‌های دیگر دارد. در Go، خطاها به عنوان مقادیر معمولی (به جای استثناها) مدیریت می‌شوند و با بازگرداندن مقادیر خطا از توابع، به صورت صریح بررسی می‌شوند. پکیج `errors` توابعی برای ایجاد خطاهای ساده، و در نسخه‌های جدیدتر Go، برای "پیچیدن" (wrapping) خطاها و افزودن اطلاعات اضافی به آن‌ها ارائه می‌دهد.

package main

import (
	"errors"
	"fmt"
)

// یک خطای سفارشی ساده
var ErrInsufficientFunds = errors.New("insufficient funds in account")

func withdraw(balance, amount int) (int, error) {
	if amount <= 0 {
		return balance, errors.New("withdrawal amount must be positive")
	}
	if balance < amount {
		return balance, ErrInsufficientFunds // استفاده از خطای از پیش تعریف شده
	}
	return balance - amount, nil
}

func main() {
	currentBalance := 100

	// مثال موفقیت آمیز
	newBalance, err := withdraw(currentBalance, 50)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Printf("Withdrawal successful. New balance: %d\n", newBalance)
		currentBalance = newBalance
	}

	// مثال با مقدار منفی
	newBalance, err = withdraw(currentBalance, -10)
	if err != nil {
		fmt.Println("Error:", err)
	} else {
		fmt.Printf("Withdrawal successful. New balance: %d\n", newBalance)
	}

	// مثال با موجودی ناکافی
	newBalance, err = withdraw(currentBalance, 70)
	if err != nil {
		fmt.Println("Error:", err)
		// بررسی نوع خطا با errors.Is (برای مقایسه با ErrInsufficientFunds)
		if errors.Is(err, ErrInsufficientFunds) {
			fmt.Println("Specific error: Insufficient funds!")
		}
	} else {
		fmt.Printf("Withdrawal successful. New balance: %d\n", newBalance)
	}

	// Example of error wrapping (Go 1.13+)
	wrappedErr := fmt.Errorf("failed to process transaction: %w", ErrInsufficientFunds)
	fmt.Println("\nWrapped error:", wrappedErr)

	// Unwrapping an error
	unwrappedErr := errors.Unwrap(wrappedErr)
	fmt.Println("Unwrapped error:", unwrappedErr)

	// Checking the unwrapped error
	if errors.Is(unwrappedErr, ErrInsufficientFunds) {
		fmt.Println("Unwrapped error is ErrInsufficientFunds.")
	}
}

استفاده از `errors.Is` و `errors.As` (برای بررسی نوع خطای خاص) و `fmt.Errorf` با ورب ` %w` برای پیچیدن خطاها، ابزارهای قدرتمندی برای مدیریت خطاهای پیچیده‌تر و امکان ردیابی علت اصلی خطاها فراهم می‌کنند. این رویکرد به مدیریت خطا، Go را به زبانی با کدهای مستحکم‌تر و قابل اعتمادتر تبدیل می‌کند.

ابزارهای خطایابی (Debugging Tools)

اگرچه Go پکیج `debug` مستقیمی ندارد که به طور معمول توسط توسعه‌دهندگان استفاده شود، اما ابزارهای خط فرمان Go مانند `go run`, `go build`, `go test`، و به ویژه `go vet` و `go tool pprof` (برای پروفایل‌سازی عملکرد) در کنار دیباگرهای خارجی مانند Delve (پروژه اصلی دیباگر Go) اکوسیستمی قوی برای خطایابی و بهینه‌سازی فراهم می‌کنند. `go vet` ابزاری برای بررسی کد Go و تشخیص مشکلات پنهان، مانند استفاده نادرست از قالب‌بندی `fmt`، استفاده از Mutexها و غیره است.

// run in terminal:
// go vet my_app.go
// go run my_app.go
// go build -gcflags=-m my_app.go (for escape analysis)
// go tool pprof http://localhost:8080/debug/pprof/heap (example for profiling web apps)

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

نتیجه‌گیری: قدرت و سادگی کتابخانه‌های استاندارد Go

همانطور که در این مقاله جامع بررسی کردیم، کتابخانه استاندارد Go یک مجموعه بی‌نظیر از پکیج‌ها را ارائه می‌دهد که نیازهای اساسی و پیشرفته توسعه نرم‌افزار را پوشش می‌دهند. از مدیریت پایه‌ای ورودی/خروجی با پکیج‌هایی مانند `fmt` و `io` گرفته تا قابلیت‌های شبکه قدرتمند با `net/http`، ابزارهای پیشرفته همزمانی با `sync` و `context`، تعامل با سیستم عامل و فایل‌ها از طریق `os` و `path/filepath`، و در نهایت ابزارهای سریال‌سازی داده‌ها (`encoding/json`, `encoding/xml`) و مدیریت زمان (`time`)، و همچنین چارچوب تست‌نویسی داخلی (`testing`)، هر پکیج در کتابخانه استاندارد Go با فلسفه‌های سادگی، کارایی و قابلیت اطمینان این زبان هماهنگ است.

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

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

اکنون که با بخش‌های ضروری کتابخانه استاندارد Go آشنا شده‌اید، تشویق می‌شوید که به صورت عملی با هر یک از این پکیج‌ها کار کنید، مثال‌های کد را اجرا کنید و با مستندات رسمی Go (pkg.go.dev) بیشتر آشنا شوید. این کاوش عمیق‌تر، درک شما را از قدرت واقعی Go و نحوه استفاده از آن برای ساخت سیستم‌های پیچیده و مقیاس‌پذیر، بیش از پیش افزایش خواهد داد.