Імпорти — групування, аліаси та _‑ import

1. Навіщо потрібен import і чому Go забороняє зайве

Коли ви пишете програму, то майже завжди використовуєте чужий код: для виведення, парсингу чисел, роботи з рядками, випадкових чисел, часу тощо. У Go це робиться через import: ви явно повідомляєте компілятору, які пакети потрібні цьому файлу. Це важливо: імпорт — не «на весь проєкт», а саме для файла, і Go ставиться до цього суворо.

Суворість проявляється в тому, що невикористані імпорти заборонені. Не «не рекомендуються», не «можна потерпіти», а прямо «ні». Це один зі способів, яким Go спонукає нас тримати залежності чистими. Якщо пакет не використовується, значить, або він вам не потрібен, або ви забули написати код, який його використовує. І краще дізнатися про це одразу, ніж через місяць.

Ось мініприклад: класичний «hello world» з імпортом fmt.

package main

import "fmt"

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

А тепер типова помилка новачка: «імпортую на майбутнє».

package main

import (
	"fmt"
	"math" // <- не використовуємо
)

func main() {
	fmt.Println("Hi")
}

Такий код не збереться: компілятор скаже приблизно так: "imported and not used: math". Це нормально. Так Go дбає про ваше майбутнє «я», якому доведеться читати код і розуміти, що насправді потрібно програмі.

2. Форми та порядок імпортів

Окремий і груповий import

Імпорти в Go бувають у двох основних формах: окремій і груповій. Обидві рівноправні — питання не в тому, що «правильно» чи «неправильно», а в читабельності. Коли пакет один, окрема форма виглядає максимально просто. Коли пакетів два або більше, майже завжди зручніше групувати.

Окремий імпорт:

package main

import "fmt"

func main() {
	fmt.Println("one import") // one import
}

Груповий імпорт:

package main

import (
	"fmt"
	"strconv"
)

func main() {
	fmt.Println(strconv.Itoa(2026)) // 2026
}

На практиці груповий імпорт — це майже стандартний стиль, щойно залежностей стає більше ніж одна. Його легше розширювати: ви просто додаєте рядки всередині дужок і не думаєте про форматування.

Усвідомлені залежності та читабельність

Коли ви починаєте писати більші програми, імпорти стають вашою мінікартою: по них видно, чим займається файл. Якщо ви бачите fmt, strconv, strings — це схоже на обробку тексту та виведення. Якщо бачите net/http — десь поруч буде сервер. Якщо бачите time — ідеться про час або таймаути.

Тому до імпортів корисно ставитися як до «вітрини» файлу. Якщо вітрина захаращена, то й усередині, найімовірніше, безлад.

Є кілька дуже практичних принципів, яких легко дотримуватися навіть новачкові, без релігійних суперечок про стиль.

• Краще тримати імпорти в алфавітному порядку, принаймні всередині стандартної бібліотеки.
• Не варто імпортувати пакет «про всяк випадок» — Go все одно не дозволить.
• Якщо ви видалили код, який використовував пакет, а компілятор почав сваритися, це підказка: видаліть і залежність.

Невелика логічна схема:

Додав рядок import -> узяв залежність
Узяв залежність -> ускладнив файл
Ускладнив файл -> читати стало важче
Отже -> імпорт має бути усвідомленим

У цей момент Go нагадує суворого викладача: «зайве викресліть, будь ласка».

3. Міні‑таскер: тренуємо акуратні імпорти

Щоб приклади не були відірваними від життя, давайте й далі працювати з одним навчальним застосунком. Нехай це буде невелика консольна утиліта «міні‑таскер»: вона читає заголовок задачі та друкує нормалізований заголовок і «псевдо‑ID».

На нашому поточному рівні, без слайсів і структур, це буде проста програма. Але вона вже корисна як тренажер для акуратного коду та імпортів.

Версія 1: читаємо рядок і друкуємо як є

Тут нам потрібен лише fmt.

package main

import "fmt"

