Язык программирования Go, также известный как Golang, был разработан в Google в 2007 году Робертом Гриземером, Робом Пайком и Кеном Томпсоном. Он стал открытым исходным кодом в 2009 году.

Go (или Golang) — это компилируемый, статически типизированный язык программирования, разработанный в Google. Он был создан для упрощения разработки масштабируемых и эффективных программ, особенно в многопоточной среде. Go обладает минималистичным синтаксисом, что делает его легким для изучения и использования. В языке отсутствуют сложные конструкции, такие как наследование и исключения, что также упрощает код.

В этой статье вы узнаете, как написать простое CLI-приложение (интерфейс командной строки) на Go. Сначала мы кратко разберём ключевые особенности языка. Затем обсудим базовую структуру файла в Go. Рассмотрим основные типы данных и конструкции языка.

Установка

Установка на Windows

1. Скачайте установщик
   Перейдите на официальный сайт Go и скачайте файл с расширением .msi для Windows.

2. Запустите установщик
   Дважды кликните на скачанный файл (например, go1.21.1.windows-amd64.msi).
   Следуйте инструкциям мастера установки (рекомендуется использовать путь по умолчанию C:\Go).

3. Проверьте переменную PATH
   Установщик автоматически добавляет Go в системную переменную PATH.
   Чтобы проверить, откройте командную строку и выполните:

   go version

   Если команда не работает, перезагрузите систему или проверьте PATH вручную:

   • Панель управления → Система → Дополнительные параметры системы → Переменные среды → Path.

Установка на Linux

1. Скачайте архив
   На странице загрузки Go выберите архив для Linux (например, go1.21.1.linux-amd64.tar.gz).

2. Распакуйте архив

   sudo tar -C /usr/local -xzf go1.21.1.linux-amd64.tar.gz

3. Добавьте Go в PATH
   Откройте файл ~/.profile или ~/.bashrc и добавьте строку:

   export PATH=$PATH:/usr/local/go/bin

   Затем выполните:

   source ~/.profile  # или source ~/.bashrc

4. Проверьте установку

   go version

   Пример вывода: go version go1.21.1 linux/amd64.

5. Настройка рабочей директории (опционально)
   Создайте папку для проектов и добавьте в ~/.profile:

   export GOPATH=$HOME/go
   export PATH=$PATH:$GOPATH/bin

Установка на macOS

Способ 1: Установщик

1. Скачайте пакет
   Загрузите файл .pkg с официального сайта (например, go1.21.1.darwin-amd64.pkg).

2. Запустите установщик
   Дважды кликните на файл и следуйте инструкциям (установка в /usr/local/go).

3. Проверьте установку
   Откройте терминал и выполните:

   go version

Способ 2: Homebrew

1. Установите Homebrew (если не установлен):

   /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

2. Установите Go

   brew install go

3. Проверьте версию

   go version

Далее нужно установить IDE (интегрированную среду разработки) на ваш выбор, если у вас её ещё нет.

Что такое IDE?
Это редактор для написания кода с дополнительными инструментами (отладка, автодополнение и т.д.).
Популярные варианты для Go: Visual Studio Code (VS Code), GoLand, Sublime Text, LiteIDE.

Первая программа

Откройте папку «go-projects» (или как вы ее назвали) с помощью VS Code (или вашего редактора кода на выбор). Создайте папку «hello-go» и создайте файл main.go. Вы можете назвать этот файл как угодно.

Далее напишите классический код с которого многие начинали свой путь в IT.

package main

import "fmt"

func main(){
	fmt.Println("Hello, Go!")
}

Ниже разберём что делает этот код.

• Объявление пакета (package main): Каждая программа на Go начинается с объявления пакета, указывающего, к какому пакету принадлежит файл. Пакет main - особый пакет, так как он является точкой входа для исполняемых программ.

• Импорт пакета fmt (import "fmt"): В Go вы импортируете пакеты, чтобы использовать их функции и возможности. Здесь мы импортируем пакет fmt, который означает «формат» и используется для операций ввода и вывода.

• Функция main(func main()): Каждая исполняемая программа на Go должна иметь main функцию. Когда вы запускаете свою программу, она выполняется первой.

• Вывод теста в консоль(fmt.Println(«Hello World»)): В этой строке используется функция Println из пакета fmt для печати текста «Hello World» в консоли. Функция Println используется для печати с символом новой строки в конце, поэтому следующий вывод появляется на новой строке.

