Go: Variablen, Typen und Konstanten

Kurz: import “fmt”

Teil des Kurses Go

Kapitel 2 von 11 im Kurs Go (Abschnitt „Grundlagen“). Mit Fortschritt, Quiz und Zertifikat auf der Lernseite.

package main
 
import "fmt"
 
func main() {
    var alter int = 17           // ausführlich
    var preis = 19.99            // Typ wird erkannt (float64)
    name := "Mia"                // Kurzform: nur in Funktionen
    var a, b int = 1, 2
    x, y := 3.5, "text"
    var leer int                 // Nullwert: 0
    var text string              // Nullwert: ""
    var ok bool                  // Nullwert: false
 
    const Pi = 3.14159
    const (
        Montag = iota            // 0
        Dienstag                 // 1
        Mittwoch                 // 2
    )
 
    fmt.Println(alter, preis, name, a, b, x, y)
    fmt.Printf("%d %q %t | %.2f | %d %d %d\n", leer, text, ok, Pi, Montag, Dienstag, Mittwoch)
    fmt.Printf("Typen: %T %T %T %T\n", alter, preis, name, ok)
}

Ausgabe:

17 19.99 Mia 1 2 3.5 text
0 "" false | 3.14 | 0 1 2
Typen: int float64 string bool

Die wichtigsten Typen

Typ	Beschreibung
int, int8 … int64, uint, uint8 …	ganze Zahlen (int = 32 oder 64 Bit)
float32, float64	Kommazahlen (float64 Standard)
bool	true / false
string	Text (UTF-8, unveränderlich)
byte (= uint8), rune (= int32)	Byte, Unicode-Zeichen
[]T, map[K]V, [N]T	Slice, Map, Array
*T	Zeiger
error	Fehler (Interface)
any (= interface{})	beliebiger Typ

Go wandelt Typen nie automatisch um. Du schreibst die Umwandlung aus:

package main
 
import (
    "fmt"
    "strconv"
)
 
func main() {
    var i int = 7
    var f float64 = float64(i) / 2        // explizit
    var u uint8 = uint8(300 % 256)
    fmt.Println(f, u, 7/2, 7%3, 7.0/2)
 
    n, err := strconv.Atoi("42")          // Text -> Zahl
    fmt.Println(n+1, err)
    _, err = strconv.Atoi("abc")
    fmt.Println(err)
    s := strconv.Itoa(2025) + "!"
    fmt.Println(s, strconv.Quote("hi"), strconv.FormatFloat(3.14159, 'f', 2, 64))
    b, _ := strconv.ParseBool("true")
    fmt.Println(b)
}

Ausgabe:

3.5 44 3 1 3.5
43 <nil>
strconv.Atoi: parsing "abc": invalid syntax
2025! "hi" 3.14
true

Strings und Runen

Ein string besteht aus Bytes (UTF-8). Umlaute belegen mehrere Bytes. Ein rune ist ein Unicode-Zeichen:

package main
 
import (
    "fmt"
    "strings"
    "unicode/utf8"
)
 
func main() {
    s := "Größe"
    fmt.Println(len(s), utf8.RuneCountInString(s), []rune(s)[2], string([]rune(s)[2]))
    for i, r := range s {                 // range über einen String liefert Runen
        fmt.Print(i, ":", string(r), " ")
    }
    fmt.Println()
    fmt.Println(strings.ToUpper(s), strings.Contains(s, "ö"), strings.Repeat("ab", 3))
    fmt.Println(strings.Split("a,b,c", ","), strings.Join([]string{"x", "y"}, "-"), strings.TrimSpace("  hi  "))
    fmt.Println(strings.Fields("  viele   Wörter hier "), strings.Replace("aaa", "a", "b", 2), strings.HasPrefix("Golang", "Go"))
    roh := `Rohtext mit "Anführungszeichen" und \n ohne Maskierung`
    fmt.Println(roh)
}

Ausgabe:

7 5 246 ö
0:G 1:r 2:ö 4:ß 6:e
GRÖßE true ababab
[a b c] x-y hi
[viele Wörter hier] bba true
Rohtext mit "Anführungszeichen" und \n ohne Maskierung

Formatierte Ausgabe

Verb	Bedeutung
%v	Standarddarstellung
%+v, %#v	mit Feldnamen, Go-Syntax
%T	Typ
%d, %b, %x	ganze Zahl dezimal, binär, hex
%f, %.2f, %e	Kommazahl
%s, %q	String, in Anführungszeichen
%c, %U	Zeichen, Unicode
%t	bool
%p	Zeiger
%5d, %-5d, %05d	Breite und Ausrichtung

package main
 
import "fmt"
 
type Punkt struct{ X, Y int }
 
func main() {
    p := Punkt{1, 2}
    fmt.Printf("%v %+v %#v %T\n", p, p, p, p)
    fmt.Printf("|%5d|%-5d|%05d|%x|%b|%c|%U|\n", 42, 42, 42, 255, 5, 'G', 'G')
    fmt.Printf("%8.3f|%e|%q|%v\n", 3.14159, 12345.678, "hi", []string{"a", "b"})
    s := fmt.Sprintf("%s hat %d Punkte", "Mia", 42)
    fmt.Println(s)
}

Ausgabe:

{1 2} {X:1 Y:2} main.Punkt{X:1, Y:2} main.Punkt
|   42|42   |00042|ff|101|G|U+0047|
   3.142|1.234568e+04|"hi"|[a b]
Mia hat 42 Punkte

Merke

• Deklaration mit var oder Kurzform := (nur in Funktionen); jede Variable hat einen Nullwert
• Keine automatischen Typumwandlungen: float64(i), strconv.Atoi
• const mit iota für Aufzählungen
• Strings sind UTF-8-Bytes; rune und range für Zeichen
• fmt.Printf mit Verben %v %d %s %f %T

Übungsaufgabe

Lies (simuliert) eine Zahl als Text ein, wandle sie mit strconv um, berechne das Quadrat und gib es formatiert aus.

Quiz zur Selbstkontrolle

Welchen Wert hat eine nicht initialisierte int-Variable in Go?

• 0 (richtig)
• undefiniert
• null
• -1

Wofür steht :=?

• Deklaration mit Typinferenz innerhalb von Funktionen (richtig)
• Vergleich
• Konstante
• Zeigerzuweisung

Was ist ein rune?

• Ein Unicode-Zeichen (int32) (richtig)
• Ein Byte
• Ein Text
• Ein Zeiger

Weiter im Kurs

Zurück: Was ist Go?

Weiter: Bedingungen, Schleifen und switch

Alle Kapitel: Go im Überblick