Mastering Slices For Dynamic Data Structures: A Deep Dive Into Slice Manipulation And Memory Efficiency

package main

import "fmt"

func main() {
	// create an array of names
	namesArray := [4]string{"John", "Paul", "George", "Ringo"}
	// create a slice of names
	namesSlice := []string{"John", "Paul", "George", "Ringo"}

	fmt.Println(namesArray)
	fmt.Println(namesSlice)
}

package main

import "fmt"

func main() {
	names := []string{"John", "Paul", "George", "Ringo"}

	for i, n := range names {
		fmt.Printf("%d - %s\n", i, n)
	}
}

type slice struct {
	Length   int
	Capacity int
	Array    [10]array
}

package main

import "fmt"

func main() {
	names := []string{}
	names = append(names, "John")

	// Append multiple items at once
	names = append(names, "Sally", "George")

	// Append an entire slice to another slice
	moreNames := []string{"Bill", "Ginger", "Wilma"}
	names = append(names, moreNames...)

	fmt.Println(names)
}

// Example variadic function that accepts any number of integers
func sum(numbers ...int) int {
	total := 0
	for _, n := range numbers {
		total += n
	}
	return total
}

// Another variadic function
func printNames(prefix string, names ...string) {
	fmt.Printf("%s: ", prefix)
	for i, name := range names {
		if i > 0 {
			fmt.Print(", ")
		}
		fmt.Print(name)
	}
	fmt.Println()
}

func main() {
	// The ellipsis operator (...) has five main uses in Go:

	// Use 1: Variadic function parameters
	// Allows a function to accept a variable number of arguments
	fmt.Println("--- Use 1: Variadic Function Parameters ---")
	fmt.Println("sum(1, 2, 3):", sum(1, 2, 3))
	fmt.Println("sum(10, 20, 30, 40, 50):", sum(10, 20, 30, 40, 50))

	// Use 2: Unpacking slices into variadic functions
	// The ... operator "unpacks" a slice into individual arguments
	fmt.Println("\n--- Use 2: Unpacking Slices ---")
	numbers := []int{5, 10, 15, 20}
	fmt.Printf("numbers slice: %v\n", numbers)
	fmt.Printf("sum(numbers...): %d\n", sum(numbers...))

	// Without ..., this would be a compile error:
	// sum(numbers) // ERROR: cannot use numbers (type []int) as type int

	// Use 3: Unpacking slices with append
	fmt.Println("\n--- Use 3: Append with Slice Unpacking ---")
	fruits := []string{"apple", "banana"}
	moreFruits := []string{"cherry", "date", "elderberry"}

	// Append individual elements
	fruits = append(fruits, "fig")
	fmt.Printf("After append single: %v\n", fruits)

	// Append entire slice - requires ... to unpack
	fruits = append(fruits, moreFruits...)
	fmt.Printf("After append slice:  %v\n", fruits)

	// Use 4: Array literals with inferred length
	fmt.Println("\n--- Use 4: Array Literals (inferred length) ---")
	// The compiler counts the elements and sets the array size
	inferredArray := [...]string{"red", "green", "blue"}
	fmt.Printf("Array: %v (type: %T, len: %d)\n", inferredArray, inferredArray, len(inferredArray))

	// This is equivalent to:
	explicitArray := [3]string{"red", "green", "blue"}
	fmt.Printf("Array: %v (type: %T, len: %d)\n", explicitArray, explicitArray, len(explicitArray))

	// Use 5: Combining variadic functions
	fmt.Println("\n--- Use 5: Practical Example ---")
	allNames := []string{"Alice", "Bob", "Charlie"}
	printNames("Team members", allNames...)

	// You can also mix literal values with slice unpacking in some contexts
	moreNames := []string{"David", "Eve"}
	combined := append(allNames, moreNames...)
	printNames("All members", combined...)

	// Common gotcha: Can't use ... on left side of assignment
	fmt.Println("\n--- Common Gotcha ---")
	fmt.Println("The ... operator ONLY works on the right side (as an argument)")
	fmt.Println("You CANNOT use it to destructure/unpack on the left side like:")
	fmt.Println("  a, b, c... := []int{1, 2, 3, 4, 5}  // This is INVALID")
}

package main

import "fmt"

func main() {
	a := []string{"zero", "one", "two", "three", "four", "five"}
	// remove 4 items, starting with the index of 1 (second item in slice)
	// append(a[:i], a[i+(number of items to remove):]...) -> i = 1, i+4=5
	a = append(a[:1], a[5:]...)
	fmt.Println(a)
}

