數(shù)組和切片的主要區(qū)別在於大小固定性、類型匹配、傳遞方式和靈活性，1. 數(shù)組是固定大小的，長度是類型的一部分，不同長度的數(shù)組類型不兼容；2. 數(shù)組賦值和傳參時會復制整個數(shù)據(jù)，原數(shù)組不受影響；3. 切片是動態(tài)的，底層引用數(shù)組，類型不包含長度；4. 切片賦值和傳參時共享底層數(shù)據(jù)，修改會影響原數(shù)據(jù)；5. 切片可通過append擴容，數(shù)組不能；6. 實際開發(fā)中應優(yōu)先使用切片，因其更靈活且符合Go語言習慣，數(shù)組僅在需要高性能小緩衝區(qū)時使用。

In Go, arrays and slices are both used to store sequences of elements, but they work differently. Let's understand the difference with clear examples.

? Array: Fixed Size

An array has a fixed length — once declared, its size cannot change.

 var nums [3]int
nums[0] = 10
nums[1] = 20
nums[2] = 30

fmt.Println(nums) // Output: [10 20 30]
fmt.Println(len(nums)) // Output: 3

You can also initialize it directly:

 nums := [3]int{10, 20, 30}

? The size is part of the type. So [3]int and [4]int are different types.

You cannot do this:

 var a [3]int
var b [4]int
a = b // ? Compile error: mismatched types

Also, if you pass an array to a function, it's passed by value (a copy is made):

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

nums := [3]int{1, 2, 3}
modify(nums)
fmt.Println(nums) // Output: [1 2 3] → unchanged!

? Slice: Dynamic, Flexible

A slice is a flexible wrapper around an array. It provides dynamic size and references underlying data.

You usually create slices like this:

 nums := []int{1, 2, 3}

No size in the type → this is a slice.

Now you can append elements:

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

Slices are reference types — when passed to a function, they refer to the same underlying data:

 func modify(slice []int) {
    slice[0] = 999
}

data := []int{1, 2, 3}
modify(data)
fmt.Println(data) // Output: [999 2 3] → changed!

You can also create a slice from an array:

 arr := [5]int{10, 20, 30, 40, 50}
slice := arr[1:4] // from index 1 to 3
fmt.Println(slice) // Output: [20 30 40]

? Key Differences Summary

?? When to Use Which?

• Use arrays when you need a fixed-size collection and care about performance (eg, small buffers).
• Use slices almost always — they're more flexible and idiomatic in Go.

Most Go code uses slices because:

• They grow as needed.
• Built-in functions ( append , len , cap ) work naturally.
• They're more convenient for loops, APIs, and general data handling.

? One More Example: Underlying Array

 arr := [5]int{1, 2, 3, 4, 5}
s1 := arr[0:3] // [1, 2, 3]
s2 := arr[2:5] // [3, 4, 5]

s1[2] = 99
fmt.Println(s2) // Output: [99, 4, 5] → shared data!

Because slices s1 and s2 share the same underlying array, modifying one can affect the other.

So, in short:

• Array : fixed, copied, low-level.
• Slice : dynamic, reference-like, built on arrays, used everywhere.

In practice, you'll mostly use slices .

基本上就這些。

以上是切片和陣列之間的區(qū)別以身例子的詳細內(nèi)容。更多資訊請關(guān)注PHP中文網(wǎng)其他相關(guān)文章！