“Journey With Go – A Weblog Collection” in regards to the fundamentals of Go Go Fundamental, superior ideas in Go Go Past Fundamentals, testing with Go Godog as Take a look at Framework, and lots of extra.
That is the third installment of the sequence. You’re right here which implies you may have more than likely learn the primary and second blogs of the sequence. If you have not, please learn them first Go Fundamentals, Management Statements.
On this weblog, we’ll be taught in regards to the Rune, String, Array, Operate, Struct, Technique, and Interface in Go.
So, let’s get began.
1. Rune
In Go, a rune is a built-in sort that represents a Unicode code level. A rune literal is expressed as a number of characters enclosed in single quotes, as in ‘x’ or ‘n’. Every Unicode code level corresponds to a novel character, which generally is a letter, a numeral, an emblem, or an emoji.
Examples:
package deal important
import (
"fmt"
)
func important() {
var om rune = 'ॐ' // rune literal declared utilizing the `rune` key phrase, use single quotes
fmt.Println(om) // prints the Unicode code level for the Om image
fmt.Printf("%Tn", om) // prints the underlying sort of rune
fmt.Println(string(om)) // prints the string illustration of the Om image
// extra examples
var coronary heart rune = '♥'
fmt.Println(coronary heart)
fmt.Println(string(coronary heart))
var smiley rune = '😀'
fmt.Println(smiley)
fmt.Println(string(smiley))
}
Output:
2384
int32
ॐ
9829
♥
128512
😀
It’s significantly vital when coping with textual content in several languages or when working with particular symbols and emojis. It ensures that every character is handled as a single entity, no matter its complexity or language.
2. String
In Go, a string is a sequence of bytes (not characters) that’s used to symbolize textual content. Strings are immutable, which implies that as soon as created, their values can’t be modified. Nevertheless, you’ll be able to assign a brand new worth to a string variable, which can create a brand new string.
Observe: The rune is encoded with single quotes, whereas the string is encoded with double quotes.
Examples:
package deal important
import (
"fmt"
)
func important() {
// declaring a variable `greeting` of sort string utilizing `string` key phrase
var greeting string = "Hiya, World!"
fmt.Println(greeting) // it prints the worth of the `greeting`
fmt.Printf("%Tn", greeting) // it prints the kind of the `greeting`
fmt.Println(len(greeting)) // it prints the size of bytes within the `greeting`
fmt.Println(greeting[0]) // it prints the byte code of the char in index 0
fmt.Println(string(greeting[0])) // it prints the string illustration of the char in index 0
fmt.Println("Hiya, " + "World!") // it prints the concatenated string `Hiya, ` and `World!` with `+`
// attempt to change the worth at index 1, i.e. `e` to `E` within the `greeting`
greeting[1] = 'E' // it provides an error `can't assign to greeting[1]`
// attempt to assign the brand new worth of the `greeting` to `Hiya, Nepal!`
greeting = "Hiya, Nepal!" // it creates a brand new string `Hiya, Nepal!` and assigns it to the `greeting`
fmt.Println(greeting) // it prints the brand new worth of the `greeting`
}
Output:
Hiya, World!
string
13
72
H
Hiya, World!
can't assign to greeting[1]
Hiya, Nepal!
2.1. Slicing of a String
Slicing is a mechanism to extract a portion of a string. It’s performed by specifying the beginning and finish indices of the a part of the string that you just need to extract. The syntax for slicing a string is string[start:end].
Taking the above greeting variable for instance:
| slice | output | description |
|---|---|---|
greeting[7:] |
World! | It provides the sub-string from index 7 to the top |
greeting[:5] |
Hiya | It provides the sub-string from the start to index 5, excluding index 5 worth |
greeting[7:12] |
World | It provides the sub-string from index 7 to index 12, together with index 7 and excluding index 12 worth |
greeting[:] |
Hiya, World! | It provides your entire string, similar as printing greeting
|
2.2. Iterating over a String
Strings are immutable, however you’ll be able to iterate over them utilizing a for loop with vary.
Examples:
package deal important
import (
"fmt"
)
func important() {
greeting := "Hiya, World!"
for index, char := vary greeting {
fmt.Printf("Index: %d, Worth: %cn", index, char)
}
}
Output:
Index: 0, Worth: H
Index: 1, Worth: e
Index: 2, Worth: l
Index: 3, Worth: l
Index: 4, Worth: o
Index: 5, Worth: ,
Index: 6, Worth:
Index: 7, Worth: W
Index: 8, Worth: o
Index: 9, Worth: r
Index: 10, Worth: l
Index: 11, Worth: d
Index: 12, Worth: !
2.3. len Vs RuneCountInString
The len operate returns the variety of bytes in a string, whereas the utf8.RuneCountInString operate returns the variety of runes in a string.
Examples:
package deal important
import (
"fmt"
"unicode/utf8"
)
func important() {
// let's take a look at the instance of English language
greeting := "Hiya, World!"
fmt.Println(len(greeting)) // it prints the variety of bytes within the string given by len operate
fmt.Println(utf8.RuneCountInString(greeting)) // it prints the variety of runes within the string given by utf8.RuneCountInString operate
// Now, take an instance of Nepali language
greetingInNepali := "नमस्कार संसार";
fmt.Println(len(greetingInNepali)) // it prints the variety of bytes within the string given by len operate
fmt.Println(utf8.RuneCountInString(greetingInNepali)) // it prints the variety of runes within the string given by utf8.RuneCountInString operate
}
Output:
13
13
37
13
Within the instance for the English language, the worth returned by the len operate is similar as the worth returned by the utf8.RuneCountInString operate.
Nevertheless, for the Nepali language, the worth returned by the len operate is completely different from the worth returned by the utf8.RuneCountInString operate. It is because the Nepali language makes use of the UTF-8 encoding scheme, which makes use of 3 bytes to symbolize a single character. Subsequently, the string “नमस्कार संसार” has 37 bytes, however solely 13 runes.
3. Array
In Go, an array is a fixed-length sequence of components of the identical sort however the content material of the array is mutable (i.e. will be modified). Arrays are helpful when you already know the variety of components that you just need to retailer upfront.
3.1. Declaration of Array
Declaration of an array will be performed utilizing the next syntax:
Syntax:
var <array_name> [<size>] <data_type>
Examples:
package deal important
import (
"fmt"
)
func important(){
// declaring an array of sort int with 5 components
var numbers [5]int
fmt.Println(numbers) // by default 0 will probably be assigned to array components
// declaring an array of sort string with 3 components
var languages [3]string
fmt.Println(languages) // by default empty array will probably be created
// declaring an array of sort bool with 2 components
var truths [2]bool
fmt.Println(truths) // by default false will probably be assigned to array components
// declaring an array of sort float64 with 4 components
var scores [4]float64
fmt.Println(scores) // by default 0 will probably be assigned to array components
}
Output:
[0 0 0 0 0]
[ ]
[false false]
[0 0 0 0]
3.2. Initialization of Array
You’ll be able to initialize an array utilizing the next syntax:
Syntax:
var <array_name> [<size>] <data_type> = [<size>]<data_type>{<comma-separated-values>}
Examples:
package deal important
import (
"fmt"
)
func important(){
// initialization of an array of sort int with 3 components
var numbers [3]int = [3]int{1, 2, 3}
fmt.Println(numbers) // prints the worth of integer array
// initialization of an array of sort string with 3 components
var languages [3]string = [3]string{"Go", "Python", "JavaScript"}
fmt.Println(languages) // prints the worth of string array
// initialization of an array of sort bool with 2 components
var truths [2]bool = [2]bool{true, false}
fmt.Println(truths) // prints the worth of boolean array
// initialization of an array of sort float64 with 3 components
var scores [3]float64 = [3]float64{9.5, 8.2, 7.8}
fmt.Println(scores) // prints the worth of float64 array
}
Output:
[1 2 3]
[Go Python JavaScript]
[true false]
[9.5 8.2 7.8]
3.3. Manipulation of Array
You’ll be able to manipulate an array utilizing the next syntax:
Syntax:
<array_name>[<index>] = <worth>
Examples:
package deal important
import (
"fmt"
)
func important() {
var numbers [3]int = [3]int{1, 2, 3}
fmt.Println(numbers) // prints the worth of the array
// altering the worth of the primary aspect
numbers[0] = 4
fmt.Println(numbers) // prints the brand new worth of the array
// accessing a component of the array
fmt.Println(numbers[0]) // prints the worth of the primary aspect
// including a brand new aspect to the array isn't doable
numbers[3] = 5 // invalid array index 3 (out of bounds for 3-element array)
// accessing a component of non-existing index isn't doable
fmt.Println(numbers[3]) // invalid array index 3 (out of bounds for 3-element array)
}
Output:
[1 2 3]
[4 2 3]
4
invalid argument: index 3 out of bounds
invalid argument: index 3 out of bounds
3.4. Array Size
You will get the size of an array utilizing the len operate.
Examples:
package deal important
import (
"fmt"
)
func important() {
var numbers [3]int = [3]int{1, 2, 3}
fmt.Println(len(numbers)) // prints the size of the array
}
Output:
3
3.5. Iterating over Array
You’ll be able to iterate over an array utilizing a for loop with vary.
Examples:
package deal important
import (
"fmt"
)
func important() {
var languages [3]string = [3]string{"Go", "Javascript", "Python"}
for index, language := vary languages {
fmt.Printf("Index: %d, Worth: %sn", index, language)
}
}
Output:
Index: 0, Worth: Go
Index: 1, Worth: Javascript
Index: 2, Worth: Python
Another strategy to iterate over an array is to make use of a for loop with the size of the array.
Examples:
package deal important
import (
"fmt"
)
func important() {
var languages [3]string = [3]string{"Go", "Javascript", "Python"}
for i := 0; i < len(languages); i++ {
fmt.Printf("Index: %d, Worth: %sn", i, languages[i])
}
}
Output:
Index: 0, Worth: Go
Index: 1, Worth: Javascript
Index: 2, Worth: Python
4. Operate
In Go, a operate is a block of code that performs a particular process. Capabilities are helpful whenever you need to reuse the identical code a number of occasions. Additionally they assist in organizing your code into smaller chunks, which makes it simpler to learn and keep.
4.1. Operate Definition
A operate should be outlined earlier than it may be referred to as. A operate definition should have a reputation and a physique with an elective checklist of parameters and a return sort. In Go, the func key phrase is used to outline a operate.
A operate will be outlined utilizing the next syntax:
Syntax:
func <function_name>(<comma-separated-parameters>) <return_type> {
// operate physique is the code that's executed when the operate known as
}
Examples:
// defining a operate named `greet`
func greet(title string) { // operate title is `greet`, parameter is `title` of sort string
fmt.Println("Hiya, " + title) // operate physique enclosed in curly braces
}
Within the above instance, we have now declared a operate named greet that takes a string parameter named title and returns nothing.
4.2. Operate Name
A operate will be referred to as utilizing the next syntax:
Syntax:
<function_name>(<comma-separated-arguments>)
Examples:
package deal important
import (
"fmt"
)
func greet(title string) {
fmt.Println("Hiya, " + title)
}
func important() {
greet("World") // Calling the `greet` operate
}
Output:
Hiya, World
4.3. Operate Parameters
The operate can have zero or extra parameters. Parameters are variables which can be used to cross values to a operate. They’re declared within the operate definition. The values handed to a operate are referred to as arguments.
Examples:
package deal important
import (
"fmt"
)
// defining a operate named `printHelloWorld` with out parameters
func printHelloWorld() {
fmt.Println("Hiya, World!")
}
// defining a operate named `add` that takes two integer parameters
func add(a int, b int) {
fmt.Println(a + b)
}
func important() {
printHelloWorld() // Calling the `printHelloWorld` operate, with out arguments
add(1, 2) // Calling the `add` operate, with two arguments
}
Output:
Hiya, World!
3
4.4. Operate Return Sort
A operate can return zero or extra values. The return sort of a operate is asserted within the operate definition. If a operate returns a couple of worth, then the return sorts are enclosed in parentheses.
Examples:
package deal important
import (
"fmt"
)
// defining a operate named `greet` that takes a string parameter and returns nothing
func greet(title string) {
fmt.Println("Hiya, " + title)
}
// defining a operate named `add` that takes two integer parameters and returns an integer
func add(a int, b int) int {
return a + b // `return` key phrase is used to return values from a operate
}
// defining a operate named `swap` that takes two integer parameters and returns two integers
func swap(a int, b int) (int, int) {
return b, a
}
func important() {
greet("World") // Calling the `greet` operate
fmt.Println(add(1, 2)) // Calling the `add` operate
sum := add(3,6) // Additionally, the `add` operate will be referred to as and retailer the returned worth in variable `sum`
fmt.Println(sum)
x, y := swap(1, 2) // Calling the `swap` operate and storing the returned values in variables `x` and `y`
fmt.Println(x, y)
}
Output:
Hiya, World
3
9
2 1
5. Struct
In Go, a struct is a composite knowledge sort that represents a group of fields. It’s helpful for grouping associated knowledge collectively. Structs are helpful whenever you need to mannequin actual world entities which have a number of properties. Struct is often known as a user-defined sort.
5.1. Struct Definition
The struct key phrase is used to outline a struct in Go.
A struct will be outlined utilizing the next syntax:
Syntax:
sort <struct_name> struct {
<comma-separated-fields>
}
Examples:
package deal important
// defining a struct named `Pupil` with three fields `title`, `telephone quantity`, `handle`
sort Pupil struct {
title string
phoneNumber int
handle string
}
5.2. Struct Initialization
A struct will be initialized utilizing the next syntax:
Syntax:
<struct_name>{<comma-separated-values>}
Examples:
package deal important
import (
"fmt"
)
sort Pupil struct {
title string
phoneNumber int
handle string
}
func important() {
// initializing a struct named `scholar` with three fields `title`, `telephone quantity`, `handle`
scholar := Pupil{"John Doe", 1234567890, "Kathmandu"} // order of values should match the order of fields
fmt.Println(scholar)
}
Output:
{John Doe 1234567890 Kathmandu}
5.3. Manipulation of Struct Fields
The struct fields are variables which can be used to retailer values in a struct. They’re declared within the struct definition. Fields will be manipulated utilizing the dot operator.
Examples:
package deal important
import (
"fmt"
)
sort Pupil struct {
title string
phoneNumber int
handle string
}
func important() {
scholar := Pupil{"John Doe", 1234567890, "Kathmandu"}
fmt.Println(scholar)
// accessing a subject of a struct
fmt.Println(scholar.title)
fmt.Println(scholar.phoneNumber)
fmt.Println(scholar.handle)
// altering the worth of a subject
scholar.title = "Jane Doe"
fmt.Println(scholar.title)
}
Output:
{John Doe 1234567890 Kathmandu}
John Doe
1234567890
Kathmandu
Jane Doe
6. Technique
In Go, a technique is a operate that’s related to a kind. It’s helpful for grouping associated features collectively. Strategies are helpful whenever you need to mannequin real-world entities which have a number of behaviors. Strategies are often known as features with receivers.
6.1. Technique Definition
A way will be outlined utilizing the next syntax:
Syntax:
func (<receiver>) <method_name>(<comma-separated-parameters>) <return_type> {
// technique physique is the code that's executed when the tactic known as
}
Examples:
package deal important
sort Triangle struct {
base float64
top float64
}
// defining a technique named `space` that takes no parameters and returns a float64
func (t Triangle) space() float64 {
return 0.5 * t.base * t.top
}
Within the above instance, we have now outlined a technique related to a struct named Triangle by including a receiver to the operate definition. The receiver is the title of the struct that the tactic is related to. The receiver is enclosed in parentheses earlier than the tactic title.
6.2. Technique Name
A way will be referred to as utilizing the next syntax:
Syntax:
<receiver>.<method_name>(<comma-separated-arguments>)
Examples:
package deal important
import (
"fmt"
)
sort Triangle struct {
base float64
top float64
}
func (t Triangle) space() float64 {
return 0.5 * t.base * t.top
}
func important() {
triangle := Triangle{base: 10, top: 5}
fmt.Println(triangle)
// calling the `space` technique
space := triangle.space() // triangle is the receiver
fmt.Println("Space of triangle is " + fmt.Sprintf("%.2f", space))
}
Output:
{10 5}
Space of triangle is 25.00
6.3. Operate Vs Technique
A operate is a block of code that performs a particular process whereas a technique is a operate that’s related to a kind. We will create a number of strategies of the identical title related to differing types however the operate title should be completely different (see an instance of seven.2).
Let’s examine the distinction between a operate and a technique with the assistance of an instance.
Examples:
package deal important
import (
"fmt"
)
// defining a operate named `getAreaOfTriangle` that takes two float64 parameters and returns a float64
func getAreaOfTriangle(base float64, top float64) float64 {
return 0.5 * base * top
}
sort Triangle struct {
base float64
top float64
}
// defining a technique named `getAreaOfTriangle` that takes no parameters and returns a float64
func (t Triangle) getAreaOfTriangle() float64 {
return 0.5 * t.base * t.top
}
func important() {
// calling the `getAreaOfTriangle` operate
space := getAreaOfTriangle(10, 5)
fmt.Println("Space of triangle is " + fmt.Sprintf("%.2f", space))
triangle := Triangle{base: 10, top: 5} // creating a brand new occasion of the `Triangle` struct
fmt.Println(triangle)
// calling the `getAreaOfTriangle` technique
space = triangle.getAreaOfTriangle() // triangle is the receiver
fmt.Println("Space of triangle is " + fmt.Sprintf("%.2f", space))
}
Output:
Space of triangle is 25.00
{10 5}
Space of triangle is 25.00
So, within the above instance, we have now outlined a operate named space that takes two float64 parameters and returns a float64. We now have additionally outlined a technique named space that takes no parameters and returns a float64. The operate and the tactic have the identical title, however they’re completely different as a result of the operate isn’t related to any sort, whereas the tactic is related to the Triangle struct.
7. Interface
In Go, an interface is a group of technique signatures. It’s helpful for grouping associated strategies collectively. Interfaces are helpful whenever you need to mannequin real-world entities which have a number of behaviors.
7.1. Interface Definition
The interface key phrase is used to outline an interface in Go.
An interface will be outlined utilizing the next syntax:
Syntax:
sort <interface_name> interface {
<comma-separated-technique-signatures>
}
Examples:
package deal important
// defining an interface named `Form` with a technique signature `space` and `perimeter`
sort Form interface {
space() float64
perimeter() float64
}
Within the above instance, we have now outlined an interface named Form with a technique signature space and perimeter. An interface can have zero or extra technique signatures. A way signature is the title of the tactic and its parameters and return sort.
7.2. Interface Implementation
A kind implements an interface by implementing all of the strategies of the interface. A kind can implement a couple of interface.
Examples:
package deal important
import (
"fmt"
"math"
)
sort Form interface {
space() float64
perimeter() float64
}
sort Triangle struct {
base float64
top float64
}
sort Rectangle struct {
size float64
width float64
}
// implementing a technique `space` for the `Triangle` struct
func (t Triangle) space() float64 {
return 0.5 * t.base * t.top
}
// implementing a technique `perimeter` for the `Triangle` struct
func (t Triangle) perimeter() float64 {
return t.base + t.top + math.Sqrt(math.Pow(t.base, 2)+math.Pow(t.top, 2))
}
// implementing a technique `space` for the `Rectangle` struct
func (r Rectangle) space() float64 {
return r.size * r.width
}
// implementing a technique `perimeter` for the `Rectangle` struct
func (r Rectangle) perimeter() float64 {
return 2 * (r.size + r.width)
}
func important() {
var triangle Form = Triangle{base: 10, top: 5}
fmt.Println(triangle)
space := triangle.space() // calling the `space` technique related to the `Triangle` struct
fmt.Println("Space of triangle is " + fmt.Sprintf("%.2f", space))
perimeter := triangle.perimeter() // calling the `perimeter` technique related to the `Triangle` struct
fmt.Println("Perimeter of triangle is " + fmt.Sprintf("%.2f", perimeter))
var rectangle Form = Rectangle{size: 10, width: 5}
fmt.Println(rectangle)
space = rectangle.space() // calling the `space` technique related to the `Rectangle` struct
fmt.Println("Space of rectangle is " + fmt.Sprintf("%.2f", space))
perimeter = rectangle.perimeter()
fmt.Println("Perimeter of rectangle is " + fmt.Sprintf("%.2f", perimeter)) // calling the `perimeter` technique related to the `Rectangle` struct
}
Output:
{10 5}
Space of triangle is 25.00
Perimeter of triangle is 26.18
{10 5}
Space of rectangle is 50.00
Perimeter of rectangle is 30.00
What we have now discovered to this point
On this weblog, we have now discovered tips on how to declare, outline, manipulate, and use the next phrases within the Go language:
- Rune
- String
- Array
- Operate
- Struct
- Technique
- Interface
Within the subsequent weblog, we’ll study some superior matters like Errors, Goroutines, and Channels within the Go language.
Preserve Studying and Preserve Training 👍
Keep tuned!!!
References
PC: Banner Picture by Maria Letta, licensed below Creative Commons 0 license.
