TOC

Grundlegendes zu Datentypen in Go

Einführung

Datentypen geben die Arten von Werten an, die bestimmte Variablen beim Schreiben eines Programms speichern. Der Datentyp bestimmt auch, welche Operationen an den Daten ausgeführt werden können.

In diesem Artikel gehen wir auf die wichtigen Datentypen von Go ein. Dies ist keine vollständige Untersuchung der Datentypen, sondern hilft Ihnen, sich mit den Optionen vertraut zu machen, die Ihnen in Go zur Verfügung stehen. Wenn Sie einige grundlegende Datentypen kennen, können Sie klareren Code schreiben, der eine effiziente Leistung erbringt.

Hintergrund

Eine Möglichkeit, über Datentypen nachzudenken, besteht darin, die verschiedenen Datentypen zu berücksichtigen, die wir in der realen Welt verwenden. Ein Beispiel für Daten in der realen Welt sind Zahlen: Wir können beispielsweise ganze Zahlen (0, 1, 2,…), ganze Zahlen (…, -1, 0, 1,…) und irrationale Zahlen (π) verwenden.

Normalerweise können wir in der Mathematik Zahlen aus verschiedenen Typen kombinieren und eine Art Antwort erhalten. Wir möchten vielleicht 5 zu π addieren, zum Beispiel: 

5 + π

Wir können entweder die Gleichung als Antwort behalten, um die irrationale Zahl zu berücksichtigen, oder π auf eine Zahl mit einer abgekürzten Anzahl von Dezimalstellen runden und dann die Zahlen addieren: 

5 + π = 5 + 3.14 = 8.14

Wenn wir jedoch versuchen, Zahlen mit einem anderen Datentyp, z. B. Wörtern, auszuwerten, sind die Dinge weniger sinnvoll. Wie würden wir die folgende Gleichung lösen? 

shark + 8

Bei Computern ist jeder Datentyp ganz anders - wie Wörter und Zahlen. Infolgedessen müssen wir vorsichtig sein, wie wir unterschiedliche Datentypen verwenden, um Werte zuzuweisen, und wie wir sie durch Operationen manipulieren.

Ganze Zahlen

Wie in der Mathematik sindintegers in der Computerprogrammierung ganze Zahlen, die positiv, negativ oder 0 (…, -1, 0, 1,…) sein können. In Go wird eine Ganzzahl alsint bezeichnet. Wie bei anderen Programmiersprachen sollten Sie keine Kommas mit vier oder mehr Ziffern verwenden. Wenn Sie also 1.000 in Ihr Programm schreiben, schreiben Sie diese als1000.

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

fmt.Println(-459)
Output-459

Oder wir können eine Variable deklarieren, die in diesem Fall ein Symbol für die Zahl ist, die wir verwenden oder bearbeiten, wie folgt: 

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

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

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

Wie die Ausgabe zeigt, subtrahierte der mathematische Operator- die ganze Zahl68 von116, was zu48 führte. Weitere Informationen zur Variablendeklaration finden Sie im AbschnittDeclaring Data Types for Variables.

Ganze Zahlen können in Go-Programmen auf viele Arten verwendet werden. Wenn Sie weiter über Go lernen, haben Sie viele Möglichkeiten, mit ganzen Zahlen zu arbeiten und auf Ihrem Wissen über diesen Datentyp aufzubauen.

Gleitkommazahlen

Einfloating-point number oder einfloat wird verwendet, umreal numbers darzustellen, die nicht als ganze Zahlen ausgedrückt werden können. Reelle Zahlen umfassen alle rationalen und irrationalen Zahlen. Daher können Gleitkommazahlen einen Bruchteil enthalten, z. B. 9.0 oder -116.42. Um an einen Gleitkommawert in einem Go-Programm zu denken, handelt es sich um eine Zahl, die einen Dezimalpunkt enthält.

Wie wir es mit ganzen Zahlen gemacht haben, können wir eine Gleitkommazahl auf einfache Weise wie folgt ausdrucken: 

fmt.Println(-459.67)
Output-459.67

Wir können auch eine Variable deklarieren, die für ein Float steht, wie folgt: 

absoluteZero := -459.67
fmt.Println(absoluteZero)
Output-459.67

Genau wie bei Ganzzahlen können wir auch in Go mit Floats rechnen: 

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

