Golang 中的切片和数组有什么区别？

In Golang, slices and arrays are two distinct data structures. Although they share some similarities in usage, there are several key differences:

1. Length Fixity and Dynamism:

   • Arrays: The length of an array is fixed at definition time and cannot be altered during runtime. For example, if you define an array of length 5, you can only store 5 elements.
   • Slices: Slices are dynamic arrays. Their length is not fixed and can grow at runtime by adding elements. Internally, slices use arrays to store the data, but they can dynamically expand as needed.

2. Declaration Method:

   • Arrays: When declaring an array, you must specify the number of elements it can store. For example: var arr [5]int denotes an integer array with 5 elements.
   • Slices: When declaring a slice, you do not need to specify the length. For example: var s []int denotes an integer slice, which initially has no elements.

3. Memory Allocation:

   • Arrays: Arrays occupy contiguous memory space. Once allocated, their size and position cannot be changed.
   • Slices: A slice is a descriptor containing three components: a pointer to the underlying array, length, and capacity. The slice points to a portion or all elements of the underlying array and can be extended up to the maximum capacity of the underlying array.

4. Use Cases and Applicability:

   • Arrays: Suitable for scenarios with a fixed number of elements, such as when an application requires a fixed-size buffer.
   • Slices: More flexible and ideal for scenarios with an unknown number of elements, such as reading lines of unknown quantity from a file.

5. Passing Method:

   • Arrays: When passing arrays between functions, a value copy is performed, meaning the entire array data is duplicated.
   • Slices: Slices are passed by reference, so passing a slice only copies the slice descriptor, not the underlying array.

Example:

Suppose we need to process a dynamically changing dataset, such as messages in a real-time message queue:

• Using arrays may lack flexibility because you must predefine a maximum length, which could lead to memory waste or insufficiency.
• Using slices can dynamically adjust size based on actual data needs, for example:

go
messages := make([]string, 0) // Create an empty slice
messages = append(messages, "New message 1") // Dynamically add elements
messages = append(messages, "New message 2")

This approach effectively handles datasets of unknown size and makes the code more concise and flexible.