Съдържание на курса

Урок 1 — Инсталиране на Go на твоя Linux Mint и първата ти програма

От Dorian Chávez · основател на Hábil и архитект на интеграции ·

Продължителност: 45–60 минути (или 2 сесии по 30). Това е единственият урок, който не преподава Go като език: преподава инструмента и терена, на който ще работиш — а този терен крие повече капани, отколкото изглежда на пръв поглед.

Като приключиш, ще можеш:

  • Да инсталираш официалната и актуална версия на Go на Linux Mint, без да зависиш от системния пакет, и да обясниш защо този пакет е остарял по замисъл, а не по небрежност.
  • Да обясниш какво са GOROOT, GOPATH и PATH и защо Go не работи, докато не пипнеш второто.
  • Да разпознаваш разликата между терминал, който чете твоята конфигурация, и такъв, който не я чете — истинската причина за „добавих го, а пак не работи“ — и да знаеш кой е твоят.
  • Да създадеш проект с go mod init, да напишеш програма и да я изпълниш с go run.
  • Да създадеш двоичен файл (binary) с go build и да обясниш, с истинска проба, защо той работи на друга машина, без там да има инсталиран Go.
  • Да използваш go fmt, за да не спориш никога повече за стила на кода.
  • Да разпознаваш, дума по дума, най-честите съобщения за грешки на този етап — от компилатора, за права и за път — и да знаеш какво да правиш с всяко от тях.

Защо е важно

Първото, което един стар туториал ще ти предложи, е apt install golang, и това е грешка. Не е дребна грешка от типа „малко по-стара версия“: това е онзи вид грешка, заради която губиш цял следобед, без да разбираш защо, седмици след инсталирането, защото симптомът не се появява при инсталирането — появява се, когато вече програмираш и нещо, което „би трябвало да работи“, не работи.

Това не е мнение, а измерване. На 30 септ. 2026 г. измерих, в контейнер със същата основа като Linux Mint 22.3 (Ubuntu 24.04 „Noble Numbat“, откъдето Mint взема пакетите си):

$ cat /etc/os-release | grep VERSION
VERSION="24.04.5 LTS (Noble Numbat)"

$ apt-cache policy golang-go
golang-go:
  Installed: (none)
  Candidate: 2:1.22~2build1
  Version table:
     2:1.22~2build1 500
        500 http://ports.ubuntu.com/ubuntu-ports noble/main arm64 Packages

$ curl -s 'https://go.dev/VERSION?m=text'
go1.27.1

Системният пакет предлага 1.22. Официалната актуална версия, измерена в същия момент, е 1.27.1. И това не е небрежност, която някой ще поправи: това е политиката на Ubuntu и на Mint.

Защо се замразява така, нарочно? Ubuntu 24.04 е LTS версия (Long Term Support): в деня, в който излезе, основните ѝ пакети се замразяват и получават само поправки за сигурност, никога нови версии на програмата. Това е правилно решение за сървър, който не бива да променя поведението си само защото са инсталирани обновления — но означава, че компилаторът на език, който пуска нови версии два пъти годишно, остава фиксиран на онази, която е съществувала, когато Ubuntu 24.04 е публикувана (април 2024 г.), завинаги, докато тази версия на Ubuntu съществува. Linux Mint няма собствени пакети за Go: буквално наследява тези на Ubuntu, така че наследява и замразяването.

Защо това е важно конкретно за теб? Защото ще търсиш неща в интернет, примерите ще използват функции или поведения, които твоят Go 1.22 няма, а грешките няма да казват „липсва ти версия“: ще казват неща, които нямат смисъл спрямо онова, което виждаш на екрана. Това е видът проблем, който изглежда като твоя грешка, а всъщност е разминаване в инструмента — и ти се случва преди да си написал първия ред код, затова този урок стои преди всички останали.

🔑 Правилният начин, и той е този, който препоръчва самият проект Go: да изтеглиш официалния пакет директно от go.dev, а не от пакетния мениджър на твоята дистрибуция. Точно това инсталира този урок, стъпка по стъпка, и точно това ще проверяваме на всяка стъпка с реалния изход на командите.

