مقدمه ای برای Golang: یک راهنمای جامع برای مبتدیان

GO چیست؟

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

خصوصیات اصلی

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

چرا یاد بگیریم؟

نحو تمیز و حداقل Go باعث می شود که مبتدیان آن را نزدیک کند ، در حالی که کارایی بالا آن را برای برنامه نویسی سیستم ها ، پشتی های وب و موارد دیگر مناسب می کند. مدل همزمانی آن ، با استفاده از goroutines و کانال ها ، کارهای پیچیده را ساده می کند. قدرت اکوسیستم رو به رشد Go فن آوری های بومی ابر مانند Docker و Kubernetes ، ابزارهای خط فرمان و میکروسرویس ها. زمان کامپایل سریع و ابزارهای عالی تقویت کننده بهره وری توسعه دهنده.

مزایای یادگیری برو

• یادگیری آسان: نحو بصری منحنی یادگیری را کاهش می دهد.
• کارایی: ایده آل برای برنامه های مهم عملکرد.
• پشتیبانی همزمان: goroutines و کانال ها برنامه نویسی همزمان را ساده تر می کنند.
• اکوسیستم در حال رشد: به طور گسترده در پشته های فناوری مدرن استفاده می شود.
• بهره وری: تدوین سریع و ابزارهای قوی.

تنظیم محیط GO

شروع کار با GO ساده است:

1. بارگیری: برای بارگیری نصب کننده سیستم عامل خود (ویندوز ، مکوس یا لینوکس) به https://go.dev/dl/ مراجعه کنید.
2. نصب کردن: دستورالعمل های نصب خاص سیستم عامل را دنبال کنید.
3. نصب را تأیید کنید: ترمینال را باز کنید و اجرا کنید go version برای تأیید GO به درستی نصب شده است.
4. فضای کاری (اختیاری): درک کنید $HOME/go ساختار (srcبا pkgبا bin). توجه داشته باشید که ماژول های GO اکنون استاندارد برای مدیریت وابستگی هستند.

اولین برنامه GO شما: “سلام ، جهان!”

بیایید یک برنامه Go Simple برای چاپ “سلام ، بوت کامپ!” به کنسول:

package main // Executable program package
import "fmt" // Import standard Formatted I/O library

func main() { // Entry point of the program
    fmt.Println("Hello, Bootcamp!") // Print to console
}

• برنامه را اجرا کنید: این را ذخیره کنید hello.go و دویدن go run hello.go در ترمینال شما
• اجزای کلیدی:
  • package main: یک برنامه اجرایی را تعریف می کند.
  • import "fmt": کتابخانه I/O فرمت شده را وارد می کند.
  • func main(): نقطه ورود برنامه.

نحو اساسی

بسته ها و متغیرها

GO کد را در بسته ها سازماندهی می کند. در main بسته برنامه های اجرایی را ایجاد می کند ، در حالی که سایر بسته ها (به عنوان مثال ، package mylib) سازمان قابل استفاده مجدد را سازماندهی کنید. استفاده کردن import بسته های خارجی مانند fmt یا mathبشر

متغیرها با استفاده از var یا اپراتور اعلامیه کوتاه := (فقط توابع داخل):

var age int = 30
var name string // Defaults to ""
var count int // Defaults to 0
message := "Hello" // Inferred string
score := 95 // Inferred int

ثابت ها و انواع اساسی

ثابت مقادیر تغییر ناپذیر تعریف شده با const:

const Pi = 3.14159
const AppName = "BootcampApp"

GO از انواع داده های اساسی پشتیبانی می کند:

• اعداد صحیح: intبا int64
• نقطه شناور: float32با float64
• بولی: bool (trueبا false)
• رشته: string (متن تغییر ناپذیر UTF-8)
• بایت: byte (نام مستعار برای uint8)

جریان کنترل: اگر/دیگری

برو if/else بیانیه ها به بریس نیاز دارند {} اما پرانتزها را در مورد شرایط غافلگیر کنید. یک عبارت اولیه سازی اختیاری می تواند مقدم بر شرط باشد:

if score >= 60 {
    fmt.Println("Passed")
} else {
    fmt.Println("Failed")
}
if num := getValue(); num < 0 {
    fmt.Println("Negative")
}

جریان کنترل: برای حلقه

در for حلقه تنها ساختار حلقه Go است ، و از چندین سبک پشتیبانی می کند:

1. به سبک C:

   for i := 0; i < 10; i++ {
       // ...
   }

1. فقط شرط (در حالی که مانند):

   for count < 5 {
       // ...
   }

1. نامتناهی:

   for {
       // ... (use break to exit)
   }

1. برای برد (مجموعه ها):

   items := []string{"a", "b", "c"}
   for index, value := range items {
       // ...
   }
   for _, value := range items { // Ignore index
       // ...
   }

جریان کنترل: سوئیچ

برو switch بیانیه یک جایگزین تمیزتر برای چندگانه است if/else بیانیه ها به طور پیش فرض از بین نمی رود و از مقادیر چند مورد پشتیبانی می کند:

switch day {
case "Saturday", "Sunday":
    fmt.Println("Weekend")
default:
    fmt.Println("Weekday")
}
switch { // Expressionless switch
case hour < 12:
    fmt.Println("Morning")
default:
    fmt.Println("Afternoon/Evening")
}

انواع کامپوزیت

آرایه

آرایه ها توالی های اندازه ثابت از عناصر از یک نوع هستند. اندازه آنها بخشی از نوع است:

var nums [5]int // Array of 5 zeros
nums[0] = 100
primes := [3]int{2, 3, 5} // Array literal