Пакеты в Go

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

Программы запускаются в пакете main. Пример программы, использующей пакет с путем импорта "fmt":

package main

import "fmt"

func main() {
    fmt.Println("Hello, Go!")
}

Пути импорта

В Go путь импорта — это уникальный идентификатор пакета. Он указывает расположение пакета в системе модулей Go и используется в операторе import для подключения внешних зависимостей.

Типы пакетов:

1. Стандартные пакеты
   Пакеты из стандартной библиотеки Go подключаются по их имени:

   import "fmt"

2. Удаленные пакеты (из репозиториев)
   Go позволяет импортировать пакеты напрямую из репозиториев (GitHub, GitLab и др.):

   import "github.com/che1nov/hello-go"

Пакет main
Объявление package main всегда указывается в начале файла, как показано в примере выше. Функция main() внутри этого пакета является точкой входа программы.

Модули в Go

Модуль — это коллекция пакетов. Он содержит информацию о проекте: зависимости, версию Go, метаданные пакетов. Все проекты на Go имеют файл go.mod.

Команда для инициализации файла go.mod через терминал:

go mod init <module-path>

Где module-path соответствует пути импорта пакета.

Команда go
«Команда Go» (go) — это инструмент командной строки в языке программирования Go. Позволяет использовать интсрументы для разработки такие как :

• Для запуска кода применяется go run, который компилирует и сразу выполняет программу.

• Чтобы собрать исполняемый файл, используется go build, преобразующий исходный код в бинарный файл.

• Тестирование кода осуществляется через go test для текущего пакета или go test ./... для всех поддиректорий.

• Управление зависимостями с модулями включает команды: go mod init для создания нового модуля и файла go.mod, go get для загрузки пакетов, go mod tidy для очистки неиспользуемых зависимостей и go list -m all для просмотра списка зависимостей.

• Документацию можно просматривать через go doc, указав пакет или элемент.

• Анализ зависимостей выполняется с помощью go list для информации о пакетах и go list -m -versions <module> для списка версий модуля.

• Форматирование кода автоматизирует go fmt,

• Информация о среде Go доступна через go env.

  Эти команды упрощают разработку, сборку, тестирование и поддержку проектов.

Переменные в Go

Переменная - это именованное значение. Переменные обеспечивают способ хранения и доступа к данным в вашей программе.

Чтобы объявить переменную, вы можете использовать одиночное, составное, создание блока. Давайте рассмотрим примеры каждого из них.

Одиночное объявление

package main

import "fmt"

func main() {
    var singleVariable int //обьявление переменной 
    singleVariable = 10 //присвоение значения 10
    fmt.Println(singleVariable)
}

В примере обьявляется переменная singleVariable с явным указанием типа int.

package main

import "fmt"

func main() {
    createAndAssignVar := 42 //обьявление и присвоение значения 
    fmt.Println(createAndAssignVar)
}

Но вы ещё можете создать переменную без явного указания типа данных с помощью := , в таком случае тип определится автоматически.

Составное обьявление

Вы также можете создать несколько переменных одновременно

package main

import "fmt"

func main() {
    var a, b, c  = 1, 2, "Coders" обьявление и присвоение переменных разных типов
    fmt.Println(a, b, c)
}

Обьявление блока переменных

package main

import "fmt"

func main() {
    {
        var blockVariable int
        blockVariable = 5
        fmt.Println(blockVariable)
    }
  
  //здесь переменные недоступны
  
}

Создание блока используется, когда вы хотите ограничить область действия переменных определенным блоком. Вы объявляете и инициализируете несколько переменных в блоке кода {}.

Именование переменных в Go

При именовании переменных в Go используется верблюжий регистр(CamelCase). Например:

const myVariable = 20

Когда вы придумываете имя переменной, рекомендуется давать ей описательное имя, например conferenceName := "Linux" вместо conference := "Linux".

Разница между ключевыми словами var и const в Go

В Go есть два способа объявления переменных: var и const. Для тех, кто знаком с JavaScript, это может показаться знакомым.

• var используется для объявления переменных, и их значения могут быть изменены после объявления.

• const используется для объявления констант, и их значения не могут быть изменены после объявления.
  Вот пример использования var и const для объявления переменных:

package main

import «fmt»

