Розбираємо базові типи bool, string, int і float64

1. Пригадуємо все, що вже знаємо

Коли ви пишете програму, ви постійно укладаєте угоди. Ви обіцяєте компілятору: «ось ця змінна зберігатиме ціле число», а компілятор натомість обіцяє вам: «тоді я перевірятиму операції, щоб ви випадково не додали огірок до температури». Тип у Go — це договір: які значення допустимі й які операції дозволені.

У Go, як і в більшості мов із суворою типізацією, тип змінної фіксується в момент оголошення і не «перевзувається» під час виконання програми. Тому корисно заздалегідь визначати: «цей вираз — int чи float64?», «порівняння дасть bool?», «рядки можна множити?» (спойлер: не можна).

2. int: цілі числа й звичайна арифметика

int — базовий робочий тип для цілих чисел: кількість задач, вік, число спроб, позиція в циклі, лічильники, суми без дробів. Він зручний тим, що підтримує зрозумілі арифметичні операції та порівняння. Але в нього є характер: ділення в int — цілочисельне, і дробову частину воно відкидає без жалю.

Основні операції int

Для int доступні +, -, *, /, % (остача від ділення), а також порівняння == != < <= > >=.

package main

import "fmt"

func main() {
	a := 10
	b := 3

	fmt.Println(a / b) // 3
	fmt.Println(a % b) // 1
}

Тут важлива саме поведінка /: 10 / 3 дає 3, а не 3,333.... Дробова частина «зникає», і це не помилка, а правило.

Пріоритет операторів

Зазвичай *, /, % виконуються раніше, ніж + і -. Якщо хочете спочатку додати, а потім помножити, ставте дужки — це не ознака слабкості, а ознака читабельного коду.

package main

import "fmt"

func main() {
	x := 2 + 3*4
	y := (2 + 3) * 4

	fmt.Println(x) // 14
	fmt.Println(y) // 20
}

3. float64: числа з дробовою частиною

float64 — базовий тип для дійсних чисел із дробовою частиною. Відсотки, середні значення, вимірювання, «скільки годин залишилося», «скільки кілометрів», «температура» — усе це зазвичай зручно зберігати у float64. У Go десяткові літерали (наприклад, 19.99) за замовчуванням мають тип float64, і це корисно запам’ятати, бо саме так працює виведення типу через :=.

Важливо розуміти, що float64 — це не «просто число», а число з особливостями зберігання та округлення. Але поки що обмежимося операціями й порівнянням.

Арифметика float64

У float64 є +, -, *, / і порівняння. А от % для float64 немає — остача від ділення в Go визначена лише для цілих типів.

package main

import "fmt"

func main() {
	price := 19.99
	qty := 2.0

	total := price * qty
	fmt.Println(total) // 39.98 (іноді може виглядати як 39.979999..., це звична особливість float64)
}

Порівняння для цього типу теж працюють:

package main

import "fmt"

func main() {
	x := 0.5
	fmt.Println(x >= 0.0) // true
}

4. string: текст, склейка й порівняння

string у Go — це текст. Із ним часто пов’язані імена, команди, повідомлення користувачеві, «назва задачі», «статус», «логін». З погляду новачка корисно запам’ятати дві речі: рядки можна склеювати через +, а порівнювати — через == і !=. І все: спроби «поділити рядок на рядок» краще залишити фантастиці.

Конкатенація + та друк

package main

import "fmt"

func main() {
	first := "Go"
	second := "lang"

	full := first + second
	fmt.Println(full) // Golang
}

Якщо вам потрібен пробіл, це теж окремий рядок:

package main

import "fmt"

func main() {
	a := "Hello"
	b := "world"
	fmt.Println(a + " " + b) // Hello world
}

Порівняння рядків

package main

import "fmt"

func main() {
	cmd := "add"

	fmt.Println(cmd == "add")    // true
	fmt.Println(cmd != "delete") // true
}

Порівняння рядків повертає bool, а отже підходить для умов if.

5. bool: істина/хиба, порівняння й умови

Тип bool зберігає одне з двох значень: true або false. Він потрібен для керування розгалуженнями й логікою: саме bool вирішує, яка гілка if виконається, коли цикл зупиниться і чи можна вважати операцію успішною.

Найчастіше bool з’являється як результат порівняння. Порівняли два числа — отримали bool. Порівняли два рядки — отримали bool. Потім цей bool можна поєднувати логічними операціями &&, ||, !.

bool із порівняння

package main

import "fmt"

func main() {
	age := 20
	isAdult := age >= 18

	fmt.Println(isAdult) // true
}

Логіка «і», «або» та «не» в реальній умові

package main

import "fmt"

func main() {
	age := 20
	hasTicket := true

	canEnter := age >= 18 && hasTicket
	fmt.Println(canEnter) // true
}

Порівняння: універсальний спосіб отримати bool

