Краткий ответ

Паника возникает потому, что оба интерфейса содержат значения одного динамического типа []int, а срезы в Go несравнимы оператором ==. Интерфейсные значения сами по себе сравнимы, но при сравнении Go сравнивает их динамические значения; если динамический тип не поддерживает сравнение, выполнение завершается паникой.

Исторический контекст

Интерфейсы в Go задумывались как единый способ работать со значениями разных конкретных типов через общий контракт. Поэтому интерфейсное значение хранит динамический тип и соответствующее значение, а операции над ним должны учитывать свойства фактического типа.

Правило сравнения сохраняет естественную семантику конкретных типов: интерфейс не делает срез сравнимым и не вводит скрытого поэлементного сравнения. Для сравнения содержимого срезов применяется явная логика, например slices.Equal или ручное сравнение.

Постановка проблемы

Проверка равенства интерфейсов может выглядеть безопасной, особенно если переменные имеют тип interface{}. Однако тип интерфейса не гарантирует, что хранимое внутри значение можно сравнивать.

Это опасно в универсальном коде, например при сравнении значений из map[string]interface{}, логировании состояния или проверке ожидаемого результата теста. Если два интерфейса содержат одинаковый несравнимый динамический тип, обычное == приведёт к панике.

Подробное решение

Интерфейсное значение можно представить как пару: динамический тип и динамическое значение. При a == b Go сначала учитывает динамические типы. Если они различаются, результатом будет false; если типы совпадают, сравниваются динамические значения.

Сравнимыми являются, в частности, числа, строки, указатели, каналы, интерфейсы, массивы и структуры, состоящие только из сравнимых полей. Срезы, карты и функции напрямую сравнивать нельзя; исключение для этих типов — сравнение с nil, где это разрешено правилами языка.

В примере оба интерфейса имеют динамический тип []int. Поэтому Go пытается сравнить два среза и обнаруживает недопустимую операцию, после чего возникает паника. Значения элементов срезов не анализируются автоматически.

Безопасная проверка должна учитывать ожидаемый конкретный тип и использовать подходящее сравнение:

package main

import "slices"

func main() {
    var a interface{} = []int{1}
    var b interface{} = []int{1}

    x, ok := a.([]int)
    y, ok2 := b.([]int)
    println(ok && ok2 && slices.Equal(x, y))
}

Типовая проверка через утверждение типа позволяет получить срезы, после чего вызывается специализированное сравнение. В старых версиях Go вместо slices.Equal можно использовать ручной цикл или reflect.DeepEqual, но reflect.DeepEqual имеет более общую и не всегда желательную семантику.

Сравнение интерфейса с nil в данном примере паники не вызовет: a == nil даст false, поскольку a содержит динамический тип []int. Это отдельный случай сравнения интерфейса с нулевым интерфейсом, а не сравнение двух срезов.

Ситуация из практики

В тесте обработчика разработчик сравнил фактический и ожидаемый результат, оба записанные в interface{}. Для скалярных результатов проверка работала, но после появления результата-среза тест начал панически завершаться.

Вариант с прямым reflect.DeepEqual быстро устраняет панику и подходит для разнородных тестовых данных, но может скрыть различия, важные для конкретного домена. Вариант с приведением к ожидаемому типу требует больше кода, зато явно фиксирует контракт и позволяет выбрать точное сравнение.

Выбран вариант с типизированными результатами и slices.Equal: он сделал ошибку типов видимой на этапе разработки, дал понятную семантику сравнения и не добавил отражение типов в критический путь. В результате тесты перестали зависеть от случайного динамического типа интерфейса.

Что кандидаты часто упускают

1. Вызовет ли панику выражение a == nil, если a содержит срез?

Нет. Интерфейс a не равен nil, потому что он содержит динамический тип []int. При сравнении с нулевым интерфейсом динамические типы не совпадают, поэтому результатом будет false, а не паника.

2. Что произойдёт при сравнении интерфейсов с разными несравнимыми динамическими типами?

Например, если один интерфейс содержит []int, а другой — map[string]int, результатом будет false, поскольку динамические типы различаются. Паника возникает при совпадении динамических типов и попытке сравнить значения этого несравнимого типа.

3. Можно ли сравнивать структуру, содержащую срез, через интерфейс?

Нет. Такая структура сама становится несравнимой, потому что один из её полей — срез. Если два интерфейса содержат значения этой структуры одного динамического типа, сравнение также завершится паникой. Для сравнения нужно определить явное правило, например сравнивать поля вручную или использовать специализированный компаратор.