Cara jenis pembolehubah berbeza ditakrifkan di Golang

Cara untuk mentakrifkan jenis pembolehubah yang berbeza di Golang memerlukan contoh kod khusus

Di Golang, kita boleh menggunakan cara yang berbeza untuk menentukan jenis pembolehubah yang berbeza. Artikel ini akan memperkenalkan cara untuk menentukan beberapa jenis pembolehubah biasa di Golang dan memberikan contoh kod yang sepadan.

1. Pembolehubah integer (int)
Pembolehubah integer dalam Golang boleh digunakan untuk menyimpan nilai integer Ia ditakrifkan seperti berikut:

var num int // Isytiharkan pembolehubah integer bernama num
num = 10 //Tugasan
. .Println(num) //Output: 10

2. Pembolehubah titik terapung (float)
Pembolehubah titik terapung dalam Golang boleh digunakan untuk menyimpan nilai sebenar, dan definisinya adalah seperti berikut:

var num float64 // Isytiharkan a pembolehubah titik terapung bernama num
num = 3.14 // Tetapkan nilai
fmt.Println(num) // Output: 3.14

3 Pembolehubah Boolean (bool)
Boolean dalam Pembolehubah jenis Golang digunakan untuk menyimpan nilai benar dan salah, dan ditakrifkan seperti berikut:

var flag bool // Isytiharkan pembolehubah Boolean bernama flag
flag = true // Berikan nilai
fmt.Println(flag) // Output: true

4 pembolehubah dalam Golang digunakan untuk menyimpan jujukan aksara. Ia ditakrifkan seperti berikut:

var str string // Isytiharkan pembolehubah rentetan bernama str

str = "Hello World" // Tugasan
fmt.Println(str) // Output: Hello World

5 Pembolehubah tatasusunan (tatasusunan)

Susun tatasusunan dalam Golang ialah jujukan unsur-unsur jenis yang sama panjang tetap, dan ditakrifkan seperti berikut Ditunjukkan:

var arr [5]int // Isytiharkan tatasusunan integer bernama arr dengan panjang 5

arr = [5]int{1, 2, 3, 4, 5} // Berikan nilai
fmt(arr) // Output: [1 2 3 4 5]

. 6. Slice variable (slice)

Slice dalam Golang ialah rujukan kepada array dan boleh berkembang secara dinamik Ia ditakrifkan seperti berikut:

var sli []int // Nyatakan kepingan integer bernama sli

sli = []int. {1, 2, 3} // Berikan nilai
fmt.Println(sli) // Output: [1 2 3]

7 .Pembolehubah kamus (peta)

Kamus di Golang ialah koleksi pasangan nilai kunci yang tidak tertib , yang ditakrifkan seperti berikut:

var m map[string]int // Isytiharkan rentetan bernama m kepada int Kamus

m = map[string]int{"a": 1, "b": 2} // Tugasan
fmt.Println(m) // Output: map[a:1 b:2]

8 Pembolehubah struktur (struct)

Struktur dalam Golang ialah jenis data tersuai yang boleh menggabungkan medan yang berbeza :

type Person struct {

Name string
Age  int

}

var p Person // Isytiharkan pembolehubah struktur Person bernama p

p = Person{Name: "Tom", Umur: 20} // Assignment
fmt.Println(p) // Output: {Tom 20}

9. Pembolehubah penunjuk (penunjuk)

Pembolehubah penunjuk dalam Golang digunakan untuk menyimpan alamat memori yang menunjuk ke pembolehubah lain ia ditakrifkan seperti berikut:

var ptr *int // Isytiharkan integer. pembolehubah penunjuk bernama ptr

num := 10
ptr = &num // Tugasan
fmt.Println(ptr) // Output: 0xc000014088

Di atas ialah kaedah takrifan beberapa jenis pembolehubah biasa di Golang dan contoh kod yang sepadan. Melalui contoh-contoh ini, kita boleh lebih memahami dan menggunakan pelbagai jenis pembolehubah di Golang. Semoga artikel ini dapat membantu anda.

Atas ialah kandungan terperinci Cara jenis pembolehubah berbeza ditakrifkan di Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!