آموزش زبان گو (Golang) از صفر با تمرین در مرورگر

package main
 
import (
	"fmt"
	"sync"
)
 
// isPrime عدد را با تقسیم تا ریشهٔ دومش بررسی می‌کند
func isPrime(n int) bool {
	if n < 2 {
		return false
	}
	for d := 2; d*d <= n; d++ {
		if n%d == 0 {
			return false
		}
	}
	return true
}
 
func main() {
	const limit, parts = 200000, 4
	size := limit / parts
	counts := make([]int, parts) // هر goroutine فقط در خانهٔ خودش می‌نویسد
	var wg sync.WaitGroup
 
	for p := 0; p < parts; p++ {
		wg.Add(1)
		go func(p int) {
			defer wg.Done()
			for n := p*size + 1; n <= (p+1)*size; n++ {
				if isPrime(n) {
					counts[p]++
				}
			}
		}(p)
	}
	wg.Wait() // صبر تا هر چهار بخش تمام شود
 
	total := 0
	for p, c := range counts {
		fmt.Printf("part %d: %6d..%-6d %5d primes\n", p+1, p*size+1, (p+1)*size, c)
		total += c
	}
	fmt.Printf("total: %d primes up to %d\n", total, limit)
}

package main
 
import "fmt"
 
type Item struct {
	Name  string
	Price int // تومان
	Qty   int
}
 
type Cart struct{ Items []Item }
 
// گیرندهٔ اشاره‌گری: Add خود سبد را تغییر می‌دهد
func (c *Cart) Add(name string, price, qty int) {
	c.Items = append(c.Items, Item{name, price, qty})
}
 
func (c Cart) Total() int {
	sum := 0
	for _, it := range c.Items {
		sum += it.Price * it.Qty
	}
	return sum
}
 
// هر نوعی که این دو متد را داشته باشد، خودبه‌خود یک Discount است
type Discount interface {
	Apply(total int) int
	String() string
}
 
type Percent int
type Fixed int
 
func (p Percent) Apply(t int) int { return t - t*int(p)/100 }
func (p Percent) String() string  { return fmt.Sprintf("%d%% off", int(p)) }
func (f Fixed) Apply(t int) int   { return t - int(f) }
func (f Fixed) String() string    { return fmt.Sprintf("%d off", int(f)) }
 
func main() {
	var cart Cart
	cart.Add("Keyboard", 850000, 1)
	cart.Add("Mouse", 320000, 2)
	cart.Add("Cable", 90000, 3)
 
	for _, it := range cart.Items {
		fmt.Printf("%-10s x%d %10d\n", it.Name, it.Qty, it.Price*it.Qty)
	}
	fmt.Printf("%-13s %10d\n", "total", cart.Total())
	for _, d := range []Discount{Percent(10), Fixed(200000)} {
		fmt.Printf("%-13s %10d\n", d, d.Apply(cart.Total()))
	}
}

package main
 
import (
	"errors"
	"fmt"
)
 
// خطای از پیش تعریف‌شده که با errors.Is شناخته می‌شود
var ErrNotEnough = errors.New("not enough balance")
 
// نوع خطای سفارشی که با errors.As باز می‌شود
type LimitError struct{ Limit, Asked int }
 
func (e *LimitError) Error() string {
	return fmt.Sprintf("daily limit is %d, asked %d", e.Limit, e.Asked)
}
 
func withdraw(balance, amount int) (int, error) {
	if amount > 500 {
		return balance, &LimitError{Limit: 500, Asked: amount}
	}
	if amount > balance {
		return balance, fmt.Errorf("withdraw %d: %w", amount, ErrNotEnough)
	}
	return balance - amount, nil
}
 
func main() {
	balance := 800
	for _, amount := range []int{300, 700, 450, 200} {
		next, err := withdraw(balance, amount)
		var limit *LimitError
		switch {
		case err == nil:
			balance = next
			fmt.Printf("ok       -%d, balance %d\n", amount, balance)
		case errors.Is(err, ErrNotEnough):
			fmt.Println("refused ", err)
		case errors.As(err, &limit):
			fmt.Printf("refused  %d over the daily limit\n", limit.Asked-limit.Limit)
		}
	}
}

package main
 
import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strings"
)
 
func main() {
	counts := map[string]int{}
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords) // ورودی را کلمه‌به‌کلمه می‌خواند
	for scanner.Scan() {
		word := strings.Trim(scanner.Text(), ".،!؟")
		counts[word]++
	}
 
	// ترتیب پیمایش مپ تصادفی است؛ برای خروجی ثابت، کلیدها را مرتب می‌کنیم
	words := make([]string, 0, len(counts))
	for w := range counts {
		words = append(words, w)
	}
	sort.Slice(words, func(i, j int) bool {
		a, b := words[i], words[j]
		if counts[a] != counts[b] {
			return counts[a] > counts[b] // اول کلمهٔ پرتکرارتر
		}
		return a < b // در تساوی، به ترتیب حروف
	})
 
	for _, w := range words[:4] {
		fmt.Printf("%d %-5s %s\n", counts[w], strings.Repeat("#", counts[w]), w)
	}
}

package main
 
import (
	"encoding/json"
	"fmt"
)
 
type Product struct {
	Name  string `json:"name"`
	Price int    `json:"price"`
	Stock int    `json:"stock"`
}
 
type Report struct {
	Count      int      `json:"count"`
	TotalValue int      `json:"total_value"`
	OutOfStock []string `json:"out_of_stock"`
}
 
func main() {
	data := `[
	  {"name": "Notebook", "price": 45000, "stock": 12},
	  {"name": "Pen", "price": 15000, "stock": 0},
	  {"name": "Backpack", "price": 690000, "stock": 3},
	  {"name": "Ruler", "price": 20000, "stock": 0}
	]`
 
	// متن JSON به برشی از استراکت تبدیل می‌شود؛ نام فیلدها از برچسب json می‌آید
	var products []Product
	if err := json.Unmarshal([]byte(data), &products); err != nil {
		fmt.Println("bad json:", err)
		return
	}
 
	report := Report{Count: len(products), OutOfStock: []string{}}
	for _, p := range products {
		report.TotalValue += p.Price * p.Stock
		if p.Stock == 0 {
			report.OutOfStock = append(report.OutOfStock, p.Name)
		}
	}
 
	out, _ := json.MarshalIndent(report, "", "  ")
	fmt.Println(string(out))
}

package main
 
import (
	"fmt"
	"unicode/utf8"
)
 
func main() {
	// len بایت‌ها را می‌شمارد؛ هر حرف فارسی در UTF-8 دو بایت است
	for _, s := range []string{"Go", "سلام", "دینا کد"} {
		fmt.Printf("%2d bytes, %d runes  %s\n", len(s), utf8.RuneCountInString(s), s)
	}
 
	// range روی رشته، rune به rune جلو می‌رود و جای بایتی هر حرف را می‌دهد
	for i, r := range "کد" {
		fmt.Printf("byte %d  U+%04X  %c\n", i, r, r)
	}
}