initial import

golang-language-samples/collection-array-slice/collection.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	//Array mit fester Größe
+	var months = [12]string{"Januar",
+		"Februar", "März", "April",
+		"Mai", "Juni", "Juli", "August",
+		"September", "Oktober", "November",
+		"Dezember"}
+
+	//Slices mit immer 3 Elementen des Arrays
+	q1 := months[:3]
+	q2 := months[3:6]
+	q3 := months[6:9]
+	q4 := months[9:12]
+	//Liefert "[Januar februar März]"
+	fmt.Println(q1)
+	fmt.Println(q2)
+	fmt.Println(q3)
+	fmt.Println(q4)
+
+}

golang-language-samples/collection-array/collection.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+	//Initialisierung eines leeren Arrays
+	var str1 [3]string
+	//Befüllung durch Zuweisungen
+	str1[0] = "Hello"
+	str1[1] = "World"
+	str1[2] = "!"
+	fmt.Println(str1[0])
+	fmt.Println(len(str1))
+
+	//Initialsierung mit direkter Befüllung
+	var str2 = [3]string{"Hello", "World", "!"}
+	fmt.Println(str2[0])
+	fmt.Println(len(str2))
+}

golang-language-samples/collection-capa/collection.go

@@ -0,0 +1,25 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	//Array mit fester Größe
+	var months = [12]string{"Januar",
+		"Februar", "März", "April",
+		"Mai", "Juni", "Juli", "August",
+		"September", "Oktober", "November",
+		"Dezember"}
+
+	//Slices mit immer 3 Elementen des Arrays
+	q1 := months[:3]
+	q2 := months[3:6]
+	q3 := months[6:9]
+	q4 := months[9:12]
+
+	fmt.Printf("Length %v, Capa %v, Values: %v\n", len(q1), cap(q1), q1)
+	fmt.Printf("Length %v, Capa %v, Values: %v\n", len(q2), cap(q2), q2)
+	fmt.Printf("Length %v, Capa %v, Values: %v\n", len(q3), cap(q3), q3)
+	fmt.Printf("Length %v, Capa %v, Values: %v\n", len(q4), cap(q4), q4)
+
+}

golang-language-samples/collection-for-range/collection.go

@@ -0,0 +1,22 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	//Array mit fester Größe
+	var months = [12]string{"Januar",
+		"Februar", "März", "April",
+		"Mai", "Juni", "Juli", "August",
+		"September", "Oktober", "November",
+		"Dezember"}
+	for i, month := range months {
+		fmt.Printf("%v: %v\n", i, month)
+	}
+
+	q2 := months[3:6]
+	for i, month := range q2 {
+		fmt.Printf("%v: %v\n", i, month)
+	}
+
+}

golang-language-samples/defer-file-open/defer.go

@@ -0,0 +1,22 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+func main() {
+
+	f, err := os.Open("testfile")
+	if err != nil {
+		log.Fatalf("Konnte die Datei nicht öffnen: %v", err)
+	}
+	defer f.Close()
+
+	f2, err := os.Open("nichtVorhanden")
+	if err != nil {
+		log.Fatalf("Konnte die Datei nicht öffnen: %v", err)
+	}
+	defer f2.Close()
+	//Arbeit mit den Dateien
+}

golang-language-samples/defer-lock/defer.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+	"sync"
+)
+
+var lock sync.Mutex
+
+func wasWichtiges() {
+	lock.Lock()
+	defer lock.Unlock()
+	//auf ressourcen zugreifen
+	fmt.Println("Arbeit an gesperrter Ressource")
+}
+
+func main() {
+
+	wasWichtiges()
+	lock.Lock()
+	fmt.Println("am Ende")
+
+}

golang-language-samples/defer/defer.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+func sagA() {
+	fmt.Println("A")
+}
+
+func sagB() {
+	fmt.Println("B")
+}
+
+func main() {
+	defer sagA()
+	sagB()
+}

golang-language-samples/errors-new/errors.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+)
+
+func erzeugeEinenNeuenFehler(i int) error {
+	if i != 42 {
+		return fmt.Errorf("Mit %v lösen Sie das Problem nicht", i)
+	}
+	return nil
+}
+
+func erzeugeNochEinenFehler() error {
+	return errors.New("Da ist noch ein Problem")
+}
+
+func main() {
+	err := erzeugeEinenNeuenFehler(13)
+	if err != nil {
+		fmt.Printf("Es ist ein Fehler aufgetreten: %v\n", err)
+	}
+	err = erzeugeNochEinenFehler()
+	if err != nil {
+		fmt.Printf("Es ist ein Fehler aufgetreten: %v\n", err)
+	}
+
+}

