forked from WEB-IMB-WS2526/lab-development-imb
07: Demos und Labor
parent
e5bed143ff
commit
9e9ab1628d
|
|
@ -1,19 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
|
||||
//Strings
|
||||
fmt.Println("go" + "lang")
|
||||
|
||||
//Integers
|
||||
fmt.Println("1+1 =", 1+1)
|
||||
//Floats
|
||||
fmt.Println("7.0/3.0 =", 7.0/3.0)
|
||||
|
||||
//Boolean
|
||||
fmt.Println(true && false)
|
||||
fmt.Println(true || false)
|
||||
fmt.Println(!true)
|
||||
}
|
||||
|
|
@ -1,23 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
var z = "initial"
|
||||
|
||||
func main() {
|
||||
|
||||
var a = "initial"
|
||||
fmt.Println(a)
|
||||
|
||||
var b, c int = 1, 2
|
||||
fmt.Println(b, c)
|
||||
|
||||
var d = true
|
||||
fmt.Println(d)
|
||||
|
||||
var e int
|
||||
fmt.Println(e)
|
||||
|
||||
f := "apple"
|
||||
fmt.Println(f)
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"math"
|
||||
)
|
||||
|
||||
const s string = "constant"
|
||||
|
||||
func main() {
|
||||
fmt.Println(s)
|
||||
|
||||
const n = 500000000
|
||||
|
||||
const d = 3e20 / n
|
||||
fmt.Println(d)
|
||||
|
||||
fmt.Println(int64(d))
|
||||
|
||||
fmt.Println(math.Sin(n))
|
||||
}
|
||||
|
|
@ -1,32 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
|
||||
i := 1
|
||||
for i <= 3 {
|
||||
fmt.Println(i)
|
||||
i = i + 1
|
||||
}
|
||||
|
||||
for j := 0; j < 3; j++ {
|
||||
fmt.Println(j)
|
||||
}
|
||||
|
||||
for i := range 3 {
|
||||
fmt.Println("range", i)
|
||||
}
|
||||
|
||||
for {
|
||||
fmt.Println("loop")
|
||||
break
|
||||
}
|
||||
|
||||
for n := range 6 {
|
||||
if n%2 == 0 {
|
||||
continue
|
||||
}
|
||||
fmt.Println(n)
|
||||
}
|
||||
}
|
||||
|
|
@ -1,28 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
|
||||
if 7%2 == 0 {
|
||||
fmt.Println("7 is even")
|
||||
} else {
|
||||
fmt.Println("7 is odd")
|
||||
}
|
||||
|
||||
if 8%4 == 0 {
|
||||
fmt.Println("8 is divisible by 4")
|
||||
}
|
||||
|
||||
if 8%2 == 0 || 7%2 == 0 {
|
||||
fmt.Println("either 8 or 7 are even")
|
||||
}
|
||||
|
||||
if num := 9; num < 0 {
|
||||
fmt.Println(num, "is negative")
|
||||
} else if num < 10 {
|
||||
fmt.Println(num, "has 1 digit")
|
||||
} else {
|
||||
fmt.Println(num, "has multiple digits")
|
||||
}
|
||||
}
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"time"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
i := 2
|
||||
fmt.Print("Write ", i, " as ")
|
||||
switch i {
|
||||
case 1:
|
||||
fmt.Println("one")
|
||||
case 2:
|
||||
fmt.Println("two")
|
||||
case 3:
|
||||
fmt.Println("three")
|
||||
}
|
||||
|
||||
switch time.Now().Weekday() {
|
||||
case time.Saturday, time.Sunday:
|
||||
fmt.Println("It's the weekend")
|
||||
default:
|
||||
fmt.Println("It's a weekday")
|
||||
}
|
||||
|
||||
t := time.Now()
|
||||
switch {
|
||||
case t.Hour() < 12:
|
||||
fmt.Println("It's before noon")
|
||||
default:
|
||||
fmt.Println("It's after noon")
|
||||
}
|
||||
|
||||
whatAmI := func(i interface{}) {
|
||||
switch t := i.(type) {
|
||||
case bool:
|
||||
fmt.Println("I'm a bool")
|
||||
case int:
|
||||
fmt.Println("I'm an int")
|
||||
default:
|
||||
fmt.Printf("Don't know type %T\n", t)
|
||||
}
|
||||
}
|
||||
whatAmI(true)
|
||||
whatAmI(1)
|
||||
whatAmI("hey")
|
||||
}
|
||||
|
|
@ -1,38 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
|
||||
var a [5]int
|
||||
fmt.Println("emp:", a)
|
||||
|
||||
a[4] = 100
|
||||
fmt.Println("set:", a)
|
||||
fmt.Println("get:", a[4])
|
||||
|
||||
fmt.Println("len:", len(a))
|
||||
|
||||
b := [5]int{1, 2, 3, 4, 5}
|
||||
fmt.Println("dcl:", b)
|
||||
|
||||
b = [...]int{1, 2, 3, 4, 5}
|
||||
fmt.Println("dcl:", b)
|
||||
|
||||
b = [...]int{100, 3: 400, 500}
|
||||
fmt.Println("idx:", b)
|
||||
|
||||
var twoD [2][3]int
|
||||
for i := 0; i < 2; i++ {
|
||||
for j := 0; j < 3; j++ {
|
||||
twoD[i][j] = i + j
|
||||
}
|
||||
}
|
||||
fmt.Println("2d: ", twoD)
|
||||
|
||||
twoD = [2][3]int{
|
||||
{1, 2, 3},
|
||||
{1, 2, 3},
|
||||
}
|
||||
fmt.Println("2d: ", twoD)
|
||||
}
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func zeroval(ival int) {
|
||||
ival = 0
|
||||
}
|
||||
|
||||
func zeroptr(iptr *int) {
|
||||
*iptr = 0
|
||||
}
|
||||
|
||||
func main() {
|
||||
i := 1
|
||||
fmt.Println("initial:", i)
|
||||
|
||||
zeroval(i)
|
||||
fmt.Println("zeroval:", i)
|
||||
|
||||
zeroptr(&i)
|
||||
fmt.Println("zeroptr:", i)
|
||||
|
||||
fmt.Println("pointer:", &i)
|
||||
}
|
||||
|
|
@ -1,58 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"slices"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
var s []string
|
||||
fmt.Println("uninit:", s, s == nil, len(s) == 0)
|
||||
|
||||
s = make([]string, 3)
|
||||
fmt.Println("emp:", s, "len:", len(s), "cap:", cap(s))
|
||||
|
||||
s[0] = "a"
|
||||
s[1] = "b"
|
||||
s[2] = "c"
|
||||
fmt.Println("set:", s)
|
||||
fmt.Println("get:", s[2])
|
||||
|
||||
fmt.Println("len:", len(s))
|
||||
|
||||
s = append(s, "d")
|
||||
s = append(s, "e", "f")
|
||||
fmt.Println("apd:", s)
|
||||
|
||||
c := make([]string, len(s))
|
||||
copy(c, s)
|
||||
fmt.Println("cpy:", c)
|
||||
|
||||
l := s[2:5]
|
||||
fmt.Println("sl1:", l)
|
||||
|
||||
l = s[:5]
|
||||
fmt.Println("sl2:", l)
|
||||
|
||||
l = s[2:]
|
||||
fmt.Println("sl3:", l)
|
||||
|
||||
t := []string{"g", "h", "i"}
|
||||
fmt.Println("dcl:", t)
|
||||
|
||||
t2 := []string{"g", "h", "i"}
|
||||
if slices.Equal(t, t2) {
|
||||
fmt.Println("t == t2")
|
||||
}
|
||||
|
||||
twoD := make([][]int, 3)
|
||||
for i := 0; i < 3; i++ {
|
||||
innerLen := i + 1
|
||||
twoD[i] = make([]int, innerLen)
|
||||
for j := 0; j < innerLen; j++ {
|
||||
twoD[i][j] = i + j
|
||||
}
|
||||
}
|
||||
fmt.Println("2d: ", twoD)
|
||||
}
|
||||
|
|
@ -1,42 +0,0 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"maps"
|
||||
)
|
||||
|
||||
func main() {
|
||||
|
||||
m := make(map[string]int)
|
||||
|
||||
m["k1"] = 7
|
||||
m["k2"] = 13
|
||||
|
||||
fmt.Println("map:", m)
|
||||
|
||||
v1 := m["k1"]
|
||||
fmt.Println("v1:", v1)
|
||||
|
||||
v3 := m["k3"]
|
||||
fmt.Println("v3:", v3)
|
||||
|
||||
fmt.Println("len:", len(m))
|
||||
|
||||
// delete(m, "k2")
|
||||
// fmt.Println("map:", m)
|
||||
|
||||
// clear(m)
|
||||
// fmt.Println("map:", m)
|
||||
|
||||
wert, prs := m["k2"]
|
||||
fmt.Println("prs:", prs)
|
||||
fmt.Println("wert:", wert)
|
||||
|
||||
n := map[string]int{"foo": 1, "bar": 2}
|
||||
fmt.Println("map:", n)
|
||||
|
||||
n2 := map[string]int{"foo": 1, "bar": 2}
|
||||
if maps.Equal(n, n2) {
|
||||
fmt.Println("n == n2")
|
||||
}
|
||||
}
|
||||
|
|
@ -1,36 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func plus(a int, b int) int {
|
||||
return a + b
|
||||
}
|
||||
|
||||
func plusPlus(a, b, c int) int {
|
||||
return a + b + c
|
||||
}
|
||||
|
||||
func plusNamed(a, b int) (result int) {
|
||||
result = a + b
|
||||
return
|
||||
}
|
||||
|
||||
func plusDescription(a int, b int) (int, string) {
|
||||
result := a + b
|
||||
return result, fmt.Sprintf("%d+%d = %d", a, b, result)
|
||||
}
|
||||
|
||||
func main() {
|
||||
|
||||
res := plus(1, 2)
|
||||
fmt.Println("1+2 =", res)
|
||||
|
||||
res = plusPlus(1, 2, 3)
|
||||
fmt.Println("1+2+3 =", res)
|
||||
|
||||
res = plusNamed(1, 2)
|
||||
fmt.Println("1+2 =", res)
|
||||
|
||||
_, desc := plusDescription(1, 2)
|
||||
fmt.Println(desc)
|
||||
}
|
||||
|
|
@ -1,7 +0,0 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
func main() {
|
||||
fmt.Println("hello world")
|
||||
}
|
||||
|
|
@ -0,0 +1,26 @@
|
|||
package main
|
||||
|
||||
import "fmt"
|
||||
|
||||
type Person struct {
|
||||
Name string
|
||||
Age int
|
||||
}
|
||||
|
||||
// Wert-Receiver: arbeitet auf einer Kopie
|
||||
func (p Person) Greet() {
|
||||
fmt.Println("Hallo,", p.Name)
|
||||
}
|
||||
|
||||
// Zeiger-Receiver: kann das Original ändern
|
||||
func (p *Person) Birthday() {
|
||||
p.Age++
|
||||
}
|
||||
|
||||
func main() {
|
||||
a := Person{Name: "Karl", Age: 30}
|
||||
|
||||
a.Greet() // Ausgabe: Hallo, Karl
|
||||
a.Birthday() // Alter wird erhöht
|
||||
fmt.Println(a.Age) // Ausgabe: 31
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
type helloHandler int
|
||||
|
||||
func (hello helloHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
fmt.Fprintf(w, "Hello World %d!", hello)
|
||||
}
|
||||
|
||||
func main() {
|
||||
var world helloHandler
|
||||
http.ListenAndServe("localhost:8080", world)
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
)
|
||||
|
||||
type respExampleHandler int
|
||||
|
||||
func (hello respExampleHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("my-http-header", "Ein beliebiger Text")
|
||||
w.Header().Set("Content-Type", "text/html; charset=utf-8")
|
||||
w.WriteHeader(http.StatusFound)
|
||||
w.Write([]byte("<h1>Dies ist eine HTML-Überschrift<h1>"))
|
||||
}
|
||||
|
||||
func main() {
|
||||
var r respExampleHandler
|
||||
http.ListenAndServe("localhost:8080", r)
|
||||
}
|
||||
|
|
@ -0,0 +1,36 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
type reqExampleHandler int
|
||||
|
||||
func (hello reqExampleHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
if r.Method != http.MethodGet {
|
||||
http.Error(w, "Only GET requests are allowed", http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
fmt.Println("Method:", r.Method)
|
||||
fmt.Println("URL:", r.URL.String())
|
||||
fmt.Println("Host:", r.Host)
|
||||
fmt.Println("Accept-Header", r.Header.Get("Accept"))
|
||||
|
||||
queryParams := r.URL.Query()
|
||||
fmt.Println("Query Parameters:")
|
||||
for key, values := range queryParams {
|
||||
for _, value := range values {
|
||||
fmt.Printf(" %s = %s\n", key, value)
|
||||
}
|
||||
}
|
||||
|
||||
w.Write([]byte("<h1>GET: http.Request-Beispiel<h1>"))
|
||||
}
|
||||
|
||||
func main() {
|
||||
var r reqExampleHandler
|
||||
http.ListenAndServe("localhost:8080", r)
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/http"
|
||||
)
|
||||
|
||||
type formExampleHandler int
|
||||
|
||||
func (formHandler formExampleHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
|
||||
|
||||
if r.Method != http.MethodPost {
|
||||
http.Error(w, "Only POST requests are allowed", http.StatusMethodNotAllowed)
|
||||
return
|
||||
}
|
||||
|
||||
// Formulardaten parsen und Überprüfen, ob ungültige Formulardaten gesendet wurde
|
||||
if err := r.ParseForm(); err != nil {
|
||||
http.Error(w, "Fehler beim Parsen des Formulars", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Überprüfen, ob leeres Formular gesendet wurde
|
||||
if len(r.PostForm) == 0 {
|
||||
http.Error(w, "Kein POST-Formular gesendet", http.StatusBadRequest)
|
||||
return
|
||||
}
|
||||
|
||||
// Zugriff auf PostForm-Daten
|
||||
// string mit Wert des Feldes "name"
|
||||
name := r.PostForm.Get("name")
|
||||
// []string mit allen ausgewählten Werten der Checkbox "hobby"
|
||||
hobbies := r.PostForm["hobby"]
|
||||
|
||||
// Ausgabe der Werte
|
||||
fmt.Fprintf(w, "Name: %s\n", name)
|
||||
fmt.Fprintf(w, "Hobbies:\n")
|
||||
for _, h := range hobbies {
|
||||
fmt.Fprintf(w, "- %s\n", h)
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
func main() {
|
||||
var r formExampleHandler
|
||||
http.ListenAndServe("localhost:8080", r)
|
||||
}
|
||||
|
|
@ -0,0 +1,22 @@
|
|||
<!DOCTYPE html>
|
||||
<html lang="en">
|
||||
|
||||
<head>
|
||||
<meta charset="UTF-8">
|
||||
<title>Einfaches Formular für Backend</title>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<form method="POST" action="http://localhost:8080">
|
||||
<label for="name">Name</label>
|
||||
<input name="name" id="name" />
|
||||
<p>Hobbies:
|
||||
<label><input type="checkbox" name="hobby" value="lesen"> Lesen</label>
|
||||
<label><input type="checkbox" name="hobby" value="kochen"> Kochen</label>
|
||||
<label><input type="checkbox" name="hobby" value="wandern"> Wandern</label>
|
||||
</p>
|
||||
<button type="submit">Absenden</button>
|
||||
</form>
|
||||
</body>
|
||||
|
||||
</html>
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
module taskmanager
|
||||
|
||||
go 1.24.5
|
||||
|
|
@ -0,0 +1,82 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"strconv"
|
||||
)
|
||||
|
||||
func main() {
|
||||
// Frage: Was macht dieser Teil genau?
|
||||
if len(os.Args) < 2 {
|
||||
fmt.Println("Usage: add <task> | list | done <id>")
|
||||
return
|
||||
}
|
||||
|
||||
// Lädt alle Tasks aus JSON-Datei in eine Liste
|
||||
// Gibt eine leere Liste zurück, falls die JSON-Datei noch nicht existiert
|
||||
// Gibt Fehlermeldung vom Typ error zurück, falls etwas schief gelaufen ist
|
||||
tasklist, err := LoadTasks("tasks.json")
|
||||
|
||||
// TODO: Fehlerbehandlung
|
||||
if err != nil {
|
||||
fmt.Println("Fehler beim Laden der JSON-Datei: " + err.Error())
|
||||
}
|
||||
|
||||
// Je nach Kommandozeilenargument wird:
|
||||
// - Task neu erstellt und zur Liste hinzugefügt (auch in JSON-Datei)
|
||||
// - Alle Tasks aus der Liste ausgegeben inkl. Status ("✓" für done, sonst " ")
|
||||
// - Task als done markiert und Ergebnis ausgegeben
|
||||
switch os.Args[1] {
|
||||
case "add":
|
||||
// TODO: Prüfen, ob 3. Kommandozeilenargument für Title vorliegt
|
||||
if len(os.Args) < 3 {
|
||||
fmt.Println("Geben Sie einen Titel ein.")
|
||||
return
|
||||
}
|
||||
|
||||
// TODO: Task zur Liste hinzufügen
|
||||
tasklist.Add(os.Args[2])
|
||||
|
||||
// TODO: Liste in JSON-Datei speichern
|
||||
tasklist.Save("tasks.json")
|
||||
|
||||
// Ergebnis ausgeben
|
||||
fmt.Println("Task added.")
|
||||
|
||||
case "list":
|
||||
// TODO: Durch alle Tasks der Liste iterieren
|
||||
for _, task := range tasklist.Tasks {
|
||||
// TODO: Task-Status bestimmen und inklusive ID und Title ausgeben
|
||||
status := " "
|
||||
if task.Done {
|
||||
status = "✓"
|
||||
}
|
||||
fmt.Printf("[%s] %d: %s\n", status, task.ID, task.Title)
|
||||
|
||||
}
|
||||
|
||||
case "done":
|
||||
// TODO: Prüfen, ob 3. Kommandozeilenargument für ID vorliegen
|
||||
if len(os.Args) < 3 {
|
||||
fmt.Println("Geben Sie eine ID ein.")
|
||||
return
|
||||
}
|
||||
|
||||
// TODO: Prüfen, ob ID vom Typ integer, sonst Fehlermeldung und Abbruch
|
||||
// Tipp: strconv.Atoi(string)
|
||||
id, err := strconv.Atoi(os.Args[2])
|
||||
if err != nil {
|
||||
fmt.Println("Falsche Eingabe der ID")
|
||||
return
|
||||
}
|
||||
// TODO: Task auf done setzen
|
||||
tasklist.Complete(id)
|
||||
|
||||
// TODO: Taskliste in JSON-Datei speichern
|
||||
tasklist.Save("tasks.json")
|
||||
|
||||
// Ergebnis ausgeben
|
||||
fmt.Println("Task marked as done.")
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
package main
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"os"
|
||||
)
|
||||
|
||||
// TODO: Task repräsentiert eine einzelne To-Do-Aufgabe mit ID, Titel und Status.
|
||||
// Tipp: struct verwenden
|
||||
type Task struct {
|
||||
ID int `json:"id"`
|
||||
Title string `json:"title"`
|
||||
Done bool `json:"done"`
|
||||
}
|
||||
|
||||
// TODO: TaskList enthält eine Liste von Aufgaben (Tasks).
|
||||
type TaskList struct {
|
||||
Tasks []Task `json:"tasks"`
|
||||
}
|
||||
|
||||
// TODO: Fügt einen neuen Task mit übergebenen Titel in die Liste ein.
|
||||
// Die neue ID entspricht der Anzahl der Elemente in der Liste. (ok, weil keine Tasks gelöscht werden)
|
||||
func (tl *TaskList) Add(title string) {
|
||||
id := len(tl.Tasks) + 1
|
||||
newTask := Task{ID: id, Title: title, Done: false}
|
||||
tl.Tasks = append(tl.Tasks, newTask)
|
||||
}
|
||||
|
||||
// TODO: Setzt vorhandenen Task mit übergebener ID auf den Status done.
|
||||
// Annahme: Wir wissen nicht, wie ID erstellt wird.
|
||||
func (tl *TaskList) Complete(id int) {
|
||||
for i := range tl.Tasks {
|
||||
if tl.Tasks[i].ID == id {
|
||||
tl.Tasks[i].Done = true
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Liste wird im JSON-Format in einer Datei mit übergebenen Dateinamen gespeichert
|
||||
func (tl *TaskList) Save(filename string) error {
|
||||
data, err := json.MarshalIndent(tl, "", " ")
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
return os.WriteFile(filename, data, 0644)
|
||||
}
|
||||
|
||||
// TODO: Lädt eine Liste von Tasks aus einer JSON-Datei (Dateiname als Parameter übergeben)
|
||||
// Falls die Datei noch nicht existiert, wird eine leere Liste (neu) zurückgegeben
|
||||
// Tipp 1: Einlesen einer Datei: os.ReadFile(filename)
|
||||
// Tipp 2: JSON-Daten in TaskList-Struktur umwandeln: json.Unmarshal(data, &tl)
|
||||
func LoadTasks(filename string) (*TaskList, error) {
|
||||
data, err := os.ReadFile(filename)
|
||||
if err != nil {
|
||||
return &TaskList{}, nil
|
||||
}
|
||||
var tl TaskList
|
||||
jsonErr := json.Unmarshal(data, &tl)
|
||||
return &tl, jsonErr
|
||||
}
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
{
|
||||
"tasks": [
|
||||
{
|
||||
"id": 1,
|
||||
"title": "Vorlesung besuchen",
|
||||
"done": false
|
||||
},
|
||||
{
|
||||
"id": 2,
|
||||
"title": "Go by Example durcharbeiten",
|
||||
"done": true
|
||||
},
|
||||
{
|
||||
"id": 3,
|
||||
"title": "Webserver lokal installieren",
|
||||
"done": false
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
@ -0,0 +1,80 @@
|
|||
# Übungsblatt 07
|
||||
|
||||
## 1. Go-Übung: Grundlagen
|
||||
|
||||
_Keine Abgabe erforderlich_
|
||||
|
||||
**Aufgabenstellung**: Machen Sie sich mit den Grundlagen der Programmiersprache vertraut.
|
||||
|
||||
#### Arbeitsschritte
|
||||
|
||||
1. Besuchen Sie die Webseite [Go by Example](https://gobyexample.com): **Go by Example** ist eine Einführung in Go anhand kommentierter Beispielprogramme.
|
||||
2. Arbeiten Sie die Liste der Beispiele nacheinander durch. Folgende Themen werden (mindestens) empfohlen:
|
||||
- Hello World
|
||||
- Values
|
||||
- Variables
|
||||
- For
|
||||
- If/Else
|
||||
- Switch
|
||||
- Arrays
|
||||
- Slices
|
||||
- Maps
|
||||
- Functions
|
||||
- Multiple Return Values
|
||||
- Closures
|
||||
- Range over Built-in Types
|
||||
- Pointers
|
||||
- Structs
|
||||
- Methods
|
||||
- Interfaces
|
||||
- Enums
|
||||
- Errors
|
||||
|
||||
## 2. Go-Übung: Kommandozeilenprogramm
|
||||
|
||||
**Aufgabenstellung**: Entwickeln Sie ein Kommandozeilenprogramm in Go, mit dem Nutzer:innen ihre persönliche Büchersammlung verwalten können.
|
||||
|
||||
_Tipp: Schauen Sie sich vorher das Demo-Programm "taskmanager" an._
|
||||
|
||||
#### Arbeitsschritte
|
||||
|
||||
Implementieren Sie ein Programm mit folgenden Funktionen:
|
||||
|
||||
1. **Buch hinzufügen**
|
||||
```bash
|
||||
go run main.go add "Titel" "Autor"
|
||||
```
|
||||
→ Fügt ein neues Buch zur Sammlung hinzu.
|
||||
|
||||
2. **Bücher auflisten**
|
||||
```bash
|
||||
go run main.go list
|
||||
```
|
||||
→ Zeigt alle Bücher mit ID, Titel, Autor und Lesestatus.
|
||||
|
||||
3. **Buch als gelesen markieren**
|
||||
```bash
|
||||
go run main.go read <ID>
|
||||
```
|
||||
→ Markiert das Buch mit der angegebenen ID als gelesen.
|
||||
|
||||
4. **Persistenz**
|
||||
- Die Bücher sollen in einer Datei `books.json` gespeichert und beim Programmstart wieder geladen werden.
|
||||
- Verwenden Sie dafür das `encoding/json`-Paket und `os.ReadFile` / `os.WriteFile`.
|
||||
|
||||
### Hinweise
|
||||
|
||||
- Verwenden Sie `struct` für die Buch- und Bibliotheksdaten.
|
||||
- Arbeiten Sie mit `slice` zur Verwaltung der Bücherliste.
|
||||
- Nutzen Sie Methoden zur Kapselung von Logik (z. B. `Add`, `MarkRead`, `Save`).
|
||||
- Behandeln Sie Fehler sinnvoll und benutzerfreundlich.
|
||||
- Strukturieren Sie Ihr Projekt in mindestens zwei Dateien (`main.go`, `book.go`).
|
||||
|
||||
## 3. Go-Übung: Formulardaten empfangen
|
||||
|
||||
**Aufgabenstellung**: Erstellen Sie ein Webserver-Programm in Go, das den HTTP-Endpunkt `/registrierung` bereitstellt.
|
||||
|
||||
- Der Endpunkt nimmt die Formulardaten der Workshop-Anmeldung aus Übungsblatt 04 entgegen und gibt sie als Response zurück.
|
||||
- Nutzen Sie dazu gerne die zuvor von Ihnen in Übungsblatt 05 definierte SWAGGER-Schnittstelle.
|
||||
- Es sollen nur `POST`-Request erlaubt sein. Falls eine andere Methode verwendet wurde, soll der Status-Code 405 (Method not allowed) zurückgegeben werden.
|
||||
- Testen Sie Ihren Endpunkt mit Ihrem HTML-Formular.
|
||||
Loading…
Reference in New Issue