Go - Règles de portée

Une portée dans toute programmation est une région du programme où une variable définie peut exister et au-delà de laquelle la variable ne peut pas être accédée. Il y a trois endroits où les variables peuvent être déclarées dans le langage de programmation Go -

À l'intérieur d'une fonction ou d'un bloc (local variables)
En dehors de toutes les fonctions (global variables)
Dans la définition des paramètres de fonction (formal paramètres)

Découvrons ce que sont local et global variables et que sont formal paramètres.

Variables locales

Les variables déclarées à l'intérieur d'une fonction ou d'un bloc sont appelées variables locales. Ils ne peuvent être utilisés que par des instructions qui se trouvent à l'intérieur de cette fonction ou de ce bloc de code. Les variables locales ne sont pas connues pour fonctionner en dehors des leurs. L'exemple suivant utilise des variables locales. Ici, toutes les variables a, b et c sont locales à la fonction main ().

package main

import "fmt"

func main() {
   /* local variable declaration */
   var a, b, c int 

   /* actual initialization */
   a = 10
   b = 20
   c = a + b

   fmt.Printf ("value of a = %d, b = %d and c = %d\n", a, b, c)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of a = 10, b = 20 and c = 30

Variables globales

Les variables globales sont définies en dehors d'une fonction, généralement au-dessus du programme. Les variables globales conservent leur valeur pendant toute la durée de vie du programme et elles sont accessibles à l'intérieur de n'importe laquelle des fonctions définies pour le programme.

Une variable globale est accessible par n'importe quelle fonction. Autrement dit, une variable globale est disponible pour une utilisation dans tout le programme après sa déclaration. L'exemple suivant utilise à la fois des variables globales et locales -

package main

import "fmt"
 
/* global variable declaration */
var g int
 
func main() {
   /* local variable declaration */
   var a, b int

   /* actual initialization */
   a = 10
   b = 20
   g = a + b

   fmt.Printf("value of a = %d, b = %d and g = %d\n", a, b, g)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of a = 10, b = 20 and g = 30

Un programme peut avoir le même nom pour les variables locales et globales mais la valeur de la variable locale à l'intérieur d'une fonction a la préférence. Par exemple -

package main

import "fmt"
 
/* global variable declaration */
var g int = 20
 
func main() {
   /* local variable declaration */
   var g int = 10
 
   fmt.Printf ("value of g = %d\n",  g)
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of g = 10

Paramètres formels

Les paramètres formels sont traités comme des variables locales dans cette fonction et ils ont la préférence sur les variables globales. Par exemple -

package main

import "fmt"
 
/* global variable declaration */
var a int = 20;
 
func main() {
   /* local variable declaration in main function */
   var a int = 10
   var b int = 20
   var c int = 0

   fmt.Printf("value of a in main() = %d\n",  a);
   c = sum( a, b);
   fmt.Printf("value of c in main() = %d\n",  c);
}
/* function to add two integers */
func sum(a, b int) int {
   fmt.Printf("value of a in sum() = %d\n",  a);
   fmt.Printf("value of b in sum() = %d\n",  b);

   return a + b;
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

value of a in main() = 10
value of a in sum() = 10
value of b in sum() = 20
value of c in main() = 30

Initialisation des variables locales et globales

Les variables locales et globales sont initialisées à leur valeur par défaut, qui est 0; tandis que les pointeurs sont initialisés à nil.

Type de données	Valeur par défaut initiale
int	0
float32	0
aiguille	néant