راه‌اندازی محیط Go شما

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

نصب ابزارهای Go

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

اگر شما یک توسعه‌دهنده Mac هستید، می‌توانید Go را با استفاده از Homebrew با دستور brew install go نصب کنید. توسعه‌دهندگان Windows که از Chocolatey استفاده می‌کنند، می‌توانند Go را با دستور choco install golang نصب کنند.

نصب‌کننده‌های مختلف Linux و BSD فایل‌های TAR فشرده‌شده با gzip هستند و به دایرکتوری با نام go باز می‌شوند. این دایرکتوری را به /usr/local کپی کنید و /usr/local/go/bin را به $PATH خود اضافه کنید تا دستور go قابل دسترسی باشد:

$ tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz
$ echo 'export PATH=$PATH:/usr/local/go/bin' >> $HOME/.bash_profile
$ source $HOME/.bash_profile

ممکن است برای نوشتن در /usr/local به مجوزهای root نیاز داشته باشید. اگر دستور tar شکست خورد، آن را با sudo tar -C /usr/local -xzf go1.20.5.linux-amd64.tar.gz دوباره اجرا کنید.

برنامه‌های Go به یک باینری بومی واحد کامپایل می‌شوند و برای اجرا نیازی به نصب نرم‌افزار اضافی ندارند. این در تضاد با زبان‌هایی مانند Java، Python و JavaScript است که نیاز به نصب یک ماشین مجازی برای اجرای برنامه دارند. استفاده از یک باینری بومی واحد، توزیع برنامه‌های نوشته‌شده با Go را بسیار آسان‌تر می‌کند. این کتاب کانتینرها را پوشش نمی‌دهد، اما توسعه‌دهندگانی که از Docker یا Kubernetes استفاده می‌کنند، اغلب می‌توانند یک برنامه Go را درون یک تصویر scratch یا distroless بسته‌بندی کنند. می‌توانید جزئیات را در پست وبلاگ Geert Baeke "Distroless or Scratch for Go Apps" پیدا کنید.

می‌توانید تأیید کنید که محیط شما به درستی راه‌اندازی شده است با باز کردن ترمینال یا خط فرمان و تایپ کردن:

$ go version

اگر همه چیز به درستی راه‌اندازی شده باشد، باید چیزی شبیه به این چاپ شود:

go version go1.20.5 darwin/arm64

این به شما می‌گوید که این Go نسخه 1.20.5 روی macOS است. (Darwin سیستم عاملی است که در قلب macOS قرار دارد، و arm64 نام چیپ‌های 64 بیتی مبتنی بر طراحی‌های ARM است.) روی x64 Linux، خواهید دید:

go version go1.20.5 linux/amd64

عیب‌یابی نصب Go شما

اگر به جای پیام نسخه خطا دریافت کردید، احتمالاً go در مسیر اجرایی شما نیست، یا برنامه دیگری با نام go در مسیر شما دارید. روی macOS و سایر سیستم‌های شبه Unix، از which go استفاده کنید تا دستور go در حال اجرا را ببینید، اگر وجود دارد. اگر چیزی برگردانده نشد، باید مسیر اجرایی خود را درست کنید.

اگر روی Linux یا BSD هستید، ممکن است ابزارهای توسعه Go 64 بیتی را روی سیستم 32 بیتی یا ابزارهای توسعه برای معماری چیپ اشتباه نصب کرده باشید.

ابزارهای Go

همه ابزارهای توسعه Go از طریق دستور go قابل دسترسی هستند. علاوه بر go version، یک کامپایلر (go build)، فرمت‌کننده کد (go fmt)، مدیر وابستگی (go mod)، اجراکننده تست (go test)، ابزاری که اشتباهات رایج کدنویسی را اسکن می‌کند (go vet)، و موارد دیگر وجود دارد. آنها به تفصیل در فصل‌های 10، 11، و 15 پوشش داده شده‌اند. در حال حاضر، بیایید نگاهی سریع به رایج‌ترین ابزارها بیندازیم با نوشتن محبوب‌ترین برنامه اول همه: "Hello, World!"

