ноль обнаружения в го

Я вижу много кода в Go, чтобы обнаружить ноль, например так:

if err != nil { 
    // handle the error    
}

Тем не менее, у меня есть такая структура:

type Config struct {
    host string  
    port float64
}

и config это экземпляр Config, когда я делаю:

if config == nil {
}

есть ошибка компиляции, говорящая: не может преобразовать ноль в тип Config

Компилятор указывает на ошибку, вы сравниваете экземпляр структуры и nil. Они не одного типа, поэтому он считает это недопустимым сравнением и кричит на вас.

Здесь вы хотите сравнить указатель на ваш экземпляр конфигурации с nil, что является допустимым сравнением. Для этого вы можете использовать новый встроенный golang или инициализировать указатель на него:

config := new(Config) // not nil

или

config := &Config{
                  host: "myhost.com", 
                  port: 22,
                 } // not nil

или

var config *Config // nil

Тогда вы сможете проверить, если

if config == nil {
    // then
}

В дополнение к Oleiade, смотрите спецификацию на нулевые значения :

Когда память выделяется для хранения значения либо через объявление, либо через вызов make или new, и не предоставляется явная инициализация, памяти назначается инициализация по умолчанию. Каждому элементу такого значения присваивается нулевое значение для его типа: false для логических значений, 0 для целых чисел, 0.0 для чисел с плавающей запятой, "" для строк и ноль для указателей, функций, интерфейсов, секций, каналов и карт. Эта инициализация выполняется рекурсивно, поэтому, например, каждый элемент массива структур будет обнулять свои поля, если не указано значение.

Как видите, nilэто не нулевое значение для каждого типа, а только для указателей, функций, интерфейсов, срезов, каналов и карт. Это причина, почему config == nilошибка и &config == nilнет.

Чтобы проверить, не является ли ваша структура неинициализированной, вы должны проверить каждый элемент на предмет его соответствующего нулевого значения (например host == "", port == 0и т. Д.) Или иметь закрытое поле, которое устанавливается внутренним методом инициализации. Пример:

type Config struct {
    Host string  
    Port float64
    setup bool
}

func NewConfig(host string, port float64) *Config {
    return &Config{host, port, true}
}

func (c *Config) Initialized() bool { return c != nil && c.setup }

Я создал пример кода, который создает новые переменные, используя различные способы, которые я могу придумать. Похоже, что первые 3 способа создания значений, а последние два создания ссылок.

package main

import "fmt"

type Config struct {
    host string
    port float64
}

func main() {
    //value
    var c1 Config
    c2 := Config{}
    c3 := *new(Config)

    //reference
    c4 := &Config{}
    c5 := new(Config)

    fmt.Println(&c1 == nil)
    fmt.Println(&c2 == nil)
    fmt.Println(&c3 == nil)
    fmt.Println(c4 == nil)
    fmt.Println(c5 == nil)

    fmt.Println(c1, c2, c3, c4, c5)
}

какие выводы:

false
false
false
false
false
{ 0} { 0} { 0} &{ 0} &{ 0}

Вы также можете проверить, как struct_var == (struct{}). Это не позволяет сравнивать с nil, но проверяет, инициализирован он или нет. Будьте осторожны при использовании этого метода. Если ваша структура может иметь нулевые значения для всех своих полей, у вас не будет отличного времени.

package main

import "fmt"

type A struct {
    Name string
}

func main() {
    a := A{"Hello"}
    var b A

    if a == (A{}) {
        fmt.Println("A is empty") // Does not print
    } 

    if b == (A{}) {
        fmt.Println("B is empty") // Prints
    } 
}

http://play.golang.org/p/RXcE06chxE

Спецификация языка описывает поведение операторов сравнения:

операторы сравнения

В любом сравнении первый операнд должен быть назначен типу второго операнда или наоборот.

Переуступка

Значение x присваивается переменной типа T («x присваивается T») в любом из следующих случаев:

• тип х идентичен т.
• Типы X и V имеют идентичные базовые типы, и по крайней мере один из V или T не является именованным типом.
• T является типом интерфейса, а x реализует T.
• x - двунаправленное значение канала, T - тип канала, x-типы V и T имеют идентичные типы элементов, и, по крайней мере, один из V или T не является именованным типом.
• x - это предварительно объявленный идентификатор nil, а T - указатель, функция, срез, карта, канал или тип интерфейса.
• x - нетипизированная константа, представимая значением типа T.

В Go 1.13 и более поздних версиях вы можете использовать Value.IsZeroметод, предложенный в reflectпакете.

if reflect.ValueOf(v).IsZero() {
    // v is zero, do something
}

Помимо основных типов, он также работает для Array, Chan, Func, Interface, Map, Ptr, Slice, UnsafePointer и Struct. Смотрите это для справки.