Результат будь-якого порівняння в Go має тип bool. Це не «0 або 1», не «порожньо/не порожньо», а саме true/false.

Приклади:

package main

import "fmt"

func main() {
	// int
	a := 10
	b := 20
	fmt.Println(a < b)  // true
	fmt.Println(a == b) // false

	// float64
	x := 1.5
	y := 1.0
	fmt.Println(x > y) // true

	// string
	user := "admin"
	fmt.Println(user == "admin") // true
}

6. Чому не можна int + float64

На цьому етапі часто виникає думка: «ну число ж і число, чого тобі, Go, шкода?». Але сувора типізація — це ремінь безпеки: спершу заважає, а потім рятує від дивних багів.

Go не дозволяє автоматично змішувати різні числові типи у виразах. Не можна просто так додати int і float64. Це свідоме правило мови: операції, що змішують числові типи, заборонені без явного перетворення.

Подивімося на типовий приклад:

package main

import "fmt"

func main() {
	count := 3     // int
	price := 19.99 // float64 (за замовчуванням для десяткового літерала)

	fmt.Println(count) // 3
	fmt.Println(price) // 19.99

	total := count * price // НЕ скомпілюється: різні типи (int і float64)
	fmt.Println(total)
}

Чому це важливо? Тому що ви маєте навчитися помічати проблему заздалегідь. Якщо у вас є «кількість» і «ціна», або все тримайте у float64, або все — в int (наприклад, ціну в копійках). А перетворення — це окремий, усвідомлений крок, а не автоматична робота «за лаштунками».

7. Памʼятка: базові типи й операції

Щоб не тримати все в голові, наче в тумані, зручно мати невелику таблицю-памʼятку. Це не заміна розумінню, а карта місцевості, щоб швидше орієнтуватися.

int

0, -5, 42

+ - * / %

== != < <= > >=

float64

0.0, 3.14, -1.5

+ - * /

== != < <= > >=

string

"Go", "", "hi"

bool

true, false

&& || !

== !=

8. Приклад: облік прогресу за задачею

Зберемо маленький приклад, який використовує всі чотири типи так, як це зазвичай буває в реальному коді: рядок — назва задачі, ціле число — план, float64 — «скільки годин витратив», bool — «задача виконана?». Це буде проста консольна програма, без масивів і функцій, зате максимально зрозуміла.

Зчитуємо дані й порівнюємо

package main

import (
	"fmt"
)

func main() {
	var title string
	var planned int
	var spent float64
	var done bool

	fmt.Scan(&title, &planned, &spent, &done)

	isBig := planned >= 5
	fmt.Println(title, isBig, done)
}

Як це використати: введіть, наприклад, так, через пробіли: report 7 2.5 false

Програма виведе щось на кшталт: report true false

Тут ви одразу бачите кілька речей: title — рядок, planned — ціле число, spent — дробове, done — булеве, а planned >= 5 — порівняння, яке дає bool.

Додамо просту логіку «показати статус»

package main

import "fmt"

func main() {
	var title string
	var planned int
	var done bool

	fmt.Scan(&title, &planned, &done)

	if done == true {
		fmt.Println(title + ": ГОТОВО")
	} else {
		fmt.Println(title + ": У ПРОЦЕСІ")
	}
}

Тут ми навмисно робимо все «в лоб», щоб було видно, що порівняння дає bool і як string склеюється через +. Так, ми могли б написати if done { ... }, але інколи новачкові корисно кілька разів побачити явне порівняння, щоб мозок перестав шукати «магічні нулі й одиниці».

9. Типові помилки

Помилка № 1: очікувати, що цілочисельне ділення дасть дріб.
Дуже часта ситуація: людина пише 7 / 2, сподівається на 3,5, а отримує 3. Це не «зламалося», а нормальне правило int: ділення відкидає дробову частину. Якщо вам справді потрібен дріб, значить, ви обрали не той тип даних. Але важливо не намагатися «полагодити» це випадковими милицями — спочатку навчіться помічати, що вираз цілочисельний.

Помилка № 2: намагатися використати число або рядок як умову if.
У деяких мовах працює правило: «0 — це false, а все інше — true». У Go так не можна: умова в if зобов’язана бути типу bool. Тому замість if x { ... } треба писати порівняння, наприклад if x > 0 { ... }, щоб отримати булевий результат.

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

Помилка № 4: думати, що string підтримує математичні операції.
Рядки можна склеювати через +, але не можна ділити, множити чи брати остачу. Якщо вам потрібно «повторити рядок 10 разів» або «розібрати число з рядка», це окремі задачі й окремі інструменти, а не арифметика.

Помилка № 5: плутати, звідки береться bool.
Новачки інколи думають, що bool — це «якийсь особливий режим». На практиці bool найчастіше з’являється як результат порівняння (a > b) або логічного виразу (x > 0 && ok). Якщо ви тримаєте це в голові, умови перестають виглядати як магія й починають читатися як звичайні фрази.