Есть ли в Go конструкция "if x in" для проверки вхождения в список, как в Python?

В Go нет встроенного оператора in, но есть несколько простых решений

Да, вы правы: в Go действительно отсутствует прямой аналог Python-овского if x in list. Это связано с философией языка — Go предоставляет минимальный набор встроенных конструкций, оставляя реализацию часто используемых паттернов разработчику. Однако это не значит, что нужно писать громоздкий код. Рассмотрим три основных подхода.

1. Ручной цикл (самый распространённый способ)

Самый прямой и идиоматичный способ для Go — написать небольшую функцию с циклом range:

package main

import "fmt"

func contains(slice []string, target string) bool {
    for _, v := range slice {
        if v == target {
            return true
        }
    }
    return false
}

func main() {
    fruits := []string{"apple", "banana", "cherry"}
    if contains(fruits, "apple") {
        fmt.Println("Found!")
    }
}

Этот код полностью эквивалентен Python-версии. Функция contains проста, эффективна (O(n)) и легко читается. Для разных типов данных можно написать перегруженные версии или использовать дженерики (Go 1.18+).

2. Использование map для частых проверок

Если вам нужно проверять вхождение многократно, гораздо быстрее будет использовать map вместо слайса. Проверка вхождения в map — это операция O(1):

package main

import "fmt"

func main() {
    fruits := map[string]bool{
        "apple":  true,
        "banana": true,
        "cherry": true,
    }
    if fruits["apple"] {
        fmt.Println("Found!")
    }
    // Или более явно:
    if _, ok := fruits["apple"]; ok {
        fmt.Println("Found with ok check!")
    }
}

Обратите внимание: если ключа нет, map возвращает нулевое значение (для bool это false), поэтому первая форма работает, но вторая с ok — более надёжная. Этот подход идеален для больших наборов данных.

3. Дженерики (Go 1.18+) для универсальной функции

Начиная с Go 1.18, вы можете написать одну универсальную функцию для любого типа:

package main

import "fmt"

// Contains работает для любого типа, поддерживающего сравнение (comparable)
func Contains[T comparable](slice []T, target T) bool {
    for _, v := range slice {
        if v == target {
            return true
        }
    }
    return false
}

func main() {
    fruits := []string{"apple", "banana", "cherry"}
    numbers := []int{10, 20, 30}
    
    fmt.Println(Contains(fruits, "apple"))  // true
    fmt.Println(Contains(numbers, 25))      // false
}

Это элегантное решение, которое можно вынести в общую утилитарную библиотеку вашего проекта.

Что использовать?

• Единичная проверка — простая функция с циклом (вариант 1).
• Множественные проверки на одном наборе — map (вариант 2).
• Универсальный код — дженерики (вариант 3).

Ни один из этих подходов не является "костылём" — это стандартные практики в Go-сообществе. Со временем вы привыкнете писать такие маленькие функции, и это станет естественным.

package main

import (
    "fmt"
    "slices"
)

func main() {
    fruits := []string{"apple", "banana", "cherry"}
    if slices.Contains(fruits, "apple") {
        fmt.Println("Found!")
    }
}