Понятията

1.1 Какво са GOROOT и GOPATH и защо преди бяха по-важни от сега

Преди да инсталираш, си струва да знаеш какво ще имаш после, защото имената GOROOT и GOPATH се появяват в почти всяка грешка при инсталиране, която потърсиш в интернет, а много отговори са писани за версия на Go отпреди десет години.

  • GOROOT е папката, в която живее самият Go: компилаторът, gofmt, стандартната библиотека. Това е папката, която ще създадеш в стъпка 1.4 (/usr/local/go). Никога не я пипаш на ръка.
  • GOPATH е папката, в която Go пази твои неща: пакети, изтеглени от интернет, и — в стари версии на Go, преди 2019 г. — и мястото, където трябваше да слагаш целия си код, без изключение, в рамките на фиксирана структура ($GOPATH/src/github.com/tu-usuario/tu-proyecto). Ако някога видиш туториал, който те кара да създадеш тази структура от папки, той е от онази епоха.

Днес почти не я пипаш, защото от Go 1.11 (2018) съществуват модулите (go.mod, който ще създадеш в стъпка 1.6): проектът ти може да живее във всяка папка, с което име искаш, и Go вече няма нужда да следваш наложена структура от папки. GOPATH все още съществува, но сега само като кеш за изтеглени пакети, а не като единственото място, където може да живее кодът ти.

Провери го с go env, която ти показва актуалната конфигурация на инсталацията ти (това можеш да пуснеш след инсталирането, в стъпка 1.5):

go env GOROOT GOPATH GOBIN

При чиста, току-що направена инсталация ще видиш нещо такова:

/usr/local/go
/home/tu-usuario/go
/home/tu-usuario/go/bin

Нито една от тези три папки не си създал на ръка: първата я създава стъпката на инсталиране (1.4), другите две ги решава сам Go, със смислени стойности по подразбиране.

1.2 PATH: какво е и защо „вече е инсталирано“ не означава „вече работи“

Когато напишеш команда в терминала, например go, терминалът не знае по магия къде е тази програма: той преглежда, една по една, списък от папки, записан в променлива, наречена PATH, и използва първата програма с това име, която намери. Ако никоя папка от списъка няма програма, наречена go, отговаря с грешка — и тази грешка е буквална, а не приблизителна:

$ go version
bash: go: command not found

Проверих това в контейнер, в който Go беше вече разархивиран в /usr/local/go, преди да пипна PATH: програмата съществува на диска, но терминалът не я намира, защото не знае къде да търси. „Инсталирано“ и „в PATH“ са две различни неща и объркването между тях е източникът на почти всички спъвания в този урок.

Това обяснява и защо съобщението се променя малко според терминала (zsh вместо bash, което ще видиш, ако следваш курса на macOS, докато се упражняваш, или ако си сменил терминала по подразбиране на своя Mint):

$ go version
zsh: command not found: go

Същият проблем, същият механизъм, различен словоред: определи кой е твоят случай с echo $SHELL, преди да търсиш грешката в интернет, защото търсенето на грешното съобщение ще те отведе до отговори за грешния shell.

1.3 Разбери коя е последната версия

Не я копирай оттук: този документ остарява точно както хранилищата на Mint, а в предишния раздел вече видя колко може да натежи на един инструмент това да остане фиксиран във времето.

curl -s 'https://go.dev/VERSION?m=text' | head -1

Ще ти отговори нещо като go1.27.1. Това е версията, която ще инсталираш, каквато и да е тя, когато го направиш.

1.4 Изтегли я и я инсталирай

Замени go1.27.1 с това, което ти каза предишната команда. linux-amd64 е правилното за обикновен компютър или лаптоп (ако машината ти беше ARM, щеше да е linux-arm64; за да разбереш: dpkg --print-architecture).

cd /tmp
wget https://go.dev/dl/go1.27.1.linux-amd64.tar.gz

А сега инсталацията:

