Welche Methoden gibt es zur Variablendeklaration in der Go-Sprache?

Variablendeklarationsmethoden sind: 1. Verwenden Sie var, um eine Variable zu deklarieren und den Datentyp der Variablen anzugeben. Die Syntax lautet „var variable name type = expression“ 2. Verwenden Sie das Zeichen „:=", um eine kurze Variable zu erstellen Deklaration. Die Syntax lautet „Variablenname:=Ausdruck“. Wenn Sie eine kurze Variablendeklaration verwenden, können Sie das Schlüsselwort var und die Typinformationen weglassen. Der Standardtyp der Variablen ist bool, rune, int, float64, complex128 oder string.

Die Betriebsumgebung dieses Tutorials: Windows 7-System, GO Version 1.18, Dell G3-Computer.

Ein wichtiges Merkmal beim Erlernen statischer Sprachen unterscheidet sich von dynamischen Sprachen: Variablendeklaration.

Woher kennt der Compiler oder Interpreter einer Programmiersprache die Grenzen des Speicherbereichs, auf den eine Variable verweisen kann?

Dynamische Sprachen und statische Sprachen haben unterschiedliche Verarbeitungsmethoden:

• Der Interpreter dynamischer Sprachen (wie Python, Ruby usw.) kann die Grenzen von Variablen automatisch bestimmen, indem er Variablenzuweisungen zur Laufzeit analysiert . Und in dynamischen Sprachen können einer Variablen zur Laufzeit Grenzen unterschiedlicher Größe zugewiesen werden.

• Statische Programmiersprachen haben diesbezüglich eine „etwas schlechtere Erfahrung“ gemacht. Der statisch typisierte Sprachcompiler muss die Grenzen einer Variablen klar kennen, bevor er diese Variable verwenden darf, aber der statische Sprachcompiler ist nicht in der Lage, diese Informationen automatisch bereitzustellen. Diese Grenzinformationen müssen vom Benutzer der Sprache bereitgestellt werden , also gibt es eine „variable“ Anweisung“. Durch die Variablendeklaration können Sprachbenutzer dem Compiler explizit die Grenzinformationen einer Variablen mitteilen. Auf der spezifischen Implementierungsebene werden diese Grenzinformationen durch das Typattribut der Variablen angegeben.

Als Go-Sprache im Lager der statischen Programmiersprachen folgt sie dieser Anforderung statischer Sprachen: Variablen müssen vor ihrer Verwendung deklariert werden.

[golang] Variablendeklaration und Initialisierung var, :=, new() und make()

Die Go-Sprache bietet eine Vielzahl von Variablendeklarations- und Initialisierungsmethoden. Hier konzentrieren wir uns darauf, sie einzeln zu erklären. Und bieten Sie eine einfache Anleitung.

Guide

• Verwenden Sie make(), um slice, map und channel zu initialisieren. make()，来初始化slice，map 和channel 。
• 大多数场合，类型明确的场合下，使用短变量声明方式:=。
• 当使用文字方式初始化一个变量，并且需要指明类型时，使用var变量声明方式。
• 避免使用new()，除非你需要一个指针变量。

变量声明方式

go语言可以使用 var 来声明一个变量，并指明变量的数据类型。

	// 初始化整数变量，值为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]

短变量声明方式

short variable declarations 符号: :=。

短变量声明时，变量的默认类型是: bool, rune, int, float64, complex128 or 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]

new(T)

new(T)的特点：

• 根据类型T分配内存
• 设置内存为0
• 返回内存的指针

	// 初始化一个整数指针变量，指向的值为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只用于初始化 slice，map 和 channel

Wenn der Typ klar ist, verwenden Sie in den meisten Fällen die

kurze VariablendeklarationMethode :=. Wenn Sie eine Variable mit Literalmethoden initialisieren und den Typ angeben müssen, verwenden Sie die Methode varVariablendeklaration

.

Vermeiden Sie die Verwendung von new(), es sei denn, Sie benötigen eine Zeigervariable.

🎜So deklarieren Sie Variablen🎜🎜🎜🎜Die Go-Sprache kann var verwenden, um eine Variable zu deklarieren und den Datentyp der Variablen anzugeben. 🎜

	// 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

🎜🎜🎜Kurze Variablendeklarationen 🎜🎜🎜🎜Kurze Variablendeklarationen Symbol: :=. 🎜🎜Bei der Deklaration einer kurzen Variablen ist der Standardtyp der Variablen: bool, rune, int, float64</code >, <code>complex128 oder string🎜

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

}

🎜🎜🎜new(T)🎜🎜🎜🎜new(T) Features: 🎜🎜🎜Zugeordnet entsprechend T-Speicher eingeben 🎜🎜Speicher auf 0 setzen 🎜🎜Speicherzeiger zurückgeben 🎜🎜rrreee🎜🎜🎜make()🎜🎜🎜🎜make wird nur zum Initialisieren von slice, map und channel. 🎜rrreee🎜🎜🎜Vollständiger Quellcode🎜🎜🎜rrreee🎜[Verwandte Empfehlungen: 🎜Go-Video-Tutorial🎜, 🎜Programmierunterricht🎜]🎜

Das obige ist der detaillierte Inhalt vonWelche Methoden gibt es zur Variablendeklaration in der Go-Sprache?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!