Verstehen von Datentypen in Go

Tutorials

Einführung

Datentypen definieren die Art von Werten, die bestimmte Variablen bei der Schreibung eines Programms speichern können. Die Datentype bestimmt auch, welche Operationen mit den Daten ausgeführt werden können. In diesem Artikel gehen wir über die wichtigen Datentypen zurück, die Go zugrunde hat. Dies ist nicht eine umfassende Untersuchung der Datentypen, sondern helfen dir, ein bisschen mehr über die verfügbaren Optionen in Go zu lernen. Ein grundlegendes Verständnis einiger Basisdatentypen wird dir erlauben, deine Code schreiben zu können, der effizienter funktioniert.

Grundlagen

Hintergrund

Eine Methode, um sich über Datentypen zu denken, ist, sie als diejenigen zu betrachten, die wir im realen Leben benutzen: Beispielsweise sind Zahlen: wir können ganze Zahlen (0, 1, 2, …), Integer (-1, 0, 1, …) und Irrationale Zahlen (π) nutzen, zum Beispiel.

Im Allgemeinen können wir in der Mathematik Zahlen aus verschiedenen Typen zusammenaddieren und erhalten einen etwas Art Antwort. Wir können zum Beispiel 5 plus π addieren:

5 + π

Wir können entweder die Gleichung als Ergebnis halten, um die irrationelle Zahl zu berücksichtigen, oder π rund zu einem abkürzten Anzahl von Dezimalstellen runden und dann die Zahlen zusammenaddieren:

5 + π = 5 + 3.14 = 8.14

Aber, wenn wir beginnen, Zahlen mit einem anderen Datentyp zu bewerten, wie Wörter, beginnt es, weniger Sinn zu machen. Wie würden wir die folgende Gleichung lösen?

shark + 8

Für Computer sind jeder Datentyp ziemlich unterschiedlich – so wie Wörter und Zahlen. Infolgedessen müssen wir vorsichtig sein, wie wir verschiedene Datentypen verwenden, um Werte zuzuweisen, und wie wir sie durch Operationen manipulieren.

Ganze Zahlen

Wie in der Mathematik sind ganze Zahlen in der Programmierung ganze Zahlen, die positiv, negativ oder 0 sein können (…, -1, 0, 1, …). In Go wird eine ganze Zahl als int bezeichnet. Wie bei anderen Programmiersprachen sollten Sie keine Kommata in Zahlen mit vier oder mehr Ziffern verwenden, daher schreiben Sie 1.000 in Ihrem Programm als 1000.

Wir können eine ganze Zahl auf einfache Weise wie folgt ausgeben:

fmt.Println(-459)

Output-459

Oder wir können eine Variable deklarieren, die in diesem Fall ein Symbol der Zahl ist, die wir verwenden oder manipulieren, wie folgt:

var absoluteZero int = -459
fmt.Println(absoluteZero)

Output-459

Wir können auch mit ganzen Zahlen in Go rechnen. Im folgenden Codeblock verwenden wir den Zuweisungsoperator :=, um die Variable sum zu deklarieren und zu instantiieren:

sum := 116 - 68
fmt.Println(sum)

Output48

Wie das Ergebnis zeigt, hat der mathematische Operator - die ganze Zahl 68 von 116 subtrahiert, was zu 48 führt. Mehr über die Deklaration von Variablen erfahren Sie im Abschnitt Deklaration von Datentypen für Variablen.

In Go können Sie Zahlen auf viele Arten innerhalb von Programmen verwenden. Wie Sie fortfahren lernen, werden Sie viel Zeit mit Zahlen zu arbeiten und Ihr Wissen über diese Datentyp erweitern.

Zahlentypen

Eine Gleitpunktzahl oder ein Float wird verwendet, um reale Zahlen zu repräsentieren, die als Integer nicht ausgedrückt werden können. Reelle Zahlen umfassen alle rationale und irrationelle Zahlen, und wegen dieses sind Gleitpunktzahlen in einem Go-Programm ein Feld, das einen Dezimalpunkt enthält.Reelle ZahlenIn der Denkweise eines Floats im Go-Programm ist es eine Zahl, die einen Dezimalpunkt enthält.

Wie bei den ganzzahligen Typen können wir auch eine Gleitpunktzahl wie folgend drucken:

