Slice

package main

import "fmt"

func main() {
    var numArr [5]int
    numArr[0] = 10
    numArr[1] = 20
    numArr[2] = 30

    fmt.Printf("Array: %v\n", numArr)
    fmt.Printf("Länge: %d\n", len(numArr))
}

package main

import "fmt"

func main() {
    var numSlice []int
    numSlice = append(numSlice, 10)
    numSlice = append(numSlice, 20)
    numSlice = append(numSlice, 30)

    fmt.Printf("Slice: %v\n", numSlice)
    fmt.Printf("Länge: %d\n", len(numSlice))

    // Slices sind flexibel erweiterbar
    numSlice = append(numSlice, 40, 50, 60)
    fmt.Printf("Slice erweitert: %v\n", numSlice)
}

package main

import "fmt"

func modifyArray(arr [3]int) {
    arr[0] = 999
}

func modifySlice(s []int) {
    s[0] = 999
}

func main() {

    // Array-Beispiel
    myArr := [3]int{1, 2, 3}
    fmt.Printf("Array vorher: %v\n", myArr)

    modifyArray(myArr)
    fmt.Printf("Array nachher: %v\n", myArr)

    fmt.Println("--- --- ---")

    // Slice-Beispiel
    mySlice := []int{1, 2, 3}
    fmt.Printf("Slice vorher: %v\n", mySlice)

    modifySlice(mySlice)
    fmt.Printf("Slice nachher: %v\n", mySlice)

}

package main

import "fmt"

func main() {
    // Ein Slice mit make erstellen
    s := make([]int, 5 10)

    fmt.Printf("Slice: %v\n", s)
    fmt.Printf("Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))
}

package main

import "fmt"

func main() {
    var s []int
    fmt.Printf("Initiale Länge: %d\n", len(s))
    fmt.Printf("Initiale Kapazität: %d\n", cap(s))

    for i := 0; i < 20; i++ {
        s = append(s, i)
        fmt.Printf("Durchlauf %d | Länge: %d | Kapazität: %d\n", i, len(s), cap(s))
    }
}

package main

import (
    "fmt"
    "unsafe"
)

func main() {
    var s []int
    fmt.Printf("Initiale Länge: %d\n", len(s))
    fmt.Printf("Initiale Kapazität: %d\n", cap(s))

    for i := 0; i < 20; i++ {
        s = append(s, i)
        fmt.Printf("Durchlauf %d | Länge: %d | Kapazität: %d\n", i, len(s), cap(s))
        fmt.Printf("Speicher (erstes Element): %p\n", unsafe.Pointer(&s[0]))
    }
}

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4}

    fmt.Printf("Slice: %v\n", nums)
    fmt.Printf("Länge: %d\n", len(nums))
    fmt.Printf("Kapazität: %d\n", cap(nums))

    fmt.Println()

    fruits := []string{"Apfel", "Birne", "Orange"}
    fmt.Printf("Früchte: %v\n", fruits)
}

package main

import "fmt"