Bei Ganzzahlen und Gleitkommazahlen muss beachtet werden, dass 3 ≠ 3.0 ist, da 3 eine Ganzzahl und 3,0 eine Gleitkommazahl ist.

Größen von numerischen Typen

Zusätzlich zur Unterscheidung zwischen Ganzzahlen und Gleitkommazahlen verfügt Go über zwei Arten numerischer Daten, die sich durch die statische oder dynamische Natur ihrer Größe unterscheiden. Der erste Typ ist einarchitecture-independent-Typ, was bedeutet, dass sich die Größe der Daten in Bits nicht ändert, unabhängig von der Maschine, auf der der Code ausgeführt wird.

Die meisten heutigen Systemarchitekturen sind entweder 32-Bit- oder 64-Bit-Architekturen. Möglicherweise entwickeln Sie für einen modernen Windows-Laptop, auf dem das Betriebssystem auf einer 64-Bit-Architektur ausgeführt wird. Wenn Sie jedoch für ein Gerät wie eine Fitnessuhr entwickeln, arbeiten Sie möglicherweise mit einer 32-Bit-Architektur. Wenn Sie einen architekturunabhängigen Typ wieint32 verwenden, hat der Typ unabhängig von der Architektur, für die Sie kompilieren, eine konstante Größe.

Der zweite Typ ist einimplementation-specific-Typ. Bei diesem Typ kann die Bitgröße abhängig von der Architektur, auf der das Programm basiert, variieren. Wenn wir beispielsweise den Typint verwenden und Go für eine 32-Bit-Architektur kompiliert, beträgt die Größe des Datentyps 32 Bit. Wenn das Programm für eine 64-Bit-Architektur kompiliert ist, hat die Variable eine Größe von 64 Bit.

Neben Datentypen mit unterschiedlichen Größen gibt es auch Typen wie Ganzzahlen in zwei Grundtypen:signed undunsigned. Einint8 ist eine vorzeichenbehaftete Ganzzahl und kann einen Wert von -128 bis 127 haben. Auint8 ist eine vorzeichenlose Ganzzahl und kann nur einen positiven Wert von 0 bis 255 haben.

Die Bereiche basieren auf der Bitgröße. Für Binärdaten können 8 Bits insgesamt 256 verschiedene Werte darstellen. Da einint-Typ sowohl positive als auch negative Werte unterstützen muss, hat eine 8-Bit-Ganzzahl (int8) einen Bereich von -128 bis 127, was insgesamt 256 eindeutigen möglichen Werten entspricht.

Go bietet die folgenden architekturunabhängigen Ganzzahltypen: 

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)

Floats und komplexe Zahlen gibt es auch in verschiedenen 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 einige Aliasnummerntypen, die bestimmten Datentypen nützliche Namen zuweisen: 

byte        alias for uint8
rune        alias for int32

Der Zweck desbyte-Alias ​​besteht darin, deutlich zu machen, wann Ihr Programm Bytes als gemeinsame Rechenmessung in Zeichenfolgenelementen verwendet, im Gegensatz zu kleinen Ganzzahlen, die nicht mit der Bytedatenmessung zusammenhängen. Obwohlbyte unduint8 nach dem Kompilieren des Programms identisch sind, wirdbyte häufig verwendet, um Zeichendaten in numerischer Form darzustellen, währenduint8 eine Zahl in sein soll Ihr Programm.

Der Aliasruneist etwas anders. Wennbyte unduint8 genau dieselben Daten sind, kannrune ein einzelnes Byte oder vier Bytes sein, ein Bereich, der durchint32 bestimmt wird. Einrune wird verwendet, um ein Unicode-Zeichen darzustellen, während nur ASCII-Zeichen nur durch einenint32-Datentyp dargestellt werden können.

Darüber hinaus bietet Go die folgenden implementierungsspezifischen 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

Die Größe der implementierungsspezifischen Typen wird durch die Architektur bestimmt, für die das Programm kompiliert wurde.

Numerische Datentypen auswählen

Die Auswahl der richtigen Größe hat in der Regel mehr mit der Leistung der Zielarchitektur zu tun, für die Sie programmieren, als mit der Größe der Daten, mit denen Sie arbeiten. Ohne dass Sie die spezifischen Auswirkungen auf die Leistung Ihres Programms kennen müssen, können Sie beim ersten Start einige dieser grundlegenden Richtlinien befolgen.

