Go - Datenarten: Ein freundlicher Leitfaden für Anfänger

Hallo da draußen, angehender Programmierer! Bist du bereit, in die wunderbare Welt der Go-Programmierung einzutauchen? Heute werden wir eines der grundlegenden Konzepte in Go erkunden: Datenarten. Keine Sorge, wenn du noch nie eine Zeile Code geschrieben hast – ich werde dich schrittweise durchführen, genau wie ich es über die Jahre mit unzähligen Schülern gemacht habe. Los geht's!

Was sind Datenarten?

Bevor wir uns den Details zuwenden, lassen Sie uns verstehen, was Datenarten sind. Stell dir vor, du organisierst eine große Party (spaßig, oder?). Du musst verschiedene Arten von Informationen im Auge behalten:

• Die Anzahl der Gäste (eine ganze Zahl)
• Die Kosten für das Essen pro Person (eine Zahl mit Dezimalstellen)
• Ob es eine Überraschungsparty ist oder nicht (ja oder nein)
• Der Name des Ehrengastes (eine Reihe von Buchstaben)

In der Programmierung verwenden wir verschiedene Datenarten, um diese verschiedenen Arten von Informationen darzustellen. Go, als das durchdachte Sprache, das es ist, bietet uns mehrere Datenarten zur Verfügung.

Ganzzahlarten

Lassen Sie uns mit Ganzzahlarten beginnen. Diese werden für ganze Zahlen verwendet, wie die Anzahl der Gäste bei unserer Party.

Grundlegende Ganzzahlarten

Go bietet mehrere Ganzzahlarten an, die in Größe und ob sie negative Zahlen darstellen können, variieren:

Typ	Größe (Bits)	Bereich
int8	8	-128 bis 127
int16	16	-32.768 bis 32.767
int32	32	-2.147.483.648 bis 2.147.483.647
int64	64	-9.223.372.036.854.775.808 bis 9.223.372.036.854.775.807
uint8	8	0 bis 255
uint16	16	0 bis 65.535
uint32	32	0 bis 4.294.967.295
uint64	64	0 bis 18.446.744.073.709.551.615

Sehen wir uns an, wie wir diese in unserem Code verwenden können:

package main

import "fmt"

func main() {
var partyGuests int = 50
var smallPartyGuests int8 = 10
var hugePartyGuests uint64 = 1000000

fmt.Println("Reguläre Partygäste:", partyGuests)
fmt.Println("Kleine Partygäste:", smallPartyGuests)
fmt.Println("Große Partygäste:", hugePartyGuests)
}

In diesem Beispiel deklarieren wir Variablen, um die Anzahl der Gäste für verschiedene Arten von Partys zu speichern. Der Typ int wird für eine reguläre Party verwendet, int8 für eine kleine Versammlung (da wir wissen, dass es nicht mehr als 127 sein wird) und uint64 für eine riesige Feier (bloß für den Fall, dass wir eine stadtbreite Veranstaltung planen!).

Die 'int' und 'uint' Typen

Go bietet auch die Typen int und uint, die mindestens 32 Bits groß sind, aber abhängig vom System größer sein können. Sie sind oft die bequemste Wahl, wenn du keine spezifische Größe benötigst.

var flexibleNumber int = 42
var positiveFlexibleNumber uint = 42

Hier kann flexibleNumber positiv oder negativ sein, während positiveFlexibleNumber immer nicht-negativ ist.

Fließkommazahlen

Nun sprechen wir über Fließkommazahlen. Diese werden für Zahlen mit Dezimalpunkten verwendet, wie die Kosten pro Person für unser Partyessen.

Go bietet zwei Fließkommatypen:

Typ	Größe (Bits)	Genauigkeit
float32	32	Etwa 7 Dezimalstellen
float64	64	Etwa 15 Dezimalstellen

Sehen wir uns an, wie wir sie verwenden können:

package main

import "fmt"

func main() {
var costPerPerson float32 = 15.50
var totalBudget float64 = 1000.75

fmt.Printf("Kosten pro Person: $%.2f\n", costPerPerson)
fmt.Printf("Gesamtbudget: $%.2f\n", totalBudget)
}

In diesem Beispiel verwenden wir float32 für die Kosten pro Person (da wir keine extreme Genauigkeit benötigen) und float64 für das Gesamtbudget (wo wir möglicherweise mehr Dezimalstellen für genaue Berechnungen wollen).

Das %.2f in der Printf-Funktion weist Go an, die Fließkommazahl mit zwei Dezimalstellen anzuzeigen.

Andere numerische Typen

Go bietet einige weitere numerische Typen, die in bestimmten Situationen nützlich sind.

Komplexe Zahlen

Ja, Go kann komplexe Zahlen handhaben! Es bietet zwei Typen:

Typ	Beschreibung
complex64	Komplexe Zahlen mit float32 realen und imaginären Teilen
complex128	Komplexe Zahlen mit float64 realen und imaginären Teilen

Hier ist ein schneller Beispiel:

package main

import "fmt"

func main() {
var c64 complex64 = 1 + 2i
var c128 complex128 = 3 + 4i

fmt.Println("Complex64:", c64)
fmt.Println("Complex128:", c128)
}

Obwohl du komplexe Zahlen vielleicht nicht oft verwendest, ist es gut zu wissen, dass Go dich unterstützt, wenn du sie benötigst!

Byte und Rune

Go hat auch zwei Aliase für Ganzzahltypen, die in bestimmten Kontexten verwendet werden:

Typ	Alias für	Gemeinsame Verwendung
byte	uint8	Repräsentiert einen Byte Daten
rune	int32	Repräsentiert einen Unicode-Zeichen

Hier ist, wie du sie verwenden könntest:

package main

import "fmt"

func main() {
var b byte = 65
var r rune = 'A'

fmt.Printf("Byte %d repräsentiert: %c\n", b, b)
fmt.Printf("Rune %d repräsentiert: %c\n", r, r)
}

In diesem Beispiel repräsentieren sowohl b als auch r den Buchstaben 'A', aber auf unterschiedliche Weise. Der Byte verwendet den ASCII-Wert, während das Rune den Unicode-Zeichenpunkt verwendet.

Fazit

Puh! Wir haben heute viel Boden coberet. Von Ganzzahlen bis hin zu Fließkommazahlen und sogar komplexen Zahlen bietet Go eine reiche Palette von Datenarten, mit denen gearbeitet werden kann. Denken daran, die richtige Datenart auszuwählen ist wie das Wahl des richtigen Werkzeugs für eine Aufgabe – es kann deinen Code effizienter machen und Fehler vorbeugen.

Während du deine Reise mit Go fortsetzt, wirst du dich mit diesen Typen wohler fühlen und lernen, wann du jeden verwenden sollst. Mach dir keine Sorgen, wenn es am Anfang überwältigend erscheint – das ist完全normal! Genau wie das Fahrradfahren, es erfordert Übung, aber bevor du es merkst, wirst du durch den Go-Code fliegen wie ein Profi.

Weiter codieren, weiter lernen und vor allem Spaß haben! Schließlich ist Programmierung ein bisschen wie die Planung der perfekten Party – es geht darum, die richtigen Elemente zusammenzubringen, um etwas Großartiges zu schaffen. Viel Spaß beim Coden!

Credits: Image by storyset