Impara Ambiti Locali e Globali

A questo punto, è fondamentale approfondire il concetto di scope per comprendere le aree in cui variabili (o costanti) specifiche possono essere accessibili e dove non lo sono.

Lo scope di una variabile o costante definisce dove essa può essere utilizzata.

Quando una variabile o costante viene dichiarata al di fuori di qualsiasi blocco di codice, diventa accessibile in tutto il programma, acquisendo così lo scope globale. Nel seguente esempio di codice, la costante pi rappresenta questo scope globale:

index.go


              12345678
            
package main
import "fmt"

const pi float32 = 3.1415

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

Al contrario, quando una variabile o una costante viene dichiarata all'interno di un blocco di codice, essa rimane accessibile esclusivamente all'interno di quel blocco di codice specifico e di eventuali blocchi di codice annidati, se presenti.

L'illustrazione sottostante delinea le differenze tra gli ambiti globale e locale:

Il codice seguente mostra le aree in cui è consentito l'accesso alle variabili e dove possono verificarsi errori:

index.go


              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 variabile value_1 rimane accessibile all'interno del blocco di codice main(), inclusi i blocchi di codice annidati come Condizione 1 e Condizione 2. È inoltre accessibile all'interno della Condizione 1 e della sua Condizione 2 annidata.

Tuttavia, tentare di accedervi direttamente al di fuori del blocco main() genererà un errore. Allo stesso modo, la variabile value_2, dichiarata all'interno della Condizione 2, è accessibile solo in quello specifico blocco di codice.

È fondamentale considerare gli ambiti nel contesto delle funzioni. Quando dichiariamo una variabile o una costante all'interno di una funzione, essa rimane confinata a quella funzione e non è accessibile da altre funzioni, incluso main().

Nota

main() funziona come una funzione eseguita automaticamente quando il programma viene avviato.

index.go


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

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

Un altro punto fondamentale da tenere a mente è che non è possibile dichiarare due o più variabili con lo stesso nome all'interno dello stesso ambito o di ambiti sovrapposti.

index.go


              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
      }
}

Tuttavia, è possibile dichiarare variabili con lo stesso nome in ambiti diversi:

index.go


              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()
}

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 4. Capitolo 2

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Suggested prompts:

Can you explain the difference between global and local scope with an example?

What happens if I try to access a variable outside its scope?

Can you clarify what is meant by overlapping scopes?

Awesome!

Completion rate improved to 1.96

Scorri per mostrare il menu

A questo punto, è fondamentale approfondire il concetto di scope per comprendere le aree in cui variabili (o costanti) specifiche possono essere accessibili e dove non lo sono.

Lo scope di una variabile o costante definisce dove essa può essere utilizzata.

index.go


              12345678
            
package main
import "fmt"

const pi float32 = 3.1415

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

L'illustrazione sottostante delinea le differenze tra gli ambiti globale e locale:

Il codice seguente mostra le aree in cui è consentito l'accesso alle variabili e dove possono verificarsi errori:

index.go


              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
}

Nota

main() funziona come una funzione eseguita automaticamente quando il programma viene avviato.

index.go


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

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

Un altro punto fondamentale da tenere a mente è che non è possibile dichiarare due o più variabili con lo stesso nome all'interno dello stesso ambito o di ambiti sovrapposti.

index.go


              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
      }
}

Tuttavia, è possibile dichiarare variabili con lo stesso nome in ambiti diversi:

index.go


              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()
}

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 4. Capitolo 2