Ошибка "cannot convert data (type interface{}) to type string: need type assertion" в Go

Проблема: интерфейсы в Go не поддерживают прямую индексацию

Ошибка возникает потому, что вы пытаетесь обратиться к переменной типа interface{} как к карте (map). В Go interface{} — это пустой контейнер, который может хранить значение любого типа, но для доступа к конкретным полям или элементам нужно сначала утвердить тип (type assertion).

В вашем примере json.Unmarshal возвращает в data значение типа map[string]interface{} (если JSON — объект), но компилятор этого не знает. Он видит только interface{}.

Правильное решение: type assertion с проверкой

Используйте синтаксис x.(T) для утверждения типа, где T — нужный тип. Всегда проверяйте успешность утверждения через второй возвращаемый параметр (ok):

package main

import (
    "encoding/json"
    "fmt"
)

func main() {
    jsonString := `{"name": "John", "age": 30}`
    var data interface{}
    err := json.Unmarshal([]byte(jsonString), &data)
    if err != nil {
        fmt.Println("Ошибка парсинга JSON:", err)
        return
    }

    // Шаг 1: утверждаем, что data — это map[string]interface{}
    m, ok := data.(map[string]interface{})
    if !ok {
        fmt.Println("data не является картой")
        return
    }

    // Шаг 2: получаем значение по ключу "name"
    nameValue, exists := m["name"]
    if !exists {
        fmt.Println("ключ 'name' отсутствует")
        return
    }

    // Шаг 3: утверждаем, что значение — строка
    name, ok := nameValue.(string)
    if !ok {
        fmt.Println("значение 'name' не является строкой")
        return
    }

    fmt.Println("Имя:", name) // Вывод: Имя: John
}

Почему это важно?

• Безопасность типов: Если утверждение неверно, программа не упадёт с паникой — вы получите ok = false.
• Гибкость: interface{} может хранить что угодно: строку, число, слайс, структуру. Проверка типов обязательна.
• JSON-специфика: Вложенные объекты и массивы потребуют каскадных утверждений.

Альтернатива: структуры вместо map

Лучший способ работать с JSON — определить структуру:

type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

func main() {
    jsonString := `{"name": "John", "age": 30}`
    var p Person
    err := json.Unmarshal([]byte(jsonString), &p)
    if err != nil {
        fmt.Println("Ошибка:", err)
        return
    }
    fmt.Println("Имя:", p.Name) // Работает напрямую, без утверждений
}

Такой подход избавляет от ручных утверждений типов и делает код чище. Используйте interface{} только когда тип данных заранее неизвестен (например, в библиотеках для работы с произвольными JSON-данными).

package main

import "fmt"

func main() {
    var data interface{} = "hello"

    switch v := data.(type) {
    case string:
        fmt.Println("Строка:", v)
    case int:
        fmt.Println("Целое число:", v)
    case map[string]interface{}:
        fmt.Println("Карта:", v)
    default:
        fmt.Println("Неизвестный тип")
    }
}

jsonString := `[1, 2, 3]`
var data interface{}
json.Unmarshal([]byte(jsonString), &data)

switch v := data.(type) {
case []interface{}:
    fmt.Println("Это массив длиной", len(v))
case map[string]interface{}:
    fmt.Println("Это объект с ключами", len(v))
}