func main() {
    // использование var
    var variable1 int = 5
    variable1 = 10 // значение variable1 может быть изменено

    // Использование const
    const constant1 int = 5
    constant1 = 10 // ошибка, константы не могут быть переназначены

    fmt.Println(variable1, constant1)
}

В приведенном выше примере variable1 может быть переназначена на новое значение, в то время как constant1 не может быть переназначена и выдаст ошибку при компиляции.

Типы данных

В Golang существуют различные типы данных, среди которых числовые, строка, булево значение, массив, указатель, структура, карта и интерфейс.

Давайте рассмотрим примеры каждого из них, чтобы вы могли понимали, как они выглядят.

• Число ( int, float64) используется для представления числовых значений (целых чисел или десятичных дробей). Вот пример:

package main

import "fmt"

func main() {
    // целое число
    var integerVar int = 42
    fmt.Println(integerVar)

    // число с плавающей точкой
    var floatVar float64 = 3.14
    fmt.Println(floatVar)
}

В этом примере integerVar - это целочисленная переменная, а floatVar - переменная с плавающей точкой.

• Строка(string)используется для представления последовательности символов.

package main

import "fmt"

func main() {
    var stringVar string = "Hello, Go!"
    fmt.Println(stringVar)
}

В этом примере stringVar - это строковая переменная, содержащая текст «Hello, Go!».

• Тип bool используется для представления логических значений (true или false).

package main

import "fmt"

func main() {
    var boolVar bool = true
    fmt.Println(boolVar)
}

В этом примере boolVar - это булева переменная, со значением true.

• Массив(array) используется для хранения последовательностей элементов фиксированного размера одного типа. Вот пример

package main

import "fmt"

func main() {
    var intArray [3]int = [3]int{1, 2, 3}
    fmt.Println(intArray)
}

В этом примере intArray - это массив целых чисел с фиксированным размером 3.

• Указатель(pointer) используется для хранения адреса переменной в памяти.

package main

import "fmt"

func main() {
    var originalVar int = 42 // переменая originalVar со значением 42
    var pointerVar *int = &originalVar //указатель на originalVar 
    fmt.Println(*pointerVar) //разыменование указателя
}

В этом примере pointerVar - это указатель на адрес памяти originalVar.

• Структура (Struct) используется для объединения переменных разных типов под одним именем.

package main

import "fmt"

type Person struct { //структура Person с полями Name и Age
    Name string
    Age  int
}

func main() {
    var personVar Person = Person{Name: "Alice", Age: 30} // инициализация значений для полей структуры
    fmt.Println(personVar)
}

В этом примере personVar - это структура, представляющая человека с именем и возрастом.

• Map используется для предоставления пар ключ-значение.

package main

import "fmt"

func main() {
    var myMap map[string]int = map[string]int{"one": 1, "two": 2, "three": 3}
    fmt.Println(myMap)
}

В этом примере myMap - это карта с ключами типа string и значениями int.

• Интерфейс(interface) используется для определения набора сигнатур методов без указания реализации. Уже посложнее. Вот пример с комментариями:

package main

import "fmt"

// Shape объявляет интерфейс для геометрических фигур, способных возвращать свою площадь.
// Любой тип, реализующий метод Area(), удовлетворяет этому интерфейсу.
type Shape interface {
    Area() float64
}

// Circle представляет структуру окружности с заданным радиусом.
// Radius хранит значение радиуса окружности в виде числа с плавающей точкой.
type Circle struct {
    Radius float64
}

// Area вычисляет площадь окружности по формуле πr².
// Реализует метод интерфейса Shape, позволяя использовать Circle через этот интерфейс.
func (c Circle) Area() float64 {
    return 3.14 * c.Radius * c.Radius
}

func main() {
    // Создаем экземпляр Circle с радиусом 5.0
    circle := Circle{Radius: 5.0}
    
    // Присваиваем Circle переменной типа Shape, демонстрируя полиморфизм.
    // Это возможно, так как Circle реализует все методы интерфейса Shape.
    var myShape Shape = circle
    
    // Вызываем метод Area() через интерфейсную переменную и выводим результат.
    // Вывод: 78.5 (3.14 * 5 * 5)
    fmt.Println(myShape.Area())
}

В этом примере Shape - это интерфейс, а Circle - тип, реализующий метод Area интерфейса Shape.

Операторы в Go

