Как определить тип переменной в Go: способы и примеры

Использование type switch для определения типа в Go

В Go нет встроенной функции наподобие typeof из JavaScript, но для определения типа переменной, особенно при работе с пустыми интерфейсами (interface{}), существует мощный механизм — type switch. Это конструкция, которая позволяет проверять тип значения на лету и выполнять соответствующий код. Она идеально подходит для вашей задачи.

Вот как решить вашу проблему с умножением int, выводом длины строки и инвертированием bool:

package main

import "fmt"

func processValue(v interface{}) {
    switch v := v.(type) { // type switch
    case int:
        fmt.Println("Это int, умноженный на 2:", v*2)
    case string:
        fmt.Println("Это строка, её длина:", len(v))
    case bool:
        fmt.Println("Это bool, инвертированное значение:", !v)
    default:
        fmt.Printf("Неизвестный тип: %T, значение: %v\n", v, v)
    }
}

func main() {
    processValue(42)       // int
    processValue("hello") // string
    processValue(true)    // bool
    processValue(3.14)    // float64 (попадает в default)
}

Вывод программы:

Это int, умноженный на 2: 84
Это строка, её длина: 5
Это bool, инвертированное значение: false
Неизвестный тип: float64, значение: 3.14

Как это работает

• v.(type) — это специальная конструкция, которая работает только внутри switch.
• Переменная v внутри каждой ветки case автоматически приводится к указанному типу. Например, в case int вы можете сразу использовать v как целое число.
• Ветка default обрабатывает все остальные типы, которые не были явно перечислены.

Более простой способ: type assertion (утверждение типа)

Если вам нужно проверить только один конкретный тип, можно использовать type assertion:

func checkType(v interface{}) {
    if str, ok := v.(string); ok {
        fmt.Println("Это строка:", str)
    } else if num, ok := v.(int); ok {
        fmt.Println("Это число:", num)
    } else {
        fmt.Println("Другой тип")
    }
}

Здесь v.(string) пытается извлечь значение как строку. Если это удаётся, ok равен true, и вы получаете доступ к значению. Если нет — ok равен false, и программа не паникует.

Отладочный вариант: fmt.Printf("%T")

Вы упомянули fmt.Printf("%T", x) — это действительно полезно только для отладки и вывода в консоль. Он не позволяет выполнять логику на основе типа. Для реальной работы используйте type switch или type assertion.

Советы для работы с JSON

При разборе JSON в Go часто используют map[string]interface{}. Type switch здесь незаменим:

jsonData := `{"name": "Alice", "age": 30, "active": true}`
var result map[string]interface{}
json.Unmarshal([]byte(jsonData), &result)

for key, value := range result {
    switch v := value.(type) {
    case string:
        fmt.Printf("Ключ %s — строка: %s\n", key, v)
    case float64: // JSON numbers по умолчанию становятся float64
        fmt.Printf("Ключ %s — число: %f\n", key, v)
    case bool:
        fmt.Printf("Ключ %s — булево: %t\n", key, v)
    }
}

Таким образом, type switch — это стандартный идиоматичный способ работы с динамическими типами в Go. Он безопасен (не вызывает панику, если тип не совпадает), читаем и эффективен.

import (
    "fmt"
    "reflect"
)

func main() {
    var x interface{} = 42
    t := reflect.TypeOf(x)
    fmt.Println("Тип:", t)          // int
    fmt.Println("Имя:", t.Name())   // int
    fmt.Println("Kind:", t.Kind())  // int (Kind — это базовый тип)

    v := reflect.ValueOf(x)
    fmt.Println("Значение:", v.Int()) // 42
}