Go - Variablen: Dein Tor zur Programmiermagie

Hallo da, zukünftige Codewizardinnen und - wizards! Ich bin begeistert, dass ich euer Guide auf dieser aufregenden Reise in die Welt der Go-Programmierung sein darf. Heute tauchen wir ein in das magische Reich der Variablen - die Bausteine jedes Programms. Also, nehmt eure Zauberstäbe (Tastaturen) und lasst uns einige Codespells werfen!

Go - Variables

Was sind Variablen überhaupt?

Bevor wir uns den Go-spezifischen Details zuwenden, lassen Sie uns einen Moment innehalten, um zu verstehen, was Variablen sind. Stellt euch vor, ihr habt eine Schachtel, in der ihr Dinge lagern könnt. In der Programmierung ist eine Variable wie diese Schachtel - sie ist ein Behälter, der Daten enthält. Diese Daten können Zahlen, Text oder sogar komplexere Informationen sein. Das Schöne an Variablen ist, dass ihr das Innere der Schachtel ändern könnt (daher der Name "variable") und das Innere in verschiedenen Teilen eures Programms verwenden könnt.

Nun schauen wir, wie Go diese magischen Behälter behandelt!

Variablendefinition in Go

In Go eine Variable zu definieren, ist wie das Erstellen einer beschrifteten Schachtel für eure Daten. Es gibt einige Möglichkeiten, dies zu tun, aber lassen wir mit der einfachsten beginnen:

var name string = "Gopher"

Lassen wir das auseinanderbrechen:

var: Dieses Schlüsselwort tells Go, dass wir eine Variable deklarieren.
name: Dies ist der Name unserer Variable (die Beschriftung auf unserer Schachtel).
string: Dies ist die Art von Daten, die unsere Variable enthalten wird (in diesem Fall Text).
"Gopher": Dies ist der tatsächliche Wert, den wir in der Variable speichern.

Denkt daran wie "Hey Go, ich möchte eine Schachtel mit der Aufschrift 'name', die Text enthalten kann, und ich möchte 'Gopher' sofort hineinlegen."

Statische Typdeklaration in Go

Die statische Typdeklaration ist so, als würdet ihr Go genau sagen, welche Art von Schachtel ihr wollt, bevor ihr etwas hineinlegt. Es ist eine Möglichkeit, sehr spezifisch darüber zu sein, was deine Variable enthalten kann. Hier sind einige Beispiele:

var age int
var height float64
var isStudent bool

In diesen Beispielen erstellen wir Variablen, aber füllen sie noch nicht, sondern sagen Go nur, welche Art von Daten sie enthalten werden:

age wird ganze Zahlen (Ganzzahlen) enthalten
height wird Dezimalzahlen (Fliekommazahlen) enthalten
isStudent wird Wahr/Falsch-Werte (Booleans) enthalten

Es ist, als würdet ihr sagen: "Ich brauche eine Schachtel für ganze Zahlen, eine für Dezimalzahlen und eine für Ja/Nein-Antworten."

Dynamische Typdeklaration / Typinferenz in Go

Nun comes Go wirklich cool. Es kann oft herausfinden, welche Art von Schachtel ihr braucht, indem es schaut, was ihr hineinlegt! Dies wird als Typinferenz bezeichnet. Schaut euch das an:

name := "Gopher"
age := 25
height := 5.9
isStudent := true

In diesen Beispielen verwenden wir den Operator :=. Dies tells Go: "Hey, erstelle eine neue Variable und.figure out, welchen Typ sie basierend darauf haben sollte, was ich hineinlege." Go ist intelligent genug zu wissen, dass:

"Gopher" bedeutet, name sollte ein string sein
25 bedeutet, age sollte ein int sein
5.9 bedeutet, height sollte ein float64 sein
true bedeutet, isStudent sollte ein bool sein

Es ist wie Magie - Go erstellt automatisch die richtige Art von Schachtel für jede Datenkategorie!

Mixed Variable Deklaration in Go

Manchmal möchtet ihr vielleicht mehrere Variablen auf einmal erstellen. Go lässt euch das auf eine saubere und ordentliche Weise tun:

var (
name string = "Gopher"
age int = 25
height float64 = 5.9
isStudent bool = true
)

Dies ist, als würdet ihr eine ganze Reihe von beschrifteten Schachteln auf einmal einrichten. Es ist großartig, um verwandte Variablen zusammenzuhalten und euren Code ordentlich aussehen zu lassen.

L-Werte und R-Werte in Go

Nun kommen wir zu etwas Fortgeschrittenerem: L-Werte und R-Werte. Keine Sorge, es ist nicht so schrecklich, wie es klingt!

Ein L-Wert (linker Wert) ist etwas, das auf der linken Seite einer Zuweisung stehen kann. Es ist wie die Beschriftung auf unserer Schachtel.
Ein R-Wert (rechter Wert) ist etwas, das auf der rechten Seite einer Zuweisung stehen kann. Es ist das, was wir in die Schachtel legen.

Hier ist ein Beispiel:

name := "Gopher"  // name ist der L-Wert, "Gopher" ist der R-Wert
age := 25         // age ist der L-Wert, 25 ist der R-Wert

Denkt daran so: Der L-Wert ist die Adresse, an der wir etwas speichern, und der R-Wert ist das, was wir speichern.

Alles zusammenfügen

Lassen Sie uns mit einem kleinen, spaßigen Programm abschließen, das alles enthält, was wir gelernt haben:

package main

import "fmt"

func main() {
// Statische Typdeklaration
var greeting string

// Dynamische Typdeklaration
name := "Gopher"

// Wert zu greeting zuweisen
greeting = "Hello"

// Variablen verwenden
fmt.Println(greeting + ", " + name + "!")

// Mixed Deklaration
var (
age int = 25
height float64 = 5.9
isStudent bool = true
)

// Unsere Variablen verwenden
fmt.Printf("%s ist %d Jahre alt, %.1f Fuß groß und es ist %t, dass sie ein Student sind.",
name, age, height, isStudent)
}

Dieses Programm gibt aus:

Hello, Gopher!
Gopher ist 25 Jahre alt, 5.9 Fuß groß und es ist true, dass sie ein Student sind.

Und da habt ihr es! Ihr habt gerade eure ersten Go-Zauber mit Variablen gewirkt. Denkt daran, Übung macht den Meister, also experimentiert weiter mit verschiedenen Variablentypen und deren Verwendung. Bereit, ein Go-Programmier-Zauberer zu werden!

Credits: Image by storyset