sudo rm -rf /usr/local/go                          # borra una instalación anterior, si había
sudo tar -C /usr/local -xzf go1.27.1.linux-amd64.tar.gz

Какво току-що направи, защото е добре да го разбереш, а не само да го копираш:

  • tar разархивира файла.
  • -C /usr/local му казва „направи го в тази папка“.
  • -xzf означава „извлечи“ (x), „компресиран е с gzip“ (z), „от този файл“ (f).
  • Резултатът е папка /usr/local/go с целия Go вътре — GOROOT от раздел 1.1.

Защо sudo, след като досега никога не ти е трябвало, за да инсталираш нещо с пакетен мениджър? Защото /usr/local е системна папка, а не папка на твоя потребител, и в Linux писането там изисква права на администратор. Без sudo ето какво точно ще видиш — предизвиках го нарочно, без sudo, за да видиш истинското съобщение, а не измислено:

$ tar -C /usr/local -xzf go1.27.1.linux-amd64.tar.gz
tar: go: Cannot mkdir: Permission denied
tar: go/VERSION: Cannot open: No such file or directory
tar: go/api: Cannot mkdir: No such file or directory
tar: go/api/README: Cannot open: No such file or directory
... (se repite, una vez por cada archivo del paquete)

Това не е една грешка, а стотици. tar се опитва да запише всеки файл от пакета, един по един, и всеки се проваля по същия начин, защото никой няма право да пише в /usr/local. Ако видиш тази стена от повтарящи се редове, причината е винаги една и съща и винаги се оправя по един и същ начин: сложи sudo отпред.

1.5 Кажи на системата си къде е — и капанът на съвременните терминали

Сега Go съществува в /usr/local/go/bin/go, но както видя в раздел 1.2, ако напишеш go, ще ти каже command not found: тази папка все още не е в PATH.

Инструкцията, която ще видиш в почти всеки туториал, включително в официалната документация на Go, е тази:

echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
source ~/.profile
  • ~/.profile е файл, който на теория системата ти чете всеки път, когато влезеш в сесия.
  • source ~/.profile прилага промяната в този терминал, точно сега, без да чакаш следващата сесия.

И тук идва онова, което повечето туториали не ти казват и което проверих с истинска проба: нов терминал не винаги е „нова сесия“.

~/.profile се чете само от онова, което Linux нарича login shell (обвивка при вход) — този, който се стартира, когато влезеш в системата (например когато включиш машината и влезеш с потребителското си име и парола). Но повечето терминални приложения (включително терминалът на Mint в настройките му по подразбиране) при отваряне на нов прозорец или раздел не стартират login shell: стартират обикновен интерактивен shell, а той чете друг файл, ~/.bashrc, не ~/.profile.

Проверих го така, симулирайки точно този сценарий — „вече редактирах файла, затварям терминала, отварям друг“ — в току-що инсталиран контейнер:

# después de agregar el export SOLO a ~/.profile, en una terminal nueva:
$ go version
bash: go: command not found          ← sigue sin funcionar

# después de agregar la MISMA línea también a ~/.bashrc, en una terminal nueva:
$ go version
go version go1.27.1 linux/arm64      ← ahora sí

Инструкцията „затвори терминала, отвори друг“ не винаги е достатъчна, а когато не е, изглежда, че си направил нещо погрешно, когато всъщност си следвал туториала буква по буква. Затова препоръката на този урок, по-надеждна от тази на повечето ръководства, е да добавиш реда и в двата файла:

echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.bashrc
source ~/.bashrc

~/.profile покрива случая на истинска сесия при вход (например ако използваш SSH или сменяш потребител); ~/.bashrc покрива много по-честия в ежедневието случай, когато отваряш нов прозорец или раздел на терминала в сесия, която вече е била отворена.

💡 Ако използваш zsh вместо bash (знаеш го, ако терминалът ти изглежда различно или ако са ти го сменили), файлът, еквивалентен на .bashrc, е ~/.zshrc. За да разбереш кой shell използваш: echo $SHELL.

