gaspersic/learngo
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

add: slice internals backing array and slice header

Browse Source
This commit is contained in:
Inanc Gumus
2019-02-08 13:10:55 +03:00
parent ff4eb232d1
commit 04c5e2bec7
16 changed files with 642 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

131
16-slices/questions/4-backing-array.md Normal file
View File

@ -0,0 +1,131 @@
# Backing Array Quiz
## Where does a slice store its elements?
1. In the slice value
2. In a global backing array that is shared by all the slices
3. In a backing array that is specific to a slice
4. In a backing array that the slice references *CORRECT*
> **1:** A slice value doesn't store any elements. It's just a simple data structure.
>
> **2:** There is not a global backing array.
>
> **3:** A backing array can be shared among slices. It may not be specific to a slice.
>
> **4:** Yep! A slice stores its elements in a backing that the slice references (or points to).
>
## When you slice a slice, what value does it return?
```go
// example:
s := []string{"i'm", "a", "slice"}
s[2:] // <-- slicing
```
1. It returns a new slice value with a new backing array
2. It returns the existing slice value with a new backing array
3. It returns a new slice value with the same backing array *CORRECT*
> **3:** Yes! Slicing returns a new slice that references to some segment of the same backing array.
## Why is slicing and indexing a slice efficient?
1. Slices are fast
2. Backing arrays are contiguous in memory *CORRECT*
3. Go uses clever algorithms
> **2:** Yes. A slice's backing array is contiguous in memory. So, accessing an element of a slice is very fast. Go can look at a specific memory location to find an element's value very fast.
## Which one is the backing array of "slice2"?
```go
arr := [...]int{1, 2, 3}
slice1 := arr[2:3]
slice2 := slice1[:1]
```
1. arr *CORRECT*
2. slice1
3. slice2
4. A hidden backing array
> **1:** Yes! When a slice is created by slicing an array, that array becomes the backing array of that slice.
>
> **4:** Nope. That only happens when a slice doesn't being created from an array.
>
## Which one is the backing array of "slice"?
```go
arr := [...]int{1, 2, 3}
slice := []int{1, 2, 3}
```
1. arr
2. slice1
3. slice2
4. A hidden backing array *CORRECT*
> **1:** Nope, the slice hasn't created by slicing an array.
>
> **4:** Yes! A slice literal always creates a new hidden array.
>
## Which answer is correct for the following slices?
```go
slice1 := []int{1, 2, 3}
slice2 := []int{1, 2, 3}
```
1. Their backing array is the same.
2. Their backing arrays are different. *CORRECT*
3. They don't have any backing arrays.
> **2:** That's right. A slice literal always creates a new backing array.
## Which answer is correct for the following slices?
```go
slice1 := []int{1, 2, 3}
slice2 := []int{1, 2, 3}
slice3 := slice1[:]
slice4 := slice2[:]
```
1. slice1 and slice2 have the same backing arrays.
2. slice1 and slice3 have the same backing arrays. *CORRECT*
3. slice1 and slice4 have the same backing arrays.
4. slice3 and slice4 have the same backing arrays.
> **2:** Yep! A slice that is being created by slicing shares the same backing with the sliced slice. Here, slice3 is being created from slice1. That is also true for slice2 and slice4.
## What does the backing array of the nums slice look like?
```go
nums := []int{9, 7, 5, 3, 1}
nums = nums[:1]
fmt.Println(nums) // prints: [9]
```
1. [9 7 5 3 1] *CORRECT*
2. [7 5 3 1]
3. [9]
4. []
## What does this code print?
```go
arr := [...]int{9, 7, 5, 3, 1}
nums := arr[2:]
nums2 := nums[1:]
arr[2]++
nums[1] -= arr[4] - 4
nums2[1] += 5
fmt.Println(nums)
```
1. [5 3 1]
2. [6 6 6] *CORRECT*
3. [9 7 5]
> **2:** Yes! Because the backing array of `nums` and `nums2` is the same: `arr`. See the explanation here: https://play.golang.org/p/xTy0W0S_8PN

90
16-slices/questions/5-slice-header.md Normal file
View File

@ -0,0 +1,90 @@
# Slice Header Quiz
## What is a slice header?
1. The first element of a slice value
2. The first element of the backing array
3. A tiny data structure that describes all or some part of a backing array *CORRECT*
4. A data structure that contains the elements of a slice
> **3:** Yes! It's just a tiny data structure with three numeric fields.
>
> **4:** A slice doesn't contain any elements on its own.
## What are the fields of a slice value?
1. Pointer, length, and capacity *CORRECT*
2. Length and capacity
3. Only a pointer
## Which slice value does the following slice header describe?
SLICE HEADER:
+ Pointer : 100th
+ Length : 5
+ Capacity: 10
Assume that the backing array is this one:
```go
var array [10]string
```
1. array[5:]
2. array[:5] *CORRECT*
3. array[3:]
4. array[100:]
> **1**: This slice's capacity is 5, it can only see the elements beginning with the 6th element.
>
> **2**: That's right. `array[:5]` returns a slice with the first 5 elements of the `array` (len is 5), but there are 5 more elements in the backing array of that slice, so in total its capacity is 10.
>
> **3**: This slice's capacity is 7, it can only see the elements beginning with the 4th element.
>
> **4**: This is an error. The backing array doesn't have 100 elements.
>
## Which one is the slice header of the following slice?
```go
var tasks []string
```
1. Pointer: 0, Length: 0, Capacity: 0 *CORRECT*
2. Pointer: 10, Length: 5, Capacity: 10
3. Pointer: 0, Length: 1, Capacity: 1
> **1:** A nil slice doesn't have backing array, so all the fields are equal to zero.
## What is the total memory usage of this code?
```go
var array [1000]int64
array2 := array
slice := array2[:]
```
1. 1024 bytes
2. 2024 bytes
3. 3000 bytes
4. 16024 bytes *CORRECT*
> **4:** `array` is 1000 x int64 (8 bytes) = 8000 bytes. Assigning an array copies all its elements, so `array2` adds additional 8000 bytes. A slice doesn't store anything on its own. Here, it's being created from array2, so it doesn't allocate a backing array as well. A slice header's size is 24 bytes. So in total: This program allocates 16024 bytes.
## What value does this code pass to the sort.Ints function?
```go
nums := []int{9, 7, 5, 3, 1}
sort.Ints(nums)
```
1. [9 7 5 3 1] — All the values of the nums slice
2. A pointer to the backing array of the nums slice
3. A pointer, length and capacity as three different arguments
4. The slice header that is stored in the nums variable *CORRECT*
> **1:** No, a slice value doesn't contain any elements. So it cannot pass the elements.
>
> **2:** Sorry but not only that.
>
> **3:** Nope. Remember, they are packed in a tiny data structure called the ....?
>
> **4:** Yep! A slice value is a slice header (pointer, length and capacity). A slice variable stores the slice header.
>

4
16-slices/questions/README.md
View File

@ -4,4 +4,6 @@
* [Appending](2-appending.md)
* [Slicing](3-slicing.md)
* [Slicing](3-slicing.md)
* [Backing Array](4-backing-array.md)