golang-language-samples/errors-owntyp-wrap/errors.go

@@ -0,0 +1,49 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"log"
+)
+
+var PermissionError = errors.New("keine Berechtigung")
+
+//StatementExecutionError ist ein eigener Fehlertyp
+//mit zusätzlicher Information
+type StatementExecutionError struct {
+	Statement string
+	Message   string
+	Cause     error
+}
+
+func (wse *StatementExecutionError) Unwrap() error {
+	return wse.Cause
+}
+
+//Implementierung der Error Methode des error Interface
+func (wse *StatementExecutionError) Error() string {
+	return wse.Message
+}
+
+func fuehreStatementAus(statement string) error {
+	if statement != "1=1" {
+		return &StatementExecutionError{
+			Statement: statement,
+			Message:   "Statement kann nicht ausgeführt werden",
+			Cause:     PermissionError,
+		}
+	}
+	return nil
+}
+
+func main() {
+	err := fuehreStatementAus("v:=b")
+	//Prüfung über errors Package
+	if errors.Is(err, PermissionError) {
+		log.Fatal("Das Statement konnte nicht ausgeführt werden.")
+	} else {
+		fmt.Println("alles ok")
+	}
+
+	panic("")
+}

golang-language-samples/errors-owntyp/errors.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"log"
+)
+
+//StatementExecutionError ist ein eigener Fehlertyp
+//mit zusätzlicher Information
+type StatementExecutionError struct {
+	Statement string
+	Message   string
+}
+
+//Implementierung der Error Methode des error Interface
+func (wse *StatementExecutionError) Error() string {
+	return wse.Message
+}
+
+func fuehreStatementAus(statement string) error {
+	if statement != "1=1" {
+		return &StatementExecutionError{
+			Statement: statement,
+			Message:   "Statement kann nicht ausgeführt werden",
+		}
+	}
+	return nil
+}
+
+func main() {
+	err := fuehreStatementAus("v:=b")
+	//Prüfung über Simple-Statement mit Type-Assertion
+	if e, ok := err.(*StatementExecutionError); ok {
+		log.Fatalf("Das Statement '%v' konnte nicht ausgeführt werden.", e.Statement)
+	} else {
+		fmt.Println("alles ok")
+	}
+}

golang-language-samples/errors/errors.go

@@ -0,0 +1,16 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+func main() {
+	f, err := os.Open("datei-ist-nicht-da.txt")
+	if err != nil {
+		//Durch den Aufruf von log.Fatalf wird die weitere
+		// Verarbeitung abgebrochen und die Anwendung beendet
+		log.Fatalf("Konnte die Datei nicht öffnen, da %v", err)
+	}
+	f.Close()
+}

golang-language-samples/for-range/main.go

@@ -0,0 +1,19 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	text := "Hello"
+
+	//Nur Zuweisung des Index
+	for v := range text {
+		fmt.Print(v)
+	}
+
+	//Zuweisung von Index und Wert
+	for i, v := range text {
+		fmt.Printf("index %d value %c\n", i, v)
+	}
+
+}

golang-language-samples/pointer-parameter/pointer.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+type Person struct {
+	Name string
+}
+
+func sayHello(p interface{}) {
+	t, ok := p.(*Person)
+	fmt.Println(t)
+	fmt.Println(ok)
+}
+
+func main() {
+
+	p := &Person{"Kristian"}
+	sayHello(p)
+
+}

golang-language-samples/pointer-receiver/pointer.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"fmt"
+)
+
+type Person struct {
+	alter int
+}
+
+func (p *Person) Alter() int {
+	return p.alter
+}
+
+func (p *Person) GeburtstagFeiern() {
+	p.alter = p.alter + 1
+}
+
+func main() {
+	p := Person{5}
+	p.GeburtstagFeiern()
+	fmt.Println(p.Alter())
+}

golang-language-samples/pointer-struct/pointer.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+type Person struct {
+	Name string
+}
+
+func main() {
+	p := &Person{}
+	p.Name = "Kristian"
+	(*p).Name = "Kristian" //beide Zeilen sind gleichbedeutend
+	fmt.Println(p)
+}

golang-language-samples/pointer/pointer.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	var month = "Januar"
+	//Erstellt einen Pointer auf die Variable month
+	var monthPtr = &month
+	//Ändern den Wert von month über den Pointer monthPtr
+	*monthPtr = "Februar"
+
+	fmt.Println(month)
+
+}

golang-language-samples/sampledoc/first.go