از زمان معرفی Go در سال 2009، چندین تغییر در نحوه سازماندهی کد و وابستگی‌های توسعه‌دهندگان Go رخ داده است. به دلیل این تلاطم، توصیه‌های متضاد زیادی وجود دارد و بیشتر آنها منسوخ شده‌اند (به عنوان مثال، می‌توانید بحث‌های مربوط به GOROOT و GOPATH را نادیده بگیرید).

برای توسعه مدرن Go، قانون ساده است: شما آزاد هستید پروژه‌های خود را هر طور که مناسب می‌دانید سازماندهی کنید و آنها را هر کجا که می‌خواهید ذخیره کنید.

اولین برنامه Go شما

بیایید اصول نوشتن یک برنامه Go را مرور کنیم. در طول مسیر، بخش‌هایی که یک برنامه ساده Go را تشکیل می‌دهند، خواهید دید. ممکن است هنوز همه چیز را درک نکنید، و مشکلی نیست؛ بقیه کتاب برای همین است!

ساخت یک ماژول Go

اولین کاری که باید انجام دهید، ایجاد دایرکتوری برای نگهداری برنامه‌تان است. آن را ch1 بنامید. در خط فرمان، وارد دایرکتوری جدید شوید. اگر ترمینال کامپیوتر شما از bash یا zsh استفاده می‌کند، این چنین به نظر می‌رسد:

$ mkdir ch1
$ cd ch1

داخل دایرکتوری، دستور go mod init را اجرا کنید تا این دایرکتوری را به عنوان یک ماژول Go علامت‌گذاری کنید:

$ go mod init hello_world
go: creating new go.mod: module hello_world

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

module hello_world

go 1.20

فایل go.mod نام ماژول، حداقل نسخه پشتیبانی‌شده Go برای ماژول، و هر ماژول دیگری که ماژول شما به آن وابسته است را اعلام می‌کند. می‌توانید آن را شبیه فایل requirements.txt استفاده‌شده توسط Python یا Gemfile استفاده‌شده توسط Ruby در نظر بگیرید.

نباید فایل go.mod را مستقیماً ویرایش کنید. به جای آن، از دستورهای go get و go mod tidy برای مدیریت تغییرات فایل استفاده کنید. باز هم، همه چیزهای مربوط به ماژول‌ها در فصل 10 پوشش داده شده‌اند.

go build

حالا بیایید کمی کد بنویسیم! یک ویرایشگر متن باز کنید، متن زیر را وارد کنید، و آن را داخل ch1 با نام فایل hello.go ذخیره کنید:

package main

import "fmt"

func main() {
fmt.Println("Hello, world!")
}

(بله، تورفتگی در این مثال کد بی‌نظم به نظر می‌رسد: من عمداً این کار را کردم! بزودی خواهید دید چرا.)

بیایید سریعاً بخش‌های فایل Go که ایجاد کردید را مرور کنیم. خط اول یک اعلان package است. درون یک ماژول Go، کد در یک یا چند package سازماندهی می‌شود. package اصلی در یک ماژول Go حاوی کدی است که یک برنامه Go را شروع می‌کند.

بعد یک اعلان import وجود دارد. دستور import لیست package هایی که در این فایل ارجاع داده شده‌اند را می‌دهد. شما از یک تابع در package fmt (معمولاً "fumpt" تلفظ می‌شود) از کتابخانه استاندارد استفاده می‌کنید، بنابراین package را اینجا لیست می‌کنید. برخلاف زبان‌های دیگر، Go تنها کل package ها را import می‌کند. نمی‌توانید import را به انواع، توابع، ثابت‌ها، یا متغیرهای خاص درون یک package محدود کنید.

همه برنامه‌های Go از تابع main در package main شروع می‌شوند. این تابع را با func main() و یک براکت چپ اعلام می‌کنید. مانند Java، JavaScript، و C، Go از براکت‌ها برای نشان دادن شروع و پایان بلوک‌های کد استفاده می‌کند.

