Explication détaillée des variables anonymes dans Golang

Dans Golang, vous pouvez utiliser des variables anonymes pour ignorer les valeurs de retour ou les espaces réservés indésirables. Les variables anonymes sont un type spécial de variable qui simplifie le code et améliore la lisibilité. Cet article présentera en détail la définition, les caractéristiques et l'utilisation des variables anonymes.

Qu'est-ce qu'une variable anonyme ?

Dans Golang, une variable anonyme est une variable sans nom explicitement déclaré, généralement utilisée lorsqu'une valeur doit être stockée temporairement mais n'a pas besoin d'être utilisée dans le code ultérieur. Les variables anonymes sont déclarées en utilisant le trait de soulignement "_" comme nom de variable. Jetez un œil à un exemple :

_ = functionName(arg1, arg2, ...)

Parmi eux, functionName est le nom de la fonction à appeler, arg1, arg2, ... est la liste de paramètres transmise à la fonction. Dans cette structure syntaxique, l'utilisation de traits de soulignement comme noms de variables indique que vous ne vous souciez pas de la valeur de retour de la fonction. De cette façon, le résultat de l'appel de fonction peut être ignoré directement, atteignant ainsi l'objectif de l'ignorer. Regardons quelques exemples différents :

package main

import "fmt"

func main() {
	// 声明一个匿名变量并初始化为10
	_ = 10

	// 声明一个匿名变量并将一个函数的返回值赋值给它
	_, _ = fmt.Println("Hello, World!")

	// 可以在同一个语句中声明多个匿名变量
	_, _ = 10, 20

	// 可以在函数返回多个值的情况下使用匿名变量来忽略某些返回值
	_, ignoredValue := someFunction()
	fmt.Println(ignoredValue)
}

func someFunction() (int, string) {
	return 10, "路多辛的博客"
}

Dans l'exemple ci-dessus, les variables anonymes sont utilisées pour ignorer les valeurs de retour des fonctions, pour stocker temporairement des valeurs et dans les situations où vous devez ignorer certaines valeurs de retour. Veuillez noter que les variables anonymes ne peuvent pas être réaffectées ou utilisées ailleurs et que leur effet est limité à l'emplacement où elles sont déclarées.

Rôle dans le package de guide

Une utilisation courante des variables anonymes dans Golang est lorsque vous devez importer un package mais n'utilisez pas ses fonctions, types, variables, etc. exportables (ou utilisez simplement la fonction init), vous pouvez utiliser des variables anonymes pour importer le package. Par exemple:

package main  
  
import (  
    _ "fmt"  
)  
  
func main() {  
    // 在这里可以使用 fmt 包的功能，但不会引入其公共接口  
}

Dans cet exemple, des variables anonymes sont utilisées pour importer le package fmt et éviter d'utiliser des variables, types, fonctions, etc. exportables dans ce package.

Rôle dans la mise en œuvre des interfaces

Regardons d'abord un exemple, https://github.com/open-telemetry/opentelemetry-go/blob/exporters/trace/zipkin/v0.20.1/exporters/trace/zipkin/zipkin.go Ce fichier contient la ligne suivante de code :

var (
	_ sdktrace.SpanExporter = &Exporter{}
)

Cette ligne de code crée une variable anonyme (nommée _) et tente de lui attribuer &Exporter{}. Étant donné que le type de _ est sdktrace.SpanExporter, si l'exportateur n'implémente pas toutes les méthodes de l'interface sdktrace.SpanExporter, cette ligne de code échouera au moment de la compilation, fournissant ainsi un mécanisme de vérification de type statique pour vérifier l'exportateur au moment de la compilation. Indique si l'interface sdktrace.SpanExporter est implémentée.

Il s'agit d'un modèle courant, en particulier lorsqu'il s'agit d'interfaces et de types, pour garantir que votre type implémente l'interface que vous attendez. L'avantage de cette approche est qu'elle n'introduit pas de surcharge d'exécution supplémentaire, car la variable _ est un identifiant spécial dans Go et ne fait pas référence ni n'alloue de mémoire. Ce mode ne crée ni n'utilise de variables réelles, il est simplement vérifié au moment de la compilation, il n'y a donc pas lieu de s'inquiéter de l'impact sur les performances d'exécution du programme.