Apakah pembolehubah dalam bahasa Go

Dalam bahasa Go, pembolehubah ialah jumlah yang boleh diubah (ubah suai) kandungan semasa menjalankan program; memori, yang boleh didapati oleh nilai pembolehubah nama pembolehubah. Fungsi pembolehubah adalah untuk menyimpan data pengguna Ia adalah konsep abstrak dalam bahasa komputer yang boleh menyimpan hasil pengiraan atau mewakili nilai.

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

1. Gambaran Keseluruhan

Pembolehubah ialah jumlah yang boleh diubah (ubah suai) semasa program dijalankan; Unit asas ialah perwakilan ruang penyimpanan data dalam ingatan Nilai pembolehubah boleh didapati melalui nama pembolehubah.

Fungsi pembolehubah adalah untuk menyimpan data pengguna Ia adalah konsep abstrak dalam bahasa komputer yang boleh menyimpan hasil pengiraan atau mewakili nilai.

Pembolehubah ialah proses mencari nilai melalui pengecam pembolehubah. Demonstrasi simulasi memori pembolehubah:

2 Definisi: pengisytiharan dan permulaan

Takrifkan pembolehubah menggunakan var. Kata kunci, jenisnya perlu ditentukan dan boleh dimulakan pada masa yang sama Jika tiada nilai pemulaan dinyatakan, nilai lalai jenis digunakan adalah seperti berikut:

// 声明变量，未初始化（默认值初始化）
var name string
// 声明变量，特定值初始化
var user string = "Hank"

Pembolehubah dalam bahasa Go mesti diisytiharkan Ia hanya boleh digunakan kemudian.

3. Taip nilai lalai (nilai sifar)

Nilai lalai jenis bahasa Go adalah seperti berikut: Integer dan float Nilai lalai untuk pembolehubah mata ialah 0. Nilai lalai pembolehubah rentetan ialah rentetan kosong. Pembolehubah Boolean lalai kepada bool. Nilai lalai untuk pembolehubah hirisan, fungsi dan penunjuk ialah sifar.

4 Penaipan yang kuat

Bahasa Go ialah bahasa yang ditaip kuat, pembolehubah mesti mempunyai jenis dan pembolehubah hanya boleh menyimpan jenis data tertentu. . [Cadangan berkaitan: Pergi tutorial video]

5 Taipkan inferens

Apabila mentakrifkan pembolehubah, jika permulaan. adalah nilai yang ditentukan, anda boleh meninggalkan definisi jenis dan bahasa Go boleh menyimpulkan jenis daripada data itu sendiri. Sintaksnya ialah:

// 声明变量，特定值初始化，类型推导出user为字符串string型
var user = "Hank"

6. Pengisytiharan ringkas (takrif)

Untuk memudahkan definisi bagi pembolehubah, gunakan operasi Simbol:= bekerjasama dengan terbitan jenis untuk melengkapkan definisi pembolehubah dengan cepat Sintaksnya ialah:

user := "hank"

7. Definisi kelompok <. 🎜>

Gunakan var atau := untuk mentakrifkan berbilang pembolehubah sekaligus. >

var

Adalah disyorkan untuk menggunakan sintaks blok pengisytiharan var() kerana penyelenggaraan kod adalah mudah.

var (
  v1 = 42
  v2 = "hank"
  )
也可以
var v1, v2 = 42, "hank"

:=8 Tugasan kelompok

v1, v2 := 42, "hank"

Tetapkan nilai kepada berbilang pembolehubah pada satu masa. (Serupa dengan definisi pendek. v1, v2, v3 := 42, "hank", false) Selepas pembolehubah ditakrifkan, tetapkan nilai kepada mereka dalam kelompok Tiada fungsi definisi! Sintaksnya ialah:

Sintaks ini biasanya digunakan dengan kumpulan pulangan fungsi untuk menerima berbilang nilai pulangan sekali gus Sintaksnya ialah:

Sangat mudah untuk menukar nilai dua pembolehubah:

var (
  v1 int
  v2 int
)
// 批量赋值
v1, v2 = 42, 1024

Selepas pelaksanaan, v1==1024, v2==42

func main() {
  var (
    v1 int
    v2 int
  )
  // 调用函数，接收其返回值
  v1, v2 = getData()
}
// 返回两个值的函数
func getData() (int, int) {
  // 返回了两个值（假设42为最小值，1024为最大值）
  return 42, 1024
}

9. , yang dipanggil ialah pembolehubah tanpa nama. Fungsinya ialah pemegang tempat pembolehubah dan struktur diberikan kepada pembolehubahnya. Biasanya digunakan semasa tugasan kelompok. Sebagai contoh, jika fungsi mengembalikan berbilang nilai dan kami hanya memerlukan sebahagian daripadanya, maka gunakan _ untuk menduduki tempat yang tidak diperlukan:

var (
  v1 = 42
  v2 = 1024
)
// 交换
v1, v2 = v2, v1

<. 🎜>

10. Skop Pembolehubah

Pembolehubah dalam bahasa Go adalah berskop blok. Sekatan merujuk kepada segmen kod yang ditakrifkan menggunakan {}, termasuk fungsi, if/switch/for statement, atau {} bebas adalah semua blok. Pembolehubah yang ditakrifkan dalam blok hanya tersedia dalam blok ini. Definisi merujuk kepada pembolehubah yang ditakrifkan oleh var atau :=. Skop bahasa Go adalah melata, yang bermaksud bahawa blok dalam boleh mengakses terus pembolehubah blok luar, dengan syarat blok dalam tidak mentakrifkan pembolehubah luar dengan nama yang sama. Demonstrasi adalah seperti berikut:

上面代码中： 在main()中，v2，v3被重新定义，则在main()中，v1是外部，而v2, v3是main函数局部的。 在main()内部的{}中，v3被重新定义，则在main()内部的{}中，v1是外部，而v2是main()定义的, v3是main()内部{}定义的的。

变量可以沿内部作用域向外部作用域查找变量的过程。

带有{}的语句，其中的变量也仅仅在内部有效，例如for，if，switch等，演示：

for i := 0; i < 10; i++ {
  fmt.Println(i)
}
fmt.Println(i)
// 会提示变量i未定义, undefined: i

注意i，是通过短声明在for内部定义的变量，仅仅在for内部有意义。

互不嵌套的{}见作用域不可见，不可互相访问。

func main() {
  {
    v := 42
  }
  {
    fmt.Println(v)
    // 会提示变量v未定义, undefined: v
  }
}

更多编程相关知识，请访问：编程教学！！

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