rilevamento zero in Go

Vedo molto codice in Vai per rilevare zero, in questo modo:

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

tuttavia, ho una struttura come questa:

type Config struct {
    host string  
    port float64
}

e config è un'istanza di Config, quando faccio:

if config == nil {
}

c'è un errore di compilazione, che dice: impossibile convertire zero per digitare Config

Il compilatore sta indicando l'errore, stai confrontando un'istanza di struttura e zero. Non sono dello stesso tipo, quindi lo considera un confronto non valido e ti urla.

Quello che vuoi fare qui è confrontare un puntatore all'istanza di configurazione con zero, che è un confronto valido. Per fare ciò puoi usare il nuovo Golang incorporato o inizializzare un puntatore ad esso:

config := new(Config) // not nil

o

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

o

var config *Config // nil

Quindi sarai in grado di verificare se

if config == nil {
    // then
}

Oltre a Oleiade, vedere le specifiche sui valori zero :

Quando la memoria viene allocata per memorizzare un valore, tramite una dichiarazione o una chiamata di make o new, e non viene fornita l'inizializzazione esplicita, alla memoria viene fornita un'inizializzazione predefinita. Ogni elemento di tale valore è impostato sul valore zero per il suo tipo: false per booleani, 0 per numeri interi, 0,0 per float, "" per stringhe e zero per puntatori, funzioni, interfacce, sezioni, canali e mappe. Questa inizializzazione viene eseguita in modo ricorsivo, quindi ad esempio ogni elemento di una matrice di strutture avrà i suoi campi azzerati se non viene specificato alcun valore.

Come puoi vedere, nilnon è il valore zero per ogni tipo, ma solo per puntatori, funzioni, interfacce, sezioni, canali e mappe. Questo è il motivo per cui config == nilè un errore e &config == nilnon lo è.

Per verificare se lo struct è inizializzato che ci si controlla ogni membro per il suo rispettivo valore pari a zero (per esempio host == "", port == 0e così via) o di avere un campo privato che si trova con un metodo di inizializzazione interna. Esempio:

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 }

Ho creato un codice di esempio che crea nuove variabili usando una varietà di modi a cui posso pensare. Sembra che i primi 3 modi creino valori e gli ultimi due creino riferimenti.

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

che produce:

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

Puoi anche controllare come struct_var == (struct{}). Questo non ti consente di confrontare con zero ma controlla se è inizializzato o meno. Fai attenzione quando usi questo metodo. Se la tua struttura può avere valori zero per tutti i suoi campi, non avrai grandi momenti.

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

Le specifiche della lingua menzionano i comportamenti degli operatori di confronto:

operatori di confronto

In qualsiasi confronto, il primo operando deve essere assegnabile al tipo di secondo operando o viceversa.

cedibilità

Un valore x è assegnabile a una variabile di tipo T ("x è assegnabile a T") in uno di questi casi:

• il tipo di x è identico a T.
• i tipi V e T di x hanno identici tipi sottostanti e almeno uno di V o T non è un tipo denominato.
• T è un tipo di interfaccia e x implementa T.
• x è un valore di canale bidirezionale, T è un tipo di canale, i tipi di V V e T hanno tipi di elementi identici e almeno uno di V o T non è un tipo con nome.
• x è l'identificatore predefinito nil e T è un puntatore, una funzione, una sezione, una mappa, un canale o un tipo di interfaccia.
• x è una costante non tipizzata rappresentabile da un valore di tipo T.

In Go 1.13 e versioni successive, è possibile utilizzare il Value.IsZerometodo offerto nel reflectpacchetto.

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

Oltre ai tipi di base, funziona anche con Array, Chan, Func, Interface, Map, Ptr, Slice, UnsafePointer e Struct. Vedi questo per riferimento.