Как установить golang на windows

GO или Golang – это высокопроизводительный и многопоточный язык программирования, разработанный компанией Google в 2007 году и выпущенный в 2009. По сей день, Golang продолжает набирать популярность. Согласно исследованию учебного центра IBS, в России этот язык входит в топ-5 по популярности и занимает 4 место на 2023 год. 

Картинка с сайта: timeweb.cloud

^{Изображение: selecty.ru}

Язык программирования Go поддерживает множество операционных систем, что делает его универсальным выбором для разработки на различных платформах. В этом руководстве мы разберем шаг за шагом процесс установки Golang на Windows.

cloud

Go поддерживает Windows 7 и более новые версии. Убедитесь, что у вас установлена поддерживаемая версия ОС. 

В настоящем руководстве мы будем использовать Windows 11. Также нам понадобится пользователь с правами администратора для настройки переменных среды.

1.  Чтобы установить Golang на Windows, пользователю необходимо скачать установочный файл последней версии для Microsoft Windows с официального сайта Go. При необходимости, вы можете выбрать вместо последней любую другую доступную версию языка.

Картинка с сайта: timeweb.cloud

1. После окончания загрузки файла запускаем его и следуем рекомендациям мастера установки. При необходимости, вы можете изменить путь к расположению файлов. Он пригодится при настройке переменных среды.
2. По завершению установки, проверим, что Golang успешно встал в систему. Для этого откроем терминал (Win + R → cmd) и выполним следующую команду:

go version

Если результат выполнения совпадает с тем, что на картинке ниже, значит Golang установлен успешно. Единственным отличием может быть версия языка, которую вы выбрали для установки на первом шаге инструкции.

Картинка с сайта: timeweb.cloud

Чтобы обновить Golang в Windows на более новую версию, необходимо удалить его старую версию и выполнить установку новой, согласно нашей инструкции.

Теперь перейдем к настройке переменных среды для корректной работы Go.

Настройка переменных среды

Настройка переменных среды — важный этап установки Go на Windows, который позволяет операционной системе определить, где находятся необходимые для работы Go файлы и каталоги.

Для корректной работы Golang потребуется две переменные среды:

• GOPATH – это переменная среды, указывающая на место, где Go хранит загруженные и скомпилированные пакеты;
• PATH – это переменная среды, позволяющая системе находить исполняемые файлы Go без указания полного пути к ним.

GOPATH

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

В рамках инструкции мы создадим рабочее пространство по адресу C:\GoProject. Также добавим в данный каталог 2 папки:

• bin – для хранения исполняемых файлов (бинарных файлов). Когда вы компилируете свой проект, Go создает исполняемый файл и размещает его в этом каталоге.;
• src – для хранения исходных файлов Go. Все файлы .go размещаются именно здесь.

Картинка с сайта: timeweb.cloud

1. После создания рабочего пространства настроим переменную GOPATH. Для этого перейдем в панель управления, затем на вкладку «Система и безопасность», далее «Система» и наконец кликаем на «Дополнительные параметры системы». 

Есть также более простой способ доступа к свойствам системы: открыть окно «Выполнить» (Win + R) и ввести:

sysdm.cpl

Картинка с сайта: timeweb.cloud

1. В открывшемся окне кликаем на «Переменные среды», после чего нажимаем на кнопку «Создать» под переменными среды пользователя. Здесь необходимо заполнить два поля: имя переменной и ее значение.

В поле «Имя переменной» указываем GOPATH, а в поле «Значение переменной» – путь к созданному ранее рабочему пространству (в нашем случае C:\GoProject), как показано на рисунке ниже.

Картинка с сайта: timeweb.cloud

Нажимаем два раза кнопку «OK», чтобы сохранить внесенные изменения.

1. Чтобы проверить создание системной переменной, откроем окно «Выполнить» (Win + R) и введем строку %GOPATH%. Если все было сделано правильно, перед вами откроет ваше рабочее пространство.

PATH

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

В открывшемся окне должна быть запись, которая хранит путь до папки bin языка Go.

Картинка с сайта: timeweb.cloud

В нашем случае это C:\Program Files\Go\bin. Если ваше значение не соответствует тому, что было указано при установке Go, поменяйте его на корректное с помощью кнопки «Изменить».

На этом установка Golang в Windows и настройка переменных среды окончена. Теперь мы можем проверить его работу, написав и запустив свою первую программу.

Проверка установки

1. Чтобы проверить работу только что установленного Golang в Windows, создадим тестовый файл с расширением .go в рабочем пространстве (C:\GoProject\src). Например, ExampleProgram.go.
2. После создания файла добавим в него простой код:

package main
import "fmt"
func main() {
    fmt.Println("Hello, Go has been successfully installed into your system!")
}

Продемонстрированная программа должна выводить сообщение об успешной установке Go в систему.

1. Чтобы скомпилировать и запустить программу, вводим в терминал:

go run %GOPATH%/src/ExampleProgram.go

Как видно по картинке ниже, программа компилируется и выполняется, выводя на экран заданный текст.

Картинка с сайта: timeweb.cloud

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

