Псевдонимы типов: byte, rune и создание собственных alias

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

Изучаем встроенные псевдонимы типов (byte и rune), их отличие от базовых типов, создание собственных псевдонимов и критическую разницу между псевдонимом (type Name = Type) и новым типом (type Name Type). Понимаем, когда типы взаимозаменяемы, а когда требуется явное приведение.

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

1. Встроенные псевдонимы в Go

byte — псевдоним для uint8

byte — это не отдельный тип, а альтернативное имя для uint8.

var value1 byte = 123
var value2 uint8 = 123

fmt.Printf("value1 = %d, тип: %T\n", value1, value1)  // value1 = 123, тип: uint8
fmt.Printf("value2 = %d, тип: %T\n", value2, value2)  // value2 = 123, тип: uint8

Обратите внимание: %T показывает uint8, а не byte!

Взаимозаменяемость:

var value1 byte = 123
var value2 uint8 = 123

value1 = value2  // ✅ Работает! Это один и тот же тип
value2 = value1  // ✅ Работает!

Вывод: byte и uint8 — полностью идентичны для компилятора.

rune — псевдоним для int32

rune — это альтернативное имя для int32, используется для представления Unicode-символов.

var value3 rune = 234

fmt.Printf("value3 = %d, тип: %T\n", value3, value3)  // value3 = 234, тип: int32

Проверка самостоятельно (задание из урока):

Поставьте код на паузу и проверьте, что rune — это псевдоним для int32.

var r rune = 'A'
var i int32 = 65

r = i  // ✅ Работает!
i = r  // ✅ Работает!

fmt.Printf("r = %d (%c), тип: %T\n", r, r, r)  // r = 65 (A), тип: int32
fmt.Printf("i = %d, тип: %T\n", i, i)          // i = 65, тип: int32

Семантическое значение:

byte — для работы с байтами (бинарные данные)
rune — для работы с Unicode-символами (текст)
Технически идентичны uint8 и int32, но имеют смысловую нагрузку

2. Создание собственных псевдонимов

Синтаксис: type NewName = ExistingType

Знак = обязателен для псевдонима!

type SerenyaType1 = uint16

var value26 SerenyaType1 = 123

fmt.Printf("value26 = %d, тип: %T\n", value26, value26)  // value26 = 123, тип: uint16

Псевдоним полностью взаимозаменяем:

type MyInt = int

var a MyInt = 10
var b int = 20

a = b  // ✅ Работает!
b = a  // ✅ Работает!

fmt.Printf("a = %d, тип: %T\n", a, a)  // a = 10, тип: int
fmt.Printf("b = %d, тип: %T\n", b, b)  // b = 20, тип: int

Применение:

Улучшение читаемости кода
Семантическая ясность (например, type UserID = int64)
Избежание длинных имён типов

3. Новый тип vs Псевдоним

⚠️ КРИТИЧЕСКОЕ ОТЛИЧИЕ:

Псевдоним (`type Name = Type`)	Новый тип (`type Name Type`)
`type Alias = uint16` (со знаком `=`)	`type Custom uint16` (без `=`)
Идентичен исходному типу	Отдельный тип
Взаимозаменяем без приведения	Требует явного приведения
`%T` показывает исходный тип	`%T` показывает новое имя

Псевдоним (со знаком =)

type SerenyaType1 = uint16

var value26 SerenyaType1 = 123
var value28 uint16 = 456

value26 = value28  // ✅ Работает! Это один тип
value28 = value26  // ✅ Работает!

fmt.Printf("value26 тип: %T\n", value26)  // uint16 (показывает исходный тип)

Новый тип (без знака =)

type SerenyaType2 uint16

var value27 SerenyaType2 = 123
var value29 uint16 = 456

// value27 = value29  // ❌ ОШИБКА! cannot use value29 (uint16) as SerenyaType2

Требуется явное приведение:

value27 = SerenyaType2(value29)  // ✅ Явное приведение типа
value29 = uint16(value27)        // ✅ Обратное приведение

fmt.Printf("value27 тип: %T\n", value27)  // main.SerenyaType2 (новый тип!)

4. Приведение между псевдонимом и новым типом

Сценарий: у вас есть псевдоним и новый тип на основе одного базового типа.

type SerenyaType1 = uint16      // Псевдоним
type SerenyaType2 uint16         // Новый тип

var value26 SerenyaType1 = 123   // По сути uint16
var value27 SerenyaType2 = 456   // Отдельный тип

// value26 = value27  // ❌ ОШИБКА! Разные типы

Явное приведение через псевдоним:

// Способ 1: через псевдоним
value26 = SerenyaType1(value27)  // ✅ Работает