🔑 Как да разбереш дали терминалът ти отваря login shell, без да гадаеш: изпълни echo $0 в току-що отворен терминал. Ако отговорът започва с тире (-bash, -zsh), това е login shell и той чете ~/.profile. Ако няма тире (bash, zsh), не е и ти трябва промяната в ~/.bashrc (или ~/.zshrc), за да се запази.

1.6 Провери, че е проработило

go version

Трябва да отговори нещо като go version go1.27.1 linux/amd64 (или linux/arm64, ако машината ти е ARM). Ако продължава да казва command not found, провери с echo $0 какъв вид shell е и в кой файл си сложил промяната, като следваш раздел 1.5.

1.7 Първата ти програма

mkdir -p ~/w/curso-go/hola && cd ~/w/curso-go/hola
go mod init hola

go mod init създава файл go.mod. Това е личната карта на проекта: казва как се казва и коя версия на Go използва. Това е механизмът на модулите, който вече споменахме в раздел 1.1, и е същият, с който ще стартираш проекта revisor (проверител) в урок 5.

Създай main.go с това съдържание:

package main

import "fmt"

func main() {
    fmt.Println("hola, ya tengo Go")
}

Ред по ред, защото всеки има своята причина:
package main „този файл принадлежи на пакета main“. Пакетът main е специален: той е единственият, който създава изпълнима програма. Без този ред щеше да имаш библиотека, а не програма
import "fmt" „ще използвам неща от пакета fmt“ (от format), който носи необходимото за отпечатване. Go не зарежда нищо по подразбиране: каквото използваш, го поискваш
func main() функцията, от която започва програмата ти. Когато я изпълниш, Go търси точно тази функция. Ако се казва другояче, програмата не се стартира
fmt.Println(...) отпечатва и минава на нов ред. Точката означава „функцията Println, която е вътре в fmt“

Пусни я:

$ go run main.go
hola, ya tengo Go

Този изход е истински: пуснах я, преди да напиша този ред.

1.8 Командите, които ще използваш винаги — и тънкостта на go.mod

go run main.go     # compila y ejecuta de una vez, sin dejar archivo. Para probar mientras trabajas
go build           # crea el programa ejecutable y lo deja ahí
go fmt ./...       # ordena tu código
go test ./...      # corre las pruebas (lección 5)

Една истинска тънкост, която си струва да пробваш сам, защото се промени между версиите на Go: с програма от един файл като горната go run main.go работи дори без go.mod. Проверих го в нова папка, без go mod init:

$ go run main.go
hola, ya tengo Go

Но go build в същата папка без go.mod изисква модула:

$ go build
go: go.mod file not found in current directory or any parent directory; see 'go help modules'

Защо е разликата? go run върху един файл може да реши всичко, без да има нужда да знае името на модула, защото няма нищо, което друг файл да импортира от него. Щом програмата ти има нужда от повече от един файл — например ако се опиташ да импортираш собствен пакет, както ще направиш в урок 5 с revisor — Go има нужда от go.mod, за да знае как се казва модулът ти и така да разреши тези импорти. Проверих и това:

$ go run main.go            # main.go importa "hola/utilidades", sin go.mod
main.go:4:5: package hola/utilidades is not in std (/usr/local/go/src/hola/utilidades)

Практическият урок: винаги изпълнявай go mod init, още от първия файл, макар че go run понякога работи и без него — спестяваш си точно тази грешка в момента, в който програмата ти трябва да импортира собствен пакет, а това ще стане още в урок 5.

Пробвай разликата между run и build:

$ go build
$ ls -la
-rwxr-xr-x 1 tu-usuario tu-usuario 2341973 ... hola
$ ./hola
hola, ya tengo Go

1.9 Защо двоичният файл е преносим: статично свързване

🔑 Файлът hola, който създаде go build, е пълна и самодостатъчна програма. И това не трябва да се приема на вяра: проверих го, като копирах точно този двоичен файл, компилиран на машина с инсталиран Go, в чист контейнер, без Go:

$ which go
go no esta instalado
$ ./hola
hola, ya tengo Go