بدنه تابع شامل یک خط واحد است. می‌گوید که شما تابع Println در package fmt را با آرگومان "Hello, world!" فراخوانی می‌کنید. به عنوان یک توسعه‌دهنده با تجربه، احتمالاً می‌توانید حدس بزنید این فراخوانی تابع چه کاری انجام می‌دهد.

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

$ go build

این یک اجرایی به نام hello_world (یا hello_world.exe روی Windows) در دایرکتوری جاری ایجاد می‌کند. آن را اجرا کنید و بدون تعجب Hello, world! را روی صفحه چاپ‌شده خواهید دید:

$ ./hello_world
Hello, world!

نام باینری با نام در اعلان ماژول مطابقت دارد. اگر نام متفاوتی برای برنامه خود می‌خواهید، یا اگر می‌خواهید آن را در مکان متفاوتی ذخیره کنید، از پرچم -o استفاده کنید. به عنوان مثال، اگر می‌خواستید کد را به باینری به نام "hello" کامپایل کنید، از موارد زیر استفاده می‌کردید:

$ go build -o hello

در "استفاده از go run برای آزمایش برنامه‌های کوچک" در صفحه 263، روش دیگری برای اجرای یک برنامه Go را پوشش خواهم داد.

go fmt

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

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

بسیاری از توسعه‌دهندگان Go فکر می‌کنند تیم Go قالب استانداردی را به عنوان راهی برای جلوگیری از بحث‌های توسعه‌دهندگان تعریف کرد و مزایای ابزاری را بعداً کشف کرد. با این حال، Russ Cox، رهبر توسعه Go، علناً اعلام کرده است که ابزار بهتر انگیزه اصلی او بوده است.

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

$ go fmt ./...
hello.go

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

اگر hello.go را باز کنید، خواهید دید که خط با fmt.Println حالا به درستی با یک تب تورفتگی دارد.

به یاد داشته باشید go fmt را قبل از کامپایل کد خود اجرا کنید، و حداقل قبل از commit تغییرات کد منبع به مخزن خود! اگر فراموش کنید، commit جداگانه‌ای بسازید که فقط go fmt ./... انجام دهد تا تغییرات منطق را در بهمن تغییرات قالب‌بندی پنهان نکنید.

قانون درج نقطه‌ویرگول

دستور go fmt براکت‌های روی خط اشتباه را به دلیل قانون درج نقطه‌ویرگول درست نمی‌کند. مانند C یا Java، Go در پایان هر دستور به نقطه‌ویرگول نیاز دارد. با این حال، توسعه‌دهندگان Go هرگز نباید خودشان نقطه‌ویرگول‌ها را وارد کنند. کامپایلر Go آنها را به طور خودکار اضافه می‌کند، با پیروی از قانون ساده‌ای که در Effective Go توضیح داده شده است. اگر آخرین token قبل از newline یکی از موارد زیر باشد، lexer پس از token نقطه‌ویرگول درج می‌کند:

• یک شناسه (که شامل کلماتی مانند int و float64 می‌شود) • یک literal پایه مانند یک عدد یا ثابت رشته • یکی از token ها: break، continue، fallthrough، return، ++، --، )، یا }

با این قانون ساده، می‌توانید ببینید چرا قرار دادن براکت در جای اشتباه خراب می‌شود. اگر کد خود را اینگونه بنویسید:

func main()
{
    fmt.Println("Hello, world!")
}

قانون درج نقطه‌ویرگول ) را در پایان خط func main() می‌بیند و آن را به این تبدیل می‌کند:

func main();
{
    fmt.Println("Hello, world!");
};

و آن Go معتبر نیست.

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

go vet

در یک کلاس از باگ‌ها، کد از نظر نحوی معتبر است اما احتمالاً نادرست است. ابزار go شامل دستوری به نام go vet برای تشخیص این نوع خطاها است. یکی را به برنامه اضافه کنید و تماشا کنید که تشخیص داده شود. خط fmt.Println در hello.go را به موارد زیر تغییر دهید:

fmt.Printf("Hello, %s!\n")