package main

import (
	"fmt"

	"slices"
)

func main() {
	a := []string{"zero", "one", "two", "three", "four", "five"}
	// slices.Delete(s, i, j) -> s = slice having items deleted from, i = start index, j = end index
	a = slices.Delete(a, 1, 4)
	fmt.Println(a)
}

names := []string{}
fmt.Println("len:", len(names)) // 0
fmt.Println("cap:", cap(names)) // 0

names = append(names, "John")
fmt.Println("len:", len(names)) // 1
fmt.Println("cap:", cap(names)) // 1

names = append(names, "Paul")
fmt.Println("len:", len(names)) // 2
fmt.Println("cap:", cap(names)) // 2

names = append(names, "George")
fmt.Println("len:", len(names)) // 3
fmt.Println("cap:", cap(names)) // 4

names = append(names, "Ringo")
fmt.Println("len:", len(names)) // 4
fmt.Println("cap:", cap(names)) // 4

names = append(names, "Stu")
fmt.Println("len:", len(names)) // 5
fmt.Println("cap:", cap(names)) // 8

fmt.Println("len:", len(names)) // 5
fmt.Println("cap:", cap(names)) // 8

package main

import "fmt"

func main() {
	a := []string{}
	b := make([]string, 0)
	var c []string

	fmt.Println(a)
	fmt.Println(b)
	fmt.Println(c)
}

package main

import "fmt"

func main() {
	a := make([]int, 1, 3)

	fmt.Println(a)      // [0]
	fmt.Println(len(a)) // 1
	fmt.Println(cap(a)) // 3
}

package main

import "fmt"

func main() {
	a := make([]string, 2)
	a = append(a, "foo", "bar")
	fmt.Printf("%q", a)
}

type Modules [][]string

course := Modules{
	[]string{"Chapter One: Syntax"},
	[]string{"Chapter Two: Arrays and Slices"},
	[]string{"Chapter Three: Maps", "Chapter Four: Packages"},
}

package main

import (
	"fmt"
)

// slice[starting_index : (starting_index + length)]

func main() {
	names := []string{"John", "Paul", "George", "Ringo"}

	fmt.Println(names) // [John Paul George Ringo]

	// Get 2 elements starting with the second element (index 1)
	fmt.Println(names[1:3]) // [Paul George] - names[1:1+2]

	// functionally equivalent
	fmt.Println(names[2:len(names)]) // [George Ringo]
	fmt.Println(names[2:])           // [George Ringo]

	// functionally equivalent
	fmt.Println(names[0:2]) // [John Paul]
	fmt.Println(names[:2])  // [John Paul]
}

// slice[starting_index : (starting_index + length)]

func main() {
	names := []string{"John", "Paul", "George", "Ringo"}

	fmt.Println(names) // [John Paul George Ringo]

	// Get the first three elements of the `names` slice
	guitars := names[:3]

	fmt.Println(guitars) // [John Paul George]

	for i, g := range guitars {
		guitars[i] = strings.ToUpper(g)
	}

	// Print out our original slice of names
	fmt.Println("names:  ", names)

	// Print out the guitars slice
	fmt.Println("guitars:", guitars)
}

func main() {
	// Create a slice with length 2 but capacity 4
	// This means there's room to append without reallocation
	a := make([]string, 2, 4)
	a[0] = "apple"
	a[1] = "banana"

	fmt.Printf("Initial slice a: %v (len=%d, cap=%d)\n", a, len(a), cap(a))

	// Create a new slice by appending to 'a'
	// Since capacity is not exceeded, 'b' shares the same underlying array
	b := append(a, "cherry")
	fmt.Printf("After append, slice b: %v (len=%d, cap=%d)\n", b, len(b), cap(b))

	// Modifying 'b' at index 0 affects 'a' because they share the underlying array
	b[0] = "MODIFIED"

	fmt.Println("\nAfter modifying b[0]:")
	fmt.Printf("slice a: %v\n", a) // a is affected!
	fmt.Printf("slice b: %v\n", b)

	fmt.Println("\n--- Example 2: Exceeding capacity ---")

	// Now let's exceed the capacity
	c := make([]string, 2, 2)
	c[0] = "dog"
	c[1] = "cat"

	fmt.Printf("\nInitial slice c: %v (len=%d, cap=%d)\n", c, len(c), cap(c))

	// Appending here exceeds capacity, so a new array is allocated
	d := append(c, "bird")
	fmt.Printf("After append, slice d: %v (len=%d, cap=%d)\n", d, len(d), cap(d))

	// Modifying 'd' does NOT affect 'c' because they use different arrays
	d[0] = "MODIFIED"

	fmt.Println("\nAfter modifying d[0]:")
	fmt.Printf("slice c: %v\n", c) // c is NOT affected
	fmt.Printf("slice d: %v\n", d)
}