Проработи. Не му трябва интерпретатор, нито виртуална машина, нито външни библиотеки, инсталирани отделно, защото Go прави статично свързване (static linking): вместо да казва „когато се изпълняваш, потърси библиотеката fmt някъде в системата“ (както работят много програми на C или Python), Go копира в самия двоичен файл всичко, от което програмата ти има нужда, за да работи. Затова файлът тежи повече — малко над 2 MB за програма от един ред — но в замяна можеш да го копираш на всяка съвместима Linux машина и той ще работи както си е, без да инсталираш нищо друго.

Това е най-практичната характеристика на Go и затова толкова много сървърни инструменти са написани на него — включително revisor, който ще компилираш и публикуваш в урок 7.

1.10 Редактор, който да ти помага

Не е задължително, но ще ти спести много време. Ако използваш VS Code, инсталирай официалното разширение Go (от golang.go). Измерено на 30 септ. 2026 г. в Marketplace на Visual Studio: публикуваната версия е 0.57.2. И това число ще остарее — важното е да инсталираш онази, която предлага Marketplace в деня, в който го правиш, а не да запишеш това число.

Разширението ще ти подчертава грешките, докато пишеш, вместо да разбереш за тях при компилиране, и ти позволява да скочиш до дефиницията на всяко нещо с F12. Първия път ще те помоли да инсталираш няколко допълнителни инструмента (gopls, езиковия сървър на Go, и други): кажи „да“ на всички.

Грешката, която ще видиш

Всички тези съобщения са истински, предизвикани нарочно за този урок — а не приблизителни описания на това, което „вероятно“ биха казали:

Симптомът Буквално съобщение Какво става и какво да направиш
Терминал bash без Go в PATH bash: go: command not found Програмата не е в никоя папка от PATH. Прегледай раздел 1.5
Терминал zsh без Go в PATH zsh: command not found: go Същият проблем, различен словоред, защото е друг shell
tar без sudo към /usr/local tar: go: Cannot mkdir: Permission denied (повтаря се за всеки файл) Липсва sudo преди командата за разархивиране (раздел 1.4)
Добавил си PATH само в ~/.profile и си отворил нов терминал bash: go: command not found (продължава) Терминалът ти не отваря login shell; добави реда и в ~/.bashrc (раздел 1.5)
go build в папка без go.mod go: go.mod file not found in current directory or any parent directory; see 'go help modules' Изпълни go mod init <nombre> в тази папка
Импорт на собствен пакет без go.mod main.go:4:5: package hola/utilidades is not in std (...) Същото като предишното: без модул Go не знае как да разреши собствените ти пакети
Забравил си import "fmt" и си използвал fmt.Println # command-line-arguments<br>./main.go:4:2: undefined: fmt Go познава всички налични символи; ако не си импортирал пакета, той не съществува за него
go version отговаря 1.22 вместо актуалната (без грешка, но грешна версия) Използва се този от apt. Премахни го със sudo apt remove golang-go и потвърди, че /usr/local/go/bin е в PATH

И общото правило, което важи и за осемте: копирай цялото съобщение за грешка и го потърси както си е, без да го преразказваш първо със свои думи. Почти винаги някой вече го е имал, а съобщението почти винаги казва точно какво липсва — да гадаеш, без да си го прочел изцяло, е най-бавният начин да го решиш.

Какво се прави погрешно

  • Инсталиране на Go с пакетния мениджър на системата (apt install golang). Това е най- честото предложение в старите туториали и е точно проблемът от раздела „Защо е важно“: замразена LTS версия те оставя години назад, без да те предупреди с каквато и да е грешка, а само със странни поведения по- късно.

  • Да приемеш за даденост, че „затвори и отвори терминала“ винаги презарежда конфигурацията. Това е капанът, измерен в раздел 1.5: ако терминалът ти не отваря login shell, затварянето и повторното му отваряне не прочита отново ~/.profile. Симптомът — „направих го както трябва, а не работи“ — не означава, че си сбъркал, а че този файл не е бил онзи, който терминалът ти чете.

  • Разархивиране на новата версия върху стара инсталация, без първо да я изтриеш. sudo rm -rf /usr/local/go от стъпка 1.4 не е за украса: ако разархивираш върху стара инсталация, остават смесени файлове от двете и резултатът е Go, който се проваля по неразбираеми начини. Първо изтрий, винаги.

  • Да разчиташ, че go run работи без go.mod, и затова да пропуснеш go mod init. Вярно е за самостоятелен файл (раздел 1.8), но престава да е вярно, щом програмата ти има повече от един файл — а дотогава вече ще си написал код, който ще трябва да реорганизираш. Изпълнявай go mod init от самото начало, винаги.

  • Да спориш за стила на кода на ръка. В Go за стила не се спори: решава го инструментът. Пробвай да напишеш това нарочно, цялото изкривено:

    package main