// Способ 2: через базовый тип
value26 = uint16(value27)        // ✅ Работает (SerenyaType1 = uint16)

// Обратное приведение
value27 = SerenyaType2(value26)  // ✅ Работает

Полный пример:

package main

import "fmt"

type SerenyaType1 = uint16   // Псевдоним (с =)
type SerenyaType2 uint16     // Новый тип (без =)

func main() {
    var value26 SerenyaType1 = 123
    var value27 SerenyaType2 = 456
    
    fmt.Printf("value26 = %d, тип: %T\n", value26, value26)  // uint16
    fmt.Printf("value27 = %d, тип: %T\n", value27, value27)  // main.SerenyaType2
    
    // Приведение нового типа к псевдониму
    value26 = SerenyaType1(value27)
    fmt.Printf("После приведения value26 = %d\n", value26)   // 456
    
    // Приведение псевдонима к новому типу
    value27 = SerenyaType2(value26)
    fmt.Printf("После приведения value27 = %d\n", value27)   // 456
}

5. Зачем нужны псевдонимы?

Семантическая ясность

// Плохо — неясно, что означают int64
func UpdateUser(id int64, companyID int64) error {
    // ...
}

// Хорошо — понятно назначение
type UserID = int64
type CompanyID = int64

func UpdateUser(id UserID, companyID CompanyID) error {
    // ...
}

Сокращение длинных типов

// Было
var users map[string]map[string][]int

// Стало
type UserRoles = map[string][]int
type UserRoleMap = map[string]UserRoles

var users UserRoleMap

Совместимость при рефакторинге

// Старое имя для обратной совместимости
type OldName = NewName

// Теперь можно постепенно мигрировать код

Работа с внешними пакетами

import "some/long/package/path"

type Config = path.Configuration
type Logger = path.LoggerInterface

// Короче и понятнее в коде

6. Зачем нужны новые типы (type Name Type)?

Новые типы создают type safety — защиту от случайного смешивания данных.

type Celsius float64
type Fahrenheit float64

func boilWater(temp Celsius) {
    fmt.Printf("Кипятим воду при %.1f°C\n", temp)
}

var c Celsius = 100
var f Fahrenheit = 212

boilWater(c)  // ✅ Работает
// boilWater(f)  // ❌ ОШИБКА! Защита от ошибки использования

// Нужно явное приведение (и конвертация значения)
boilWater(Celsius((f - 32) * 5 / 9))  // ✅ Работает

Применение новых типов:

Предотвращение логических ошибок (нельзя перепутать градусы Цельсия и Фаренгейта)
Методы для пользовательских типов
Строгая типизация в бизнес-логике

Практические примеры

Пример 1: Встроенные псевдонимы

package main

import "fmt"

func main() {
    // byte = uint8
    var b byte = 255
    var u uint8 = 200
    
    b = u  // ✅ Взаимозаменяемы
    fmt.Printf("byte: %d (тип: %T)\n", b, b)  // byte: 200 (тип: uint8)
    
    // rune = int32
    var r rune = 'Я'        // Unicode-символ
    var i int32 = 1071      // Код символа 'Я'
    
    r = i  // ✅ Взаимозаменяемы
    fmt.Printf("rune: %d = '%c' (тип: %T)\n", r, r, r)  // rune: 1071 = 'Я' (тип: int32)
}

Пример 2: Собственные псевдонимы для читаемости

package main

import "fmt"

// Псевдонимы для ID различных сущностей
type UserID = int64
type ProductID = int64
type OrderID = int64

func main() {
    var userID UserID = 12345
    var productID ProductID = 67890
    
    // Технически это всё int64, можно смешивать (но семантически неправильно!)
    userID = productID  // ⚠️ Компилируется, но логически неверно!
    
    fmt.Printf("UserID: %d (тип: %T)\n", userID, userID)        // int64
    fmt.Printf("ProductID: %d (тип: %T)\n", productID, productID)  // int64
}

Пример 3: Новые типы для type safety

package main

import "fmt"

// Новые типы (без =)
type UserID int64
type ProductID int64

func GetUser(id UserID) {
    fmt.Printf("Получаем пользователя с ID: %d\n", id)
}

func main() {
    var userID UserID = 12345
    var productID ProductID = 67890
    
    GetUser(userID)  // ✅ Правильно
    
    // GetUser(productID)  // ❌ ОШИБКА! cannot use productID (ProductID) as UserID
    
    // Нужно явное приведение (но это сигнал об ошибке!)
    GetUser(UserID(productID))  // ⚠️ Компилируется, но логически неверно!
    
    fmt.Printf("UserID: %d (тип: %T)\n", userID, userID)        // main.UserID
    fmt.Printf("ProductID: %d (тип: %T)\n", productID, productID)  // main.ProductID
}

