Шпаргалка по Go

Полезные команды и конструкции Go

Содержимое страницы

Вот базовая структура программы на Go, шаблоны обработки ошибок и сравнение каналов и горутин.

кролики вокруг знака golang

Шпаргалка по языку Go

Базовая синтаксис

Объявление пакета

package main

Импорт пакетов

import "fmt"
import (
    "fmt"
    "math"
)

Основная функция

func main() {
    // Ваш код здесь
}

Переменные и типы

Объявление переменных

var name string
var age int = 25
x := 10 // Короткое объявление

Базовые типы

bool
string
int, int8, int16, int32, int64
uint, uint8, uint16, uint32, uint64
float32, float64
complex64, complex128

Управляющие конструкции

Условный оператор

if x > 0 {
    // код
} else if x < 0 {
    // код
} else {
    // код
}

Цикл for

for i := 0; i < 10; i++ {
    // код
}

Цикл range

for index, value := range collection {
    // код
}

Конструкция switch

switch variable {
case value1:
    // код
case value2:
    // код
default:
    // код
}

Функции

Объявление функции

func functionName(param1 type1, param2 type2) returnType {
    // код
    return value
}

Множественные значения возврата

func divideAndRemainder(x, y int) (int, int) {
    return x / y, x % y
}

Структуры данных

Массивы

var numbers int
numbers := int{1, 2, 3, 4, 5}

Срезы

slice := []int{1, 2, 3}
slice := make([]int, 3, 5)

Карты

m := make(map[string]int)
m["key"] = value

Структуры

type Person struct {
    Name string
    Age  int
}
p := Person{Name: "Alice", Age: 30}

Методы

Объявление метода

func (r Rectangle) Area() float64 {
    return r.width * r.height
}

Интерфейсы

Объявление интерфейса

type Shape interface {
    Area() float64
}

Конкуренция

Горутины

go functionName()

Каналы

ch := make(chan int)
ch <- value  // Отправка
value := <-ch  // Получение

Обработка ошибок

Проверка ошибок

if err != nil {
    // Обработка ошибки
}

Отложенное выполнение

defer file.Close()

Тестирование

Тестовая функция

func TestFunction(t *testing.T) {
    // Тестовый код
}

Эта шпаргалка охватывает наиболее важные конструкции и команды языка Go. В неё включены базовая синтаксис, управляющие конструкции, функции, структуры данных, методы, интерфейсы, примитивы конкуренции и обработка ошибок. Помните, что Go делает акцент на простоте и читаемости, поэтому эти конструкции составляют основу для написания эффективного и понятного кода на Go.

Обработка ошибок в Go

Обработка ошибок в Go проста и явна, делая акцент на ясности и надежности. Вот основные техники обработки ошибок в Go:

Возвращайте ошибки как значения: Функции, которые могут завершиться неудачно, должны возвращать ошибку в качестве последнего возвращаемого значения. Например:

func Hello(name string) (string, error) {
    if name == "" {
        return "", errors.New("пустое имя")
    }
    message := fmt.Sprintf("Привет, %v. Добро пожаловать!", name)
    return message, nil
}

Всегда проверяйте ошибки: После вызова функции, возвращающей ошибку, немедленно проверьте, является ли ошибка ненулевой. Например:

result, err := SomeFunction()
if err != nil {
    // Обработка ошибки
    log.Fatal(err)
}

Используйте обертку ошибок: При передаче ошибок вверх по стеку вызовов, оборачивайте их для добавления контекста с помощью fmt.Errorf() с вершиной %w. Например:

f, err := os.Open(path)
if err != nil {
    return nil, fmt.Errorf("открытие не удалось: %w", err)
}

Используйте defer для очистки: Используйте defer, чтобы убедиться, что ресурсы правильно закрываются или очищаются, даже если произошла ошибка.
Создавайте пользовательские типы ошибок: Реализуйте интерфейс error для пользовательских типов ошибок, чтобы предоставить более подробную информацию об ошибках.
Используйте пакет errors: Используйте функции, такие как errors.New(), для создания простых сообщений об ошибках, и errors.Is() или errors.As() для проверки и преобразования типов ошибок.
Избегайте использования panic: Оставьте panic для действительно невосстановимых ситуаций. Обычная обработка ошибок должна использовать возвращаемые значения.
Предоставляйте явную информацию об ошибках: Делайте сообщения об ошибках четкими и информативными, чтобы облегчить отладку и устранение неполадок.

Следуя этим практикам, вы можете создавать надежные программы на Go, которые эффективно обрабатывают ошибки и сохраняют ясность кода.

Лучшие практики для горутин и каналов в Go

Эффективное использование горутин

Избегайте чрезмерного создания горутин: Создавайте горутины осознанно, учитывая природу задачи и то, приносит ли она пользу от параллельного выполнения.
Правильная синхронизация: Используйте механизмы синхронизации, такие как каналы или группы ожидания, для эффективного управления горутинами и предотвращения расточительства ресурсов.
Оценка природы задачи: Оцените, действительно ли задача выигрывает от параллельного выполнения, прежде чем использовать горутины.

Эффективное использование каналов

Выбор подходящего типа канала: Используйте небуферизированные каналы для синхронизации и буферизированные каналы, когда вам нужно отделить операции отправки и получения.
Размер буфера: При использовании буферизированных каналов тщательно выбирайте размер буфера, чтобы сбалансировать производительность и использование ресурсов.
Правильное закрытие каналов: Убедитесь, что каналы закрываются, когда больше не будет отправляться данных, чтобы предотвратить взаимные блокировки и утечки ресурсов.

Шаблоны конкуренции

Шаблон пула рабочих процессов: Реализуйте пулы рабочих процессов с использованием горутин и каналов для эффективного распределения задач и сбора результатов.
Шаблон производитель-потребитель: Используйте горутины в качестве производителей и потребителей, а каналы для обмена данными между ними.

Обработка ошибок и управление ресурсами

Используйте defer для очистки: Применяйте операторы defer, чтобы обеспечить правильную очистку ресурсов, даже в случае ошибок.
Обработка паники: Реализуйте recover() в долго работающих горутинах, чтобы предотвратить сбой всей программы из-за паники в одной горутине.

Коммуникация и синхронизация

Предпочитайте каналы общей памяти: Используйте каналы для коммуникации между горутинами, чтобы избежать гонок и упростить синхронизацию.
Используйте select для нескольких каналов: Применяйте оператор select для обработки нескольких операций с каналами одновременно.

Рассмотрение производительности

Ограничьте параллельные операции: Используйте семафоры или пулы рабочих процессов, чтобы ограничить количество параллельных операций и предотвратить истощение ресурсов.
Избегайте преждевременной оптимизации: Профилируйте свой код, чтобы выявить узкие места, прежде чем применять оптимизации конкуренции.

Тестирование и отладка

Используйте детектор гонок: Регулярно запускайте свои тесты с флагом -race, чтобы обнаруживать гонки данных.
Пишите тесты на конкуренцию: Создавайте тесты, которые специально проверяют ваши пути кода конкуренции, чтобы обеспечить надежность.

Следуя этим лучшим практикам, вы сможете эффективно использовать модель конкуренции Go, делая ваши программы более эффективными, поддерживаемыми и менее подверженными общим проблемам, связанным с конкуренцией.

Посмотрите другие технические статьи блога.

Обновление golang на linux

перейдите и скачайте новую версию: https://go.dev/doc/install
удалите старую:

sudo rm -rf /usr/local/go

установите новую:

cd Downloads
sudo tar -C /usr/local -xzf go1.24.3.linux-amd64.tar.gz