Картинка с сайта: habr.com

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 соответствует пути импорта пакета.

Картинка с сайта: habr.com

Картинка с сайта: habr.com

Команда 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 не может быть переназначена и выдаст ошибку при компиляции.

Картинка с сайта: habr.com

Типы данных

В 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 основных типа операторов: арифметические операторы, логические операторы и реляционные операторы

Картинка с сайта: habr.com

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

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

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

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 в действии. Мы также поговорили о том, что такое пакеты, как работают модули и многое другое.

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

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

Если эта публикация вас вдохновила и вы хотите поддержать автора — не стесняйтесь нажать на кнопку

Опубликовано: 24.10.2023

Используемые термины: Golang, Windows.

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

Чтобы начать программировать на Golang, нужно его установить. В этой статье подробно разберем процесс установки — от проверки системы до запуска и тестирования.

После того, как мы разберем процесс установки на Windows, вы сможете сразу приступать к освоению синтаксиса Golang, изучению работы с переменными, условиями, циклами и другими базовыми конструкциями. А также затем перейти к более продвинутым темам вроде взаимодействия с базами данных, создания веб-сервисов, организации многопоточности в приложениях.

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

Подготовка к установке

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

Вот рекомендуемые минимальные требования для установки Golang на вашем устройстве:

• Операционная система: Windows 7 или более новая. В данной инструкции мы рассмотрим процесс установки на Windows 10.
• Процессор: должен поддерживать набор инструкций SSE2. Это стандартное требование для большинства современных процессоров.
• Оперативная память: для обеспечения стабильной работы Golang рекомендуется иметь не менее 1 Гб оперативной памяти.

Дополнительно, перед тем как начать загрузку дистрибутива Golang, важно определить разрядность вашей операционной системы: 32-битная или 64-битная. Этот параметр влияет на выбор версии дистрибутива для скачивания.

Чтобы проверить версию вашей операционной системы и другие параметры компьютера, кликните по Пуск — Параметры. Перейдите в раздел О программе. В подразделе «Характеристики устройства» представлена вся необходимая информация:

Картинка с сайта: www.dmosk.ru

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

Скачивание дистрибутива Golang

Дистрибутив Golang доступен для скачивания на официальном сайте. На главной странице переходим по ссылке Download и видим список версий:

Картинка с сайта: www.dmosk.ru

Нужно скачать последнюю стабильную версию. На момент написания статьи — это Golang версии go1.21.3:

Картинка с сайта: www.dmosk.ru

Далее выбираем версию, соответствующую разрядности Windows:

• Для 64-битной системы — go1.21.3.windows-amd64.msi
• Для 32-битной — go1.21.3.windows-386.msi

Размер дистрибутива около 60-70 мб. Скачивание по быстрому интернету займёт буквально одну минуту. После скачивания можно приступать к установке.

Процесс установки Golang

Рассмотрим установку Go на Windows 10 и 11 подробнее.

На Windows 10

После загрузки установщика Golang, запустите его и следуйте инструкциям:

1. Нажмите Next на странице приветствия установщика.

2. Примите лицензионное соглашение и нажмите Next.

3. По умолчанию Golang будет устанавливаться в директорию C:\Go. Можно изменить директорию установки. Нажмите Next.

4. Выберите компоненты для установки. Оставьте отмеченным по умолчанию «Go programming language». Нажмите Next.

5. Нажмите Install для начала установки.

6. После завершения установки нажмите Finish.

Далее необходимо настроить системные переменные для Golang:

1. Нажмите правой кнопкой мыши на кнопку Пуск, выберите Система и кликните по ссылке справа Дополнительные параметры системы.

2. На вкладке «Дополнительно» кликаем по кнопке Переменные системы:

Картинка с сайта: www.dmosk.ru

3. Найдите переменную Path и добавьте к ней путь к bin директории вашей установки Go. Обычно это C:\Go\bin:

4. Создайте новую переменную среды с именем GOPATH и укажите в ней путь к каталогу, где вы будете хранить свой код Go. Например, C:\GoWorkspace.

После этого перезагрузите компьютер, чтобы изменения вступили в силу.

На Windows 11

Процесс установки Golang на Windows 11 практически не отличается от Windows 10.

Единственное отличие в том, что в Windows 11 для доступа к переменным среды нужно зайти в Настройки — Система — Информация о системе — Дополнительные параметры системы в левом меню.

В остальном все этапы установки и настройки остаются такими же, как и для Windows 10:

• Скачивание подходящего дистрибутива Golang
• Запуск процесса установки
• Настройка путей в переменных средах

Поэтому, если вы уже устанавливали Golang на Windows 10, то на Windows 11 сможете сделать это так же без особых проблем.

Проверка установки

Чтобы убедиться, что Golang установлен правильно, откройте командную строку Windows (cmd) и введите команду:

go version

Если установка прошла успешно, вы увидите информацию о версии Golang.

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

• Правильность настройки переменных среды PATH
• Отсутствие опечаток в пути к папке bin
• Что вы выбрали версию Golang для своей системы (32/64 bit)

После решения проблем, перезагрузите компьютер и запустите проверку еще раз. Команда go version должна отобразить актуальную версию Golang.

