ماژول در زبان گو؛ قابلیتی جذاب در یک زبان مدرن

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

ماژول ها در زبان برنامه نویسی گو

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

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

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

کاربرد های ماژول ها در گو

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

در ادامه مطلب مثال‌هایی از کاربردهای ماژول در زبان گو را مشاهده خواهید کرد:

ماژول logrus 

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

برای استفاده از این قابلیت می‌توانید یک فولدر ایجاد کرده و به صورت زیر دستورات را داخل ترمینال وارد کنید. این دستورات فایل go.mod پروژه را ایجاد کرده و ماژول مورد نظر را دانلود خواهد کرد:

 

 go mod init example.com/gopro 
go get -u github.com/sirupsen/logrus

 

 

اکنون، محتویات زیر را داخل فایل main.go وارد کنید:

 

package main
import (
    "github.com/sirupsen/logrus"
)
func main() {
    logrus.SetFormatter(&logrus.JSONFormatter{})
    logrus.WithFields(logrus.Fields{
        "event": "event_name",
        "topic": "some_topic",
    }).Info("Something happened")
    logrus.Error("An error occurred")
}

 

با کلیک روی گزینه Play در ادیتور، خروجی زیر را مشاهده خواهید کرد:

 

 

ماژول cobra

امکان ایجاد خط فرمان cli در زبان گولنگ وجود دارد. برای این کار تنها کافی است تا ماژول مربوطه را به پروژه خود اضافه کرده و از آن استفاده کنید. با cobra امکان ایجاد ابزارهای خط فرمان با قابلیت‌های مختلف فراهم است:

 

package main
import (
    "fmt"
    "github.com/spf13/cobra"
)
func main() {
    var rootCmd = &cobra.Command{
        Use:   "myapp",
        Short: "MyApp is a CLI tool",
    }
    var helloCmd = &cobra.Command{
        Use:   "hello",
        Short: "Print Hello",
        Run: func(cmd *cobra.Command, args []string) {
            fmt.Println("Hello!")
        },
    }
    rootCmd.AddCommand(helloCmd)
    rootCmd.Execute()
}

 

در صورت اجرای این کد به خروجی زیر در ترمینال VSCode خواهید رسید:

ماژول go-cache

ماژول go-cache برای کش کردن دیتا در حافظه یا همان in-memory cache استفاده خواهد شد. این ابزار مناسب ذخیره دیتاهایی است که موقت هستند. از این دیتاها در آینده می‌توان برای بهبود عملکرد برنامه‌های وب بهره برد. 

با استفاده از دستور زیر در ترمینال می‌توانید این ماژول را نصب کنید:

 

go get -u github.com/patrickmn/go-cache

 

کد زیر را داخل فایل main.go قرار دهید تا یک کش موقت از دیتای مورد نظر ایجاد کنیم:

 

package main
import (
    "fmt"
    "time"
    "github.com/patrickmn/go-cache"
)
func main() {
    // ایجاد کش با زمان انقضا ۵ دقیقه و زمان پاکسازی پس‌زمینه هر ۱۰ دقیقه
    c := cache.New(5*time.Minute, 10*time.Minute)
    // قرار دادن داده در کش
    c.Set("foo", "bar", cache.DefaultExpiration)
    // گرفتن داده از کش
    value, found := c.Get("foo")
    if found {
        fmt.Println("Value found:", value)
    } else {
        fmt.Println("Value not found")
    }
}

 

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

 

 

ماژول gorilla/mux 

ماژول gorilla/mux یکی از معروف‌ترین و محبوب‌ترین ماژول ها در زبان گو است. از این قابلیت می‌توانید برای مدیریت درخواست‌های HTTP استفاده کنید و مسیریابی‌های پیچیده در برنامه‌تان را بهبود دهید. 

با استفاده از دستور زیر در ترمینال می‌توان این ماژول را نصب کرد:

 

go get -u github.com/gorilla/mux

 

 

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

 

package main
import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)
func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    r.HandleFunc("/hello/{name}", HelloHandler)
    http.Handle("/", r)
    fmt.Println("Server is running on port 8080")
    http.ListenAndServe(":8080", nil)
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the home page!")
}
func HelloHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    name := vars["name"]
    fmt.Fprintf(w, "Hello, %s!", name)
}

 

در صورت اجرای این کد، خروجی وب‌سرور به صورت زیر برایتان نمایش داده می‌شود:

 

 

 

می‌توانید به مسیر لوکال‌هاست در مرورگر مراجعه کنید و برنامه را تست کنید:

 

 

ساختار ماژول ها در زبان گو

ساختار ماژول در زبان گو از یک روش روتین پیروی می‌کند و شما پس از تسلط روی این ساختار می‌توانید از قابلیت‌های آن استفاده کنید. اضافه کردن یک ماژول در زبان گو به برنامه شاید ۲۰ ثانیه از شما زمان بگیرد و پس از آن می‌توانید توابع مورد نظر را در برنامه خود به کار برید. ساختار ماژول در زبان گو به صورتی است که توسعه‌دهندگان بتوانند کدهای خود را به راحتی و بدون مشکل در سیستم‌های مدیریت نسخه به اشتراک گذاشته و صرفه‌جویی زمانی زیادی را نیز به دست آورند. 

دقت داشته باشید که هر ماژول در زبان گو دارای یک فایل go.mod است که اطلاعاتی مانند نام ماژول و نسخه‌های وابستگی‌ها را ذخیره خواهد کرد. این فایل در همان دایرکتوری پروژه قرار می‌گیرد و با استفاده از آن می‌توان وابستگی‌ها را مدیریت کرده و به روز رسانی کرد. 

