Основы Golang

var car string
var name string = "John"
var age int = 25
var isStudent bool = false

// Возможно во внутренней функции
name := "Alice"  // Тип определен как string
age := 30        // Тип определен как int
isStudent := true // bool

var p *int // создать указатель
a := 2
p = &a
*p++
fmt.Println(*p) // значение (3)
fmt.Println(&p) // адрес (0xc0000a2038)

const Pi float64 = 3.14159
const Greeting = "Hello, Go!"

type Age int
var myAge Age = 25

var numbers [3]int = [3]int{10, 20, 30}
fmt.Println(numbers[0]) // Вывод: 10

numbers := [...]int{1, 2, 3} // Объявление без указания точного размера

var slice1 = make([]int, 4, 7) // Установка длинны и емкости
nums := []int{10, 20, 30} // создаем срез с 3 элементами
slice4 := array[:] // Конвертируем массив в срез
nums = append(nums, 40) // Добавляем значение в срез

baseArray := [8]string{"Anna", "Max", "Eva", "Leo", "Nina", "Tom", "Sophie", "Chris"} // Базовый массив

slice1 := baseArray[1:5] // с 2 по 5 элемент [Max Eva Leo Nina]
slice2 := baseArray[:3]  // с 1 по 3 элемент [Anna Max Eva]
slice3 := baseArray[4:]  // с 5 [Nina Tom Sophie Chris]

a := []int{1, 2, 3, 4, 5, 6, 7}
a = append(a[0:2], a[3:]...)
fmt.Println(a) // [1 2 4 5 6 7]

person := map[string]int{"Alice": 25, "Bob": 30}
fmt.Println(person["Alice"]) // Вывод: 25

if value, ok := m[1]; ok {
 fmt.Println(value) // Если ключ существует
}

type Person struct {
  Name string
  Age int
}
p := Person{Name: "John", Age: 30}
fmt.Println(p.Name) // Вывод: John

student := struct {
  name string
  id   int64
  age  int32
}{
  name: "Julia",
  id:   12345,
  age:  30,
}

func counter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}

func main() {
    inc := counter() // Создать встраивание
    fmt.Println(inc()) // 1
    fmt.Println(inc()) // 2
    fmt.Println(inc()) // 3
}

func newProduct(name, category string, price float64)
 *Product {
     return &Product{name, category, price}
}

type Speaker interface {
  MetaSpeakerInterface
  Speak() string
}

type Dog struct{}
  func (d Dog) Speak() string {
  return "Woof!"
}

var animal Speaker = Dog{}
fmt.Println(animal.Speak()) // Вывод: Woof!

func display(a interface{}) {
  // Using type switch
  switch a.(type) {
  case int, uint: //задаем два условия
    fmt.Printf("Type:%T -- Value:%v\n", a, a.(int))
  case string:
    fmt.Printf("Type:%T -- Value:%v\n", a, a.(string))
  case float64:
    fmt.Printf("Type:%T -- Value:%v\n", a, a.(float64))
  default:
    fmt.Println("Type not found")
  }
}

type error interface {
 Error() string
}

err := errors.New("my error") // Создаем ошибку
eff := fmt.Errorf("other error")
panic("division by zero!") // Сгенерировать ошибку и выйти

func safeFunction() {
    defer func() {
        if r := recover(); r != nil { // Обработка panic
            fmt.Println("Recovered:", r)
        }
    }()

    fmt.Println("Before panic")
    panic("Unexpected error!")  // Вызываем panic
    fmt.Println("After panic")
}

package main

import (
  "fmt"
  "time"
)

func sayHello() {
  fmt.Println("Hello from goroutine!")
}

func main() {
  go sayHello() // Starts a new goroutine
  fmt.Println("Hello from main function!")

    time.Sleep(1 * time.Second) // Ожидаем завершение горутин

// Последовательность вывода может отличаться:
// Hello from main function!
// Hello from goroutine!
}

package main

import (
  "fmt"
  "time"
)

func printNumber(n int) {
  fmt.Println("Number:", n)
}

func main() {
  for i := 1; i <= 5; i++ {
  go printNumber(i) // Создаем новую горутину на каждой итерации
  }
    time.Sleep(1 * time.Second) // Предотвращаем раннее завершение работы main
}

package main

import (
  "fmt"
  "sync"
)

func worker(id int, wg *sync.WaitGroup) {
  fmt.Printf("Worker %d started\n", id)
  wg.Done() // Уменьшаем счетчик WaitGroup
}

func main() {
  var wg sync.WaitGroup

  for i := 1; i <= 3; i++ {
    wg.Add(1) // Увеличиваем счетчик
    go worker(i, &wg)
  }

  wg.Wait() // Ожидаем завершение горутин
  fmt.Println("All workers finished")
}

package main

import "fmt"

func sendMessage(ch chan string) {
  ch <- "Hello from Goroutine!" // Отправляем данные в канал
}