fmt.Printf شبیه printf در C، Java، Ruby، و بسیاری از زبان‌های دیگر است. اگر قبلاً fmt.Printf را ندیده‌اید، تابعی است با الگویی برای پارامتر اولش، و مقادیری برای جایگزین‌های موجود در الگو در پارامترهای باقی‌مانده.

در این مثال، شما یک الگو ("Hello, %s!\n") با جایگزین %s دارید، اما هیچ مقداری برای جایگزین مشخص نشده است. این کد کامپایل و اجرا خواهد شد، اما درست نیست. یکی از چیزهایی که go vet تشخیص می‌دهد این است که آیا مقداری برای هر جایگزین در الگوی قالب‌بندی وجود دارد. go vet را روی کد تغییر یافته اجرا کنید، و خطا پیدا می‌کند:

$ go vet ./...
# hello_world
./hello.go:6:2: fmt.Printf format %s reads arg #1, but call has 0 args

حالا که go vet باگ را پیدا کرد، می‌توانید آن را به راحتی درست کنید. خط 6 در hello.go را به این تغییر دهید:

fmt.Printf("Hello, %s!\n", "world")

در حالی که go vet چندین خطای رایج برنامه‌نویسی را می‌گیرد، چیزهایی هستند که نمی‌تواند تشخیص دهد. خوشبختانه، ابزارهای کیفیت کد Go شخص ثالث می‌توانند شکاف را پر کنند. برخی از محبوب‌ترین ابزارهای کیفیت کد در "استفاده از اسکنرهای کیفیت کد" در صفحه 267 پوشش داده شده‌اند.

درست همانطور که باید go fmt را اجرا کنید تا مطمئن شوید کد شما به درستی قالب‌بندی شده است، go vet را اجرا کنید تا باگ‌های احتمالی در کد معتبر را اسکن کنید. این دستورها تنها گام اول در اطمینان از کیفیت بالای کد شما هستند. علاوه بر توصیه‌های این کتاب، همه توسعه‌دهندگان Go باید Effective Go و صفحه Code Review Comments در ویکی Go را بخوانند تا درک کنند کد Go اصطلاحی چگونه به نظر می‌رسد.

انتخاب ابزارهای خود

در حالی که شما یک برنامه کوچک Go را با استفاده از چیزی بیشتر از یک ویرایشگر متن و دستور go نوشتید، احتمالاً هنگام کار روی پروژه‌های بزرگ‌تر به ابزارهای پیشرفته‌تری نیاز خواهید داشت. محیط‌های توسعه یکپارچه (IDE) Go مزایای زیادی نسبت به ویرایشگرهای متن ارائه می‌دهند، از جمله قالب‌بندی خودکار هنگام ذخیره، تکمیل کد، بررسی نوع، گزارش خطا، و اشکال‌زدایی یکپارچه. ابزارهای عالی توسعه Go برای اکثر ویرایشگرهای متن و محیط‌های توسعه یکپارچه در دسترس هستند. اگر هنوز ابزار مورد علاقه‌ای ندارید، دو تا از محبوب‌ترین محیط‌های توسعه Go عبارتند از Visual Studio Code و GoLand.

Visual Studio Code

اگر به دنبال یک محیط توسعه رایگان هستید، Visual Studio Code از مایکروسافت بهترین گزینه شما است. از زمان انتشار آن در سال ۲۰۱۵، VS Code به محبوب‌ترین ویرایشگر کد منبع برای توسعه‌دهندگان تبدیل شده است. این نرم‌افزار با پشتیبانی از Go عرضه نمی‌شود، اما می‌توانید آن را به یک محیط توسعه Go تبدیل کنید با دانلود کردن افزونه Go از گالری افزونه‌ها.

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

سرور زبان چیست؟ این یک مشخصات استاندارد برای یک API است که ویرایشگرها را قادر می‌سازد رفتار ویرایش هوشمند را پیاده‌سازی کنند، مانند تکمیل کد، بررسی کیفیت، یا یافتن تمام مکان‌هایی که یک متغیر یا تابع در کد شما استفاده شده است. می‌توانید درباره سرورهای زبان و قابلیت‌هایشان بیشتر بدانید با بررسی وب‌سایت Language Server Protocol.

