web-dev-qa-db-fra.com

Comment éviter les erreurs ennuyeuses "déclarées et non utilisées"

J'apprends Go mais je trouve un peu gênant de ne pas laisser de variable ou de paquet inutilisé lors de la compilation.

Cela me ralentit vraiment. Par exemple, je voulais simplement déclarer un nouveau package et prévoir l’utiliser plus tard ou tout simplement annuler la mise en commentaire d’une commande à tester. Je reçois toujours l'erreur et je dois commenter toutes ces utilisations.

Existe-t-il un moyen d'éviter ce type de contrôle dans Go?

go
176
A-letubby

Cette erreur est là pour vous obliger à é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 vous éviterez un éventuel code mort.

Mais si vous voulez vraiment ignorer cette erreur, vous pouvez utiliser le 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 trouver la position officielle de l'équipe de Go dans la FAQ :

La présence d'une variable inutilisée peut indiquer un bogue, alors que les importations inutilisées ne font que ralentir la compilation. Accumulez suffisamment d'importations inutilisées dans votre arborescence de codes et les choses peuvent devenir très lentes. Pour ces raisons, Go ne permet ni l'un ni l'autre.

187
Florent Bayle

Selon la FAQ :

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

Il n'y a pas d'avertissements pour deux raisons. Premièrement, si cela vaut la peine de se plaindre, cela vaut la peine de fixer le code. (Et si cela ne vaut pas la peine de le corriger, ça ne vaut pas la peine de le mentionner.) Deuxièmement, le fait de générer des avertissements par le compilateur encourage l’implémentation à signaler les cas faibles qui peuvent rendre la compilation bruyante, masquant ainsi les erreurs qui doivent être corrigées.

Je ne suis pas nécessairement d'accord avec cela pour diverses raisons qui ne valent pas la peine d'entrer. C'est ce que c'est, et il est peu probable que cela change dans un proche avenir.

Pour les packages, il existe l'outil goimports qui ajoute automatiquement les packages manquants et supprime les packages inutilisé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 être capable de l'exécuter à partir de n'importe quel éditeur à mi-chemin, par exemple pour Vim:

:!goimports -w %

La page goimports répertorie certaines commandes pour d'autres éditeurs et vous la configurez pour qu'elle s'exécute automatiquement lorsque vous enregistrez le tampon sur le disque.

Notez que goimports exécutera é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
23
Martin Tournoij

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 y a aussi un paquet pour cela vous n'avez donc pas à définir la fonction Use à chaque fois:

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

func main() {
  // [..]

  xulu.Use(a, b, c)
}
20
lunux2008

Les outils utilisés pour éditer le code ne sont pas encore mentionnés.

Utiliser Code Visual Studio avec l'extension de lukehoban appelée Go fera de la magie automatique pour vous. L'extension Go exécute automatiquement gofmt, golint etc, et supprime et ajoute les entrées import. Donc au moins cette partie est maintenant automatique.

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

8
miltonb

Si d’autres ont du mal à comprendre, je pense qu’il serait peut-être plus simple de l'expliquer. 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 vide/vide à la fonction pour qu'elle ne soit plus non utilisée:

myFn := func () { }
_ = myFn
// myFn()
4
max pleaner