Bagaimanakah Skop Pembolehubah dan Bayangan Berfungsi?

Skop Pembolehubah dan Bayangan dalam Go: Panduan Komprehensif

Dalam Go, memahami skop pembolehubah dan pembayang adalah penting untuk menulis kod yang bersih dan boleh diselenggara . Skop pembolehubah mentakrifkan keterlihatan pembolehubah dalam atur cara, manakala pembayangan merujuk kepada pengisytiharan semula pembolehubah dengan nama yang sama dalam skop bersarang.

Skop Pembolehubah dalam Go

Go menggunakan skop leksikal, bermakna skop pembolehubah ditentukan oleh kedudukannya dalam kod. Terdapat lima tahap skop berbeza:

• Blok alam semesta: Pengecam yang dipraisytiharkan (cth., benar, palsu)
• Blok pakej: pengecam diisytiharkan di peringkat atas
• Blok fail : nama pakej
• Badan fungsi: penerima kaedah, parameter fungsi dan hasil pembolehubah
• Skop blok: pemalar, pembolehubah dan jenis diisytiharkan dalam blok

Pembayangan Pembolehubah dalam Go

Pembayangan berlaku apabila pembolehubah dalam skop dalaman diisytiharkan dengan nama yang sama seperti pembolehubah dalam skop luar. Dalam kes sedemikian, pembolehubah dalam skop dalaman diutamakan dan membayangi pembolehubah luar.

Kelebihan Pembolehubah Skop dan Pembayang

• Integriti data : Data dalam skop luar tidak boleh diakses atau diubah suai secara tidak sengaja oleh pembolehubah dalam skop.
• Skop terhad: Pembolehubah boleh diskop kepada blok kod tertentu, mengurangkan risiko kesan sampingan daripada bahagian lain program.

Bentuk Berbeza Pembayang Pembolehubah

Dalam Go, pembayang boleh ubah boleh dicapai dalam beberapa cara:

• Menggunakan tugasan pendek dalam pernyataan:

  for i := 'a'; i 

• Menggunakan {...} pasangan:

  {
    i := "hi" //new local var
  }

• Menggunakan panggilan fungsi:

  func fun(i int) {
    i++ //use as local var without side effect
  }

• Membayang global pembolehubah:

  var i int = 1 //global
  func main() {
    i := 10 //Shadowing global var
  }

Sampel dan Contoh Kod

Skop Pembolehubah:

package main

func main() {
    i := 10 //scope: main
    fmt.Println(i) //output: 10
}

Dalam contoh ini, i diisytiharkan dalam fungsi utama dan hanya boleh diakses dalam fungsi tersebut fungsi.

Pembayangan Pembolehubah:

package main

func shadow() {
    x := 10 //shadowing global variable x
    fmt.Println(x) //output: 10
}

var x int = 1 //global variable

func main() {
    fmt.Println(x) //output: 1
    shadow()
}

Dalam contoh ini, pembolehubah global x dibayangi oleh pembolehubah tempatan x dalam fungsi bayang-bayang. Oleh itu, apabila x diakses di dalam fungsi bayang, ia merujuk kepada pembolehubah tempatan dengan nilai 10.

Atas ialah kandungan terperinci Bagaimanakah Skop Pembolehubah dan Bayangan Berfungsi?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!