Wie weiter oben in diesem Artikel erläutert, gibt es architekturunabhängige und implementierungsspezifische Typen. Für ganzzahlige Daten werden in Go häufig Implementierungstypen wieint oderuint anstelle vonint64 oderuint64 verwendet. Dies führt normalerweise zu der schnellsten Verarbeitungsgeschwindigkeit für Ihre Zielarchitektur. Wenn Sie beispielsweiseint64 verwenden und zu einer 32-Bit-Architektur kompilieren, dauert die Verarbeitung dieser Werte mindestens doppelt so lange wie zusätzliche CPU-Zyklen, um die Daten über die Architektur zu verschieben. Wenn Sie stattdessen einint verwenden, definiert das Programm es als 32-Bit-Größe für eine 32-Bit-Architektur und ist wesentlich schneller zu verarbeiten.

Wenn Sie wissen, dass Sie einen bestimmten Größenbereich nicht überschreiten, kann die Auswahl eines architekturunabhängigen Typs die Geschwindigkeit erhöhen und die Speichernutzung verringern. Wenn Sie beispielsweise wissen, dass Ihre Daten den Wert von100 nicht überschreiten und nur eine positive Zahl sind, würde die Auswahl vonuint8 Ihr Programm effizienter machen, da weniger Speicher benötigt wird.

Nachdem wir uns einige der möglichen Bereiche für numerische Datentypen angesehen haben, schauen wir uns an, was passiert, wenn wir diese Bereiche in unserem Programm überschreiten.

Überlauf vs. Umlauf

Go hat das Potenzial, sowohloverflowals auchwraparoundals Zahl zu speichern, wenn Sie versuchen, einen Wert zu speichern, der größer ist als der Datentyp, der gespeichert werden soll, je nachdem, ob der Wert zur Kompilierungszeit oder zur Laufzeit berechnet wird. Ein Fehler bei der Kompilierung tritt auf, wenn das Programm beim Versuch, das Programm zu erstellen, einen Fehler findet. Ein Laufzeitfehler tritt auf, nachdem das Programm kompiliert wurde, während es tatsächlich ausgeführt wird.

Im folgenden Beispiel setzen wirmaxUint32 auf den Maximalwert: 

package main

import "fmt"

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

Es wird mit folgendem Ergebnis kompiliert und ausgeführt: 

Output4294967295

Wenn wir dem Wert zur Laufzeit1 hinzufügen, wird0 umgangen: 

Output0

Auf der anderen Seite ändern wir das Programm, um der Variablen1 hinzuzufügen, wenn wir sie vor der Kompilierungszeit zuweisen: 

package main

import "fmt"

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

}

Wenn der Compiler beim Kompilieren feststellen kann, dass ein Wert zu groß ist, um ihn in dem angegebenen Datentyp zu halten, wird einoverflow-Fehler ausgegeben. Dies bedeutet, dass der berechnete Wert für den von Ihnen angegebenen Datentyp zu groß ist.

Da der Compiler bestimmen kann, dass er den Wert überschreitet, wird jetzt ein Fehler ausgegeben: 

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

Wenn Sie die Grenzen Ihrer Daten kennen, können Sie potenzielle Programmfehler in Zukunft vermeiden.

Nachdem wir uns nun mit numerischen Typen befasst haben, wollen wir uns ansehen, wie boolesche Werte gespeichert werden.

Boolesche

Der Datentypboolean kann einer von zwei Werten sein, entwedertrue oderfalse, und wird alsbool definiert, wenn er als Datentyp deklariert wird. Boolesche Werte werden verwendet, um die Wahrheitswerte darzustellen, die dem logischen Zweig der Mathematik zugeordnet sind, der Algorithmen in der Informatik informiert.

Die Wertetrue undfalse werden immer mit Kleinbuchstabent bzw.f angegeben, da sie in Go vordeklarierte Bezeichner sind.

Viele mathematische Operationen geben uns Antworten, die entweder wahr oder falsch sind:

  • größer als

    • 500> 100 wahr

    • 1> 5 falsch

  • weniger als

    • 200 <400 wahr

    • 4 <2 falsch

  • gleich

    • 5 = 5 wahr

    • 500 = 400 falsch

