Restructured code into directories

Author: Rajeev Kumar Singh

07-slices/slice_literal.go renamed to 07-slices/01-create-slice/main.go

@@ -0,0 +1,27 @@
+package main
+
+import "fmt"
+
+func main() {
+	var a = [5]string{"Alpha", "Beta", "Gamma", "Delta", "Epsilon"}
+
+	// Creating a slice from the array
+	var s []string = a[1:4]
+
+	fmt.Println("Array a = ", a)
+	fmt.Println("Slice s = ", s)
+
+	/*
+		low and high parameters are optional in a[low:high]
+		The default value for low is 0, and high is the length of the slice.
+	*/
+	slice1 := a[1:4]
+	slice2 := a[:3]
+	slice3 := a[2:]
+	slice4 := a[:]
+
+	fmt.Println("slice1 = ", slice1)
+	fmt.Println("slice2 = ", slice2)
+	fmt.Println("slice3 = ", slice3)
+	fmt.Println("slice4 = ", slice4)
+}

07-slices/02-create-slice-from-array/main.go

@@ -0,0 +1,14 @@
+package main
+
+import "fmt"
+
+func main() {
+	/*
+		The length of the slice is the number of elements in the slice.
+		The capacity is the number of elements in the underlying array starting from the first element in the slice.
+	*/
+	a := [6]int{10, 20, 30, 40, 50, 60}
+	s := a[1:4]
+
+	fmt.Printf("s = %v, len = %d, cap = %d\n", s, len(s), cap(s))
+}

07-slices/slicing_a_slice.go renamed to 07-slices/03-create-slice-from-another-slice/main.go

@@ -0,0 +1,17 @@
+package main
+
+import "fmt"
+
+func main() {
+	// Creates an array of size 10, slices it till index 5, and returns the slice reference
+	s := make([]int, 5, 10)
+	fmt.Printf("s = %v, len = %d, cap = %d\n", s, len(s), cap(s))
+
+	/*
+		The capacity parameter in the make() function is optional. When omitted, it defaults to the specified length
+	*/
+	// Creates an array of size 5, and returns a slice reference to it
+	var s1 = make([]int, 5)
+	fmt.Printf("s1 = %v, len = %d, cap = %d\n", s1, len(s1), cap(s1))
+
+}

07-slices/slice_modify.go renamed to 07-slices/04-slice-modify/main.go

@@ -3,6 +3,7 @@ package main
 import "fmt"
 
 func main() {
+	// The zero value of a slice is nil. A nil slice doesn’t have any underlying array, and has a length and capacity of 0
 	var s []int
 	fmt.Printf("s = %v, len = %d, cap = %d\n", s, len(s), cap(s))
 

07-slices/05-slice-length-capacity/main.go

@@ -3,6 +3,11 @@ package main
 import "fmt"
 
 func main() {
+	/*
+		The copy() function copies elements from one slice to another
+		func copy(dst, src []T) int
+	*/
+
 	src := []string{"Sublime", "VSCode", "IntelliJ", "Eclipse"}
 	dest := make([]string, 2)
 

07-slices/slice_capacity_extend.go renamed to 07-slices/06-slice-extend-capacity/main.go

@@ -0,0 +1,24 @@
+package main
+
+import "fmt"
+
+func main() {
+	// The append() function appends new elements at the end of a given slice.
+
+	// Appending to a slice that doesn't have enough capacity to accommodate new elements
+	slice1 := []string{"C", "C++", "Java"}
+	slice2 := append(slice1, "Python", "Ruby", "Go")
+
+	fmt.Printf("slice1 = %v, len = %d, cap = %d\n", slice1, len(slice1), cap(slice1))
+	fmt.Printf("slice2 = %v, len = %d, cap = %d\n", slice2, len(slice2), cap(slice2))
+
+	slice1[0] = "C#"
+	fmt.Println("\nslice1 = ", slice1)
+	fmt.Println("slice2 = ", slice2)
+
+	/*
+		In the above example, since slice1 has capacity 3, it can’t accommodate more elements.
+		So a new underlying array is allocated with bigger capacity when we append more elements to it.
+		So if you modify slice1, slice2 won’t see those changes because it refers to a different array.
+	*/
+}