fmt.Println(-459.67)

Output-459.67

Wir können auch einen Variablen festlegen, die für einen Float steht, wie folgt:

absoluteZero := -459.67
fmt.Println(absoluteZero)

Output-459.67

So funktioniert das Mitmachen von Mathematik mit Gleitpunktzahlen in Go, wie bei ganzzahligen Typen:

var sum = 564.0 + 365.24
fmt.Println(sum)

Output929.24

Bei ganzzahligen und Gleitpunktzahlen ist es wichtig zu beachten, dass 3 ≠ 3.0, da 3 eine ganzzahlige Zahl ist, während 3.0 eine Gleitpunktzahl ist.

Größen der numerischen Typen

Neben der Unterscheidung zwischen Ganzzahlen und Gleitkommazahlen verfügt Go über zwei Arten numerischer Daten, die durch die statische oder dynamische Natur ihrer Größen unterschieden werden. Der erste Typ ist ein architekturunabhängiger Typ, was bedeutet, dass die Größe der Daten in Bits unverändert bleibt, unabhängig von der Maschine, auf der der Code ausgeführt wird.

Die meisten Systemarchitekturen heute sind entweder 32-Bit oder 64-Bit. Zum Beispiel könnten Sie für einen modernen Windows-Laptop entwickeln, auf dem das Betriebssystem auf einer 64-Bit-Architektur läuft. Wenn Sie jedoch für ein Gerät wie eine Fitness-Uhr entwickeln, arbeiten Sie möglicherweise mit einer 32-Bit-Architektur. Wenn Sie einen architekturunabhängigen Typ wie int32 verwenden, hat der Typ unabhängig von der Architektur, für die Sie kompilieren, eine konstante Größe.

Der zweite Typ ist ein implementierungsspezifischer Typ. Bei diesem Typ kann die Bitgröße je nach Architektur, für die das Programm erstellt wird, variieren. Wenn wir beispielsweise den int-Typ verwenden, wird bei der Go-Kompilierung für eine 32-Bit-Architektur die Datentypgröße 32 Bit betragen. Wenn das Programm für eine 64-Bit-Architektur kompiliert wird, beträgt die Variablengröße 64 Bit.

Neben Datentypen mit unterschiedlichen Größen gibt es auch ganzzahlige Typen in zwei grundlegenden Typen: vorzeichenbehaftete und vorzeichenlose. Ein int8 ist eine vorzeichenbehaftete Ganzzahl und kann Werte von -128 bis 127 haben. Ein uint8 ist eine vorzeichenlose Ganzzahl und kann nur positive Werte von 0 bis 255 haben.

Die Bereiche basieren auf der Bit-Größe. Für binäre Daten kann ein 8-Bit-Integer (z. B. int8) insgesamt 256 verschiedene Werte repräsentieren. Da ein int Typ sowohl positive als auch negative Werte benötigt, wird ein 8-Bit-Integer (-128 bis 127), insgesamt 256 unterschiedliche Werte haben.

Go hat die folgenden architektonisch-unabhängigen Integer-Typen:

uint8       unsigned  8-bit integers (0 to 255)
uint16      unsigned 16-bit integers (0 to 65535)
uint32      unsigned 32-bit integers (0 to 4294967295)
uint64      unsigned 64-bit integers (0 to 18446744073709551615)
int8        signed  8-bit integers (-128 to 127)
int16       signed 16-bit integers (-32768 to 32767)
int32       signed 32-bit integers (-2147483648 to 2147483647)
int64       signed 64-bit integers (-9223372036854775808 to 9223372036854775807)

Float und komplexe Zahlen kommen in unterschiedlichen Größen:

float32     IEEE-754 32-bit floating-point numbers
float64     IEEE-754 64-bit floating-point numbers
complex64   complex numbers with float32 real and imaginary parts
complex128  complex numbers with float64 real and imaginary parts

Es gibt auch ein paar Alias-Zahlentypen, die nützliche Namen zu bestimmten Datentypenassignieren:

byte        alias for uint8
rune        alias for int32