Пример 4: Полный код из урока

package main

import "fmt"

type SerenyaType1 = uint16   // Псевдоним (с =)
type SerenyaType2 uint16     // Новый тип (без =)

func main() {
    // Встроенные псевдонимы
    var value1 byte = 123
    var value2 uint8 = 123
    value1 = value2  // ✅ Взаимозаменяемы
    
    var value3 rune = 234
    
    fmt.Printf("value1 = %d, %T\n", value1, value1)  // 123, uint8
    fmt.Printf("value2 = %d, %T\n", value2, value2)  // 123, uint8
    fmt.Printf("value3 = %d, %T\n", value3, value3)  // 234, int32
    
    // Собственные типы
    var value26 SerenyaType1 = 123  // Псевдоним
    var value27 SerenyaType2 = 123  // Новый тип
    
    fmt.Printf("value26 = %d, %T\n", value26, value26)  // 123, uint16
    
    // Приведение нового типа к псевдониму
    value26 = SerenyaType1(value27)  // ✅ Явное приведение
    
    fmt.Printf("value27 = %d, %T\n", value27, value27)  // 123, main.SerenyaType2
}

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

1. Псевдоним = базовый тип

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

type MyInt = int
// MyInt и int — это одно и то же

2. Знак = решает всё

type Alias = int     // Псевдоним (взаимозаменяем)
type Custom int      // Новый тип (требует приведения)

3. %T показывает реальный тип

type Alias = int
var a Alias = 10
fmt.Printf("%T\n", a)  // int (показывает базовый тип)

type Custom int
var c Custom = 10
fmt.Printf("%T\n", c)  // main.Custom (показывает новый тип)

4. Встроенные псевдонимы

byte = uint8 (для байтов)
rune = int32 (для Unicode-символов)

5. Не путайте псевдонимы и новые типы

При встрече незнакомого типа — проверьте через %T или Go to Definition (F12).

6. Явное приведение для новых типов

type Custom int
var c Custom = 10
var i int = int(c)      // ✅ Явное приведение необходимо
c = Custom(i)           // ✅ Обратное приведение

7. Семантика важнее синтаксиса

Используйте псевдонимы для ясности, новые типы — для безопасности.

Best Practices

1. Используйте псевдонимы для семантики

// Хорошо — понятно назначение
type RequestID = string
type ResponseBody = []byte

// Плохо — слишком общие типы
var id string
var body []byte

2. Используйте новые типы для type safety

// Хорошо — защита от ошибок
type Celsius float64
type Fahrenheit float64

// Плохо — легко перепутать
var tempC float64
var tempF float64

3. Документируйте назначение типов

// UserID представляет уникальный идентификатор пользователя в системе
type UserID = int64

// Temperature представляет температуру в градусах Цельсия
type Temperature float64

4. Избегайте избыточных псевдонимов

// Плохо — не добавляет ясности
type MyInt = int
type MyString = string

// Хорошо — несёт смысловую нагрузку
type UserRole = string
type EmailAddress = string

5. Используйте PascalCase для экспортируемых типов

// Экспортируемый псевдоним (доступен из других пакетов)
type UserID = int64

// Неэкспортируемый (только внутри пакета)
type internalID = int64

6. Группируйте связанные типы

// Хорошо — логическая группировка
type (
    UserID    = int64
    ProductID = int64
    OrderID   = int64
)

// Или через отдельные объявления
type UserID = int64
type ProductID = int64
type OrderID = int64

7. Не злоупотребляйте явными приведениями

type Celsius float64
type Fahrenheit float64

// Плохо — частые приведения намекают на проблему дизайна
temp := Celsius(32)
temp = Celsius(Fahrenheit(temp))

// Хорошо — функции конвертации
func ToFahrenheit(c Celsius) Fahrenheit {
    return Fahrenheit(c*9/5 + 32)
}

temp := Celsius(100)
fmt.Printf("%.1f°C = %.1f°F\n", temp, ToFahrenheit(temp))

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

Псевдоним объявляется со знаком =: type Name = Type
Новый тип объявляется без =: type Name Type
Псевдоним взаимозаменяем с исходным типом
Новый тип требует явного приведения
byte = uint8 (для байтов)
rune = int32 (для Unicode-символов)
%T показывает реальный тип (для псевдонимов — базовый)
Незнакомый тип? Проверьте через %T или F12 (Go to Definition)
Псевдонимы для семантики, новые типы для type safety
Явное приведение: NewType(value)
Не путайте псевдонимы и новые типы!