Come evitare il fastidioso errore "dichiarato e non utilizzato"

Sto imparando Go ma sento che è un po 'fastidioso che durante la compilazione non debba lasciare inutilizzata alcuna variabile o pacchetto.

Questo mi sta davvero rallentando. Ad esempio, volevo solo dichiarare un nuovo pacchetto e pianificare di usarlo in un secondo momento o semplicemente decommentare alcuni comandi per testare. Ricevo sempre l'errore e devo andare a commentare tutti quegli usi.

Esiste un modo per evitare questo tipo di controllo in Go?

Quell'errore è qui per costringerti a scrivere codice migliore e assicurarti di usare tutto ciò che dichiari o importi. Semplifica la lettura del codice scritto da altre persone (sei sempre sicuro che verranno utilizzate tutte le variabili dichiarate) ed evita alcuni possibili codici morti.

Ma, se vuoi davvero saltare questo errore, puoi usare l' identificatore vuoto ( _):

package main

import (
    "fmt" // imported and not used: "fmt"
)

func main() {
    i := 1 // i declared and not used
}

diventa

package main

import (
    _ "fmt" // no more error
)

func main() {
    i := 1 // no more error
    _ = i
}

Come detto da kostix nei commenti qui sotto, puoi trovare la posizione ufficiale del team Go nelle FAQ :

La presenza di una variabile non utilizzata può indicare un errore, mentre le importazioni non utilizzate rallentano la compilazione. Accumula abbastanza importazioni non utilizzate nella tua struttura di codice e le cose possono andare molto lentamente. Per questi motivi, Go non consente nessuno dei due.

A tale scopo è possibile utilizzare una semplice "funzione null", ad esempio:

func Use(vals ...interface{}) {
    for _, val := range vals {
        _ = val
    }
}

Che puoi usare così:

package main

func main() {
    a := "declared and not used"
    b := "another declared and not used"
    c := 123

    Use(a, b, c)
}

C'è anche un pacchetto per questo, quindi non è necessario definire la Usefunzione ogni volta:

import (
  "github.com/lunux2008/xulu"
)

func main() {
  // [..]

  xulu.Use(a, b, c)
}

Secondo le FAQ :

Alcuni hanno chiesto un'opzione del compilatore per disattivare quei controlli o almeno ridurli in avvisi. Tale opzione non è stata aggiunta, tuttavia, perché le opzioni del compilatore non dovrebbero influire sulla semantica della lingua e perché il compilatore Go non riporta avvisi, ma solo errori che impediscono la compilazione.

Esistono due motivi per non avere avvisi. Innanzitutto, se vale la pena lamentarsi, vale la pena correggerlo nel codice. (E se non vale la pena aggiustarlo, non vale la pena menzionarlo.) Secondo, fare in modo che il compilatore generi avvisi incoraggia l'implementazione a mettere in guardia su casi deboli che possono rendere rumorosa la compilazione, mascherando errori reali che dovrebbero essere corretti.

Non sono necessariamente d'accordo con questo per vari motivi che non vale la pena approfondire. È quello che è, e non è probabile che cambi nel prossimo futuro.

Per i pacchetti, c'è lo goimportsstrumento che aggiunge automaticamente i pacchetti mancanti e rimuove quelli inutilizzati. Per esempio:

# Install it
$ go get golang.org/x/tools/cmd/goimports

# -w to write the source file instead of stdout
$ goimports -w my_file.go

Dovresti essere in grado di eseguirlo da qualsiasi editor decente a metà strada, ad esempio per Vim:

:!goimports -w %

Il goimports pagina elenca alcuni comandi per altri editor e in genere viene impostato per l'esecuzione automatica quando si salva il buffer su disco.

Si noti che goimportsverrà eseguito anche gofmt.

Come già accennato, per le variabili il modo più semplice è assegnarle (temporaneamente) a _:

// No errors
tasty := "ice cream"
horrible := "marmite"

// Commented out for debugging
//eat(tasty, horrible)

_, _ = tasty, horrible

Un angolo non menzionato finora sono i set di strumenti utilizzati per la modifica del codice.

L'uso di Visual Studio Code insieme all'estensione di lukehoban chiamato Gofarà un po 'di magia automatica per te. L'estensione Go viene eseguita automaticamente gofmt, golintecc., Rimuove e aggiunge importvoci . Quindi almeno quella parte è ora automatica.

Devo ammettere che non è il 100% della soluzione alla domanda, ma comunque abbastanza utile.

Nel caso in cui altri abbiano difficoltà a dare un senso a questo, penso che potrebbe aiutare a spiegarlo in termini molto semplici. Se hai una variabile che non usi, ad esempio una funzione per la quale hai commentato l'invocazione (un caso d'uso comune):

myFn := func () { }
// myFn()

È possibile assegnare una variabile inutile / vuota alla funzione in modo che non sia più inutilizzata :

myFn := func () { }
_ = myFn
// myFn()