Hello there! So today we will be learning about Go variables and the different data types associated with Go.
Just in case you are just started the Go language, you should read this.
We would be using the Go Playground to learn and practice this example, and you can grab a pop-corn, this would be a long and interesting ride. Ready? Let hop in.
Go is all about types, type is Go and Go is type. - Bill Kennedy
In this article, we are going to look at:
And after this article, you will get in-depth understanding of data types in Go.
Drop by drop the bucket gets filled - Todd Mcleaon.
Let's look at the code snippet below:
package main
import (
"fmt"
)
func main() {
var name string = "Franklin"
var number int = 34
fmt.Println("Hello, playground")
}
The above is what your Go playground should look like, now let analyze what is happening there.
The main package is a package provided by Go that is used with the programs to show that they are executable. The package main is the entry point of the Go compiler to know that the file is ready to be executed and complied.
package main
import (
"fmt"
)
func main() {
var name string = "Franklin"
var number int = 34
fmt.Println(name)
fmt.Println(number)
}
Output:
"Franklin"
34
var is the keyword used to declare a VARIABLE( name) to a TYPE(string , int) and assign a VALUE( Franklin,34).
Now see Variables as paper box , and the Type as a certain color the papers in the box should have, storing values with are the papers.
Variables can also be declared using the short declaration method with works only if the variable is declared within a function block. By doing this, we are asking Go to deduce what Type should the value be using the ' : ' and the ' = ' .
Example:
package main
import (
"fmt"
)
func main() {
var name := "Franklin"
var number : = 34
fmt.Println(name)
fmt.Println(number)
}
Output:
"Franklin"
34
We also have the Constant method using the
const
keyword. This can be declared and used both in the package level and the function level just like the var. Example:
package main
import (
"fmt"
)
const name = "Franklin"
func main() {
const number = 34
fmt.Println(name)
fmt.Println(number)
}
Output:
"Franklin"
34
When using the "const" and the short declaration method, we didn't have to specify the Type, but Go deduced it. That one of the benefits of using them.
Key take away :
That is for variables. Try and play around with it and print different stuffs, your name, age, etc.
Now let talk about Go data types. A data type simply means the different ways data are stored across a computer program, this data includes numbers, strings(letters), slices e.t.c. Where and how we store this data is what is called a Data Type.
In Go we have 7 Data types :
But today we would be looking at the following types:
We would discuss the rest in the next series. Trying to keep this as short as possible.
Boolean types are data types used to store values that are either "True" or "False". Example :
package main
import (
"fmt"
)
func main() {
var isMarried bool = false
var loveFood bool = true
fmt.Println(isMarried)
fmt.Println(loveFood)
}
Output:
false
true
As we noticed Types are declared after the variable names for Go to understand what type of value you want the variable to hold and in this case Boolean.
Numeric types come in two kinds, we have the int (interger) which are whole numbers, and float64 which are decimal numbers. These two numeric types are used to hold values that are either whole numbers or decimals.
NOTE: There are more kinds of Numeric types but this article is limited to two.
package main
import (
"fmt"
)
func main() {
var x int = 19
var y float64 = 99.7
fmt.Println("Hello, playground")
}
Output:
19
99.7
Note that putting a float is a variable that has a Type int would throw errors, vice-versa.
Strings types are used to hold values that are letters but are called strings in computer science. They are letters. SIMPLE!
Example:
package main
import (
"fmt"
)
func main() {
var myName = "DeveloperAspire"
fmt.Println(myName)
}
Output:
"DeveloperAspire"
Strings are put in-between " " symbols or the back ticks ` `.
Slices are types used to group values of the same types. When I want a variable to hold more than one number, I would use a slice type to hold the value. When you go to the market to get groceries, you use a bag to put all of them, and they are all the same.
package main
import (
"fmt"
)
func main() {
var names = []string{`Franklin`, `Okolie`, `DeveloperAspire`}
var num = []int{1, 2, 3, 4}
fmt.Println(names)
}
Output:
[ `Franklin`, `Okolie`, `DeveloperAspire`]
[1, 2, 3, 4]
From the above code example, we noticed that the type came after the '='. That is how the syntax is declared. The ' [ ] ' is telling Go that this is going to be a list and hold it with this ' [ ]', then the Type(int or string), declared after is telling Go the type of values you want your slice to hold, and the ' { }' is used to hold the values.
Quick Tip:
Slice is like a list, it is used to hold the same type of value which are multiple. It is called an Array in languages like JavaScript.
Map types are used to store data that have a Key and Value pair, these are used to store values that make reference to each other. They are used to store data of different types. This is like an Object in other languages like JavaScript.
Let make an example:
package main
import (
"fmt"
)
func main() {
var x =map[string]int{
"Day" : 30,
"Night" : 23,
}
var y =map[int]string{
30 : "Day",
50 : "Night",
}
fmt.Println(x)
fmt.Println(y)
}
Output:
map[Day:30 Night:23]
map[30:Day 50:Night]
Now let break it down; from the code snippet above, we can see we used the word "map" to declare the type. Now all those are syntax, how a language is being constructed but we are to understand them and not memorize them.
After the map keyword the ' [ ]' is telling Go that the " Key" of the Map type should be what is passed in-between, it may be an int or string. The next declaration after it which is type int, string, slice e.t.c is telling Go what the Values of the map should be. Lastly, the '{ }' just like the slice is the place holder of the value.
var x = map= type [ ]= key int= value { }=placeholder
Key take aways:
Struct types are the advanced way of writing Maps but there a difference. A struct is a sequence of named elements, called fields, each of which has a name and a type.
See it as a Map type that has its key and value already declared and you can use it multiple times anywhere in your code. We have the Named struct and the Anonymous struct. This is likened to be a Class in JavaScript.
package main
import (
"fmt"
)
type person struct {
firstname string
lastname string
age int
}
func main() {
var person1 = person{
firstname: "Perry",
lastname: "Jack",
age: 24,
}
var person2 = person{
firstname: "Mark",
lastname: "Honest",
age: 36,
}
fmt.Println(person1)
fmt.Println(person2)
}
Output:
{Perry Jack 24}
{Mark Honest 36}
As we can see struct types are ways of writing Map in a more advanced, neat, and re-usable way, where you can make a Map of a certain structure and use it anywhere you need it.
Go is all about types, type is Go and Go is type - Bill Kennedy
Now let analyze it. We started by declaring a type using the 'Type' keyword that has a name called 'person' using the underlying type called 'struct', after that between the { } we gave the key a variable name and assigned them a specific type their value should have.
It saved us a lot of strength and time from writing the map twice for 2 people as seen above. We simply declared a variable and assigned it the Named type 'person', and use the key names while putting our own different values for the different person. The above example of a struct is called the Named struct as it has the name 'person'.
Example of anonymous struct type:
package main
import (
"fmt"
)
func main() {
var person1 = struct {
firstname string
lastname string
age int
}person{
firstname: "Perry",
lastname: "Jack",
age: 24,
}
fmt.Println(person1)
}
Output:
{Perry Jack 24}
The anonymous struct does not need a name as it is used right when the variable is declared. This is used in most cases when a struct is unique in a code. But why not use a map instead of for clearer code.
The use of Struct proves the 3 chief purposes of Go which are: efficient compilation, efficient execution, and ease of programming. Yes... ease of programming.
Key take aways:
Go is all about types, type is Go and Go is type. - Bill Kennedy.
You must have seen this quote all over this article right?. That quote was said by Bill Kennedy; one of the Pros of Go. It means that Go is all about type and how to use them efficiently of concurrency, speed, and memory management, once you understand TYPES in Go, you can use it to make program in Go.
That was a long article, right? But that not all we still have more types to discuss but it would be on a different article on this series ' Go for Us '. Watch out for the next article for the other Types in Go. See you in the next series.
Also published at https://dev.to/developeraspire/understanding-variables-and-data-types-in-go-2490