Die Zweck des byte Aliases ist, zu verdeutlichen, wenn dein Programm Bytes als gemeinsame Computermessung in Zeichenstringelementen verwendet, statt auf eine geringere Anzahl von Zahlen zu hören, die keinem Bytedatenmessung zugeordnet sind. Selbst wenn byte und uint8 nach der Kompilierung identisch sind, wird byte oft für Zeichendaten im numerischen Format verwendet, während uint8 dafür vorgesehen ist, einen Zahltyp zu verwenden, der nicht mit dem Bytedatenmessung verbunden ist.

Der runeAlias ist etwas anders. Während byte und uint8 genau dieselben Daten sind, kann ein rune ein Byte oder vier Bytes sein, eine Range, die durch den int32 festgelegt ist. Ein rune wird verwendet, um einen Unicode-Charakter darzustellen, während nur ASCII-Zeichen von einem int32 Datatype repräsentiert werden können.

Zusätzlich hat Go die folgenden Implementationspezifischen Typen:

uint     unsigned, either 32 or 64 bits
int      signed, either 32 or 64 bits
uintptr  unsigned integer large enough to store the uninterpreted bits of a pointer value

Implementationspezifische Typen haben ihre Größe definiert durch die Architektur, für die das Programm kompiliert wurde.

Auswahl von numerischen Datentypen

Die Auswahl der richtigen Größe hat in der Regel mehr mit der Leistung für die Zielarchitektur zu tun, für die Sie programmieren, als mit der Größe der Daten, mit denen Sie arbeiten. Ohne jedoch die spezifischen Auswirkungen auf die Leistung für Ihr Programm zu kennen, können Sie beim Einstieg einige dieser grundlegenden Richtlinien befolgen.

Wie weiter oben in diesem Artikel erläutert, gibt es architekturunabhängige Typen und implementierungsspezifische Typen. Für ganzzahlige Daten ist es in Go üblich, die implementierungsspezifischen Typen wie int oder uint anstelle von int64 oder uint64 zu verwenden. Dies führt in der Regel zu der schnellsten Verarbeitungsgeschwindigkeit für Ihre Zielarchitektur. Wenn Sie beispielsweise einen int64 verwenden und für eine 32-Bit-Architektur kompilieren, wird die Verarbeitung dieser Werte mindestens doppelt so lange dauern, da zusätzliche CPU-Zyklen benötigt werden, um die Daten über die Architektur zu übertragen. Wenn Sie stattdessen einen int verwendet hätten, würde das Programm dies für eine 32-Bit-Architektur als 32-Bit-Größe definieren und wesentlich schneller verarbeiten.

Wenn Sie wissen, dass Sie einen bestimmten Größenbereich nicht überschreiten werden, kann die Auswahl eines architekturunabhängigen Typs sowohl die Geschwindigkeit erhöhen als auch den Speicherverbrauch reduzieren. Wenn Sie beispielsweise wissen, dass Ihre Daten den Wert 100 nicht überschreiten und nur positive Zahlen sein werden, würde die Wahl eines uint8 Ihr Programm effizienter machen, da weniger Speicher benötigt wird.

Nachdem wir einige der möglichen Bereiche für numerische Datentypen gesehen haben, schauen wir uns jetzt an, was passiert, wenn wir in unserem Programm die Grenzen dieser Typen überschreiten.

Überlauf vs. Zurückspulung

Go hat das Potential, sowohl einen Überlauf als auch einen Zurückspulung zu erleben, wenn Sie versuchen, einen Wert zu speichern, der größer ist als der vom Datentyp festgelegt ist, abhängig davon, ob die Berechnung zur Zeit der Kompilierung oder zur Laufzeit stattfindet. Ein Compile-Time-Fehler entsteht, wenn das Programm bei der Versuchung findet, eine Fehlermeldung zu erstellen. Eine Runtime-Fehler entsteht, nachdem das Programm kompiliert wurde, während es tatsächlich ausgeführt wird.

Im folgenden Beispiel setzen wir maxUint32 auf seine maximale Werte:

package main

import "fmt"

func main() {
	var maxUint32 uint32 = 4294967295 // Max uint32 size
	fmt.Println(maxUint32)
}

Es wird mit dem folgenden Ergebnis kompiliert und ausgeführt:

Output4294967295

Wenn wir den Wert 1 zur Zeit der Zuweisung hinzufügen, wird er zur Laufzeit um 1 addieren:

Output0

Das Ergebnis ist nun:

package main

import "fmt"

func main() {
	var maxUint32 uint32 = 4294967295 + 1
	fmt.Println(maxUint32)

}

