Terdapat beberapa jenis pembolehubah dalam bahasa Go

Terdapat tiga jenis pembolehubah: 1. Pembolehubah yang ditakrifkan dalam fungsi dipanggil pembolehubah tempatan, dan skopnya terhad kepada bahagian dalam fungsi itu tidak selalu wujud, ia hanya wujud selepas fungsi yang mentakrifkan mereka dipanggil. Pembolehubah tempatan ini akan dimusnahkan selepas panggilan fungsi tamat. 2. Pembolehubah yang ditakrifkan di luar fungsi dipanggil pembolehubah global Ia hanya perlu ditakrifkan dalam satu fail sumber dan boleh digunakan dalam semua fail sumber, pengisytiharan pembolehubah global mesti bermula dengan kata kunci var dalam pakej luaran Huruf pertama pembolehubah mesti ditulis dengan huruf besar. 3. Pembolehubah dalam definisi fungsi dipanggil parameter formal.

Persekitaran pengendalian tutorial ini: sistem Windows 7, GO versi 1.18, komputer Dell G3.

Bahasa Go ialah bahasa yang ditaip secara statik, jadi pembolehubah mempunyai jenis yang jelas, dan pengkompil juga akan menyemak ketepatan jenis pembolehubah. Dalam matematik, pembolehubah mewakili nombor yang tidak mempunyai nilai tetap dan boleh diubah. Tetapi dari perspektif pelaksanaan sistem komputer, pembolehubah ialah satu atau lebih segmen memori yang digunakan untuk menyimpan data.

Pembolehubah (malar, jenis atau fungsi) mempunyai skop tertentu dalam atur cara, yang dipanggil skop.

Memahami skop pembolehubah adalah lebih penting untuk kita mempelajari bahasa Go, kerana bahasa Go akan menyemak sama ada setiap pembolehubah telah digunakan semasa penyusunan Apabila pembolehubah yang tidak digunakan muncul, ralat kompilasi akan dilaporkan. Jika anda tidak dapat memahami skop pembolehubah, ia mungkin menyebabkan beberapa ralat kompilasi yang tidak dapat dijelaskan.

Mengikut lokasi definisi pembolehubah, ia boleh dibahagikan kepada tiga jenis berikut:

• Pembolehubah yang ditakrifkan dalam fungsi dipanggil pembolehubah tempatan

• Pembolehubah yang ditakrifkan di luar fungsi dipanggil pembolehubah global

• Pembolehubah dalam definisi fungsi dipanggil parameter formal

The berikut adalah perbezaan Biar saya perkenalkan.

Pembolehubah setempat

Pembolehubah yang diisytiharkan/ditakrifkan di dalam fungsi dipanggil pembolehubah tempatan dan skop pembolehubah tempatan dihadkan kepada bahagian dalam fungsi. Pembolehubah yang ditakrifkan di dalam fungsi, parameter dan nilai pulangan fungsi, pembolehubah yang digunakan di dalam jika dan untuk struktur, dsb. adalah semua pembolehubah tempatan.

Pembolehubah setempat tidak selalu wujud selepas fungsi yang mentakrifkannya dipanggil Pembolehubah tempatan ini akan dimusnahkan selepas panggilan fungsi tamat.

[Contoh] Fungsi utama() berikut menggunakan pembolehubah setempat a, b dan c.

package main
import (
    "fmt"
)
func main() {
    //声明局部变量 a 和 b 并赋值
    var a int = 3
    var b int = 4
    //声明局部变量 c 并计算 a 和 b 的和
    c := a + b
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

Gunakan {} untuk mengehadkan skop pembolehubah

package main
import "fmt"
func main() {
	{
		name := "HaiCoder"
		fmt.Println("Name =", name)
	}
}

Kami menggunakan {} untuk mengehadkan skop nama pembolehubah kepada {}, iaitu, skop nama pembolehubah pada masa ini hanya dalam {} dan nama ialah pembolehubah setempat.

Nota: Jika pembolehubah diakses di luar skop pembolehubah, program akan melaporkan ralat

package main
import "fmt"
func main() {
	for i := 0; i < 3; i++{
		fmt.Print(i)
		fmt.Print(" ")
	}
	fmt.Print(i)
}

Kami telah menentukan pembolehubah setempat i di dalam gelung for dan Use, pada masa ini skop pembolehubah i dihadkan kepada {} di dalam gelung for. Akhir sekali, apabila kita mengakses pembolehubah i di luar {} gelung for, atur cara melaporkan ralat kerana pembolehubah i melebihi skop.

Pembolehubah global

Pembolehubah yang diisytiharkan di luar fungsi dipanggil pembolehubah global hanya perlu ditakrifkan dalam fail sumber digunakan dalam semua fail sumber sudah tentu, fail sumber yang tidak mengandungi pembolehubah global ini perlu menggunakan kata kunci "import" untuk memperkenalkan fail sumber di mana pembolehubah global berada sebelum mereka boleh menggunakan pembolehubah global ini.

Pengisytiharan pembolehubah global mesti bermula dengan kata kunci var Jika anda ingin menggunakan pembolehubah global dalam pakej luaran, huruf pertama mesti menggunakan huruf besar.

[Contoh] Dalam kod berikut, baris 6 mentakrifkan pembolehubah global c.

package main
import "fmt"
//声明全局变量
var c int
func main() {
    //声明局部变量
    var a, b int
    //初始化参数
    a = 3
    b = 4
    c = a + b
    fmt.Printf("a = %d, b = %d, c = %d\n", a, b, c)
}

Nota: Nama pembolehubah global dan pembolehubah tempatan dalam program bahasa Go boleh sama, tetapi pembolehubah tempatan dalam badan fungsi akan diberi keutamaan.

package main
import "fmt"
//声明全局变量
var a float32 = 3.14
func main() {
    //声明局部变量
    var a int = 3
    fmt.Printf("a = %d\n", a)
}

Parameter formal

Apabila mentakrifkan fungsi, pembolehubah dalam kurungan selepas fungsi nama dipanggil Parameter formal (dirujuk sebagai parameter formal). Parameter formal hanya akan berkuat kuasa apabila fungsi dipanggil, dan akan dimusnahkan selepas panggilan fungsi selesai Apabila fungsi tidak dipanggil, parameter formal fungsi tidak menduduki unit storan sebenar dan tidak mempunyai nilai sebenar.

Parameter formal akan digunakan sebagai pembolehubah tempatan fungsi.

[Contoh] Baris 21 kod di bawah mentakrifkan parameter formal a dan b.

package main
import (
    "fmt"
)
//全局变量 a
var a int = 13
func main() {
    //局部变量 a 和 b
    var a int = 3
    var b int = 4
    fmt.Printf("main() 函数中 a = %d\n", a)
    fmt.Printf("main() 函数中 b = %d\n", b)
    c := sum(a, b)
    fmt.Printf("main() 函数中 c = %d\n", c)
}
func sum(a, b int) int {
    fmt.Printf("sum() 函数中 a = %d\n", a)
    fmt.Printf("sum() 函数中 b = %d\n", b)
    num := a + b
    return num
}

【相关推荐：Go视频教程、编程教学】

Atas ialah kandungan terperinci Terdapat beberapa jenis pembolehubah dalam bahasa Go. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!