هنگامی که ابزارهای شما راه‌اندازی شدند، می‌توانید پروژه خود را باز کنید و با آن کار کنید. شکل ۱-۱ نشان می‌دهد که پنجره پروژه شما باید چگونه به نظر برسد. "Getting Started with VS Code Go" یک راهنمای گام به گام است که افزونه VS Code Go را نمایش می‌دهد.

شکل ۱-۱. Visual Studio Code

GoLand

GoLand محیط توسعه یکپارچه مخصوص Go از JetBrains است. در حالی که JetBrains بیشتر به خاطر ابزارهای Java-محور شناخته شده است، GoLand یک محیط توسعه عالی برای Go است. همان‌طور که در شکل ۱-۲ می‌بینید، رابط کاربری GoLand شبیه به IntelliJ، PyCharm، RubyMine، WebStorm، Android Studio، یا هر یک از دیگر محیط‌های توسعه یکپارچه JetBrains به نظر می‌رسد. پشتیبانی Go آن شامل بازسازی کد، برجسته‌سازی نحو، تکمیل کد و ناوبری، پنجره‌های مستندات، اشکال‌زدا، پوشش کد، و موارد بیشتر است. علاوه بر پشتیبانی Go، GoLand شامل ابزارهای JavaScript/HTML/CSS و پایگاه داده SQL است. برخلاف VS Code، GoLand نیازی ندارد که شما یک افزونه نصب کنید تا کار کند.

شکل ۱-۲. GoLand

اگر قبلاً به IntelliJ Ultimate مشترک شده‌اید، می‌توانید پشتیبانی Go را از طریق یک افزونه اضافه کنید. در حالی که GoLand نرم‌افزار تجاری است، JetBrains یک برنامه مجوز رایگان برای دانشجویان و مشارکت‌کنندگان اصلی متن باز دارد. اگر واجد شرایط مجوز رایگان نیستید، یک آزمایش رایگان ۳۰ روزه در دسترس است. پس از آن، باید برای GoLand پرداخت کنید.

زمین بازی Go

یک ابزار مهم دیگر برای توسعه Go وجود دارد، اما این یکی است که شما نصب نمی‌کنید. از The Go Playground بازدید کنید و پنجره‌ای خواهید دید که شبیه شکل ۱-۳ است. اگر از محیط خط فرمان مانند irb، node، یا python استفاده کرده‌اید، The Go Playground حس مشابهی خواهد داشت. این به شما مکانی برای آزمایش و اشتراک‌گذاری برنامه‌های کوچک می‌دهد. برنامه خود را در پنجره وارد کنید و روی دکمه Run کلیک کنید تا کد اجرا شود. دکمه Format دستور go fmt را روی برنامه شما اجرا می‌کند و import های شما را به‌روزرسانی می‌کند. دکمه Share یک URL منحصر به فرد ایجاد می‌کند که می‌توانید آن را برای کسی بفرستید تا نگاهی به برنامه شما بیندازد یا در تاریخ آینده به کد خود بازگردید (URL ها برای مدت طولانی پایدار بوده‌اند، اما من روی playground به عنوان مخزن کد منبع شما تکیه نمی‌کنم).

شکل ۱-۳. زمین بازی Go

همان‌طور که در شکل ۱-۴ می‌بینید، می‌توانید چندین فایل را با جداسازی هر فایل با خطی که شبیه -- filename.go -- است، شبیه‌سازی کنید. حتی می‌توانید زیرشاخه‌های شبیه‌سازی شده را با گنجاندن / در نام فایل ایجاد کنید، مانند -- subdir/my_code.go --.

