GoLang Tutorial - Arrays vs Slices with an array left rotation sample

We looked at arrays and slices separately in Arrays and Slices.

So, what are the differences?

When we write a go program, for most the cases, we use slices instead of arrays.

An array is fixed in size. But slices can be dynamic: the number of elements in a slice can grow dynamically. Keep in mind that slice uses array behind the curtain but slice by itself cannot store any data. So, we can think of slice like a reference to an array. All it does is to play with just a portion of the underlying array.

Let's look at the following diagram:

The length of a slice is the length of the segment of the array that the slice contains. The capacity is the maximum size up to which the segment can grow. In our example, the capacity is the number of elements in the underlying array starting from the first element in the slice. So, it is 5.

The code for the diagram looks like this:

The code: slice-array.go

Golang provides a library function called make() for creating slices. Following is the signature:

func make([]T, len, cap) []T

The make() function takes a type, a length, and an optional capacity. It allocates an underlying array with size equal to the given capacity, and returns a slice that refers to that array:

The code creates an array of size 10, slices it till index 4, and returns the slice reference.

The capacity parameter in the make() function is optional. When skipped, it defaults to the specified length:

Try to write a code that does rotating an array. We'll find ourselves end up using slices instead of arrays.

Here is the code:

The code: left_rotation.go

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)