import "fmt"
func main(){
fmt.Println( "hola" )
}

    Изпълни go fmt ./... и отвори файла отново: подредил се е сам. Няма спорове за това къде отива скобата или колко интервала има отстъпът, защото gofmt има един-единствен отговор и всички го използват. Свикни да го пускаш, преди да запазиш, вместо да форматираш на ръка.

Упражнения

  1. Инсталирай Go, като следваш раздели от 1.3 до 1.6, и потвърди версията с go version.
  2. Изпълни echo $0 в терминала си преди да пипнеш PATH. Според отговора реши дали трябва да промениш ~/.profile, ~/.bashrc или и двата (раздел 1.5) — и обясни защо, със свои думи, преди да продължиш.
  3. Създай проекта hola от раздел 1.7, изпълни go run main.go, а след това go build + ./hola.
  4. (Както в раздел 1.9) Копирай двоичния си файл hola на друга Linux машина или на виртуална машина / контейнер без инсталиран Go и потвърди, че работи по същия начин.
  5. Смени съобщението на fmt.Println с нещо свое, разбъркай нарочно отстъпа и изпълни go fmt ./.... Провери, че файлът е форматиран правилно.
  6. (Малко по-трудно) Създай нова папка, без go mod init, с main.go от един-единствен файл. Потвърди, че go run main.go все пак работи. След това изпълни go build в същата папка и сравни грешката с тази от раздел 1.8. Обясни със свои думи защо едното работи, а другото — не.
  7. (Малко по-трудно) Изтрий нарочно реда import "fmt" и изпълни go run main.go. Прочети цялата грешка, без още да я търсиш, и се опитай да обясниш със свои думи какво ти казва, преди да продължиш.

Решения

  1. go version трябва да отпечата същата версия, която видя в curl -s 'https://go.dev/VERSION?m=text', никога go1.22.x (това е версията от apt на Mint).

  2. Ако echo $0 отговори с тире в началото (-bash), терминалът ти отваря login shell-ове и ~/.profile е достатъчен. Ако отговори без тире (bash), това не е login shell и само ~/.bashrc (или ~/.zshrc в zsh) ще се запазва между новите прозорци — добави промяната и там, както в раздел 1.5.

  3. go run main.go отпечатва hola, ya tengo Go. След go build в папката се появява файл hola; ./hola го изпълнява директно, без да компилира отново.

  4. Двоичният файл работи по същия начин на машината без Go, защото Go прави статично свързване (раздел 1.9): всичко, от което програмата има нужда, вече е копирано в самия файл.

  5. Преди go fmt файлът изглежда точно както е написан (изкривен). След това gofmt го пренарежда със стандартния отстъп и интервали на Go — без ти да решаваш каквото и да е от това.

  6. go run main.go работи, защото с един-единствен файл Go няма нужда да разрешава собствени импорти, за да го компилира и изпълни наведнъж. go build, от друга страна, изисква да знае името на модула от първия момент и отговаря go: go.mod file not found.... Разликата е, че build оставя двоичния файл готов за използване извън това конкретно извикване, а за това му трябва идентичност на проект — на run не му трябва.

  7. Компилаторът отговаря:

    # command-line-arguments
