detección nula en Go

Veo mucho código en Ir para detectar nulo, así:

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

Sin embargo, tengo una estructura como esta:

type Config struct {
    host string  
    port float64
}

y config es una instancia de Config, cuando lo hago:

if config == nil {
}

hay un error de compilación que dice: no se puede convertir nil para escribir Config

El compilador le está señalando el error, está comparando una instancia de estructura y nula. No son del mismo tipo, por lo que lo considera como una comparación no válida y le grita.

Lo que desea hacer aquí es comparar un puntero a su instancia de configuración con nil, que es una comparación válida. Para hacerlo, puede usar el nuevo programa incorporado de golang o inicializar un puntero:

config := new(Config) // not nil

o

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

o

var config *Config // nil

Entonces podrás comprobar si

if config == nil {
    // then
}

Además de Oleiade, vea la especificación de valores cero :

Cuando se asigna memoria para almacenar un valor, ya sea a través de una declaración o una llamada de make o new, y no se proporciona una inicialización explícita, la memoria recibe una inicialización predeterminada. Cada elemento de dicho valor se establece en el valor cero para su tipo: falso para booleanos, 0 para enteros, 0.0 para flotantes, "" para cadenas y nulo para punteros, funciones, interfaces, sectores, canales y mapas. Esta inicialización se realiza de forma recursiva, por lo que, por ejemplo, cada elemento de una matriz de estructuras tendrá sus campos a cero si no se especifica ningún valor.

Como puede ver, nilno es el valor cero para cada tipo, sino solo para punteros, funciones, interfaces, sectores, canales y mapas. Esta es la razón por la cual config == niles un error y &config == nilno lo es.

Para comprobar si su estructura está sin inicializar que tendría que comprobar todos los miembros de su respectivo valor de cero (por ejemplo host == "", port == 0, etc.) o tienen un campo privado que se configura mediante un método de inicialización interna. Ejemplo:

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 }

He creado un código de muestra que crea nuevas variables usando una variedad de formas en las que puedo pensar. Parece que las primeras 3 formas crean valores, y las dos últimas crean referencias.

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

que salidas:

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

También puedes consultar como struct_var == (struct{}). Esto no le permite comparar a cero, pero sí verifica si se inicializa o no. Tenga cuidado al usar este método. Si su estructura puede tener valores cero para todos sus campos, no lo pasará en grande.

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

La especificación del lenguaje menciona los comportamientos de los operadores de comparación:

operadores de comparación

En cualquier comparación, el primer operando debe ser asignable al tipo del segundo operando, o viceversa.

Asignabilidad

Un valor x se puede asignar a una variable de tipo T ("x se puede asignar a T") en cualquiera de estos casos:

• El tipo de x es idéntico a T.
• Los tipos V y T de x tienen tipos subyacentes idénticos y al menos uno de V o T no es un tipo con nombre.
• T es un tipo de interfaz y x implementa T.
• x es un valor de canal bidireccional, T es un tipo de canal, los tipos V y T de x tienen tipos de elementos idénticos, y al menos uno de V o T no es un tipo con nombre.
• x es el identificador predefinido nil y T es un puntero, función, segmento, mapa, canal o tipo de interfaz.
• x es una constante sin tipo representable por un valor de tipo T.

En Go 1.13 y posterior, puede usar el Value.IsZerométodo ofrecido en el reflectpaquete.

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

Además de los tipos básicos, también funciona para Array, Chan, Func, Interface, Map, Ptr, Slice, UnsafePointer y Struct. Vea esto como referencia.