آگاه باشید که The Go Playground روی کامپیوتر شخص دیگری است (به طور خاص، کامپیوتر Google)، بنابراین شما کاملاً آزاد نیستید. این به شما انتخابی از چند نسخه Go می‌دهد (معمولاً انتشار فعلی، انتشار قبلی، و آخرین نسخه توسعه). شما می‌توانید تنها به localhost اتصال شبکه برقرار کنید، و فرآیندهایی که خیلی طولانی اجرا می‌شوند یا حافظه زیادی استفاده می‌کنند متوقف می‌شوند. اگر برنامه شما به زمان وابسته است، باید در نظر بگیرید که ساعت روی ۱۰ نوامبر ۲۰۰۹، ۲۳:۰۰:۰۰ UTC (تاریخ اعلام اولیه Go) تنظیم شده است. حتی با این محدودیت‌ها، The Go Playground روش مفیدی برای آزمایش ایده‌های جدید بدون ایجاد یک پروژه جدید محلی است. در سراسر این کتاب، لینک‌هایی به The Go Playground خواهید یافت تا بتوانید نمونه‌های کد را بدون کپی کردن آن‌ها روی کامپیوتر خود اجرا کنید.

اطلاعات حساس (مانند اطلاعات شخصی قابل شناسایی، رمزهای عبور، یا کلیدهای خصوصی) را در playground خود قرار ندهید! اگر روی دکمه Share کلیک کنید، اطلاعات روی سرورهای Google ذخیره می‌شود و برای هر کسی که URL Share مرتبط را دارد قابل دسترسی است. اگر این کار را به طور تصادفی انجام دادید، با Google در security@golang.org با URL و دلیل اینکه محتوا باید حذف شود تماس بگیرید.

شکل ۱-۴. زمین بازی Go از چندین فایل پشتیبانی می‌کند

Makefile ها

استفاده از یک محیط توسعه یکپارچه خوب است، اما خودکارسازی آن سخت است. توسعه نرم‌افزار مدرن بر build های قابل تکرار و خودکار متکی است که می‌توانند توسط هر کسی، در هر جایی، در هر زمانی اجرا شوند. الزام به این نوع ابزار، شیوه مهندسی نرم‌افزار خوبی است. این از موقعیت قدیمی جلوگیری می‌کند که توسعه‌دهنده خودش را از هر مشکل build با شانه بالا انداختن و بیان "روی دستگاه من کار می‌کند!" مبرا می‌داند. راه انجام این کار استفاده از نوعی اسکریپت برای مشخص کردن مراحل build شما است. توسعه‌دهندگان Go، make را به عنوان راه‌حل خود پذیرفته‌اند. این به توسعه‌دهندگان اجازه می‌دهد مجموعه‌ای از عملیات که برای ساخت یک برنامه ضروری هستند و ترتیبی که مراحل باید در آن انجام شوند را مشخص کنند. ممکن است با make آشنا نباشید، اما از سال ۱۹۷۶ برای ساختن برنامه‌ها روی سیستم‌های Unix استفاده شده است.

فایلی به نام Makefile در دایرکتوری ch1 با محتوای زیر ایجاد کنید:

.DEFAULT_GOAL := build

.PHONY:fmt vet build
fmt:
        go fmt ./...

vet: fmt
        go vet ./...

build: vet
        go build

حتی اگر قبلاً Makefile ندیده‌اید، فهمیدن اینکه چه اتفاقی می‌افتد خیلی سخت نیست. هر عملیات ممکن، target نامیده می‌شود. .DEFAULT_GOAL تعریف می‌کند که کدام target زمانی که هیچ target مشخص نشده باشد اجرا شود. در این مورد، پیش‌فرض target بیلد است. سپس تعاریف target ها را دارید. کلمه قبل از دونقطه (:) نام target است. هر کلمه بعد از target (مانند vet در خط build: vet) target های دیگری هستند که باید قبل از اجرای target مشخص شده اجرا شوند. وظایفی که توسط target انجام می‌شوند در خطوط تو رفته بعد از target هستند. خط .PHONY make را از گیج شدن باز می‌دارد اگر دایرکتوری یا فایلی در پروژه شما همان نام یکی از target های فهرست شده را داشته باشد.

make را اجرا کنید و باید خروجی زیر را ببینید:

$ make
go fmt ./...
go vet ./...
go build

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

