Apakah kaedah pengisytiharan berubah dalam bahasa go?

Kaedah pengisytiharan pembolehubah ialah: 1. Gunakan var untuk mengisytiharkan pembolehubah dan menunjukkan jenis data pembolehubah Sintaks ialah "var variable name type = expression" 2. Gunakan aksara ":=" untuk buat pengisytiharan pembolehubah pendek , sintaks "nama pembolehubah:= ungkapan". Apabila menggunakan pengisytiharan pembolehubah pendek, anda boleh meninggalkan kata kunci var dan jenis maklumat Jenis lalai pembolehubah ialah bool, rune, int, float64, complex128 atau rentetan.

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

Ciri penting pembelajaran bahasa statik adalah berbeza daripada bahasa dinamik: perisytiharan berubah-ubah.

Bagaimanakah pengkompil atau penterjemah bahasa pengaturcaraan mengetahui sempadan kawasan memori yang boleh dirujuk oleh pembolehubah?

Bahasa dinamik dan bahasa statik mempunyai kaedah pemprosesan yang berbeza:

• Penterjemah bahasa dinamik (seperti Python, Ruby, dll.) boleh memberikan nilai kepada pembolehubah semasa Analisis masa, secara automatik menentukan sempadan pembolehubah. Dan dalam bahasa dinamik, pembolehubah boleh diberikan sempadan saiz yang berbeza pada masa jalan.

• Bahasa pengaturcaraan statik mempunyai "pengalaman yang lebih teruk" dalam hal ini. Pengkompil bahasa yang ditaip secara statik mesti mengetahui dengan jelas sempadan pembolehubah sebelum dibenarkan menggunakan pembolehubah ini, tetapi pengkompil bahasa statik tidak mempunyai keupayaan untuk memberikan maklumat ini secara automatik. Maklumat sempadan ini mesti disediakan oleh pengguna bahasa tersebut , jadi terdapat pernyataan "pembolehubah"". Melalui pengisytiharan pembolehubah, pengguna bahasa boleh memberitahu pengkompil secara eksplisit maklumat sempadan pembolehubah. Pada peringkat pelaksanaan khusus, maklumat sempadan ini diberikan oleh atribut jenis pembolehubah.

Sebagai bahasa dalam kem bahasa pengaturcaraan statik, bahasa Go mengikut keperluan bahasa statik ini: pembolehubah perlu diisytiharkan sebelum menggunakannya.

[golang] Pengisytiharan pembolehubah dan pemulaan var, :=, new() dan make()

Bahasa Go menyediakan pelbagai kaedah pengisytiharan pembolehubah dan kaedah permulaan. Di sini kami fokus untuk menerangkannya satu persatu. Dan berikan panduan mudah.

Garis Panduan

• Gunakan make() untuk memulakan slice, map dan channel.
• Dalam kebanyakan kes, apabila jenisnya jelas, gunakan pengisytiharan pembolehubah pendekkaedah:=.
• Apabila memulakan pembolehubah menggunakan teks dan jenisnya perlu ditentukan, gunakan kaedah varpengisytiharan pembolehubah.
• Elakkan menggunakan new() melainkan anda memerlukan pembolehubah penunjuk.

Kaedah pengisytiharan pembolehubah

