Базовые типы данных. bool, string, int, float

Краткое описание

В этом уроке знакомимся с четырьмя основными типами данных, которых достаточно для начала разработки на Go: логический тип bool, строки string, целые числа int и числа с плавающей точкой float64. Разбираем особенности работы со строками в Go и их отличия от других языков программирования.

Ключевые концепции

Логический тип (bool)

bool — самый простой тип данных в Go. Переменная булевого типа может принимать только два значения:

true (истина)
false (ложь)

Используется для условий, флагов состояния, результатов сравнений:

var isActive bool = true
var hasError bool = false

Строковый тип (string)

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

Ключевые отличия от C#/Java/Python:

В C# и Java:

Строка = последовательность символов (char)
Один символ = один тип char = фиксированный размер

В Go:

Строка = последовательность байтов (UTF-8 encoding)
Один символ может занимать от 1 до 4 байтов
Символ представлен типом rune (альяс для int32)

Неизменяемость (immutability): После создания строку нельзя изменить. Любая операция “изменения” создаёт новую строку:

s := "Hello"
// s[0] = 'h' // ОШИБКА! Нельзя изменить символ
s = "hello"   // OK - создаётся новая строка

Числовые типы для практики

Хотя в Go есть множество числовых типов (8 типов целых чисел + float32/float64), для повседневной работы достаточно двух:

int — для целых чисел:

var count int = 42
var index int = -10

float64 — для чисел с плавающей точкой:

var price float64 = 99.99
var temperature float64 = -15.5

Особенности строк в Go

Функция len() работает иначе

В Python len() возвращает количество символов:

# Python
s = "Привет"
print(len(s))  # 6 символов

В Go len() возвращает количество байтов, а не символов:

s := "Привет"
fmt.Println(len(s))  // 12 байтов (не 6!)

Почему 12? Кириллические символы в UTF-8 занимают по 2 байта каждый: 6 символов × 2 байта = 12 байт.

Получение количества символов (rune)

Для подсчёта именно символов нужно конвертировать строку в срез рун:

s := "Привет"
runes := []rune(s)
fmt.Println(len(runes))  // 6 символов

ASCII vs Unicode

Латинские символы (ASCII) занимают 1 байт:

s1 := "Hello"
fmt.Println(len(s1))  // 5 байт = 5 символов

Кириллица, китайские иероглифы, эмодзи занимают 2-4 байта:

s2 := "你好"  // китайские символы
fmt.Println(len(s2))  // 6 байт (2 символа по 3 байта)

s3 := "🚀"  // эмодзи
fmt.Println(len(s3))  // 4 байта (1 символ)

Четыре типа для старта

Для начала работы с Go достаточно освоить четыре базовых типа:

Тип	Назначение	Примеры значений
`bool`	Логические значения	`true`, `false`
`string`	Текстовые данные	`"Hello"`, `"Привет"`, `""`
`int`	Целые числа	`42`, `-10`, `0`
`float64`	Дробные числа	`3.14`, `-0.5`, `99.99`

Примеры объявления

// Логический тип
var isValid bool = true
var completed bool = false

// Строки
var name string = "Иван"
var message string = "Hello, World!"

// Целые числа
var age int = 25
var temperature int = -15

// Числа с плавающей точкой
var price float64 = 1299.99
var pi float64 = 3.14159

Важные моменты

1. Строки в Go — UTF-8 по умолчанию Это современный стандарт, поддерживающий все языки мира. Никаких проблем с кодировками, как в старых языках.

2. Неизменяемость строк — это feature Неизменяемость делает строки потокобезопасными и позволяет компилятору оптимизировать работу с памятью. Для модификации строк используйте strings.Builder или срезы байт.

3. len() — это длина в байтах Запомните раз и навсегда: len(string) возвращает байты, не символы. Для символов конвертируйте в []rune.

4. Значения по умолчанию Неинициализированные переменные получают нулевые значения:

bool: false
string: "" (пустая строка)
int: 0
float64: 0.0

5. Не нужно выбирать из 8 типов целых чисел Для учебных и большинства реальных задач используйте просто int. Конкретные типы (int8, uint32 и т.д.) нужны для специфичных сценариев: работа с протоколами, оптимизация памяти, binary data.

6. Строковые литералы

Двойные кавычки — интерпретируемые строки:

s := "Hello\nWorld"  // \n = перевод строки

Обратные кавычки — сырые строки (raw string):

s := `Hello\nWorld`  // \n как есть, без интерпретации

Практика

Работа с четырьмя базовыми типами

package main

import "fmt"

func main() {
    // Bool
    var isStudent bool = true
    fmt.Println("Студент:", isStudent)
    
    // String
    var greeting string = "Привет, мир!"
    fmt.Println(greeting)
    fmt.Println("Байтов:", len(greeting))
    fmt.Println("Символов:", len([]rune(greeting)))
    
    // Int
    var count int = 100
    fmt.Println("Количество:", count)
    
    // Float64
    var price float64 = 1499.99
    fmt.Println("Цена:", price)
}

Сравнение с другими языками

C#:

string s = "Hello";
char c = s[0]; // 'H'

Java:

String s = "Hello";
char c = s.charAt(0); // 'H'

Go:

s := "Hello"
b := s[0]    // 72 (byte, не char!)
r := []rune(s)[0]  // 'H' (rune)

Что запомнить

Четыре основных типа: bool, string, int, float64
bool принимает только true или false
string — неизменяемая последовательность байтов (UTF-8)
Один символ может занимать 1-4 байта
len(string) возвращает байты, не символы
Для подсчёта символов: len([]rune(string))
int — для целых чисел (размер зависит от архитектуры)
float64 — для дробных чисел
Не нужно запоминать все 8+ числовых типов — используйте int и float64
Нулевые значения: false, "", 0, 0.0