Wie bei Zahlen können wir einen Booleschen Wert in einer Variablen speichern: 

myBool := 5 > 8

Wir können dann den booleschen Wert mit einem Aufruf derfmt.Println()-Funktion drucken: 

fmt.Println(myBool)

Da5 nicht größer als8 ist, erhalten wir die folgende Ausgabe: 

Outputfalse

Wenn Sie mehr Programme in Go schreiben, werden Sie besser mit der Funktionsweise von Booleschen Werten vertraut und wissen, wie verschiedene Funktionen und Operationen, die entwedertrue oderfalse ergeben, den Programmverlauf ändern können.

Streicher

Eine Zeichenfolge besteht aus einem oder mehreren Zeichen (Buchstaben, Zahlen, Symbolen), die entweder eine Konstante oder eine Variable sein können. Zeichenfolgen existieren entweder in Anführungszeichen+\ + `oder in Anführungszeichen" in Go und haben unterschiedliche Eigenschaften, je nachdem, welche Anführungszeichen Sie verwenden.

Wenn Sie die hinteren Anführungszeichen verwenden, erstellen Sie einraw-Zeichenfolgenliteral. Wenn Sie doppelte Anführungszeichen verwenden, erstellen Sie eininterpreted-Zeichenfolgenliteral.

Raw String Literals

Rohe String-Literale sind Zeichenfolgen zwischen Anführungszeichen, die oft als Back Ticks bezeichnet werden. Innerhalb der Anführungszeichen wird jedes Zeichen so angezeigt, wie es zwischen den Anführungszeichen angezeigt wird, mit Ausnahme des Anführungszeichens. 

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

In der Regel werden Backslashes verwendet, um Sonderzeichen in Zeichenfolgen darzustellen. Beispielsweise würde in einer interpretierten Zeichenfolge eine neue Zeile in einer Zeichenfolge darstellen. Backslashes haben in reinen String-Literalen jedoch keine besondere Bedeutung: 

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

Da der Backslash in einem String-Literal keine besondere Bedeutung hat, wird der Wert von gedruckt, anstatt eine neue Zeile zu erstellen: 

OutputSay "hello" to Go!\n

Rohe Zeichenfolgenliterale können auch zum Erstellen mehrzeiliger Zeichenfolgen verwendet werden: 

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 vorhergehenden Codeblöcken wurden die neuen Zeilen buchstäblich von der Eingabe zur Ausgabe übertragen.

Interpretierte String-Literale

Interpretierte String-Literale sind Zeichenfolgen zwischen doppelten Anführungszeichen, wie in"bar". Innerhalb der Anführungszeichen können alle Zeichen außer Zeilenumbrüchen und doppelten Anführungszeichen vorkommen. Um doppelte Anführungszeichen in einer interpretierten Zeichenfolge anzuzeigen, können Sie den umgekehrten Schrägstrich wie folgt als Escape-Zeichen verwenden: 

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

Sie werden fast immer interpretierte Zeichenfolgenliterale verwenden, da diese Escapezeichen enthalten. Weitere Informationen zum Arbeiten mit Zeichenfolgen finden Sie unterAn Introduction to Working with Strings in Go.

Zeichenfolgen mit UTF-8-Zeichen

UTF-8 ist ein Kodierungsschema, mit dem Zeichen variabler Breite in ein bis vier Bytes kodiert werden. Go unterstützt UTF-8-Zeichen ohne spezielle Einstellungen, Bibliotheken oder Pakete. Römische Zeichen wie der BuchstabeA können durch einen ASCII-Wert wie die Zahl 65 dargestellt werden. Bei Sonderzeichen wie einem internationalen Zeichen von世 wäre jedoch UTF-8 erforderlich. Go verwendet den Alias-Typrunefür UTF-8-Daten. 

a := "Hello, 世界"

Sie können das Schlüsselwortrange in einerfor-Schleife verwenden, um durch eine beliebige Zeichenfolge in Go zu indizieren, sogar durch eine UTF-8-Zeichenfolge. for Schleifen undrange werden später in der Serie ausführlicher behandelt. Im Moment ist es wichtig zu wissen, dass wir damit die Bytes in einer bestimmten Zeichenfolge zählen können: 

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 Variablea deklariert und ihr den WertHello, 世界 zugewiesen. Der zugewiesene Text enthält UTF-8-Zeichen.

Wir haben dann eine Standardschleife vonfor sowie das Schlüsselwortrange verwendet. In Go indiziert das Schlüsselwortrangedurch eine Zeichenfolge, die jeweils ein Zeichen zurückgibt, sowie durch den Byte-Index, an dem sich das Zeichen in der Zeichenfolge befindet.

Mit der Funktionfmt.Printf haben wir eine Formatzeichenfolge von%d: %s bereitgestellt. %d ist das Druckverb für eine Ziffer (in diesem Fall eine Ganzzahl) und%s ist das Druckverb für eine Zeichenfolge. Wir haben dann die Werte voni, dem aktuellen Index derfor-Schleife, undc, dem aktuellen Zeichen in derfor-Schleife, angegeben.

Schließlich haben wir die gesamte Länge der Variablena mit der integrierten Funktionlen gedruckt.

Wir haben bereits erwähnt, dass eine Rune ein Alias ​​fürint32 ist und aus ein bis vier Bytes bestehen kann. Das世-Zeichen benötigt drei Bytes zum Definieren und der Index bewegt sich entsprechend, wenn er durch die UTF-8-Zeichenfolge reicht. Dies ist der Grund, warumi beim Ausdrucken nicht sequentiell ist. 

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

Wie Sie sehen, ist die Länge länger als die Häufigkeit, mit der der Bereich über die Zeichenfolge reicht.

Sie werden nicht immer mit UTF-8-Zeichenfolgen arbeiten, aber wenn Sie dies tun, werden Sie jetzt verstehen, warum es sich um Runen handelt und nicht um ein einzigesint32.

Datentypen für Variablen deklarieren

Nachdem Sie nun die verschiedenen primitiven Datentypen kennen, werden wir uns mit der Zuordnung dieser Typen zu Variablen in Go befassen.

In Go können wir eine Variable mit dem Schlüsselwortvar definieren, gefolgt vom Namen der Variablen und dem gewünschten Datentyp.

Im folgenden Beispiel deklarieren wir eine Variable namenspi vom Typfloat64.

Das Schlüsselwortvar ist das erste, was deklariert wird: 

var pi float64

Gefolgt vom Namen unserer Variablenpi: 

var pi float64

Und schließlich der Datentypfloat64: 

var pi float64

Optional können wir auch einen Anfangswert angeben, z. B.3.14: 

var pi float64 = 3.14

Go ist einestatically typed-Sprache. Statisch typisiert bedeutet, dass jede Anweisung im Programm zur Kompilierungszeit überprüft wird. Dies bedeutet auch, dass der Datentyp an die Variable gebunden ist, während in dynamisch verknüpften Sprachen der Datentyp an den Wert gebunden ist.

In Go wird der Typ beispielsweise beim Deklarieren einer Variablen deklariert: 

var pi float64 = 3.14
var week int = 7

Jede dieser Variablen kann einen anderen Datentyp haben, wenn Sie sie unterschiedlich deklariert haben.

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

$s = "sammy";         // $s is automatically a string
$s = 123;             // $s is automatically an integer

Im vorhergehenden Codeblock ist das erste$s eine Zeichenfolge, weil ihm der Wert"sammy" zugewiesen wurde, und das zweite ist eine Ganzzahl, weil es den Wert123 hat.

Betrachten wir als Nächstes komplexere Datentypen wie Arrays.

Arrays

Einarray ist eine geordnete Folge von Elementen. Die Kapazität eines Arrays wird zum Zeitpunkt der Erstellung festgelegt. Sobald ein Array seine Größe zugewiesen hat, kann die Größe nicht mehr geändert werden. Da die Größe eines Arrays statisch ist, wird der Speicher nur einmal zugewiesen. Dies macht Arrays etwas starrer, erhöht aber die Leistung Ihres Programms. Aus diesem Grund werden bei der Optimierung von Programmen in der Regel Arrays verwendet. Slices, die als nächstes behandelt werden, sind flexibler und bilden das, was Sie als Arrays in anderen Sprachen betrachten würden.

Arrays werden definiert, indem die Größe des Arrays und dann der Datentyp mit den Werten in geschweiften Klammern{ } deklariert werden.

Ein Array von Zeichenfolgen sieht folgendermaßen aus: 

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

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

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 jedoch wesentlich flexibler. Werfen wir einen Blick auf diesen veränderlichen Datentyp.

Scheiben

Aslice ist eine geordnete Folge von Elementen, deren Länge sich ändern kann. Slices können dynamisch vergrößert werden. Wenn Sie einem Slice neue Elemente hinzufügen und das Slice nicht über genügend Speicher verfügt, um die neuen Elemente zu speichern, fordert es bei Bedarf mehr Speicher vom System an. Da ein Slice bei Bedarf erweitert werden kann, um mehr Elemente hinzuzufügen, werden sie häufiger als Arrays verwendet.

Slices werden definiert, indem der Datentyp deklariert wird, dem eine öffnende und schließende eckige Klammer[] vorangestellt ist und Werte zwischen geschweiften Klammern{ } vorliegen.

Ein Stück Ganzzahl sieht so aus: 

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

Ein Stück Float sieht so aus: 

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

Ein Stück Saiten sieht so aus: 

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

Definieren wir unser String-Slice alsseaCreatures: 

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

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

fmt.Println(seaCreatures)

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

Output[shark cuttlefish squid mantis shrimp]

Wir können das Schlüsselwortappendverwenden, um unserem Slice ein Element hinzuzufügen. Der folgende Befehl fügt dem Slice den Zeichenfolgenwert vonseahorse hinzu: 

seaCreatures = append(seaCreatures, "seahorse")

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

fmt.Println(seaCreatures)
Output[shark cuttlefish squid mantis shrimp seahorse]

Wie Sie sehen, ist ein Slice viel vielseitiger als ein Array, wenn Sie eine unbekannte Größe von Elementen verwalten müssen.

Maps

map ist der integrierte Hash- oder Wörterbuchtyp von Go. Karten verwendenkeys undvalues als Paar zum Speichern von Daten. Dies ist nützlich beim Programmieren, um schnell Werte anhand eines Index oder in diesem Fall eines Schlüssels nachzuschlagen. Beispielsweise möchten Sie möglicherweise eine Karte der Benutzer führen, die nach ihrer Benutzer-ID indiziert ist. Der Schlüssel wäre die Benutzer-ID und das Benutzerobjekt wäre der Wert. Eine Karte wird unter Verwendung des Schlüsselwortsmap gefolgt vom Schlüsseldatentyp in eckigen Klammern[ ] erstellt, gefolgt vom Wertdatentyp und den Schlüsselwertpaaren in geschweiften Klammern. 

map[key]value{}

In der Regel werden verwandte Daten gespeichert, z. B. die in einer ID enthaltenen Informationen. Eine Karte sieht folgendermaßen aus: 

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

Sie werden feststellen, dass sich auf der Karte neben den geschweiften Klammern auch Doppelpunkte befinden. Die Wörter links von den Doppelpunkten sind die Schlüssel. Schlüssel können in Go ein beliebigercomparable-Typ sein. Vergleichbare Typen sind primitive Typen wiestrings,ints usw. Ein primitiver Typ wird durch die Sprache definiert und nicht aus der Kombination anderer Typen erstellt. Obwohl es sich um benutzerdefinierte Typen handeln kann, empfiehlt es sich, diese einfach zu halten, um Programmierfehler zu vermeiden. Die Schlüssel im obigen Wörterbuch sind:name,animal,color undlocation.

Die Wörter rechts von den Doppelpunkten sind die Werte. Werte können aus einem beliebigen Datentyp bestehen. Die Werte im obigen Wörterbuch sind:Sammy,shark,blue undocean.

Speichern Sie die Karte in einer Variablen und drucken Sie sie aus: 

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 Sammys Farbe isolieren möchten, können wir dies tun, indem wirsammy["color"] aufrufen. Drucken wir das aus: 

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.

Fazit

An dieser Stelle sollten Sie einige der wichtigsten Datentypen kennen, die in Go zur Verfügung stehen. Jeder dieser Datentypen wird wichtig, wenn Sie Programmierprojekte in der Sprache Go entwickeln.

Sobald Sie ein solides Verständnis der in Go verfügbaren Datentypen haben, können SieHow To Convert Data Types lernen, um Ihre Datentypen entsprechend der Situation zu ändern.

Related