func main() {
	var title string
	fmt.Scan(&title)

	fmt.Println("task:", title) // наприклад: task: BuyMilk
}

Але швидко зʼясується, що введення через Scan «ріже» рядок за пробілами. Користувач хотів "Buy milk", а отримав "Buy". Поки залишимо це так: про просунуте введення поговоримо пізніше. А зараз додамо просту нормалізацію — обріжемо пробіли по краях і зробимо «гарну мітку».

Версія 2: додаємо strings і груповий імпорт

package main

import (
	"fmt"
	"strings"
)

func main() {
	var title string
	fmt.Scan(&title)

	title = strings.TrimSpace(title)
	fmt.Println("task:", title) // task: BuyMilk
}

У нас два пакети, тож груповий імпорт одразу виглядає природно.

Версія 3: збираємо все разом

Тепер зберемо «міні‑таскер» у трохи приємнішу форму: нормалізуємо введення, зробимо «ID» як число, хай навіть просте, і виведемо результат.

Тут зʼявляться strings і strconv. Два пакети — отже, групуємо.

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func main() {
	var raw string
	fmt.Scan(&raw)

	title := strings.TrimSpace(raw)
	id := strconv.Itoa(len(title))

	fmt.Println("id:", id, "task:", title) // id: 7 task: BuyMilk
}

Так, «ID за довжиною рядка» — це не справжня система ідентифікаторів. Але для нашого поточного рівня це чудовий спосіб потренуватися: імпорти чисті, усі використовуються, логіка проста, програма не розвалюється.

4. Аліаси імпортів: коли вони справді потрібні

Іноді назва пакета незручна в конкретному файлі. Або ви імпортували два пакети з однаковими «останніми словами» і хочете в коді явно їх розрізняти. Або вам потрібно уникнути конфлікту імен. Для цього існує аліас імпорту: ви можете перейменувати пакет в межах одного файла.

Синтаксис такий:

import f "fmt"

І тоді замість fmt.Println ви пишете f.Println. Це працює, але важливо розуміти: аліас — не прикраса. Якщо ви почнете масово скорочувати все підряд, код стане схожим на криптографію, а ми поки що не вивчаємо криптографію — максимум у навчальному варіанті.

Аліас заради читабельності: обережно

package main

import (
	"fmt"
	s "strings"
)

func main() {
	var title string
	fmt.Scan(&title)

	title = s.TrimSpace(title)
	fmt.Println("task:", title) // task: BuyMilk
}

Так можна, але постає запитання: чи стало зрозуміліше? Для новачка зазвичай навпаки: strings.TrimSpace читається простіше, ніж s.TrimSpace. Аліаси варто застосовувати лише тоді, коли є реальна причина.

Конфлікт імен: crypto/rand vs math/rand

Це дуже життєва ситуація: два пакети хочуть називатися однаково в коді. Класичний приклад — crypto/rand і math/rand. Обидва — «rand», але сенс у них різний: один для криптографії, інший для звичайної псевдовипадковості. Навіть якщо ви поки не використовуєте обидва, важливо вміти читати такий код.

package main

import (
	crand "crypto/rand"
	fmt "fmt"
	mrand "math/rand"
)

func main() {
	_ = crand.Reader // просто щоб показати: пакет існує
	fmt.Println(mrand.Intn(10)) // 0..9 (приклад)
}

Тут аліаси роблять код чесним: crand і mrand — це різні речі, і це видно одразу.

Аліас проти shadowing

Є кумедна, але дуже дратівлива помилка: ви імпортували пакет, а потім випадково назвали змінну так само, як і пакет. Це називається shadowing, тобто затінення: імʼя з внутрішньої області видимості перекриває зовнішнє.

Наприклад:

package main

import "fmt"

func main() {
	fmt.Println("before") // before

	fmt := "oops"
	_ = fmt

	// fmt.Println("after") // не скомпілюється
}

Усередині main імʼя fmt стало рядковою змінною, і звернутися до пакета fmt уже не можна.

