Comment éviter une erreur gênante «déclarée et non utilisée»

J'apprends Go, mais je pense qu'il est un peu ennuyeux de ne pas laisser de variable ou de package inutilisé lors de la compilation.

Cela me ralentit vraiment. Par exemple, je voulais simplement déclarer un nouveau package et planifier de l'utiliser plus tard ou simplement décommenter une commande à tester. J'ai toujours l'erreur et je dois commenter toutes ces utilisations.

Existe-t-il un moyen d'éviter ce type d'enregistrement dans Go?

Cette erreur est là pour vous forcer à écrire un meilleur code et à utiliser tout ce que vous déclarez ou importez. Cela facilite la lecture du code écrit par d'autres personnes (vous êtes toujours sûr que toutes les variables déclarées seront utilisées) et évite un code mort possible.

Mais, si vous voulez vraiment ignorer cette erreur, vous pouvez utiliser l' identifiant vide ( _):

package main

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

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

devient

package main

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

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

Comme dit par kostix dans les commentaires ci-dessous, vous pouvez retrouver la position officielle de l'équipe Go dans la FAQ :

La présence d'une variable inutilisée peut indiquer un bogue, tandis que les importations inutilisées ralentissent simplement la compilation. Accumulez suffisamment d'importations inutilisées dans votre arborescence de code et les choses peuvent devenir très lentes. Pour ces raisons, Go n'autorise ni l'un ni l'autre.

Vous pouvez utiliser une simple "fonction null" pour cela, par exemple:

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

Que vous pouvez utiliser comme ceci:

package main

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

    Use(a, b, c)
}

Il existe également un package pour cela , vous n'avez donc pas à définir la Usefonction à chaque fois:

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

func main() {
  // [..]

  xulu.Use(a, b, c)
}

Selon la FAQ :

Certains ont demandé une option de compilation pour désactiver ces vérifications ou au moins les réduire à des avertissements. Une telle option n'a pas été ajoutée, cependant, car les options du compilateur ne devraient pas affecter la sémantique du langage et parce que le compilateur Go ne signale pas les avertissements, seulement les erreurs qui empêchent la compilation.

Il y a deux raisons de ne pas avoir d'avertissement. Tout d'abord, si cela vaut la peine de se plaindre, cela vaut la peine d'être corrigé dans le code. (Et si cela ne vaut pas la peine d'être corrigé, cela ne vaut pas la peine d'être mentionné.) Deuxièmement, le fait que le compilateur génère des avertissements encourage la mise en œuvre à avertir des cas faibles qui peuvent rendre la compilation bruyante, masquant les vraies erreurs qui devraient être corrigées.

Je ne suis pas nécessairement d'accord avec cela pour diverses raisons qui ne valent pas la peine d'être abordées. C'est ce qu'il est et il est peu probable qu'il change dans un avenir proche.

Pour les packages, il existe l' goimportsoutil qui ajoute automatiquement les packages manquants et supprime ceux qui ne sont pas utilisés. Par exemple:

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

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

Vous devriez pouvoir l'exécuter à partir de n'importe quel éditeur décent à mi-chemin - par exemple pour Vim:

:!goimports -w %

La goimportspage répertorie certaines commandes pour d'autres éditeurs et vous la définissez généralement pour qu'elle s'exécute automatiquement lorsque vous enregistrez le tampon sur le disque.

Notez que goimportscela fonctionnera également gofmt.

Comme cela a déjà été mentionné, pour les variables, le moyen le plus simple consiste à les affecter (temporairement) à _:

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

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

_, _ = tasty, horrible

Un angle non mentionné jusqu'à présent est les ensembles d'outils utilisés pour éditer le code.

L'utilisation de Visual Studio Code avec l'extension de lukehoban appelée Gofera de la magie automatique pour vous. L'extension Go s'exécute automatiquement gofmt, golintetc., et supprime et ajoute des importentrées . Donc, au moins, cette partie est maintenant automatique.

J'admettrai que ce n'est pas 100% de la solution à la question, mais cependant assez utile.

Au cas où d'autres auraient du mal à comprendre cela, je pense que cela pourrait aider à l'expliquer en termes très simples. Si vous avez une variable que vous n'utilisez pas, par exemple une fonction pour laquelle vous avez commenté l'invocation (un cas d'utilisation courant):

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

Vous pouvez affecter une variable inutile / vide à la fonction afin qu'elle ne soit plus inutilisée :

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