Skip to main content

Datentypen & Verzweigungen

Variablen

Variablen (Spec) werden mit dem Schlüsselwort var deklariert:

var [Bezeichner] [Datentyp]

Im Gegensatz zu vielen anderen Programmiersprachen wird zuerst der Bezeichner und erst dann der Datentyp angegeben!

Beispiele:

var result int
var caption string
var isReady bool

Eine neu deklarierte Variable wird mit dem Nullwert (zero value) des jeweiligen Datentyps initialisiert, z.B. 0 bei Ganzzahlen, false bei Wahrheitswerten, oder "" bei Zeichenketten.

Es ist auch möglich, bei der Deklaration einen Wert anzugeben:

var [Bezeichner] [Datentyp] = [Wert]

Beispiele:

var result int = 5
var caption string = "Hello"
var isReady bool = true

Gibt man einen Wert an, kann der Compiler den Datentyp anhand dieses Werts festlegen. Der Datentyp kann dann auch weggelassen werden:

var result = 5
var caption = "Hello"
var isReady = true

Die Deklaration kann mit folgender Kurzschreibweise und dem Operator := weiter vereinfacht werden:

result := 5
isReady := true
caption := "Hello"

Es ist auch möglich, mehrere Variablen in einer Zeile zu deklarieren und zu initialisieren:

var a, b, c = 1, "Hey", false
d, e, f := 2, "Ho", true

Konstanten

Konstanten (Spec) lassen sich mit dem Schlüsselwort const definieren:

const [Bezeichner] [Datentyp] = [Wert]

Da sich Konstanten im weiteren Programmverlauf nicht ändern können, muss der Wert gleich bei der Deklaration angegeben werden. Der Datentyp ist wiederum optional, da er vom Compiler erraten werden kann. Beispiele:

const g float32 = 9.81
const pi float64 = 3.14159265359
const name = "Brandon"

Konstanten stehen nur für Ausdrücke zur Verfügung, die zur Kompilierzeit ermittelt werden können.

Primitive Datentypen

In Go stehen u.a. die folgenden (primitiven) Datentypen (Spec) zur Verfügung:

  • Zahlen
    • Ganzzahlen (integer)
      • vorzeichenbehaftet (signed): int, int8, int16, int32, int64
      • ohne Vorzeichen (unsigned): uint, uint8, uint16, uint32, uint64
        • byte ist ein Alias für uint8
      • Die Zahl steht jeweils für die Anzahl verwendeter Bits.
      • Bei int und uint verwendet der Compiler die native Anzahl Bytes der Architektur (z.B. 64 Bits bei amd64)
    • Gleitkommazahlen: float32 und float64
  • Wahrheitswerte (boolean): bool mit den Werten true und false
  • Zeichen: rune (ein Unicode-Zeichen und Alias für int32)
  • Zeichenketten: string

Eine rune wird mit dem Wert '0' initialisiert, ein string mit der leeren Zeichenkette "". Ein string besteht aus runes.

Beispiel:

var rooms uint8 = 7
var amount uint64 = 10_000_000
var result int64 = 1e9

var g float32 = 9.81
var pi float64 = 3.141592653589793

var ready bool = false

var ellipsis rune = '…'
var meal string = "Smørrebrød"
var author string = "Достоевский"

fmt.Println(rooms, amount, result, g, pi, ready, ellipsis, meal, author)

Ausgabe:

7 10000000 1000000000 9.81 3.141592653589793 false 8230 Smørrebrød Достоевский
  • _ kann als Tausendertrennzeichen verwendet werden.
  • Die Exponentialschreibweise 1e9 bedeutet: 1 * 10^9 (eine Milliarde bzw. eine Eins mit neun Nullen).
  • In Go können Unicode-Zeichen verwendet werden. Eine rune ist ein sogenannter Unicode Code Point; ein string besteht aus mehreren runes.

Formatierte Ausgabe