./main.go:4:5: undefined: fmt

    Казва, че си използвал fmt.Println, без да си импортирал пакета fmt: компилаторът познава всички символи, които можеш да използваш, и ако не си го импортирал, той не съществува за него. Оправя се, като върнеш реда import "fmt".

Как разбирам, че съм успял

  • go version отговаря с версията, която видях в go.dev/VERSION, а не с 1.22.
  • Знам дали терминалът ми отваря login shell-ове или не (echo $0) и в кой файл (или файлове) сложих промяната на PATH съответно.
  • go run main.go отпечатва моето съобщение.
  • go build създаде файл и ./hola работи.
  • Копирах двоичния си файл на друга машина (или контейнер) без Go и той работи по същия начин.
  • Пробвах go fmt върху зле написан код и той го подреди.
  • Предизвиках грешката на go build без go.mod и мога да обясня защо go run не я получи.
  • Предизвиках грешката с липсващ import и разбрах съобщението, без да ми трябва решението.
  • Мога да обясня, без да гледам текста, каква е разликата между GOROOT, GOPATH и PATH.

Резюме

  • Никога не инсталирай Go с пакетния мениджър на системата (apt install golang): LTS версиите на Linux се замразяват и пакетът остава години назад, без да предупреди с каквато и да е грешка.
  • GOROOT е мястото, където живее Go; GOPATH е мястото, където Go пази изтеглени пакети; нито едното не пипаш на ръка в съвременен проект с модули (go.mod).
  • PATH е списъкът от папки, в които терминалът търси програми. Да имаш инсталиран Go и да имаш Go в PATH са две различни неща.
  • Нов терминал не винаги е login сесия: повечето четат само ~/.bashrc (или ~/.zshrc), а не ~/.profile. Добави промяната на PATH и в двата файла.
  • go mod init създава идентичността на проекта (go.mod); всеки проект на Go има нужда от нея, макар че go run понякога работи без нея с един-единствен файл.
  • go run компилира и изпълнява, без да оставя файл; go build оставя двоичния файл; go fmt форматира автоматично, без възможност за спор относно стила.
  • Двоичният файл, който създава go build, е самодостатъчен благодарение на статичното свързване: работи на друга съвместима Linux машина без инсталиран Go.
  • Всяко съобщение за грешка в този урок е буквално, предизвикано нарочно: command not found, Permission denied, go.mod file not found, undefined: fmt — копирай ги както са, когато ги търсиш.

За допълнително четене

  1. Download and install — официалното ръководство за инсталиране, източникът на истината, ако нещо в този урок остарее. Съдържа същата препоръка за ~/.profile, която използваме тук, със същото предупреждение, че промяната „може да не се приложи до следващото влизане в сесия“ — което е точно онова, което беше измерено и обяснено подробно в раздел 1.5.
  2. A Tour of Go — официалната интерактивна обиколка; започва точно там, където свършва този урок.
  3. Effective Go — съдържа раздела за gofmt и защо за форматирането не се спори в Go.
  4. GNU Bash — Manual: Bash Startup Files — официалният справочник за това кога се чете ~/.profile и кога ~/.bashrc; струва си да го прочетеш целия веднъж в живота, защото объркването между двата не е присъщо само на Go.

Термини от този урок

Термин Какво означава
GOROOT папката, в която живее инсталацията на Go: компилаторът, gofmt, стандартната библиотека
GOPATH папката, в която Go пази изтеглени пакети; преди модулите там трябваше да живее и целият ти код
PATH списъкът от папки, в които терминалът търси изпълними програми
login shell терминалната сесия, която се стартира при влизане в системата; тя е единствената, която чете ~/.profile
go.mod файлът, който идентифицира проект на Go: неговото име и версията на Go, която използва
двоичен файл (binary) изпълнимият файл, който създава go build, самодостатъчен, без да зависи от това дали има инсталиран Go
статично свързване техниката, при която Go копира в двоичния файл всичко, от което програмата има нужда, вместо да го търси в системата при изпълнение
gofmt инструментът, който форматира автоматично кода на Go, без опции за спорове
Да обсъдим вашия проект

Предпочитате имейл? Пишете ни на hola@habil.mx