package main

import "fmt"

func main() {
	original := []string{"carrot", "potato", "cucumber", "onion"}
	// create a new reference to the existing slice
	ref := original

	// initialize a variable named 'dup' to the
	// same size as the original slice
	dup := make([]string, len(original))

	// copy the values from original to dup
	// NOTE: if the slices are not the same size, it will
	// only copy what it has space for (length)
	copy(dup, original)

	// changing either `ref` or `original` will change either
	// of them as they still share the reference to the same
	// backing array
	ref[0] = "zuchinni"
	original[1] = "tomato"

	fmt.Println("original: ", original)
	fmt.Println("ref:      ", ref)
	fmt.Println("dup:      ", dup)
}

func main() {
	// The copy() function copies min(len(src), len(dst)) elements
	// This means it only copies as many elements as will fit

	// Example 1: Copying to a zero-size slice (copies 0 elements)
	fmt.Println("--- Example 1: Copying to zero-size slice ---")
	source1 := []string{"apple", "banana", "cherry"}
	dest1 := []string{} // zero length

	n1 := copy(dest1, source1)
	fmt.Printf("Source: %v (len=%d)\n", source1, len(source1))
	fmt.Printf("Dest:   %v (len=%d)\n", dest1, len(dest1))
	fmt.Printf("Copied: %d elements\n", n1)

	// Example 2: Copying to same-size slice (copies all elements)
	fmt.Println("\n--- Example 2: Copying to same-size slice ---")
	source2 := []string{"dog", "cat", "bird"}
	dest2 := make([]string, 3)

	n2 := copy(dest2, source2)
	fmt.Printf("Source: %v (len=%d)\n", source2, len(source2))
	fmt.Printf("Dest:   %v (len=%d)\n", dest2, len(dest2))
	fmt.Printf("Copied: %d elements\n", n2)

	// Example 3: Copying to larger slice (copies only source elements)
	fmt.Println("\n--- Example 3: Copying to larger slice ---")
	source3 := []string{"red", "green"}
	dest3 := make([]string, 5) // larger than source

	n3 := copy(dest3, source3)
	fmt.Printf("Source: %v (len=%d)\n", source3, len(source3))
	fmt.Printf("Dest:   %v (len=%d)\n", dest3, len(dest3))
	fmt.Printf("Copied: %d elements\n", n3)
	fmt.Println("Note: Remaining elements in dest are zero values")

	// Example 4: Copying to smaller slice (partial copy)
	fmt.Println("\n--- Example 4: Copying to smaller slice (partial copy) ---")
	source4 := []string{"alpha", "beta", "gamma", "delta", "epsilon"}
	dest4 := make([]string, 2) // smaller than source

	n4 := copy(dest4, source4)
	fmt.Printf("Source: %v (len=%d)\n", source4, len(source4))
	fmt.Printf("Dest:   %v (len=%d)\n", dest4, len(dest4))
	fmt.Printf("Copied: %d elements\n", n4)
	fmt.Println("Note: Only the first 2 elements were copied")

	// Example 5: Common pitfall - using capacity instead of length
	fmt.Println("\n--- Example 5: Capacity vs Length pitfall ---")
	source5 := []int{10, 20, 30, 40, 50}
	dest5 := make([]int, 0, 10) // length is 0, but capacity is 10

	n5 := copy(dest5, source5)
	fmt.Printf("Source: %v (len=%d)\n", source5, len(source5))
	fmt.Printf("Dest:   %v (len=%d, cap=%d)\n", dest5, len(dest5), cap(dest5))
	fmt.Printf("Copied: %d elements\n", n5)
	fmt.Println("Note: Even though capacity is 10, length is 0, so nothing is copied!")

	// Solution: ensure destination has correct length
	fmt.Println("\n--- Example 6: Correct approach with length ---")
	source6 := []int{10, 20, 30, 40, 50}
	dest6 := make([]int, len(source6)) // length matches source

	n6 := copy(dest6, source6)
	fmt.Printf("Source: %v (len=%d)\n", source6, len(source6))
	fmt.Printf("Dest:   %v (len=%d, cap=%d)\n", dest6, len(dest6), cap(dest6))
	fmt.Printf("Copied: %d elements\n", n6)
}