Das Package fmt (Doc) stellt Funktionen zur formatierten Ausgabe von Werten zur Verfügung. Die Funktionen mit dem Suffix f (z.B. Printf) erwarten als erstes Argument einen Format-String; als weitere Argumente werden die auszugebenden Ausdrücke erwartet.

Beispiel:

var x byte = 129
fmt.Printf("%d %o %b\n", x, x, x)

var y int = 0xdeadbeef
fmt.Printf("%d %x %X\n", y, y, y)

var z float64 = 10.0 / 3.0
fmt.Printf("%.5f %10.5f %1.1f\n", z, z, z)

var ready bool = false
fmt.Printf("%t %v\n", ready, ready)

var ellipsis rune = '…'
fmt.Printf("%d %c %U\n", ellipsis, ellipsis, ellipsis)

var name string = "Достоевский"
fmt.Printf("%s %q %v\n", name, name, name)

Ausgabe:

129 201 10000001
3735928559 deadbeef DEADBEEF
3.33333    3.33333 3.3
false false
8230 … U+2026
Достоевский "Достоевский" Достоевский
  • Ganzzahlen können dezimal (%d), oktal (%o), binär (%b) oder hexadezimal (%x bzw. %X) ausgegeben werden.
  • Bei Gleitkommazahlen kann die Länge links und rechts vom Komma separat spezifiziert werden (%X.Yf).
  • Booleans können mit %t als true oder false ausgegeben werden.
  • Eine rune kann als dezimaler Wert, als Zeichen oder in Unicode-Notation (Code Point) ausgegeben werden.
  • Mithilfe von %q kann ein Wert in Go-Syntax ausgegeben werden.
  • Mit %v lassen sich alle Werte ausgeben.

Standardausgabe, Standardfehler

Bei Unix-artigen Betriebssystemen erfolgt der Dateizugriff über sogenannte File Handles, welche von einer Zahl repräsentiert werden. Jedes Programm, auch wenn es keine Dateien öffnet, verfügt über die folgende File Handles:

  • 0 (os.Stdin): Standardeingabe
  • 1 (os.Stdout): Standardausgabe
  • 2 (os.Stderr): Standardfehler

Funktionen im fmt-Modul mit dem Präfix F erwarten als ersten Parameter einen File Handle:

fmt.Fprintln(os.Stdout, "Hello, Output!")
fmt.Fprintln(os.Stderr, "Hello, Error!")

Standardausgabe und -fehler erfolgen normalerweise aufs Terminalfenster, sodass man die Ausgaben auf diese Handles nicht ohne Weiteres unterscheiden kann:

$ go run main.go
Hello, Output!
Hello, Error!

Eine Unix-Shell erlaubt jedoch die Umleitung via > (stdout) und 2> (stderr):

$ go run main.go >out.txt
Hello, Error!
$ cat out.txt
Hello, Output!

$ go run main.go 2>err.txt
Hello, Output!
$ cat err.txt
Hello, Error!

Will man beide Ausgaben in die gleiche Datei umleiten, steht der Operator 2>&1 zur Verfügung:

$ go run main.go >out.txt 2>&1
$ cat out.txt
Hello, Output!
Hello, Error!

Dieser Mechanismus wird gebraucht, um verschiedenartige Ausgaben des gleichen Programms an verschiedene Stellen zu schreiben. Beispielsweise soll der Anwender die Standardausgabe direkt sehen; Fehlermeldungen sollen jedoch nur in der Standardfehlerausgabe erscheinen.

Ausgabe in einen String

Die Funktionen mit dem Präfix S schreiben den formatierten Wert nicht auf die Standardausgabe, sondern geben einen String zurück:

result := fmt.Sprintf("%.3f", 10.0/3.0)
fmt.Printf("10 divided by 3 is %s\n", result)

Ausgabe:

10 divided by 3 is 3.333

Kommentare

Kommentare beginnend mit // erstrecken sich bis zum Zeilenende.