В Go существует 3 основных типа операторов: арифметические операторы, логические операторы и реляционные операторы

Теперь давайте пройдемся по каждой категории операторов и посмотрим, как они работают, на примерах.

Арифметические операторы

Арифметические операторы используются, когда вам нужно выполнить основные математические операции в коде. К ним относятся следующие:

package main

import "fmt"

func main() {
    a := 15
    b := 4

    // Арифметические операции
    sum := a + b       // Сложение
    difference := a - b // Вычитание
    product := a * b    // Умножение
    quotient := a / b   // Деление (целочисленное)
    remainder := a % b  // Остаток от деления

    // Вывод результатов
    fmt.Printf("%d + %d = %d\n", a, b, sum)
    fmt.Printf("%d - %d = %d\n", a, b, difference)
    fmt.Printf("%d * %d = %d\n", a, b, product)
    fmt.Printf("%d / %d = %d (целочисленное деление)\n", a, b, quotient)
    fmt.Printf("%d %% %d = %d (остаток)\n", a, b, remainder)
}

Реляционные операторы

Реляционные операторы используются для сравнения значений и принятия решений на основе результатов сравнения. Пример:

package main

import "fmt"

func main() {
    a := 15
    b := 4
    c := 15
    d := "apple"
    e := "banana"

    // Реляционные операторы для чисел
    greater := a > b       // Больше
    less := b < a          // Меньше
    greaterOrEqual := a >= c // Больше или равно
    lessOrEqual := b <= a  // Меньше или равно
    equal := a == c        // Равно
    notEqual := a != b     // Не равно

    // Реляционные операторы для строк (лексикографическое сравнение)
    strCompare := d < e

    // Вывод результатов
    fmt.Printf("Числовые сравнения:\n")
    fmt.Printf("%d > %d → %t\n", a, b, greater)
    fmt.Printf("%d < %d → %t\n", b, a, less)
    fmt.Printf("%d >= %d → %t\n", a, c, greaterOrEqual)
    fmt.Printf("%d <= %d → %t\n", b, a, lessOrEqual)
    fmt.Printf("%d == %d → %t\n", a, c, equal)
    fmt.Printf("%d != %d → %t\n\n", a, b, notEqual)

    fmt.Printf("Строковые сравнения:\n")
    fmt.Printf("%q < %q → %t (лексикографическое сравнение)\n", d, e, strCompare)
}

Запустим программу, выведет:

Числовые сравнения:
15 > 4 → true
4 < 15 → true
15 >= 15 → true
4 <= 15 → true
15 == 15 → true
15 != 4 → true

Строковые сравнения:
"apple" < "banana" → true (лексикографическое сравнение)

Логические операторы

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

package main

import "fmt"

func main() {
    // Исходные значения для операций
    a := true
    b := false
    c := true
    d := false

    // Логические операции
    andResult := a && b     // Логическое И
    orResult := b || c      // Логическое ИЛИ
    notResult := !d         // Логическое НЕ
    
    // Комбинированная операция
    combined := (a || b) && !(c == d)
    
    // Специфика Go: короткие вычисления (short-circuiting)
    shortCircuit := b && someFunc()  // someFunc() не будет вызвана

    // Вывод результатов
    fmt.Printf("Логические операторы:\n")
    fmt.Printf("%t && %t → %t\n", a, b, andResult)
    fmt.Printf("%t || %t → %t\n", b, c, orResult)
    fmt.Printf("!%t → %t\n", d, notResult)
    fmt.Printf("(%t || %t) && !(%t == %t) → %t\n", a, b, c, d, combined)
    fmt.Printf("Short-circuit: %t (someFunc не вызывалась)\n", shortCircuit)

    // Особенность Go: строгая типизация
    // x := 1 || 0 // Ошибка: invalid operation
}

// Вспомогательная функция для демонстрации short-circuit
func someFunc() bool {
    fmt.Println("Эта функция не должна вызываться!")
    return true
}

Заключение

В этой статье вы узнали о языке программирования Go. Вы узнали о характеристиках Go и о том, как установить Go. Затем вы узнали, как начать писать код на Go, и увидели примеры многих возможностей Go в действии. Мы также поговорили о том, что такое пакеты, как работают модули и многое другое.

Буду рад, если вы поделитесь в комментариях, мнением и советами по изучению языка.

Желаю успехов в дальнейшем изучении!