Go中的append函數(shù)用於向切片添加元素，必須將結果重新賦值給切片，因為底層數(shù)組可能改變；1. 使用append(slice, elem)添加單個或多個元素；2. 使用append(slice, otherslice...)合併兩個切片，需用...展開；3. append可安全用於nil切片；4. 當容量不足時，append會自動擴容並可能重新分配底層數(shù)組；5. append適用於任何類型切片，如用於合併rune切片構建字符串。

In Go, the append function is used to add elements to slices. It's one of the most commonly used built-in functions when working with dynamic arrays (slices). Here's a clear breakdown with examples to show how append works.

? Basic Usage of append

The append function takes a slice and one or more values, then returns a new slice containing all the original elements plus the new ones.

 package main

import "fmt"

func main() {
    // Start with a slice
    nums := []int{1, 2, 3}

    // Append a single element
    nums = append(nums, 4)
    fmt.Println(nums) // Output: [1 2 3 4]

    // Append multiple elements
    nums = append(nums, 5, 6, 7)
    fmt.Println(nums) // Output: [1 2 3 4 5 6 7]
}

? Note: append may modify the underlying array if there's enough capacity. Otherwise, it allocates a new, larger underlying array.

? Appending a Slice to Another Slice

To append one slice to another, you need to unpack the second slice using the ... operator.

 package main

import "fmt"

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

    // Append slice b to slice a
    a = append(a, b...) // The '...' spreads the elements of b
    fmt.Println(a) // Output: [1 2 3 4 5]
}

? Without ... , you'll get a compile-time error because Go expects individual elements, not a slice.

? Common Pattern: Building a Slice Dynamically

You often start with an empty or nil slice and build it up using append .

 package main

import "fmt"

func main() {
    var fruits []string // nil slice

    fruits = append(fruits, "apple")
    fruits = append(fruits, "banana")
    fruits = append(fruits, "cherry")

    fmt.Println(fruits) // Output: [apple banana cherry]
}

This works safely even if the slice is nil — append handles it correctly.

? Capacity and Reallocation

Go slices have both length and capacity. When a slice runs out of capacity, append automatically allocates a bigger underlying array.

 package main

import "fmt"

func main() {
    s := make([]int, 2, 5) // len=2, cap=5
    fmt.Printf("len=%d cap=%d value=%v\n", len(s), cap(s), s) // len=2 cap=5 value=[0 0]

    s = append(s, 3)
    fmt.Printf("len=%d cap=%d value=%v\n", len(s), cap(s), s) // len=3 cap=5 value=[0 0 3]

    s = append(s, 4, 5, 6)
    fmt.Printf("len=%d cap=%d value=%v\n", len(s), cap(s), s) // len=6 cap=10 (likely) value=[0 0 3 4 5 6]
}

? The growth strategy is not guaranteed but typically increases capacity by around 100% when full.

? Appending to Strings or Other Types

append works with slices of any type — not just integers.

 chars := []rune{'h', 'e', 'l'}
chars = append(chars, 'l', 'o')
result := string(chars)
fmt.Println(result) // Output: hello

This is useful when building strings from runes safely (eg, handling Unicode).

Key Takeaways

• Use append(slice, elem) to add one or more elements.
• Use append(slice, otherslice...) to merge two slices.
• append is safe on nil slices.
• Always assign the result: slice = append(slice, ...) — because the underlying array might change.
• append can trigger reallocation when capacity is exceeded.

That's it. append is simple but powerful — just remember to use ... when adding another slice, and always reassign the result.

以上是以示例進行切片的附加功能的詳細內容。更多資訊請關注PHP中文網其他相關文章！