Mehrzeilige Kommentare beginnen mit /* und enden mit */.

Beispiel:

var g float32 = 9.81 // approximation of the gravity constant

/* these variables are used
   for some intermediary
   computations to be used
   later in the program. */
var a, b, c int

Verzweigungen (Branching)

Go kennt zwei Arten der Verzwegungen: if/else und switch/case. Die Funktionsweise ist vergleichbar mit den entsprechenden Konstrukten aus anderen Programmiersprachen, jedoch gibt es auch einige wichtige Unterschiede.

if/else

Ein bedingter Codeblock kann mit if (Spec) umgesetzt werden, wobei die Bedingung nicht in Klammern stehen muss:

maxPoints := 100.0
scored := 75.0
ratio := scored / maxPoints

if ratio > 0.8 {
	fmt.Println("a ratio of", ratio, "is excellent")
}
if ratio > 0.6 {
	fmt.Println("a ratio of", ratio, "is good")
}

Es wird immer ein Codeblock benötigt, der auf der gleichen Zeile wie die Bedingung anfangen muss.

Ausgabe:

a ratio of 0.75 is good

Alternativbedingungen können mit else formuliert werden. Mehrere Alternativbedingungen lassen sich mittels else if definieren:

if ratio > 0.8 {
	fmt.Println("a ratio of", ratio, "is excellent")
} else if ratio > 0.6 {
	fmt.Println("a ratio of", ratio, "is good")
} else if ratio > 0.4 {
	fmt.Println("a ratio of", ratio, "is acceptable")
} else {
	fmt.Println("a ratio of", ratio, "is poor")
}

switch/case

Oftmals wird dieselbe Variable in allen Bedingungen mit einem konstanten Wert verglichen:

if grade == 6 {
	fmt.Println("very good")
} else if grade == 5 {
	fmt.Println("good")
} else if grade == 4 {
	fmt.Println("sufficient")
} else if grade == 3 {
	fmt.Println("insufficient")
} else if grade == 2 {
	fmt.Println("bad")
} else if grade == 1 {
	fmt.Println("very bad")
}

In diesem Fall ist ein switch/case-Konstrukt (Spec) besser lesbar:

switch grade {
case 6:
	fmt.Println("very good")
case 5:
	fmt.Println("good")
case 4:
	fmt.Println("sufficient")
case 3:
	fmt.Println("insufficient")
case 2:
	fmt.Println("bad")
case 1:
	fmt.Println("very bad")
}

Im Gegensatz zu anderen Programmiersprachen aus der C-Sprachfamilie ist kein break nötig um einen Arm zu terminieren! (Das Gegenteilige Verhalten kann jedoch mit fallthrough erreicht werden; siehe weiter unten.)

default

Beim if/else-Konstrukt fängt der else-Block alle Fälle ab, auf die keine der vorhergehenden if- oder else if-Bedingungen gepasst hat. Beim switch/case-Konstrukt gibt es hierfür den default-Block:

switch grade {
case 6:
	fmt.Println("very good")
case 5:
	fmt.Println("good")
case 4:
	fmt.Println("sufficient")
case 3:
	fmt.Println("insufficient")
case 2:
	fmt.Println("bad")
case 1:
	fmt.Println("very bad")
default:
	fmt.Println("unknown grade")
}

fallthrough

Soll nach zutreffender Bedingung nicht nur der aktuelle Block ausgeführt werden, sondern auch der nächste Block, kann dies mit fallthrough (Spec) erreicht werden:

switch grade {
case 6:
	fallthrough
case 5:
	fallthrough
case 4:
	fmt.Println("passed the exam")
case 3:
	fallthrough
case 2:
	fallthrough
case 1:
	fmt.Println("failed the exam")
default:
	fmt.Println("unknown result")
}

Für die Werte 4, 5 und 6 von grade gilt die Prüfung als bestanden, für die Werte 1, 2 und 3 als nicht bestanden.