یک اشکال Makefile ها این است که آن‌ها بسیار سختگیر هستند. شما باید مراحل در یک target را با یک tab تو ببرید. آن‌ها همچنین به طور پیش‌فرض روی Windows پشتیبانی نمی‌شوند. اگر توسعه Go خود را روی کامپیوتر Windows انجام می‌دهید، ابتدا باید make را نصب کنید. آسان‌ترین راه برای انجام این کار نصب یک مدیر بسته مانند Chocolatey و سپس استفاده از آن برای نصب make است (برای Chocolatey، دستور choco install make است).

اگر می‌خواهید درباره نوشتن Makefile ها بیشتر بدانید، آموزش خوبی توسط Chase Lambert وجود دارد، اما برای توضیح مفاهیم از مقدار کمی C استفاده می‌کند.

می‌توانید کد این فصل را در مخزن فصل ۱ این کتاب پیدا کنید.

قول سازگاری Go

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

در سخنرانی کلیدی GopherCon 2022 خود با عنوان "سازگاری: چگونه برنامه‌های Go به کار خود ادامه می‌دهند"، راس کاکس تمام راه‌هایی را که تیم Go برای جلوگیری از شکستن کد Go استفاده می‌کند، مورد بحث قرار می‌دهد. او می‌گوید: "من معتقدم که اولویت‌دادن به سازگاری مهم‌ترین تصمیم طراحی بود که در Go 1 گرفتیم."

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

به‌روز ماندن

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

وقتی آماده به‌روزرسانی ابزارهای توسعه Go نصب شده روی کامپیوتر خود هستید، کاربران Mac و Windows ساده‌ترین مسیر را دارند. کسانی که با brew یا chocolatey نصب کرده‌اند می‌توانند از این ابزارها برای به‌روزرسانی استفاده کنند. کسانی که از نصب‌کننده‌های موجود در https://golang.org/dl استفاده کرده‌اند می‌توانند آخرین نصب‌کننده را دانلود کنند که نسخه قدیمی را هنگام نصب نسخه جدید حذف می‌کند.

کاربران Linux و BSD باید آخرین نسخه را دانلود کنند، نسخه قدیمی را به یک دایرکتوری پشتیبان منتقل کنند، نسخه جدید را استخراج کنند و سپس نسخه قدیمی را حذف کنند:

$ mv /usr/local/go /usr/local/old-go
$ tar -C /usr/local -xzf go1.20.6.linux-amd64.tar.gz
$ rm -rf /usr/local/old-go

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

تمرین‌ها

هر فصل در انتها تمرین‌هایی دارد تا بتوانید ایده‌هایی که پوشش می‌دهم را امتحان کنید. می‌توانید پاسخ این تمرین‌ها را در مخزن فصل 1 پیدا کنید.

1. برنامه "Hello, world!" را بگیرید و آن را در The Go Playground اجرا کنید. لینک کد موجود در playground را با همکاری که علاقه‌مند به یادگیری Go است به اشتراک بگذارید.
2. یک هدف به Makefile اضافه کنید به نام clean که فایل اجرایی hello_world و هر فایل موقت دیگری که توسط go build ایجاد شده را حذف کند. نگاهی به مستندات دستور Go بیندازید تا یک دستور go برای کمک به پیاده‌سازی این کار پیدا کنید.
3. با تغییر قالب‌بندی در برنامه "Hello, world!" آزمایش کنید. خطوط خالی، فاصله‌ها اضافه کنید، تورفتگی را تغییر دهید، خطوط جدید درج کنید. پس از انجام یک تغییر، go fmt را اجرا کنید تا ببینید آیا تغییر قالب‌بندی لغو می‌شود یا نه. همچنین، go build را اجرا کنید تا ببینید آیا کد همچنان کامپایل می‌شود یا نه. می‌توانید فراخوانی‌های اضافی fmt.Println نیز اضافه کنید تا ببینید اگر خطوط خالی در وسط یک تابع قرار دهید چه اتفاقی می‌افتد.

جمع‌بندی

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