@@ -0,0 +1,7 @@
+//Package sampledoc zeigt wie man Integer Werte addiert.
+package sampledoc
+
+//Add addiert zwei Integer Werte und liefert das Ergebnis.
+func Add(first int, second int) int {
+	return first + second
+}

golang-language-samples/sampledoc/first_example_test.go

@@ -0,0 +1,12 @@
+package sampledoc
+
+import "fmt"
+
+func ExampleAdd() {
+
+	res := Add(1, 2)
+	fmt.Println(res)
+
+	//Output: 3
+
+}

golang-language-samples/switch-case-falltrough/switch-case.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	val := 2
+	var erg int
+
+	switch {
+	case val == 2:
+		erg = val * 2
+		fallthrough
+	case val < 10:
+		erg = erg * 2
+	case val < 100:
+		erg = erg * 3
+	default:
+		erg = 1
+	}
+
+	fmt.Println(erg)
+
+}

golang-language-samples/switch-case-no-expression/switch-case.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	val := 2 * 5
+
+	switch {
+	case val == 10:
+		fmt.Println("10!")
+	case val < 10:
+		fmt.Println("kleiner 10")
+	default:
+		fmt.Println("größer 10")
+	}
+
+}

golang-language-samples/switch-case/switch-case.go

@@ -0,0 +1,18 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	val := 2 * 6
+
+	switch val {
+	case 10:
+		fmt.Println("10!")
+	case 1, 2, 3, 4, 5, 6, 7, 8, 9:
+		fmt.Println("kleiner 10")
+	default:
+		fmt.Println("größer 10")
+	}
+
+}

golang-language-samples/type-alias-definition/type-definition.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+type (
+	A1 = string // A1 und string bezeichen identische Typen
+	A2 = A1     // A2 und A1 bezeichen identische Typen
+)
+
+func main() {
+	var text A2
+	fmt.Println(text)
+}

golang-language-samples/type-definition-assertion/type-definition.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+	//Variable muss ein Interfacetyp sein
+	var i interface{} = "hello"
+
+	//direkte Zuweisung ohne Prüfung
+	s := i.(string)
+	fmt.Println(s)
+
+	//Zuweisung mit Prüfung ob möglich
+	s, ok := i.(string)
+	fmt.Println(s, ok)
+
+	//Zuweisung mit Prüfung ob möglich
+	f, ok := i.(int)
+	fmt.Println(f, ok)
+
+	//Zuweisung ohne Prüfung führt zu Panic
+	f = i.(int)
+	fmt.Println(f)
+}

golang-language-samples/type-definition-interface-receiver/type-definition.go

@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+type Dog interface {
+	Bark()
+}
+
+type Dackel struct {
+	name string
+}
+
+func (d Dackel) Bark() {
+	fmt.Printf("Wuff %v\n", d.name)
+}
+
+func main() {
+	var d Dog
+	d = Dackel{"Heino"}
+	d.Bark()
+}

golang-language-samples/type-definition-interface/type-definition.go

@@ -0,0 +1,16 @@
+package main
+
+import "fmt"
+
+type File interface {
+	Read([]byte) (int, error)
+	Write([]byte) (int, error)
+	Close() error
+}
+
+func main() {
+
+	var f File
+	fmt.Println(f)
+
+}

golang-language-samples/type-definition-struct/type-definition.go

@@ -0,0 +1,15 @@
+package main
+
+import "fmt"
+
+type Person struct {
+	vorname  string
+	nachname string
+}
+
+func main() {
+	p := Person{"Kristian", "Köhler"}
+	p2 := Person{nachname: "Köhler"}
+	fmt.Println(p.vorname)
+	fmt.Println(p2.nachname)
+}

golang-language-samples/type-definition-switch/type-definition.go

@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+func checkMyType(i interface{}) {
+	switch i.(type) {
+	case string:
+		fmt.Println("Es ist ein string")
+	case int:
+		fmt.Println("Es ist ein int")
+	default:
+		fmt.Println("Es ist weder string noch int")
+	}
+}
+
+func main() {
+	checkMyType("Hello")
+	checkMyType(1)
+	checkMyType(3.4)
+}

golang-language-samples/type-definition/type-definition.go

@@ -0,0 +1,13 @@
+package main
+
+import "fmt"
+
+type (
+	Point struct{ x, y float64 }
+	polar Point
+)
+
+func main() {
+	var p Point
+	fmt.Println(p)
+}

golang-language-samples/type-failure/type-failure.go

@@ -0,0 +1,11 @@
+package main
+
+import "fmt"
+
+func main() {
+
+	var i int = "Hello"
+
+	fmt.Println(i)
+
+}