Gegenüberhinweise: Wenn Sie bei der Zuweisung des Variablen einen Wert hinzufügen, der vor der Kompilierung berechnet wird, so dass der Compiler feststellen kann, dass der berechnete Wert zu groß ist, um im speziell definierten Datentyp zu bleiben, wird er einen overflow-Fehler werfen. Das heißt, dass die berechnete Werte zu groß ist, um im gewünschten Datentyp zu bleiben.

Weil der Compiler sieht, dass sich der Wert über die festgelegten Grenzen hinausgehen wird, wird er jetzt einen Fehler werfen:

Outputprog.go:6:36: constant 4294967296 overflows uint32

Verstehen Sie die Grenzen Ihrer Daten, wird Ihnen helfen, zukünftig möglichen Bugs in Ihrem Programm zu vermeiden.

Nun, dass wir numerische Datentypen behandelt haben, lassen Sie uns anschauen, wie wir boolean Werte speichern können.

Booleans

Der boolean Datentyp kann zwei Werte haben, entweder true oder false, und wird als bool definiert, wenn Sie ihn als Datentyp deklarieren. Booleans werden verwendet, um die Wahrheitswerte zu repräsentieren, die mit der logischen Teilbarkeit der Mathematik verbunden sind, die Algorithmen in der Informatik informiert.

Die Werte true und false werden immer mit Kleinbuchstaben t bzw. f stehen, da sie in Go als vorher deklarierte Identifikatoren definiert sind.

Viele Operationen in der Mathematik geben uns Antworten, die auf true oder false ausgewertet werden:

größer als
- 500 > 100 true
- 1 > 5 false
kleiner als
- 200 < 400 true
- 4 < 2 false
gleich
- 5 = 5 true
- 500 = 400 false

Wie bei Zahlen, können wir einen boolean Wert in einer Variable speichern:

myBool := 5 > 8

Wir können dann den booleschen Wert mit einem Aufruf der fmt.Println()-Funktion ausgeben:

fmt.Println(myBool)

Da 5 nicht größer als 8 ist, erhalten wir die folgende Ausgabe:

Outputfalse

Wenn Sie mehr Programme in Go schreiben, werden Sie sich mit der Funktionsweise von Booleschen Werten und wie verschiedene Funktionen und Operationen, die entweder true oder false ergeben, den Verlauf des Programms beeinflussen, vertrauter werden.

Strings

