Wie verschiedene Variablentypen in Golang definiert sind

Die Art und Weise, verschiedene Arten von Variablen in Golang zu definieren, erfordert spezifische Codebeispiele.

In Golang können wir verschiedene Methoden verwenden, um verschiedene Arten von Variablen zu definieren. In diesem Artikel wird erläutert, wie mehrere gängige Variablentypen in Golang definiert werden, und es werden entsprechende Codebeispiele bereitgestellt.

1. Integer-Variable (int)
Integer-Variablen in Golang können zum Speichern von Integer-Werten verwendet werden. Sie sind wie folgt definiert:

var num int // Deklarieren Sie eine Integer-Variable mit dem Namen num
num = 10 //Zuweisung
fmt .Println(num) //Ausgabe: 10

2. Gleitkommavariable (Float)
Gleitkommavariablen in Golang können zum Speichern realer Werte verwendet werden und ihre Definition lautet wie folgt:

var num float64 // Deklariere a Gleitkommavariable mit dem Namen num
num = 3.14 // Wert zuweisen
fmt.Println(num) // Ausgabe: 3.14

3. Boolesche Variable (bool)
Boolean in Golang-Typvariablen werden zum Speichern wahrer und falscher Werte verwendet. und sind wie folgt definiert:

var flag bool // Deklariere eine boolesche Variable mit dem Namen flag
flag = true // Wert zuweisen
fmt.Println(flag) // Ausgabe: true

4 Variablen in Golang werden zum Speichern von Zeichenfolgen verwendet. Sie sind wie folgt definiert:

var str string // Deklarieren Sie eine Zeichenfolgenvariable mit dem Namen str

str = „Hello World“ // Zuweisung
fmt.Println(str) // Ausgabe: Hallo Welt

5. Array-Variable (Array)

Ein Array in Golang ist eine Folge von Elementen fester Länge und gleichen Typs und ist wie folgt definiert. Gezeigt:

var arr [5]int // Deklarieren Sie ein ganzzahliges Array benannt arr mit einer Länge von 5

arr = [5]int{1, 2, 3, 4, 5} // Weisen Sie einen Wert zu
fmt(arr) // Ausgabe: [1 2 3 4 5]

6. Slice-Variable (Slice)

Ein Slice in Golang ist eine Referenz auf ein Array und kann dynamisch wachsen. Es ist wie folgt definiert:

var sli []int // Deklarieren Sie ein ganzzahliges Slice mit dem Namen sli

sli = []int {1, 2, 3} // Wert zuweisen
fmt.Println(sli) // Ausgabe: [1 2 3]

7 .Dictionary-Variable (Karte)

Ein Wörterbuch in Golang ist eine ungeordnete Sammlung von Schlüssel-Wert-Paaren , das wie folgt definiert ist:

var m map[string]int // Deklarieren Sie einen String mit dem Namen m für int Wörterbuch

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

8. Strukturvariable (Struktur)

Die Struktur in Golang ist ein benutzerdefinierter Datentyp, der verschiedene Felder kombinieren kann :

type Person struct {

Name string
Age  int

}

var p Person // Deklariere eine Personenstrukturvariable mit dem Namen p

p = Person{Name: „Tom“, Alter: 20} // Zuweisung
fmt.Println(p) // Ausgabe: {Tom 20}

9. Zeigervariable (Zeiger)

Zeigervariablen in Golang werden zum Speichern von Speicheradressen verwendet, die auf andere Variablen zeigen. Sie sind wie folgt definiert:

var ptr *int // Deklarieren Sie eine Ganzzahl Zeigervariable namens ptr

num := 10
ptr = &num // Zuweisung
fmt.Println(ptr) // Ausgabe: 0xc000014088

Das Obige sind die Definitionsmethoden einiger gängiger Variablentypen in Golang und die entsprechenden Codebeispiele. Anhand dieser Beispiele können wir verschiedene Arten von Variablen in Golang besser verstehen und verwenden. Ich hoffe, dieser Artikel kann für Sie hilfreich sein.

Das obige ist der detaillierte Inhalt vonWie verschiedene Variablentypen in Golang definiert sind. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!