Tutorial5 - Strings, Runes, and UTF-8 Encoding

Author: Shikha-code36

README.md

@@ -46,3 +46,4 @@ go run tutorial1/main.go
 - [x] [Constants Variables and Basic Data Types](tutorial2)
 - [x] [Functions and Control Structures](tutorial3)
 - [x] [Arrays, Slices, Maps and Loops](tutorial4)
+- [x] [Strings, Runes, and UTF-8 Encoding](tutorial4)

tutorial5/README.md

@@ -0,0 +1,61 @@
+# Strings, Runes, and UTF-8 Encoding in Go
+
+This README will guide you through some basic concepts in Go, including strings, runes, and UTF-8 encoding. The code we'll be discussing demonstrates these concepts in a simple and understandable way.
+
+## Strings and UTF-8 Encoding
+
+In Go, a string is a sequence of bytes. This means when you create a string in Go, it's encoded in UTF-8 by default. UTF-8 is a variable-width character encoding that can represent every character in the Unicode standard, yet the initial encoding of byte sequences is ASCII.
+
+Let's take a look at this piece of code:
+
+```go
+var myString = "résumé"
+var indexed = myString[1]
+fmt.Println(indexed)
+fmt.Printf("%v %T \n", indexed, indexed)
+```
+
+Here, `myString[1]` doesn't give you the second character 'é', but instead it gives you a number which is the Unicode of the second byte of 'é'. This is because 'é' is a non-ASCII character represented by two bytes in UTF-8.
+
+## Runes
+
+A rune in Go is a type that represents a Unicode CodePoint. It does not matter if the character is ASCII or not, it can be represented as a rune. A rune literal is just a number. We usually use it to represent a character's unicode code point.
+
+Let's modify the code to use runes:
+
+```go
+var myString2 = []rune("résumé")
+var indexed2 = myString2[1]
+fmt.Println(indexed2)
+fmt.Printf("%v %T \n", indexed2, indexed2)
+```
+
+Now `myString2[1]` gives you the Unicode of 'é', because we're treating the string as a sequence of runes instead of a sequence of bytes.
+
+## String Concatenation
+
+In Go, you can concatenate strings using the `+` operator:
+
+```go
+var strSlice = []string{"s", "h", "i", "k", "h", "a"}
+var catStr = ""
+for i := range strSlice{
+	catStr += strSlice[i]
+}
+fmt.Printf("\nString building: %v",catStr)
+```
+
+However, since strings are immutable in Go, string concatenation using `+` creates a new string, which can be inefficient when concatenating a large number of strings. A more efficient way is to use the `strings.Builder`:
+
+```go
+var strBuilder strings.Builder
+for i := range strSlice{
+	strBuilder.WriteString(strSlice[i])
+}
+var catStr1 = strBuilder.String()
+fmt.Printf("\nString building through built in package: %v",catStr1)
+```
+
+### Checkout the code
+
+ - [main.go](main.go)

tutorial5/main.go

@@ -0,0 +1,87 @@
+package main
+
+import (
+	"fmt"
+	"strings"
+)
+
+func main() {
+	var myString = "résumé"
+	var indexed = myString[1]
+	fmt.Println(indexed) //if we run this we get a number 
+
+	//let's print out the type of the index value
+	fmt.Printf("%v %T \n", indexed, indexed) //even wierder we get unsigned int8
+
+	for i,v := range myString{
+		fmt.Println(i,v)
+	} // we get index start with 0 and bunch of numbers with it's value which is bytes due to utf-8
+
+	fmt.Printf("\n The length of 'myString' is %v", len(myString))
+
+	// easier way to deal with the strings for indexing and iterating is to cast them in array of runes
+	
+	fmt.Println("\n----------After rune------------")
+	var myString2 = []rune("résumé")
+	var indexed2 = myString2[1]
+	fmt.Println(indexed2) //if we run this we get a number 
+
+	//let's print out the type of the index value
+	fmt.Printf("%v %T \n", indexed2, indexed2) //now we get int32
+
+	for i,v := range myString2{
+		fmt.Println(i,v)
+	} // we get index start with 0 and bunch of numbers with it's value which is bytes due to utf-8
+
+	fmt.Printf("\n The length of 'myString2' is %v", len(myString2))
+
+	// we can concantenate string using "+" symbol
+
+	var strSlice = []string{"s", "h", "i", "k", "h", "a"}
+	var catStr = ""
+	for i := range strSlice{
+		catStr += strSlice[i]
+	}
+	fmt.Printf("\nString building: %v",catStr)
+
+	// strings are immutable in GO we are creating a new string catStr
+	// we can use built in package for string building
+
+	var strBuilder strings.Builder
+	for i := range strSlice{
+		strBuilder.WriteString(strSlice[i])
+	}
+	var catStr1 = strBuilder.String()
+	fmt.Printf("\nString building through built in package: %v",catStr1)
+
+}
+
+/*
+>>>>>>>>>>>>>>>>>>>>>>>>>>>> go run tutorial5/main.go
+
+O/P :::::::::::::::::::::
+
+195
+195 uint8 
+0 114
+1 233
+3 115
+4 117
+5 109
+6 233
+
+ The length of 'myString' is 8
+----------After rune------------
+233
+233 int32 
+0 114
+1 233
+2 115
+3 117
+4 109
+5 233
+
+ The length of 'myString2' is 6
+String building: shikha
+String building through built in package: shikha
+*/