برش

برش ها از نماهای پویا و انعطاف پذیر آرایه ها هستند و بیشتر مورد استفاده قرار می گیرند. آنها حمایت می کنند len()با cap()وت append():

letters := []string{"a", "b", "c"} // Slice literal
s := make([]int, 3, 5) // make(type, length, capacity)
s = append(s, 10, 20)
sub := letters[1:3] // Slicing: ["b", "c"]

نقشه

نقشه ها جفت های ارزش کلید بدون هماهنگ ، ایجاد شده با make() یا تحت اللفظی:

ages := make(map[string]int)
ages["Bob"] = 25
scores := map[string]int{"Math": 95}
val, ok := ages["Alice"] // Check existence
if ok {
    // ...
}
delete(ages, "Bob") // Remove key
for key, value := range ages { // Iterate
    // ...
}

ساختار

زمینه های مرتبط با گروه برای تعریف انواع داده های سفارشی:

type Person struct {
    FirstName string
    LastName  string
    Age       int
}

func main() {
    p1 := Person{FirstName: "Ada", LastName: "Lovelace", Age: 36}
    fmt.Println(p1.FirstName) // Output: Ada
    p2 := &Person{FirstName: "Alan"} // Pointer to struct
    fmt.Println(p2.FirstName) // Auto-dereferenced
}

توابع

توابع در پارامترهای پشتیبانی GO ، انواع بازگشت ، مقادیر بازگشت چندگانه و آرگومان های متغیر:

func add(a, b int) int {
    return a + b
}
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("division by zero")
    }
    return a/b, nil
}
func sumAll(nums ...int) int { // Variadic
    // nums is a slice
}

نشانگرها

نشانگرها آدرسهای حافظه را ذخیره می کنند ، با استفاده از & برای گرفتن آدرس و * به Dereference:

x := 10
p := &x // p holds address of x
fmt.Println(*p) // Output: 10
*p = 20 // Changes x
fmt.Println(x) // Output: 20

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

روش

روشها توابع مربوط به یک نوع خاص (گیرنده) هستند. گیرنده های ارزش بر روی نسخه ها کار می کنند ، در حالی که گیرنده های نشانگر اصلی را تغییر می دهند:

type Rect struct {
    width, height float64
}

func (r Rect) Area() float64 { // Value receiver
    return r.width * r.height
}

func (r *Rect) Scale(factor float64) { // Pointer receiver
    r.width *= factor
    r.height *= factor
}

رابط

رابط ها امضاهای متد را تعریف می کنند و پلی مورفیسم را بدون اعلامیه های اجرای صریح فعال می کنند:

type Shape interface {
    Area() float64
}

func printArea(s Shape) {
    fmt.Println("Area:", s.Area())
}

انواع مانند Rect یا Circle به طور ضمنی پیاده سازی کنید Shape اگر آنها تعریف کنند Area()بشر رابط خالی interface{} می تواند هر مقدار را نگه دارد.

همزمانی

گودال

گوروتین ها کارکردهای سبک و همزمان هستند که توسط زمان اجرا مدیریت می شوند:

import "time"

func say(s string) {
    fmt.Println(s)
    time.Sleep(100 * time.Millisecond)
}

func main() {
    go say("World") // Runs concurrently
    say("Hello")    // Runs in main goroutine
    time.Sleep(500 * time.Millisecond) // Wait
}

کانال

کانال ها ارتباط و هماهنگ سازی بین گوروتین ها را فعال می کنند:

messages := make(chan string) // Unbuffered channel
go func() {
    messages <- "ping" // Send
}()
msg := <-messages // Receive
fmt.Println(msg) // Output: ping
close(messages) // Close channel

رسیدگی به خطا

GO از مقادیر بازگشت خطای صریح استفاده می کند ، با nil نشان دهنده موفقیت:

import "os"

file, err := os.Open("filename.txt")
if err != nil {
    log.Fatal("Error opening file:", err)
}
defer file.Close() // Close when function returns

در defer بیانیه وظایف پاکسازی را برای زمان خروج از عملکرد اطراف برنامه ریزی می کند.

نکات برجسته کتابخانه استاندارد

کتابخانه استاندارد Go غنی و همه کاره است ، از جمله:

• fmt: فرمت I/O
• net/http: سرورهای وب و مشتریان
• encoding/json: پردازش JSON
• os: عملیات پرونده و سیستم
• io: I/O بدوی
• stringsبا strconv: دستکاری رشته
• time: توابع مربوط به زمان
• sync: هماهنگ سازی همزمانی
• errors: ایجاد خطا

کتابخانه کامل را در https://pkg.go.dev/std کاوش کنید.

ساخت و دویدن برنامه های GO

• go run .go: بدون صرفه جویی در دودویی ، کامپایل و اجرا می شود.
• go build: یک باینری اجرایی در فهرست فعلی ایجاد می کند.
• go install: باینری را به کامپایل و نصب می کند $GOPATH/bin یا $GOBINبشر

مراحل و منابع بعدی

برای تعمیق دانش خود:

• ماژول ها برو: وابستگی ها را مدیریت کنید go mod init وت go getبشر
• تست: با استفاده از تست ها بنویسید testing بسته بندی و go testبشر
• همزمانی پیشرفته: کاوش کنید selectبا sync.Mutexوت sync.WaitGroupبشر
• بسته متن: لغو و مهلت ها را کنترل کنید.
• ساخت پروژه ها: ایجاد یک سرویس وب ، ابزار CLI یا میکروسرویس.

منابع توصیه شده

پایان

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