CODEWITHSUNDEEP
goslice
pierrotlefou
pierrotlefou

Reputation: 40721

What is the point of slice type in Go?

I have read this but still not fully aware of the advantage of slice against array.So I am expecting somebody in SO explain better than it and I am sure you can :)

Upvotes: 26

Views: 5705

Answers (4)

Rohit
Rohit

Reputation: 7629

I think slices and arrays are described much better and in more detail in this post on the Go Blog.

Upvotes: 2

Russell Newquist
Russell Newquist

Reputation: 2666

Slices have a lot of uses over arrays, several of which other posters have already mentioned.

  • Slices can operate in many ways like pointers.
    • Multiple slices can "point" to the same base array
    • Slices are passed by reference, but since a slice itself is a pointer it can be used to pass "arrays" around much more efficiently since the entire array doesn't need to be copied.
  • However, unlike pointers, slices provide additional buffer safety
    • Slice underflows and overflows trigger exceptions, rather than allowing you an unsafe ability to access other areas of memory.
    • Slices allow you to limit access to only certain areas of an array. This can be extremely useful in working with subsets.
  • The length of a slice is dynamically determined at runtime, unlike arrays which have their sizes fixed at compile time. Also, slices can be dynamically resized at runtime.

Upvotes: 24

Evan Shaw
Evan Shaw

Reputation: 24547

In addition to the answers already given, slices can be dynamically sized while arrays cannot be. That is, you can only use constants to specify the size of an array, while you can use a variable to specify the size of a slice.

Upvotes: 1

Alex Martelli
Alex Martelli

Reputation: 881555

In go, arrays are passed by value; so, to "pass by reference", you use a slice. And that's not all! Quoting Go's tutorial:

The size of the array is part of its type; however, one can declare a slice variable, to which one can assign a pointer to any array with the same element type or—much more commonly—a slice expression of the form a[low : high], representing the subarray indexed by low through high-1. Slices look a lot like arrays but have no explicit size ([] vs. [10]) and they reference a segment of an underlying, often anonymous, regular array. Multiple slices can share data if they represent pieces of the same array; multiple arrays can never share data.

Slices are much more common in Go programs than regular arrays; they're more flexible, have reference semantics, and are efficient. What they lack is the precise control of storage layout of a regular array; if you want to have a hundred elements of an array stored within your structure, you should use a regular array.

When passing an array to a function, you almost always want to declare the formal parameter to be a slice. When you call the function, take the address of the array and Go will create (efficiently) a slice reference and pass that.

Upvotes: 14

Related Questions