Ein String ist eine Folge aus einem oder mehreren Zeichen (Buchstaben, Zahlen, Symbole), die entweder eine Konstante oder eine Variable sein kann. Strings befinden sich in Go entweder in einfachen Anführungszeichen ` oder doppelten Anführungszeichen " und haben je nach verwendeten Anführungszeichen unterschiedliche Eigenschaften.

Wenn Sie die einfachen Anführungszeichen verwenden, erstellen Sie ein rohes Zeichenkettenliteral. Wenn Sie die doppelten Anführungszeichen verwenden, erstellen Sie ein interpretiertes Zeichenkettenliteral.

Rohe Zeichenkettenliterale

Rohe Zeichenkettenliterale sind Zeichenfolgen zwischen einfachen Anführungszeichen, oft auch als Backticks bezeichnet. Innerhalb der Anführungszeichen erscheinen alle Zeichen genau so, wie sie zwischen den einfachen Anführungszeichen dargestellt werden, mit Ausnahme des einfachen Anführungszeichens selbst.

a := `Say "hello" to Go!`
fmt.Println(a)

OutputSay "hello" to Go!

Usualerweise werden Backslashes im Bereich der Zeichenfolgen zur Darstellung spezieller Zeichen verwendet. So wird zum Beispiel im interpretierten Zeichenfolgenliteral das Zeichen als neue Zeile in einer Zeichenfolge ausgedruckt. In einem uninterpretierten Zeichenfolgenliteral hat die Backslash jedoch keinen besonderen Bedeutung innerhalb des Zeichenfolgenliterals; sie wird tatsächlich als Wert von ausgedruckt:

a := `Say "hello" to Go!\n`
fmt.Println(a)

Auch weil die Backslash keine Sonderbedeutung innerhalb eines Zeichenfolgenliteral hat, wird sie in einem Zeichenfolgenliteral tatsächlich als ein Zeichen ausgedruckt und nicht als eine neue Zeile:

OutputSay "hello" to Go!\n

Die Verwendung von uninterpretiertem Zeichenfolgenliteralen erlaubt auch mehrzeilige Zeichenfolgen:

a := `This string is on 
multiple lines
within a single back 
quote on either side.`
fmt.Println(a)

OutputThis string is on 
multiple lines
within a single back 
quote on either side.

In den vorherigen Code-Blöcken wurden die neuen Zeilen vom Eingabestream übernommen und als solche ausgeben.

Interpretierte Zeichenfolgenliterale

Interpretierte Zeichenfolgenliterale sind Zeichensequenzen zwischen doppelten Anführungszeichen, wie z. B. "bar". Innerhalb der Anführungszeichen können beliebige Zeichen auftreten, außer Leerzeichen und unentschlossene Doppelanführungszeichen. Um Doppelanführungszeichen innerhalb interpretierter Zeichenfolgen zu zeigen, kann die Backslash als Escape-Zeichen verwendet werden, wie folgt:

a := "Say \"hello\" to Go!"
fmt.Println(a)

OutputSay "hello" to Go!

Sie werden fast immer interpretierte Zeichenfolgenliterale verwenden, weil sie Escape-Zeichen innerhalb von ihnen erlauben. Für mehr Informationen über die Arbeit mit Zeichenfolgen in Go schauen Sie bitte unter Einleitung in die Arbeit mit Zeichenfolgen in Go.

Zeichenketten mit UTF-8-Zeichen

UTF-8 ist ein Kodierungsschema, das zum Kodieren von Zeichen variabler Breite in ein bis vier Bytes verwendet wird. Go unterstützt UTF-8-Zeichen direkt, ohne dass eine spezielle Einrichtung, Bibliotheken oder Pakete erforderlich sind. Römische Zeichen wie der Buchstabe A können durch einen ASCII-Wert wie die Zahl 65 dargestellt werden. Spezielle Zeichen wie ein internationales Zeichen von 世 erfordern jedoch UTF-8. Go verwendet den Alias-Typ rune für UTF-8-Daten.

a := "Hello, 世界"

Sie können das Schlüsselwort range in einer for-Schleife verwenden, um eine beliebige Zeichenkette in Go zu durchlaufen, auch eine UTF-8-Zeichenkette. for-Schleifen und range werden später in der Serie ausführlicher behandelt; für den Moment ist es wichtig zu wissen, dass wir dies verwenden können, um die Bytes in einer gegebenen Zeichenkette zu zählen:

package main

import "fmt"

func main() {
	a := "Hello, 世界"
	for i, c := range a {
		fmt.Printf("%d: %s\n", i, string(c))
	}
	fmt.Println("length of 'Hello, 世界': ", len(a))
}

Im obigen Codeblock haben wir die Variable a deklariert und ihr den Wert Hello, 世界 zugewiesen. Der zugewiesene Text enthält UTF-8-Zeichen.

Anschließend haben wir eine Standard-for-Schleife sowie das Schlüsselwort range verwendet. In Go durchläuft das Schlüsselwort range eine Zeichenkette und gibt jeweils ein Zeichen sowie den Byte-Index des Zeichens in der Zeichenkette zurück.

Mit der Funktion fmt.Printf haben wir einen Formatstring von %d: %s\n bereitgestellt. %d ist das Druckverb für eine Ziffer (hier ein Integer) und %s ist das Druckverb für einen String. Anschließend gaben wir die Werte von i wieder, was der aktuelle Index des for-Schleifens ist, und c, was das aktuelle Zeichen in der for-Schleife ist.

Schließlich druckten wir die gesamte Länge der Variablen a mit der eingebauten len-Funktion aus.

Früher haben wir erwähnt, dass ein Rune ein Alias für int32 ist und aus einem bis vier Bytes bestehen kann. Das Zeichen 世 benötigt drei Bytes zur Definition und der Index bewegt sich entsprechend, wenn durch den UTF-8-String iteriert wird. Dies ist der Grund, warum i nicht fortlaufend ist, wenn es ausgegeben wird.

Output0: H
1: e
2: l
3: l
4: o
5: ,
6:
7: 世
10: 界
length of 'Hello, 世界':  13

Wie Sie sehen können, ist die Länge länger als die Anzahl der Male, die benötigt wurde, um über den String zu iterieren.

Sie werden nicht immer mit UTF-8-Strings arbeiten, aber wenn Sie es tun, werden Sie jetzt verstehen, warum sie Runes und nicht einzelne int32 sind.

Deklaration von Datentypen für Variablen

Nun, da Sie die verschiedenen primitiven Datentypen kennen, gehen wir darüber, wie man diese Typen Variablen in Go zuweist.

In Go können wir eine Variable mit dem Schlüsselwort var und dem Namen der Variablen sowie dem gewünschten Datentyp definieren.

Im folgenden Beispiel werden wir eine Variable namens pi vom Typ float64 deklarieren.

Das Schlüsselwort var ist das erste, was deklariert wird:

var pi float64

Danach folgt der Name unserer Variable, pi:

var pi float64

Und schließlich der Datentyp float64:

var pi float64

Wir können optional auch einen Anfangswert angeben, wie zum Beispiel 3.14:

var pi float64 = 3.14

Go ist eine statisch typisierte Sprache. Statisch typisiert bedeutet, dass jede Anweisung im Programm zur Kompilierzeit überprüft wird. Es bedeutet auch, dass der Datentyp an die Variable gebunden ist, während er in dynamisch typisierten Sprachen an den Wert gebunden ist.

Zum Beispiel wird in Go der Typ bei der Deklaration einer Variable angegeben:

var pi float64 = 3.14
var week int = 7

Jede dieser Variablen könnte ein anderer Datentyp sein, wenn sie anders deklariert werden.

Dies unterscheidet sich von einer Sprache wie PHP, bei der der Datentyp dem Wert zugeordnet ist:

$s = "sammy";         // $s ist automatisch ein String
$s = 123;             // $s ist automatisch eine Ganzzahl

Im vorherigen Codeblock ist der erste $s ein String, weil ihm der Wert "sammy" zugewiesen wird, und der zweite ist eine Ganzzahl, weil er den Wert 123 hat.

Als Nächstes werfen wir einen Blick auf komplexere Datentypen wie Arrays.

Arrays

Ein Array ist eine geordnete Folge von Elementen. Die Kapazität eines Arrays wird bei der Erstellung definiert. Sobald ein Array seine Größe zugewiesen hat, kann diese Größe nicht mehr geändert werden. Da die Größe eines Arrays statisch ist, bedeutet dies, dass es nur einmal Speicher zuweist. Dies macht Arrays etwas starr, verbessert aber die Leistung Ihres Programms. Aus diesem Grund werden Arrays typischerweise verwendet, wenn Programme optimiert werden. Slices, die im Folgenden behandelt werden, sind flexibler und entsprechen dem, was Sie als Arrays in anderen Sprachen vorstellen würden.

Arrays werden definiert, indem die Größe des Arrays deklariert wird, gefolgt vom Datentyp mit den zwischen geschweiften Klammern { } definierten Werten.

Ein Array von Zeichenketten sieht folgendermaßen aus:

[3]string{"blue coral", "staghorn coral", "pillar coral"}

Wir können ein Array in einer Variablen speichern und es ausgeben:

coral := [3]string{"blue coral", "staghorn coral", "pillar coral"}
fmt.Println(coral)

Output[blue coral staghorn coral pillar coral]

Wie bereits erwähnt, ähneln Slices Arrays, sind aber viel flexibler. Werfen wir einen Blick auf diesen veränderlichen Datentyp.

Slices

Ein Slice ist eine geordnete Folge von Elementen, deren Länge sich ändern kann. Slices können ihre Größe dynamisch erhöhen. Wenn Sie neue Elemente zu einem Slice hinzufügen, fordert das Slice bei Bedarf mehr Speicher vom System an, wenn nicht genügend Speicherplatz vorhanden ist. Da ein Slice erweitert werden kann, um bei Bedarf weitere Elemente hinzuzufügen, werden sie häufiger verwendet als Arrays.

Slices werden definiert, indem der Datentyp vorangestellt wird, gefolgt von eckigen Klammern [] und Werten in geschweiften Klammern { }.

Ein Slice von Ganzzahlen sieht so aus:

[]int{-3, -2, -1, 0, 1, 2, 3}

Ein Slice von Gleitkommazahlen sieht so aus:

[]float64{3.14, 9.23, 111.11, 312.12, 1.05}

Ein Slice von Zeichenketten sieht so aus:

[]string{"shark", "cuttlefish", "squid", "mantis shrimp"}

Definieren wir unser Slice von Zeichenketten als seaCreatures:

seaCreatures := []string{"shark", "cuttlefish", "squid", "mantis shrimp"}

Wir können sie ausgeben, indem wir die Variable aufrufen:

fmt.Println(seaCreatures)

Die Ausgabe sieht genau wie die Liste aus, die wir erstellt haben:

Output[shark cuttlefish squid mantis shrimp]

Wir können das Schlüsselwort append verwenden, um ein Element zu unserem Slice hinzuzufügen. Der folgende Befehl fügt den Zeichenkettenwert von seahorse zum Slice hinzu:

seaCreatures = append(seaCreatures, "seahorse")

Sie können überprüfen, ob es hinzugefügt wurde, indem Sie es ausgeben:

fmt.Println(seaCreatures)

Output[shark cuttlefish squid mantis shrimp seahorse]

Wie Sie sehen, ist ein Slice viel flexibler als ein Array, wenn Sie eine unbekannte Anzahl von Elementen verwalten müssen.

Maps

Die map ist der eingebaute Hash- oder Wörterbuchtyp von Go. Maps verwenden Schlüssel und Werte als Paar zum Speichern von Daten. Dies ist in der Programmierung nützlich, um Werte schnell über einen Index oder in diesem Fall einen Schlüssel zu suchen. Beispielsweise möchten Sie vielleicht eine Map von Benutzern behalten, indiziert nach ihrer Benutzer-ID. Der Schlüssel wäre die Benutzer-ID und das Benutzerobjekt wäre der Wert. Eine Map wird erstellt, indem das Schlüsselwort map verwendet wird, gefolgt vom Schlüsseldatentyp in eckigen Klammern [ ], gefolgt vom Wertedatentyp und den Schlüssel-Wert-Paaren in geschweiften Klammern.

map[key]value{}

Typischerweise verwendet, um Daten zu speichern, die zusammengehören, wie die Informationen in einer ID, sieht eine Map so aus:

map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}

Man wird bemerken, dass es neben den geschweiften Klammern auch Doppelpunkte in der Map gibt. Die Wörter links vom Doppelpunkt sind die Schlüssel. Schlüssel können in Go jeden vergleichbaren Typ haben. Vergleichbare Typen sind primitive Typen wie strings, ints, usw. Ein primitiver Typ wird von der Sprache definiert und nicht aus anderen Typen kombiniert. Obwohl sie benutzerdefinierte Typen sein können, gilt es als beste Praxis, sie einfach zu halten, um Programmierfehler zu vermeiden. Die Schlüssel im obigen Wörterbuch sind: name, animal, color und location.

Die Wörter rechts vom Doppelpunkt sind die Werte. Werte können aus jedem Datentyp bestehen. Die Werte im obigen Wörterbuch sind: Sammy, shark, blue und ocean.

Lassen Sie uns die Map in einer Variablen speichern und ausgeben:

sammy := map[string]string{"name": "Sammy", "animal": "shark", "color": "blue", "location": "ocean"}
fmt.Println(sammy)

Outputmap[animal:shark color:blue location:ocean name:Sammy]

Wenn wir die Farbe von Sammy isolieren möchten, können wir dies tun, indem wir sammy["color"] aufrufen. Lassen Sie uns das ausgeben:

fmt.Println(sammy["color"])

Outputblue

Da Maps Schlüssel-Wert-Paare zum Speichern von Daten bieten, können sie wichtige Elemente in Ihrem Go-Programm sein.

Schlussfolgerung

An dieser Stelle sollten Sie ein besseres Verständnis für einige der wichtigsten Datentypen haben, die Ihnen in Go zur Verfügung stehen. Jeder dieser Datentypen wird wichtig werden, wenn Sie Programmierprojekte in der Go-Sprache entwickeln.

Sobald Sie ein solides Verständnis der in Go verfügbaren Datentypen haben, können Sie lernen, Datentypen zu konvertieren, um Ihre Datentypen je nach Situation anzupassen.

Source:
https://www.digitalocean.com/community/tutorials/understanding-data-types-in-go