Bahasa Go boleh menggunakan var untuk mengisytiharkan pembolehubah dan menunjukkan jenis data pembolehubah.

	// 初始化整数变量，值为10。
	var v int = 10
	fmt.Println(v)
	// 输出: 10

	// 变量声明: 一个slice变量
	var vSlice []int = []int{1, 2, 3, 4}
	fmt.Println(vSlice, "type: ", reflect.TypeOf(vSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	var vMap map[string]int = map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(vMap)
	// 输出: map[a:1 b:2]

Pengisytiharan pembolehubah pendek

pengisytiharan pembolehubah pendek Simbol: :=.

Apabila pembolehubah pendek diisytiharkan, jenis lalai pembolehubah ialah: bool, rune, int, float64, complex128 atau string

	// 短变量声明: 一个整数变量。
	sdvInt := 10
	fmt.Println(sdvInt, "type: ", reflect.TypeOf(sdvInt).Kind())
	// 输出: 10 type:  int

	// 短变量声明: 一个slice变量
	sdvSlice := []int{1, 2, 3, 4}
	fmt.Println(sdvSlice, "type: ", reflect.TypeOf(sdvSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	sdvMap := map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(sdvMap)
	// 输出: map[a:1 b:2]

baharu(T)

: new(T)

Peruntukkan memori mengikut jenis T
• Tetapkan memori kepada 0
• Mengembalikan penuding ke ingatan

	// 初始化一个整数指针变量，指向的值为0
	var i3 *int = new(int)
	fmt.Println(*i3)

	// 初始化一个slice指针变量
	var i4 = new([10]int)[0:5]
	fmt.Println(i4, "type: ", reflect.TypeOf(i4).Kind())
	// 输出: [0 0 0 0 0] type: slice

	// 初始化一个map指针变量，指向的值为[]
	var i5 *map[string]int = new(map[string]int)
	fmt.Println(*i5)
	// 输出: map[]

	// 初始化一个chan指针变量，指向的值为nil
	var i6 *chan int = new(chan int)
	fmt.Println(*i6)
	// 输出: nil

make()

make hanya digunakan untuk permulaan

, slice dan map. channel

	// make只能用于创建slice, map, channel
	// 切片类型(slice)
	makeSlice := make([]int, 5, 10)
	fmt.Println(makeSlice)
	// 输出: [0 0 0 0 0]

	// Map 类型
	var makeMap map[string]int = make(map[string]int)
	fmt.Println(makeMap)
	// 输出: map[]

	// Channel 类型
	var makeChan chan int32 = make(chan int32, 100)
	fmt.Println(makeChan)
	// 输出: 0xc000112000

Kod sumber lengkap

package main

import (
	"fmt"
	"reflect"
)

func main() {

	// 初始化整数变量，值为10。
	var v int = 10
	fmt.Println(v)
	// 输出: 10

	// 变量声明: 一个slice变量
	var vSlice []int = []int{1, 2, 3, 4}
	fmt.Println(vSlice, "type: ", reflect.TypeOf(vSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	var vMap map[string]int = map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(vMap)
	// 输出: map[a:1 b:2]

	// 短变量声明: 一个整数变量。
	sdvInt := 10
	fmt.Println(sdvInt, "type: ", reflect.TypeOf(sdvInt).Kind())
	// 输出: 10 type:  int

	// 短变量声明: 一个slice变量
	sdvSlice := []int{1, 2, 3, 4}
	fmt.Println(sdvSlice, "type: ", reflect.TypeOf(sdvSlice).Kind())
	// 输出: [1 2 3 4] type: slice

	// 短变量声明: 一个map变量，指向的值为[]
	sdvMap := map[string]int{
		"a": 1,
		"b": 2,
	}
	fmt.Println(sdvMap)
	// 输出: map[a:1 b:2]

	// 初始化一个整数指针变量，指向的值为0
	var newInt *int = new(int)
	fmt.Println(*newInt)

	// 初始化一个slice指针变量
	var newSlice = new([10]int)[0:5]
	fmt.Println(newSlice, "type: ", reflect.TypeOf(newSlice).Kind())
	// 输出: [0 0 0 0 0] type: slice

	// 初始化一个map指针变量，指向的值为[]
	var newMap *map[string]int = new(map[string]int)
	fmt.Println(*newMap)
	// 输出: map[]

	// 初始化一个chan指针变量，指向的值为nil
	var newChan *chan int = new(chan int)
	fmt.Println(*newChan)
	// 输出: nil

	// make只能用于创建slice, map, channel
	// 切片类型(slice)
	makeSlice := make([]int, 5, 10)
	fmt.Println(makeSlice)
	// 输出: [0 0 0 0 0]

	// Map 类型
	var makeMap map[string]int = make(map[string]int)
	fmt.Println(makeMap)
	// 输出: map[]

	// Channel 类型
	var makeChan chan int32 = make(chan int32, 100)
	fmt.Println(makeChan)
	// 输出: 0xc000112000

}

[Cadangan berkaitan:

Pergi tutorial video, Pengajaran Pengaturcaraan】

Atas ialah kandungan terperinci Apakah kaedah pengisytiharan berubah dalam bahasa go?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!