func main() {
    // Slice mit Länge 5
    // Kapazität wird automatisch auf 5 gesetzt
    s := make([]int, 5)

    fmt.Printf("Slice: %v\n", s)
    fmt.Printf("Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))

    // Bestimmte Elemente ändern
    s[0] = 100
    s[2] = 200
    fmt.Printf("Modifiziert: %v\n", s)
}

package main

import "fmt"

func main() {
    // Slice mit Länge 3 & Kapazität 10
    s := make([]int, 3, 10)

    fmt.Printf("Slice: %v\n", s)
    fmt.Printf("Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))

    // Man kann nur auf die ersten 3 Elemente zugreifen.
    s[0] = 10
    s[1] = 20
    s[2] = 30

    // s[3] => würde einen Fehler verursachen

    // Man kann allerdings ein Slice erweitern
    s = append(s, 40, 50)
    fmt.Printf("Nach Erweiterung: %v\n", s)
    fmt.Printf("Neue Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))

}

package main

import "fmt"

func main() {
    // Ein Array erstellen
    myArr := [5]int{1, 2, 3, 4, 5}

    // Ein Slice vom gesamten Array
    mySlice := myArr[:]
    fmt.Printf("Slice myArr[:]: %v\n", mySlice)

    // Ein Slice von einem Teil des Arrays
    myPartSlice := myArr[1:4] // 1, 2, 3 (4 exklusiv)
    fmt.Printf("Slice myArr[1:4]: %v\n", myPartSlice)

    // Änderungen am Slice beeinflussen das Array
    mySlice[0] = 999
    fmt.Printf("Array nach Slice-Änderung: %v\n", myArr)
}

package main

import "fmt"

func main() {
    var s[] int

    fmt.Printf("Slice: %v\n", s)
    fmt.Printf("Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))

    // Man kann das Slice erweitern
    s = append(s, 1, 2, 3)
    fmt.Printf("Slice aktualisiert: %v\n", s)
    fmt.Printf("Länge aktualisiert: %d\n", len(s))
}

package main

import "fmt"

func main() {
    s := []int{1, 2, 3}
    fmt.Printf("Original: %v\n", s)

    // Ein Elemente hinzufügen
    s = append(s, 4)
    fmt.Printf("Nach append(s, 4): %v\n", s)

    // Mehrere Elemente hinzufügen
    s = append(s, 5, 6, 7)
    fmt.Printf("Nach append(s, 5, 6, 7): %v\n", s)
}

package main

import "fmt"

func main() {
    // Slice mit begrenzter Kapazität
    s := make([]int, 3, 5)
    s[0], s[1], s[2] = 1, 2, 3

    fmt.Printf("Initiales Slice: %v\n", s)
    fmt.Printf("Initiale Länge: %d\n", len(s))
    fmt.Printf("Initiale Kapazität: %d\n", cap(s))

    // Innerhalb der Kapazität
    s = append(s, 4)
    fmt.Println("\nNach append(4)")
    fmt.Printf("Slice: %v\n", s)
    fmt.Printf("Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))

    s = append(s, 5)
    fmt.Println("\nNach append(5)")
    fmt.Printf("Slice: %v\n", s)
    fmt.Printf("Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))

    // Überschreitung der Kapazität
    // Neues Array wird alloziert
    s = append(s, 6)
    fmt.Println("\nNach append(6)")
    fmt.Printf("Slice: %v\n", s)
    fmt.Printf("Länge: %d\n", len(s))
    fmt.Printf("Kapazität: %d\n", cap(s))
}

package main

import "fmt"

func main() {
    sOne := []int{1, 2, 3}
    sTwo := []int{4, 5, 6}

    // sTwo an sOne anhängen
    sOne = append(sOne, sTwo...)

    fmt.Printf("Zusammengeführt: %v\n", sOne)
}

package main

import "fmt"

func main() {
    sourceSlice := []int{1, 2, 3, 4, 5}
    targetSlice := make([]int, 5)

    // Alle Elemente kopieren
    n := copy(targetSlice, sourceSlice)

    fmt.Printf("Quelle: %v\n", sourceSlice)
    fmt.Printf("Ziel: %v\n", targetSlice)
    fmt.Printf("Anzahl kopierter Elemente: %d\n", n)

    // Änderungen am Ziel beeinflussen die Quelle nicht
    targetSlice[0] = 999
    fmt.Printf("Quelle nach Änderung: %v\n", sourceSlice)
    fmt.Printf("Ziel nach Änderung: %v\n", targetSlice) 
}

package main

import "fmt"

func main() {
    sourceSlice := []int{1, 2, 3, 4, 5}
    targetSlice := make([]int, 3)

    n := copy(targetSlice, sourceSlice)

    fmt.Printf("Quelle: %v\n", sourceSlice)
    fmt.Printf("Ziel: %v\n", targetSlice)
    fmt.Printf("Anzahl kopierter Elemente: %d\n", n)
}

package main

import "fmt"

func main() {
    s := []int{1, 2, 3, 4, 5}
    fmt.Printf("Original: %v\n", s)

    index := 2
    copy(s[index:], s[index+1:])
    s = s[:len(s)-1]

    fmt.Printf("Nach Entfernung: %v\n", s)
}

package main

import "fmt"

func main() {
    s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Printf("Original: %v\n", s)

    sliced := s[2:5]
    fmt.Printf("s[2:5]: %v\n", sliced)
}

package main

import "fmt"

func main() {
    s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Printf("Original: %v\n", s)

    sliced := s[:4]
    fmt.Printf("s[:4]: %v\n", sliced)
}

package main

import "fmt"

func main() {
    s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    fmt.Printf("Original: %v\n", s)

    sliced := s[6:]
    fmt.Printf("s[6:]: %v\n", sliced)
}

package main

import "fmt"

func main() {
    original := []int{0, 1, 2, 3, 4, 5}
    sliceOne := original[1:4]
    sliceTwo := original[2:5]

    fmt.Printf("Original: %v\n", original)
    fmt.Printf("sliceOne [1:4]: %v\n", sliceOne)
    fmt.Printf("sliceTwo [2:5]: %v\n", sliceTwo)

    // Änderung in sliceOne
    sliceOne[0] = 999

    fmt.Printf("\nNach sliceOne[0] = 999:\n")
    fmt.Printf("Original: %v\n", original)
    fmt.Printf("sliceOne [1:4]: %v\n", sliceOne)
    fmt.Printf("sliceTwo [2:5]: %v\n", sliceTwo)
}

package main

import "fmt"

func main() {
    s := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}

    // Normales Slicing
    sliceOne := s[2:5]
    fmt.Printf("--- s[2:5] ---\n")
    fmt.Printf("Länge: %d\n", len(sliceOne))
    fmt.Printf("Kapazität: %d\n", cap(sliceOne))
    fmt.Printf("Slice: %v\n", sliceOne)

    // Mit Kapazitätsbeschränkung
    sliceTwo := s[2:5:7]
    fmt.Printf("\n--- s[2:5:7] ---\n")
    fmt.Printf("Länge: %d\n", len(sliceTwo))
    fmt.Printf("Kapazität: %d\n", cap(sliceTwo))
    fmt.Printf("Slice: %v\n", sliceTwo)
}

package main

import "fmt"

func main() {
    nums := []int{10, 20, 30, 40, 50}

    // Index und Wert
    fmt.Println("Mit Index und Wert:")
    for i, value := range nums {
        fmt.Printf("Index: %d: %d\n", i, value)
    }

    // Nur Wert
    fmt.Println("\nNur Wert:")
    for _, value := range nums {
        fmt.Printf("%d ", value)
    }
    fmt.Println()

    // Nur Index
    fmt.Println("\nNur Index:")
    for i := range nums {
        fmt.Printf("%d ", i)
    }
    fmt.Println()
}

package main

import "fmt"

func main() {
    nums := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

    // Jedes zweite Element
    fmt.Println("Jedes zweite Element")
    for i := 0; i < len(nums); i += 2 {
        fmt.Printf("%d ", nums[i])
    }
    fmt.Println()

    // Rückwärts iterieren
    fmt.Println("Rückwärts:")
    for i := len(nums) - 1; i >= 0; i-- {
        fmt.Printf("%d ", nums[i])
    }
    fmt.Println()
}

package main

import "fmt"

func main() {
    arr := [10]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
    slice := arr[2:5]

    fmt.Printf("Array: %v\n", arr)
    fmt.Printf("Slice s[2:5]: %v\n", slice)
    fmt.Printf("Länge slice: %d\n", len(slice))
    fmt.Printf("Kapazität slice: %d\n", cap(slice))
}
``
</div>
<div slot="output">

Slice s[2:5]: [2 3 4] Länge slice: 3 Kapazität slice: 8

</div>
</CodeBlock>

Das Kapazitätswachtum von Go folgt einer bestimmten Strategie, um die Anzahl der Reallokationen zu minimieren. Für kleinere Slices verdoppelt Go typischerweise die Kapazität, für größere Slices wächst die Kapazität um 25%.

Hier ein Beispiel, das das Wachstum der Kapazität verdeutlicht.

<CodeBlock filename="Beispiel - Kapazität Wachstum" showOutput={true}>
<div slot="code">
```go
package main

import "fmt"

func main() {
    s := make([]int, 0)
    prevCap := 0

    for i := 0; i < 1000; i++ {
        s = append(s, i)
        if cap(s) != prevCap {
            fmt.Printf("Länge: %3d\n", len(s))
            fmt.Printf("Kapazität: %3d (Wachstum von %d)\n", cap(s), cap(s)-prevCap)
            prevCap = cap(s)
        }
    }
}

package main

import "fmt"

func main() {

    // Ineffizient - Mehrere Reallokationen
    sOne := []int{}
    for i := 0; i < 1000; i++ {
        sOne = append(sOne, i)
    }

    // Effizient - Kapazität im Voraus reserviert
    sTwo := make([]int, 0, 1000)
    for i := 0; i < 1000; i++ {
        sTwo = append(sTwo, i)
    }

    fmt.Printf("Beide Slices haben 1000 Elemente\n")
    fmt.Printf("sOne - Länge = %d | Kapazität = %d\n", len(sOne), cap(sOne))
    fmt.Printf("sTwo - Länge = %d | Kapazität = %d\n", len(sTwo), cap(sTwo))
}