Slices in Go

-
This is a study note from YouTube Go tutorial https://www.youtube.com/watch?v=YS4e4q9oBaU
Slice is used in most of cases in Go instead of arrays because it is dynamic. This means you can increase the capacity of slice on the runtime. You can create a slice like below:

Slice creation using []int


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

It is very similar to array creation except no size in the square bracket "[]".

Unlike array is a value type, slice is a reference type like list in Java. So when you create a slice and then assign it to another slice variable, both of them refer to the same memory.
package main

import (
"fmt"
)

func main() {

a := []int{1, 2, 3}
b := a
b[1] = 5
fmt.Println(a)
fmt.Println(b)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))
}

Result:
[1 5 3] [1 5 3] Length: 3 Capacity: 3

From the result, you can see both a and b has the same values even though only b was changed.

Slice operations


There are different ways to create slices.
func main() {

a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
b := a[:] // slice of all elements
c := a[3:] // slice from 4th element to end
d := a[:6] // slice first 6 elements
e := a[3:6] // slice the 4th, 5th and 6th elements

fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)

}
The result is:
[1 2 3 4 5 6 7 8 9 10] [1 2 3 4 5 6 7 8 9 10] [4 5 6 7 8 9 10] [1 2 3 4 5 6] [4 5 6]

To make easier to remember, if we represent the creation operation using format "[left:right]", it will get the data ranging from left to right. Value in left is inclusive while value in right is exclusive.

Here I emphasise again that slice is a reference type. No matter what above methods you use, all slice still refer to the same memory. Once you change value in one slice, it will be changed in all other slices.
For example:
func main() {

a := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
b := a[:] // slice of all elements
c := a[3:] // slice from 4th element to end
d := a[:6] // slice first 6 elements
e := a[3:6] // slice the 4th, 5th and 6th elements

e[1] = 0 // Here modify the 2nd value to be 0
fmt.Println(a)
fmt.Println(b)
fmt.Println(c)
fmt.Println(d)
fmt.Println(e)
}
The result is:
[1 2 3 4 0 6 7 8 9 10] [1 2 3 4 0 6 7 8 9 10] [4 0 6 7 8 9 10] [1 2 3 4 0 6] [4 0 6]

The value in the same memory in different slices is changed as well.

Slice creation using make function


You can also use "make" function to create a slice. The make built-in function allocates and initialises an object of type slice, map, or chan(only). 

Make function can have two parameters or three parameters.

Two-parameter make function prototype is like below:
make(type, length)

func main() {

a := make([]int, 3)
fmt.Println(a)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))

}
The result is:
[0 0 0] Length: 3 Capacity: 3

Three-parameter make function prototype is:
make(type, length, capacity)

func main() {

a := make([]int, 3, 100)
fmt.Println(a)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))

}
The result is:
[0 0 0] Length: 3 Capacity: 100

Add elements in slice using append function

func main() {

a := []int{}
fmt.Println(a)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))
a = append(a, 1)
fmt.Println(a)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))
a = append(a, 2, 3, 4, 5)
fmt.Println(a)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))
}
The result is:
[] Length: 0 Capacity: 0 [1]
Length: 1
Capacity: 1
[1 2 3 4 5] Length: 5 Capacity: 6

Append a slice to a slice

If you want to append a slice to another slice, you cannot do so by just using a = append(a, b) because append function only accepts the same type as the slice element - it cannot accept slice as an input.

However you can use spread operator to archive this - a = append(a, b...). It is same as a = append(a, 2, 3, 4, 5). 

func main() {

a := []int{1}
b := []int{2, 3, 4, 5}
fmt.Println(a)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))
a = append(a, b...)
fmt.Println(a)
fmt.Printf("Length: %v\n", len(a))
fmt.Printf("Capacity: %v\n", cap(a))

}
The result is:
[1] Length: 1 Capacity: 1
[1 2 3 4 5] Length: 5 Capacity: 6

Remove operation in slice

To remove the first element.
func main() {

a := []int{1, 2, 3, 4, 5}
b := a[1:]
fmt.Println(b)
}
The result is:
[2 3 4 5]

To remove the last element.
func main() {

a := []int{1, 2, 3, 4, 5}
b := a[:len(a)-1]
fmt.Println(b)
}

The result is:
[1 2 3 4]

To remove the element in the middle.
func main() {

a := []int{1, 2, 3, 4, 5}
b := append(a[:2], a[3:]...)
fmt.Println(b)
}
The result is:
[1 2 4 5]

However, as mentioned before, slice is a reference type. When you modify a slice, it will impact all other slice variables that refer to it.
When you do fmt.Println(a), you will get result like below:
[1 2 4 5 5]

From above you can see that remove operation impact the original slice a as well. So be aware of this!



Comments

Post a Comment

Popular posts from this blog

Basic understanding of TLS-PSK protocol

-
Image
This post will talk about the basic understanding of TLS-PSK protocol. It will not cover TLS's history and how its mathematical algorithms work. Instead, what is TLS-PSK protocol and how it works will be discussed here. I prefer using diagrams to help explain things. Hopefully, it can give readers a very basic insights of TLS-PSK. What is TLS-PSK Before talking about what is TLS-PSK, I would like to introduce what is TLS first. TLS, Transport Layer Security, is a cryptographic protocol, aims to provide protection to end-to-end communication over the internet. It helps to protect network users from eavesdropping, tempering and so on. Clear data transmission is dangerous, given that technical hacker can listen to the communication between two computers and steal sensitive data like user name, password and so on. This is situation where TLS can step in and protect you. TLS has two steps: TLS handshake and data transmission. During TLS handshake, the communicating parties mus...
Read more

Differences between ASIC, ASSP and ASIP

-
ASIC (Application Specified Integrated Circuit) is a customized integrated circuit. It is usually used by a person or company for a very limited usage. So when it is developed, only the person or company who orders it can use it. It is not useful for other usages, for example, an IC designed for a specific line of cellular phones of a company, whereby no other products can use it except the cell phones belonging to that product line. - ASIC is just built for one and only one customer. - ASIC is used only in one product line - Only volume production of ASICs for one product can make sense which means low unit cost for high volume products, otherwise the cost is not efficient. - Can exploit parallelism to achieve high performance - Low power consumption ASSP (Application Specified Standard Processor) is an integrated circuit that implements a specific function that appeals to a wide market, which means its function is specified for example a motor drive chip. But it is used widel...
Read more

Orthogonal instruction set

-
Definition: "In computer engineering, an orthogonal instruction set is an instruction set architecture where  all instruction types  can use  all addressing modes . It is 'orthogonal' in the sense that the instruction type and the addressing mode vary independently." The story of orthogonal instruction set: In the past, because the  memory is very precious , so the processor designer tends to  make instructions as powerful as possible . So they hope one instruction can perform  full function  like get data from memory and then perform the calculation. They make  all instructions can have all the addressing modes . By this way,  one instruction can fetch data and do the calculation at the same time .  But this will  inscrease the complexity  of the processor design. Also, accessing memory directly is very time-consuming, so some companies choose to use RISC processor (like ARM) which has a  LOAD-STORE a...
Read more