ایجاد و مدیریت ماژول ها در گو

ایجاد یک ماژول شخصی در زبان گو بسیار آسان است و این کار را می‌توانید در چند ثانیه انجام دهید. پس از ایجاد ماژول در زبان گو به راحتی می‌توان از آن در پروژه‌ها و برنامه‌های دیگر استفاده کرد. 

مرحله ۱ برای ایجاد ماژول ها در گو

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

 

 

مرحله ۲ برای ایجاد ماژول ها در گو

برای ایجاد یک ماژول جدید نیاز است تا کد زیر را در مسیر فولدر اجرا کنید. با اجرای این دستور، نام ماژول example.com/mathutils است:

 

go mod init example.com/mathutils

 

 

مرحله ۳ برای ایجاد ماژول ها در گو

در این مرحله یک فولدر با نام mathutils ایجاد کنید و محتویات زیر را داخل mathutils.go قرار دهید:

 

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

 

 مرحله ۴ برای ایجاد ماژول ها در گو

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

 

 

با استفاده از دستور go mod init می‌توان فایل مربوط به پروژه جدید را ایجاد کرد:

 

go mod init example.com/myproject

 

مرحله ۵ برای ایجاد ماژول ها در گو

دستورات زیر را داخل این فایل قرار دهید تا پروژه ماژول mathutils را از مسیر مورد نظر فراخوانی کند. این خطوط به Go می‌گوید که ماژول example.com/mathutils را از مسیر محلی ../mathutils بارگذاری کند:

 

module example.com/myproject
go 1.20
replace example.com/mathutils => ../mathutils

 

فایل main.go پروژه جدید ما به صورت زیر است. این فایل از ماژول mathutils استفاده می‌کند تا تابع Add را استفاده کند:

 

package main
import (
    "fmt"
    "example.com/mathutils/mathutils"
)
func main() {
    result := mathutils.Add(3, 4)
    fmt.Println("Result:", result)
}

 

مرحله ۶ برای ایجاد ماژول ها در گو

با دستور زیر ماژول ها را به روز رسانی کنید:

 

go mod tidy

 

 

با اجرای این کد، خطاهای پروژه هم برطرف می‌شوند:

 

 

مرحله ۷ برای ایجاد ماژول ها در گو

اکنون، روی کلید Play در ادیتور کلیک کنید تا خروجی را به صورت زیر دریافت کنید:

 

 

این یک ماژول شخصی بود که می‌توانید از آن در تمامی پروژه‌های آینده خود استفاده کنید. بهتر است به این نکته نیز اشاره کنیم که امکان push کردن ماژول در زبان گو روی github وجود دارد تا در آینده روش آسانی را برای افزودن آن به پروژه در اختیار داشته باشید.

نحوه انتشار و اشتراک گذاری ماژول های گو

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

تست و نگهداری ماژول ها در زبان گو

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

برای مثال، کد زیر را در نظر بگیرید که قرار است مدیریت درخواست‌های http را برعهده بگیرد. ابتدا پروژه را ایجاد کنید و با نصب gorilla/mux کد را اجرا کنید.

 

package main
import (
    "fmt"
    "net/http"
    "github.com/gorilla/mux"
)
func main() {
    r := mux.NewRouter()
    r.HandleFunc("/", HomeHandler)
    r.HandleFunc("/hello/{name}", HelloHandler)
    http.Handle("/", r)
    fmt.Println("Server is running on port 8080")
    http.ListenAndServe(":8080", nil)
}
func HomeHandler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Welcome to the home page!")
}
func HelloHandler(w http.ResponseWriter, r *http.Request) {
    vars := mux.Vars(r)
    name := vars["name"]
    fmt.Fprintf(w, "Hello, %s!", name)
}

 

خروجی کد به صورت زیر است:

 

 

اکنون، یک فایل با نام main_test.go ایجاد کنید و محتویات تست زیر را داخل آن قرار دهید:

 

package main
import (
    "net/http"
    "net/http/httptest"
    "testing"
    "github.com/gorilla/mux"
)
func TestHomeHandler(t *testing.T) {
    req, err := http.NewRequest("GET", "/", nil)
    if err != nil {
        t.Fatal(err)
    }
    rr := httptest.NewRecorder()
    handler := http.HandlerFunc(HomeHandler)
    handler.ServeHTTP(rr, req)
    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }
    expected := "Welcome to the home page!"
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}
func TestHelloHandler(t *testing.T) {
    req, err := http.NewRequest("GET", "/hello/John", nil)
    if err != nil {
        t.Fatal(err)
    }
    rr := httptest.NewRecorder()
    r := mux.NewRouter()
    r.HandleFunc("/hello/{name}", HelloHandler)
    r.ServeHTTP(rr, req)
    if status := rr.Code; status != http.StatusOK {
        t.Errorf("handler returned wrong status code: got %v want %v",
            status, http.StatusOK)
    }
    expected := "Hello, John!"
    if rr.Body.String() != expected {
        t.Errorf("handler returned unexpected body: got %v want %v",
            rr.Body.String(), expected)
    }
}

 

با استفاده از دستور زیر می‌توانید تست را روی کد مورد نظر اجرا کنید:

 

go test -v

 

 

همان‌طور که مشاهده می‌کنید، تمامی تست‌ها با موفقیت Pass شده‌اند.

جمع بندی 

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