detecção nula no Go

Vejo muito código no Go para detectar nada, assim:

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

no entanto, eu tenho uma estrutura como esta:

type Config struct {
    host string  
    port float64
}

e config é uma instância do Config, quando:

if config == nil {
}

há erro de compilação, dizendo: não é possível converter nil para digitar Config

O compilador está apontando o erro para você; você está comparando uma instância de estrutura e nada. Eles não são do mesmo tipo, por isso considera uma comparação inválida e gritam com você.

O que você deseja fazer aqui é comparar um ponteiro com sua instância de configuração com zero, que é uma comparação válida. Para fazer isso, você pode usar o golang new builtin ou inicializar um ponteiro para ele:

config := new(Config) // not nil

ou

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

ou

var config *Config // nil

Então você poderá verificar se

if config == nil {
    // then
}

Além da Oleiade, consulte a especificação sobre valores zero :

Quando a memória é alocada para armazenar um valor, por meio de uma declaração ou uma chamada de marca ou nova, e nenhuma inicialização explícita é fornecida, a memória recebe uma inicialização padrão. Cada elemento desse valor é definido com o valor zero para seu tipo: false para booleanos, 0 para números inteiros, 0,0 para números flutuantes "" para seqüências de caracteres e nulo para ponteiros, funções, interfaces, fatias, canais e mapas. Essa inicialização é feita recursivamente, portanto, por exemplo, cada elemento de uma matriz de estruturas terá seus campos zerados se nenhum valor for especificado.

Como você pode ver, nilnão é o valor zero para todos os tipos, mas apenas para ponteiros, funções, interfaces, fatias, canais e mapas. Esta é a razão pela qual config == nilé um erro e &config == nilnão é.

Para verificar se o struct é inicializado você teria que verificar cada membro de seu respectivo valor zero (por exemplo host == "", port == 0, etc.) ou ter um campo privado, que é definido por um método de inicialização interno. Exemplo:

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 }

Eu criei um código de exemplo que cria novas variáveis ​​usando várias maneiras em que consigo pensar. Parece que as três primeiras maneiras de criar valores e as duas últimas criam referências.

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)
}

quais saídas:

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

Você também pode verificar como struct_var == (struct{}). Isso não permite comparar com zero, mas verifica se foi inicializado ou não. Tenha cuidado ao usar este método. Se sua estrutura puder ter valores zero para todos os seus campos, você não terá muito tempo.

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

A especificação da linguagem menciona os comportamentos dos operadores de comparação:

operadores de comparação

Em qualquer comparação, o primeiro operando deve ser atribuído ao tipo do segundo operando, ou vice-versa.

Atribuição

Um valor x é atribuível a uma variável do tipo T ("x é atribuível a T") em qualquer um destes casos:

• o tipo de x é idêntico a T.
• os tipos V e T de x têm tipos subjacentes idênticos e pelo menos um de V ou T não é um tipo nomeado.
• T é um tipo de interface ex implementa T.
• x é um valor de canal bidirecional, T é um tipo de canal, os tipos V e T de x têm tipos de elementos idênticos e pelo menos um de V ou T não é um tipo nomeado.
• x é o identificador pré-declarado nulo e T é um tipo de ponteiro, função, fatia, mapa, canal ou interface.
• x é uma constante sem tipo representável por um valor do tipo T.

No Go 1.13 e posterior, você pode usar o Value.IsZerométodo oferecido no reflectpacote.

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

Além dos tipos básicos, ele também funciona para Array, Chan, Func, Interface, Mapa, Ptr, Slice, UnsafePointer e Struct. Veja isto para referência.