Як із цим жити? По-перше, не називайте змінні іменами пакетів. По-друге, якщо конфлікт усе ж неминучий, хоч і трапляється рідко, аліас імпорту може врятувати.

package main

import f "fmt"

func main() {
	fmt := "still ok"
	_ = fmt

	f.Println("пакет і далі доступний") // пакет і далі доступний
}

Це приклад, де аліас — не «краса», а справді «рятувальний круг».

5. _‑імпорт: підключаємо пакет заради ініціалізації

Є спеціальна форма імпорту, яка виглядає дивно, але трапляється в реальних проєктах:

import _ "some/package"

Такий імпорт називається blank import. Сенс у тому, що ви імпортуєте пакет, але не вводите його імʼя в код. Тобто ви не зможете писати pkg.Something, бо pkg у вас немає. Тоді навіщо він потрібен?

Людською мовою: «мені не потрібні функції чи типи цього пакета напряму, але мені потрібно, щоб пакет був підключений і виконав свою ініціалізацію».

У Go в пакета може бути код ініціалізації, який виконується автоматично під час старту програми. Зазвичай це повʼязано з реєстрацією певних можливостей. Найпоширеніший приклад із реального життя — драйвери баз даних: ви не викликаєте їх напряму, але вони «реєструються» всередині database/sql. Ще один поширений приклад — реєстрація форматів декодування: наприклад, підключили пакет формату, і загальний декодер навчився його розуміти.

На нашому рівні важливо зафіксувати дві речі.

Перша: _‑імпорт не вважається невикористаним. Тобто компілятор не свариться, бо ви явно сказали: «мені потрібен сам факт імпорту».

Друга: _‑імпорт майже завжди означає побічний ефект, а побічні ефекти погіршують передбачуваність. Тому новачку краще ставитися до _‑імпорту як до гострого ножа: він корисний, але махати ним у натовпі не варто.

«Порожній» приклад суто про синтаксис

Цей приклад не робить нічого корисного, але показує механіку: зі звичайним імпортом math компілятор сваритиметься, а з _ — ні.

package main

import (
	"fmt"
	_ "math"
)

func main() {
	fmt.Println("started") // started
}

Так, беззмістовно. Але це як навчальний манекен: на ньому тренуються, щоб потім не тренуватися на продакшені.

6. Типові помилки під час роботи з імпортами

Помилка №1: «Імпортую заздалегідь, щоб потім не забути».
У Go це не працює: компілятор не дозволить тримати невикористані пакети. І це навіть добре: ви не носите в рюкзаку цеглину «про всяк випадок». Якщо пакет не потрібен, його немає. Якщо потрібен, ви додаєте його й одразу використовуєте, інакше збірка зупиниться та чесно покаже проблему.

Помилка №2: аліаси заради «стилю», а не заради сенсу.
Новачки інколи перетворюють код на ребус: f.Println, s.TrimSpace, st.Atoi, e.New… Формально програма працює, але читати її складно. Аліас добрий тоді, коли він розвʼязує конкретну проблему: конфлікт імен, суттєве покращення ясності, рідкісне затінення імені пакета. В усіх інших випадках краще залишити стандартну назву пакета.

Помилка №3: плутанина між _ в імпорті та _ у коді.
Символ _ трапляється часто, але сенс у нього різний. В імпорті _ "pkg" означає «імпортувати заради побічного ефекту ініціалізації». У присвоюванні x, _ := ... означає «результат є, але він мені не потрібен». Якщо змішати ці ідеї в голові, можна почати думати, що _ — це просто «викинути щось непотрібне». У випадку blank import ви нічого не викидаєте — ви підключаєте мовчки.

Помилка №4: очікування, що імпорт «працює на весь пакет», а не на файл.
Навіть якщо у вас кілька файлів в одному пакеті, імпорти пишуться в кожному файлі окремо. Це інколи дивує: «але ж я вже імпортував fmt в іншому файлі!» — так, але той інший файл не ділиться імпортами з поточним. Так і влаштовано: залежності оголошує кожен файл, щоб його можна було читати й розуміти окремо.