Если проблемы сохраняются, попробуйте переустановить Golang или обратитесь за помощью в техподдержку или на IT-форумы.

Настройка рабочего окружения для разработки на Golang

После установки Golang на компьютер следующим важным шагом будет настройка удобного и продуктивного рабочего окружения.

В первую очередь необходимо выбрать и установить подходящий текстовый редактор или интегрированную среду разработки (IDE). Наиболее популярные варианты:

• Visual Studio Code.
• GoLand от JetBrains.
• Atom.
• Sublime Text.

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

Картинка с сайта: www.dmosk.ru

Далее желательно добавить полезные plug-ins и расширения. Например, расширения для автодополнения кода, отладки, форматирования, проверки и рефакторинга кода. Это значительно упростит и ускорит написание качественного кода.

Также имеет смысл установить утилиты командной строки для работы с Go-модулями, зависимостями и тестированием кода.

Потратьте время на настройку продуктивного окружения — это поможет быстрее и комфортнее осваивать язык и создавать проекты.

Первые шаги в программировании на Golang

После того как окружение для разработки настроено, можно смело приступать к написанию своей первой программы на Golang.

Для начала создайте простую программу, выводящую классическое «Hello, World!». Напишите код в редакторе, сохраните файл с расширением .go, затем запустите и проверьте работу программы.

Далее рекомендуется последовательно изучать основы синтаксиса языка, принципы работы с переменными, условными конструкциями, циклами, функциями, структурами данных.

Очень важно сразу закреплять полученные знания на практике, решая упражнения и реальные задачи. Полезными ресурсами в изучении станут документация Golang, обучающие курсы, видеоуроки, форумы. 

Заключение

Правильная установка Golang — это важная основа для дальнейшей работы с языком. Мы рассмотрели все необходимые шаги: проверка системы, выбор версии, запуск установщика, настройка переменных среды.

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

Помните, что качественная установка — это залог дальнейшего продуктивного освоения Golang и разработки на нем. Успехов в изучении!

Last Updated :
05 Oct, 2021

Prerequisite: Introduction to Go Programming Language

Before, we start with the process of Installing Golang on our System. We must have first-hand knowledge of What the Go Language is and what it actually does? Go is an open-source and statically typed programming language developed in 2007 by Robert Griesemer, Rob Pike, and Ken Thompson at Google but launched in 2009. It is also known as the Golang and it supports the procedural programming language. It was initially developed to improve programming productivity of the large codebases, multicore, and networked machines.

Golang programs can be written on any plain text editor like notepad, notepad++ or anything of that sort. One can also use an online IDE for writing Golang codes or can even install one on their system to make it more feasible to write these codes. Using an IDE makes it easier to write Golang codes because IDEs provide a lot of features like intuitive code editor, debugger, compiler, etc.
To begin with, writing Golang Codes and performing various intriguing and useful operations, one must have the Go language installed on their System. This can be done by following the step by step instructions provided below:

How to check the Preinstalled Go Language Version?

Before we begin with the installation of Go, it is good to check if it might be already installed on your System. To check if your device is preinstalled with Golang or not, just go to the Command line(For Windows, search for cmd in the Run dialog( + R).

Now run the following command:

go version

If Golang is already installed, it will generate a message with all the details of the Golang’s version available, otherwise, if Golang is not installed then an error will arise stating Bad command or file name

Downloading and Installing Go

Before starting with the installation process, you need to download it. For that, all versions of Go for Windows are available on golang.org.

Картинка с сайта: www.geeksforgeeks.org

Download the Golang according to your system architecture and follow the further instructions for the installation of Golang.

Step 1: After downloading, unzip the downloaded archive file. After unzipping you will get a folder named go in the current directory.

Step 2: Now copy and paste the extracted folder wherever you want to install this. Here we are installing in C drive.

Step 3: Now set the environment variables. Right click on My PC and select Properties. Choose the Advanced System Settings from the left side and click on Environment Variables as shown in the below screenshots.

Картинка с сайта: www.geeksforgeeks.org

Картинка с сайта: www.geeksforgeeks.org

Step 4: Click on Path from the system variables and then click Edit. Then Click New and then add the Path with bin directory where you have pasted the Go folder. Here we are editing the path C:\go\bin and click Ok as shown in the below screenshots.

Картинка с сайта: www.geeksforgeeks.org

Картинка с сайта: www.geeksforgeeks.org

Step 5: Now create a new user variable which tells Go command where Golang libraries are present. For that click on New on User Variables as shown in the below screenshots.

Картинка с сайта: www.geeksforgeeks.org

Now fill the Variable name as GOROOT and Variable value is the path of your Golang folder. So here Variable Value is C:\go\. After Filling click OK.

Картинка с сайта: www.geeksforgeeks.org

After that Click Ok on Environment Variables and your setup is completed. Now Let’s check the Golang version by using the command go version on command prompt.

Картинка с сайта: www.geeksforgeeks.org

After completing the installation process, any IDE or text editor can be used to write Golang Codes and Run them on the IDE or the Command prompt with the use of command:

go run filename.go