GoLang Tutorial - Arrays and Slices

The slice type is an abstraction built on top of Go's array type, and so to understand slices we must first understand arrays.

An array variable denotes the entire array; unlike C, array name is not a pointer to the first array element. This means that when we assign or pass around an array value we will make a copy of its contents. (To avoid the copy you could pass a pointer to the array, but then that's a pointer to an array, not an array.

Here is an example of an array:

Note that we can declare and assign at the same time:

Or like this:

Slices are where the action is, but to use them well one must understand exactly what they are and what they do.

We don't see arrays too often in Go code. Slices, though, are everywhere. They build on arrays to provide great power and convenience.

The type specification for a slice is []T, where T is the type of the elements of the slice. Unlike an array type, a slice type has no specified length.

A slice is a data structure describing a contiguous section of an array stored separately from the slice variable itself. A slice is not an array but it describes a piece of an array.

A slice literal is declared just like an array literal, except we leave out the element count:

alphabet := []string{"a", "b", "c", "d"}

A slice has both a length and a capacity. The length of a slice is the number of elements it contains. The capacity of a slice is the number of elements in the underlying array, counting from the first element in the slice. The length and capacity of a slice s can be obtained using the expressions len(s) and cap(s):

When the capacity argument is omitted, it defaults to the specified length. Here's a more succinct version of the same code:

s := make([]int, 5)

The length and capacity of a slice can be inspected using the built-in len and cap functions as shown in the previous example.

len(s) == 5
cap(s) == 5

Another sample code:

In this section, we'll create a byte slice from a string literal "abc" and append a byte to the byte slice. Then, we convert the byte slice into a string with the string() built-in method. A byte slice has a length, which we retrieve with len. Also, we can access individual bytes. Here is the code:

Want to play with arrays and slices? Check this : Arrays vs Slices with an array left rotation sample.

For more on slice - Go Slices: usage and internals

Go Tutorial

1. GoLang Tutorial - HelloWorld
2. Calling code in an external package & go.mod / go.sum files
3. Workspaces
4. Workspaces II
5. Visual Studio Code
6. Data Types and Variables
7. byte and rune
8. Packages
9. Functions
10. Arrays and Slices
11. A function taking and returning a slice
12. Conditionals
13. Loops
14. Maps
15. Range
16. Pointers
17. Closures and Anonymous Functions
18. Structs and receiver methods
19. Value or Pointer Receivers
20. Interfaces
21. Web Application Part 0 (Introduction)
22. Web Application Part 1 (Basic)
23. Web Application Part 2 (Using net/http)
24. Web Application Part 3 (Adding "edit" capability)
25. Web Application Part 4 (Handling non-existent pages and saving pages)
26. Web Application Part 5 (Error handling and template caching)
27. Web Application Part 6 (Validating the title with a regular expression)
28. Web Application Part 7 (Function Literals and Closures)
29. Building Docker image and deploying Go application to a Kubernetes cluster (minikube)
30. Serverless Framework (Serverless Application Model-SAM)
31. Serverless Web API with AWS Lambda
32. Arrays vs Slices with an array left rotation sample
33. Variadic Functions
34. Goroutines
35. Channels ("<-")
36. Channels ("<-") with Select
37. Channels ("<-") with worker pools
38. Defer
39. GoLang Panic and Recover
40. String Formatting
41. JSON
42. SQLite
43. Modules 0: Using External Go Modules from GitHub
44. Modules 1 (Creating a new module)
45. Modules 2 (Adding Dependencies)
46. AWS SDK for Go (S3 listing)
47. Linked List
48. Binary Search Tree (BST) Part 1 (Tree/Node structs with insert and print functions)
49. Go Application Authentication I (BasicAuth, Bearer-Token-Based Authentication)
50. Go Application Authentication II (JWT Authentication)