1. Функции в Go? Да это просто!

Начнем с базы. Объявить функцию можно через func, и сразу видно, что Go любит минимализм:

func hello() {
    fmt.Println("Привет, я функция!")
}

А если нужно вернуть результат — добавляем тип возвращаемого значения:

func add(a int, b int) int {
    return a + b
}

Мое открытие: В Go нет “магии” вроде перегрузки функций (как в C++ или Java), зато есть кристальная ясность. И это нравится!

2. Параметры: копии, указатели и “сколько угодно аргументов”

Что удивило:

• Передача по значению — функция получает копию аргумента. Хочешь изменить оригинал? Используй указатели:

  func double(number *int) {
      *number *= 2
  }
  

• Вариативные функции с ...Type — можно передать любое количество аргументов:

  func sum(nums ...int) int {
      total := 0
      for _, v := range nums {
          total += v
      }
      return total
  }
  // Вызов: sum(1, 2, 3, 42)
  

Прикол: В Go даже слайсы передаются как копии, но это не проблема — они ссылаются на те же данные.

3. Множественный возврат и именованные результаты

Здесь Go выделяется: функция может вернуть несколько значений!

func swap(x, y string) (string, string) {
    return y, x
}

А еще можно давать имена возвращаемым значениям — удобно для документирования и упрощения кода:

func calc(a, b int) (sum, product int) {
    sum = a + b
    product = a * b
    return // голый return!
}

Мое мнение: Это круто, но надо не злоупотреблять — читаемость важнее.

4. Функции-анонимы и замыкания

Оказывается, в Go можно создавать анонимные функции и даже использовать замыкания! Пример счетчика:

func createCounter() func() int {
    count := 0
    return func() int {
        count++
        return count
    }
}
// Использование:
counter := createCounter()
fmt.Println(counter()) // 1
fmt.Println(counter()) // 2

Вау-эффект: Замыкания позволяют “сохранять” состояние между вызовами. Это как мини-классы, но без ООП!

5. Функции как типы и callback-и

Go позволяет присваивать функции переменным и передавать их как аргументы. Например:

type Operation func(int, int) int

func compute(a, b int, op Operation) int {
    return op(a, b)
}

// Используем:
result := compute(5, 3, func(x, y int) int { return x * y })

Моя мысль: Это открывает дверь к гибким абстракциям, вроде middleware или обработчиков событий.

6. Рекурсия: просто, но с осторожностью

Факториал в Go пишется классически:

func factorial(n int) int {
    if n == 0 {
        return 1
    }
    return n * factorial(n-1)
}

Важно: Go не оптимизирует хвостовую рекурсию, поэтому глубокие вызовы могут “уронить” программу.

Мои лайфхаки для начинающих:

1. Делайте функции короткими. Одна функция — одна задача.
2. Возвращайте ошибки первым аргументом. Это стандарт Go:

   func divide(a, b float64) (float64, error) { ... }
   

3. Используйте defer для закрытия ресурсов (файлы, соединения).

Итог

Go заставляет писать простой и понятный код, а функции здесь — как кирпичики Lego: четкие, предсказуемые, но при этом мощные. Да, пришлось отвыкнуть от некоторых привычек (привет, ООП!), зато теперь я чувствую, как “дышит” язык.

P.S. Если накосячил в примерах — пишите, исправлю. Всем добра!