func main() {
  ch := make(chan string) // Создаем канал

  go sendMessage(ch)

  msg := <-ch // Получение данных из канала
  fmt.Println(msg)
}

ch := make(chan int, 3) // Размер буфера 3
ch <- 1
ch <- 2
ch <- 3
fmt.Println(<-ch) // Вывод: 1

   ch := make(chan int)

go func() {
  for i := 1; i <= 5; i++ {
  ch <- i
}
  close(ch) // Закрываем канал
}()

for num := range ch {
  fmt.Println(num) // Читать пока канал не закроется
}

package main

import (
  "fmt"
  "time"
)

func main() {
  ch1 := make(chan string)
  ch2 := make(chan string)

  go func() {
      time.Sleep(1 * time.Second)
      ch1 <- "Message from channel 1"
  }()

  go func() {
      time.Sleep(2 * time.Second)
      ch2 <- "Message from channel 2"
  }()

  select { // Слушаем каналы
  case msg1 := <-ch1:
      fmt.Println(msg1)
  case msg2 := <-ch2:
      fmt.Println(msg2)
  case <-time.After(3 * time.Second):
      fmt.Println("Timeout!")
  }

}

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

func worker(id int, jobs <-chan int, results chan<- int) {
  for j := range jobs {
    fmt.Printf("Worker %d processing job %d\n", id, j)
    time.Sleep(time.Second)
    results <- j * 2
  }
}

func main() {
  jobs := make(chan int, 5)
  results := make(chan int, 5)

  var wg sync.WaitGroup

  for w := 1; w <= 3; w++ {
    wg.Add(1)
    go func(id int) {
      worker(id, jobs, results)
      wg.Done()
    }(w)
  }

  for j := 1; j <= 5; j++ {
    jobs <- j
  }
  close(jobs)

  wg.Wait()
  close(results)

  for res := range results {
    fmt.Println("Result:", res)
  }
}

package main

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

var counter = 0
var mu sync.Mutex // Mutex для безапасного доступа

func increment() {
  for i := 0; i < 1000; i++ {
  mu.Lock() // Блокируем доступ
  counter++ // Обновляем
  mu.Unlock() // Снимаем блокировку
  }
}

func main() {
  for i := 0; i < 5; i++ {
    go increment()
  }

  time.Sleep(time.Second)
  fmt.Println("Final Counter:", counter)
}

package main

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

var value = 0
var rw sync.RWMutex // Read-Write Mutex

func readValue(id int) {
  rw.RLock() // Блокировка на чтение
  fmt.Printf("Reader %d reads value: %d\n", id, value)
  rw.RUnlock()
}

func writeValue(newValue int) {
  rw.Lock() // Блокировка на запись
  value = newValue
  fmt.Printf("Writer updated value to %d\n", value)
  rw.Unlock()
}

func main() {
  go readValue(1)
  go readValue(2)
  go writeValue(42)
  go readValue(3)

  time.Sleep(time.Second)
// Несколько читателей могут читать одновременно, но писать может только один писатель.
}

package main

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

func worker(ctx context.Context) {
  for {
    select {
      case <-ctx.Done():
        fmt.Println("Worker stopped")
        return
      default:
        fmt.Println("Working...")
        time.Sleep(500 * time.Millisecond)
    }
  }
}

func main() {
  ctx, cancel := context.WithCancel(context.Background())

  go worker(ctx)

  time.Sleep(2 * time.Second)
  cancel() // Отправляем сигнал завершения

  time.Sleep(time.Second)
}

package main

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

func worker(ctx context.Context) {
  for {
    select {
      case <-ctx.Done():
        fmt.Println("Timeout reached, worker stopping")
        return
      default:
        fmt.Println("Worker is running...")
        time.Sleep(500 * time.Millisecond)
    }
  }
}

func main() {
  ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
  defer cancel() // Завершаем

      go worker(ctx)

      time.Sleep(3 * time.Second)

}

package main

import (
 "fmt"
 "sync"
)

var once sync.Once

func initConfig() {
 fmt.Println("Initializing config...")
}

func main() {
 wg := sync.WaitGroup{}

 for i := 0; i < 3; i++ {
  wg.Add(1)
  go func() {
   defer wg.Done()
   once.Do(initConfig) // Запустить единожды
  }()
 }

 wg.Wait()
}

package main

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

var cond = sync.NewCond(&sync.Mutex{})
var ready = false

func worker(id int) {
  cond.L.Lock()
  for !ready {
    cond.Wait() // Ожидание сигнала
  }
  fmt.Printf("Worker %d is running\n", id)
  cond.L.Unlock()
}

func main() {
  for i := 1; i <= 3; i++ {
    go worker(i)
  }

  time.Sleep(time.Second)
  cond.L.Lock()
  ready = true
  cond.Broadcast() // Уведомить ожидающее горутины
  cond.L.Unlock()

  time.Sleep(time.Second)
}