Portées Locales et Globales

À ce stade, il est essentiel d'approfondir le concept de portées pour comprendre les zones où des variables spécifiques (ou constantes) peuvent être accessibles et où elles ne le peuvent pas.

La portée d'une variable ou d'une constante définit où elle peut être utilisée.

Lorsqu'une variable ou une constante est déclarée en dehors de tout bloc de code, elle devient accessible dans tout le programme, ce qui lui vaut le label de portée globale. Dans l'extrait de code suivant, la constante pi illustre cette portée globale :

index


              12345678
            
package main
import "fmt"

const pi float32 = 3.1415

func main() {
      fmt.Println(pi)
}

Inversement, lorsqu'une variable ou une constante est déclarée à l'intérieur d'un bloc de code, elle reste accessible uniquement dans ce bloc de code spécifique et dans tous les blocs de code imbriqués, le cas échéant.

L'illustration ci-dessous délimite les distinctions entre les portées globales et locales :

Le code suivant démontre les zones où l'accès aux variables est autorisé et où des erreurs peuvent survenir :

index


              12345678910111213141516171819202122232425262728
            
package main
import "fmt"

func main() {
      var value_1 int = 1
     
      // Condition 1
      if(true) {
            var value_2 int = 2
           
            // Condition 2
            if (true) {
                  var value_3 int = 3
                 
                  fmt.Println("In Condition 2:", value_1)      
                  fmt.Println("In Condition 2:", value_2)
                  fmt.Println("In Condition 2:", value_3)
            }
           
            fmt.Println("In Condition 1:", value_1)
            fmt.Println("In Condition 1:", value_2)
            fmt.Println("In Condition 1:", value_3) // Error here
      }
     
      fmt.Println("In Main:", value_1)
      fmt.Println("In Main:", value_2) // Error here
      fmt.Println("In Main:", value_3) // Error here
}

La variable value_1 reste accessible tout au long du bloc de code main(), y compris dans les blocs de code imbriqués comme Condition 1 et Condition 2. Elle est également accessible dans la Condition 1 et sa Condition 2 imbriquée.

Cependant, tenter de l'accéder directement en dehors du bloc main() entraînera une erreur. De même, la variable value_2, déclarée dans la Condition 2, n'est accessible que dans ce bloc de code spécifique.

Il est crucial de considérer les portées dans le contexte des fonctions. Lorsque nous déclarons une variable ou une constante dans une fonction, elle reste confinée à cette fonction et est inaccessible dans d'autres fonctions, y compris main().

Remarque

main() fonctionne comme une fonction exécutée automatiquement lorsque le programme est lancé.

index


              12345678
            
func myFunc() {
      var number int = 7
      fmt.Println(number) // Accessible here
}

func main() {
      fmt.Println(number) // Not accessible here
}

Un autre point crucial à garder à l'esprit est que nous ne pouvons pas déclarer deux ou plusieurs variables avec le même nom dans le même scope ou dans des scopes qui se chevauchent.

index


              1234567891011
            
func myFunc1() {
      var number int = 7
      var number int = 9 // Error here
}

func myFunc2() {
      var number int = 7
      if(2 > 1) {
            var number int = 9 // Error here
      }
}

Cependant, il est possible de déclarer des variables avec le même nom dans des scopes différents:

index


              1234567891011121314151617
            
package main
import "fmt"

func myFunc1() {
      var number int = 7
      fmt.Println("In Func 1:", number)
}

func myFunc2() {
      var number int = 9
      fmt.Println("In Func 2:", number)
}

func main() {
      myFunc1()
      myFunc2()
}

Tout était clair ?

Merci pour vos commentaires !

Section 4. Chapitre 2