Golang Tutorial: Learn Golang by Examples

DZone 's Guide to

Golang Tutorial: Learn Golang by Examples

Google developed Go to better handle the issues presented by large-scale programming.

· Open Source Zone ·
Free Resource

Golang has become one of the most trending languages in the developer community. Go provides the best of both worlds by striking a balance between dynamic and statically compiled languages. The code is easy to read, the specifications are short, and it still includes a built-in web server! Throughout this Golang tutorial, not only will we be covering the reasons that make Go such a fantastic open-source language, we will also go over a majority of its concepts.

Following are the topics that we will cover throughout this Golang tutorial:

  • Why Learn Golang?
  • What Makes Golang Special?
  • Hello World: First Golang Program
  • Variables and Constants
  • Data Types
  • Operators
  • Pointers
  • Printf
  • Loops
  • Decision-Making
  • Arrays
  • Maps
  • Functions
  • Recursion
  • Defer, Recover, Panic
  • Structures
  • Interfaces
  • Simple Webserver Using Go
  • Before you learn any language, you should always know why you're learning the language. Every language serves a special purpose, and the same goes for Golang. So why exactly should someone learn Golang? Well, Golang was built by Google to help solve problems faced by developers at Google, where lots of big programs are built for server software that runs on massive clusters. Before Go, Google was using languages like C++ and Java to solve problems, but these languages didn't really have the fluidity and ease of construction that was needed for problems of such scale. Keeping these things in mind, a few years ago Ken Thompson and Robert Greaser thought about building a new language that would be good for these kinds of problems, and hence Golang was born. Basically, if you're trying to solve a problem of enormous scale or just need efficient and scalable code, Go should be your "Go-to" language!

    What Makes Golang Special?

    The existing languages have been good enough for large-scale programming until recent years, but there have been big changes in the computing environment in the last decade. These changes have included a lot of networking and a lot of cluster computing — or the cloud, as common folk might know it by. The languages that were being used to implement services until now are at least 10 to 20 years old, so there are a lot of properties of a modern computing environment that these languages don't address directly. Therefore, having a modern language that works really well in the modern computing environment is actually very important. You also want it to be efficient, because you're going to be running it on hundreds or maybe even thousands of machines. You don't want to waste resources, either, by having an inefficient interpreter or some of the problems that generally come up with virtual machine implementations.

    Golang ticks all these boxes, and hence has garnered much-deserved fame in developer communities.

    Hello World: First Golang Program

    package main
    import "fmt"
    func main () {
    fmt.Println("Hello World! This is my first Golang programme")

    Let's go over the code line by line.

    The first line is a package declaration. Every Go program must belong to a package, and this particular program belongs to the "main" package. Next, we import the "fmt" or format library which provides the developer with a wide array of functions that allows formatting of output. Then we create the main function, which is the first function that is invoked when a Go program is executed. In the main function, we simply invoke the 'Println' function to print our statement.

    Variables and Constants

    What exactly is a variable? A variable is nothing but a name given to a storage area that programs can manipulate. Each variable in Go has a specific type, which determines the size and layout of the variable's memory, the range of values that can be stored within that memory, and the set of operations that can be applied to the variable. Next, constants refer to fixed values that the program may not alter during its execution. These fixed values are also called literals. Constants can be of any of the basic data types like an integer constant, a floating constant, a character constant, or a string literal. There are also enumeration constants as well. Constants are treated just like regular variables, except that their values cannot be modified after their definition.

    package main
    import "fmt"
    func main () {
    var x int = 5 //declaration of variable x
    var (
    a = 10
    b = 15 //declaration of multiple variables
    y := 7 // shorthand declaration of variables
    const pi float64 = 3.14272345 //declaration of constants
    var name string = "Aryya Paul" //declaration of a string

    Data Types

    Data Types - Golang Tutorial - EdurekaPhoto: Data Types - Golang Tutorial - Edureka

    Data Type Range
    uint8 0 to 255
    uint16 0 to 65535
    uint32 0 to 4294967295
    uint64 0 to 18446744073709551615

    Data Type Range
    int8 -128 to 127
    int16 -32768 to 32767
    int32 -2147483648 to 2147483647

    -9223372036854775808 to 9223372036854775808


    Golang has the three general types of operators that are prevalent in every major programming language.

    Operators - Golang Tutorial - Edureka

    Photo: Operators - Golang Tutorial - Edureka


    Now it's time to see how pointers work in Go. Pointers in Go are easy and fun to learn. Some Go programming tasks are performed more easily with pointers, and other tasks, such as call by reference, cannot be performed without using pointers. So it becomes necessary to learn pointers to become a perfect Go programmer. As you know, every variable is a memory location and every memory location has its address defined which can be accessed using an ampersand (&), which denotes an address in memory.

    package main
    import "fmt"
    func main() {
    // We pass the value of a variable to the function
    x := 0
    fmt.Println("x =",x)
    // If we pass a reference to the variable we can change the value
    // in a function
    fmt.Println("x =",x)
    // Get the address x points to with &
    fmt.Println("Memory Address for x =", &x)
    // We can also generate a pointer with new
    func changeVal(x int) {
    // Has no effect on the value of x in main()
    x = 2
    // * signals that we are being sent a reference to the value
    func changeXValNow(x *int){
    // Change the value at the memory address referenced by the pointer
    // * gives us access to the value the pointer points at
    *x = 2 // Store 2 in the memory address x refers to


    Printf is used for format printing our outputs in Golang. It is a part of the format (fmt) library. Below is a table listing out the noteworthy uses of Printf function.

    Function Usage
    fmt.Printf(“%f \n”,pi) %f is for floats
    fmt.Printf(“%.3f \n”,pi) You can also define the decimal precision of a float
    fmt.Printf(“%T \n”,pi) %T prints the data type
    fmt.Printf(“%t \n”,isOver40) %t prints booleans
    fmt.Printf(“%d \n”,100) %d is used for integers
    fmt.Printf(“%b \n”,100) %b prints  (100) in binary
    fmt.Printf(“%c \n”,44) %c prints the character associated with a keycode
    fmt.Printf(“%x \n”,17) %x prints in hexcode
    fmt.Printf(“%e \n”,pi)

    %e prints in scientific notation

    Ok, it's time we move on to loops.


    If you're new to programming, a loop is a basic iterating mechanism in computer science and it's used mostly when you need to perform a repetitive pattern in programming. Now in most programming languages, there are three types of loops, namely for, while(exit controlled) and do-while(entry controlled) but Golang has only one type of loop that is the 'for' loop. The syntax of go allows while loops to be implemented with the syntax of a 'for' loop.

    package main
    import "fmt"
    func main() {
    // For loops
    i := 1
    for i <= 10 {
    // Shorthand for i = i + 1
    // Relational Operators include ==, !=, <, >, <=, and >=
    // You can also define a for loop like this, but you need semicolons
    for j := 0; j < 5; j++ {


    Decision-making is a critical part of programming. In Golang, we can implement decision-making using the 'if-else' and 'switch' keywords. Let's see how Golang implements decision making with this piece of code below:

    package main
    import "fmt"
    func main() {
    // If Statement
    age := 15
    if age >= 16 {
    } else {
    fmt.Println("Not an adult")
    // You can use else if perform different actions, but once a match
    // is reached the rest of the conditions aren't checked
    if age >= 16 {
    fmt.Println("in school")
    } else if age >= 18 {
    fmt.Println("in college")
    } else {
    fmt.Println("probably dead")
    // Switch statements are used when you have limited options
    switch age {
    case 16: fmt.Println("Go Drive")
    case 18: fmt.Println("Go Vote")
    default: fmt.Println("Go Have Fun")


    An array is a data structure in programming that is used to containerize data of the same type. For example, if you were to store all the student name of a certain class, you would use a string array to store them all. The code below shows how arrays are implemented in Golang.

    package main
    import "fmt"
    func main() {
    // An Array holds a fixed number of values of the same type
    var favNums2[5] float64
    favNums2[0] = 163
    favNums2[1] = 78557
    favNums2[2] = 691
    favNums2[3] = 3.141
    favNums2[4] = 1.618
    // You access the value by supplying the index number
    // Another way of initializing an array
    favNums3 := [5]float64 { 1, 2, 3, 4, 5 }
    // How to iterate through an array (Use _ if a value isn't used)
    for i, value := range favNums3 {
    fmt.Println(value, i)
    // Slices are like arrays but you leave out the size
    numSlice := []int {5,4,3,2,1}
    // You can create a slice by defining the first index value to
    // take through the last
    numSlice2 := numSlice[3:5] // numSlice3 == [2,1]
    fmt.Println("numSlice2[0] =", numSlice2[0])
    // If you don't supply the first index it defaults to 0
    // If you don't supply the last index it defaults to max
    fmt.Println("numSlice[:2] =", numSlice[:2])
    fmt.Println("numSlice[2:] =", numSlice[2:])
    // You can also create an empty slice and define the data type,
    // length (receive value of 0), capacity (max size)
    numSlice3 := make([]int, 5, 10)
    // You can copy a slice to another
    copy(numSlice3, numSlice)
    // Append values to the end of a slice
    numSlice3 = append(numSlice3, 0, -1)


    Besides arrays, we also have another data structure called "Maps" which maps unique keys to values. A key is an object that you use to retrieve a value at a later date. Given a key and a value, you can store the value in a Map object. After the value is stored, you can retrieve it by using its key.

    package main
    import "fmt"
    func main() {
    // A Map is a collection of key value pairs
    // Created with varName := make(map[keyType] valueType)
    presAge := make(map[string] int)
    presAge["Narendra Modi"] = 42
    fmt.Println(presAge["Narendra Modi"])
    // Get the number of items in the Map
    // The size changes when a new item is added
    presAge["Rahul Gandhi"] = 43
    // We can delete by passing the key to delete
    delete(presAge, "Rahul Gandhi")

    Next up, let's move on to functions.


    A function is a group of statements that together perform a task. Every Go program has at least one function, which is main(). You can divide your code into separate functions. How you divide your code among different functions is up to you, but logically, the division should be such that each function performs a specific task. A function declaration tells the compiler about a function name, return type, and parameters.

    package main
    import "fmt"
    func main () {
    fmt.Println("5 + 4 = ", add(5,4))
    func add(a,b int) int {
    return a+b
    func subtract(args ... int) {
    sub := 0
    for _, value := range args {
    sub -= value
    return sub


    Recursion is the process of repeating items in a self-similar way. The same concept applies to programming languages as well. If a program allows calling a function inside the same function, then it is called a 'recursive function' call. GoLang supports recursion i.e, it allows a function to call itself. But while using recursion, programmers need to be careful to define an exit condition from the function, otherwise, it will go on to become an infinite loop.

    package main
    import "fmt"
    func main () {
    func factorial(num int) int {
    if num == 0 {
    return 1
    return num * factorial(num-1)

    Defer, Panic, and Recover

    Defer statement defers the execution of a function until the surrounding function returns. They are generally used to execute necessary closing statements — for example, closing a file after you are done with it. Multiple defers are pushed into stack and executes in Last In First Out (LIFO) order. Defer is generally used to clean up resources like a file, database connection, etc.

    Panic is similar to throwing an exception like other languages. Generally when a panic is called, then the normal execution flow stops immediately, but the deferred functions are executed normally. It is a built-in function in Golang.

    Recover is another built-in function in Go. It helps to regain the normal flow of execution after a panic. Generally, it used with a defer statement to recover panic in a goroutine.

    package main
    import "fmt"
    func main() {
    // Defer executes a function after the inclosing function finishes
    // Defer can be used to keep functions together in a logical way
    // but at the same time execute one last as a clean up operation
    // Ex. Defer closing a file after we open it and perform operations
    defer printTwo()
    // Use recover() to catch a division by 0 error
    fmt.Println(Div(3, 0))
    fmt.Println(Div(3, 2))
    // We can catch our own errors and recover with panic & recover
    func factorial(num int) int {
    if num == 0 {
    return 1
    return num * factorial(num - 1)
    // Used to demonstrate defer
    func printOne(){ fmt.Println(1)}
    func printTwo(){ fmt.Println(2)}
    // If an error occurs we can catch the error with recover and allow
    // code to continue to execute
    func Div(num1, num2 int) int {
    defer func() {
    solution := num1 / num2
    return solution
    // Demonstrate how to call panic and handle it with recover
    func demPanic(){
    defer func() {
    // If I didn't print the message nothing would show


    Go allow you to define variables that can hold several data items of the same kind. A structure is another user-defined data type available in Go programming, which allows you to combine data items of different kinds. Structures are used to represent a record. Suppose you want to keep track of the books in a library. You might want to track the following attributes of each book:

    • Title

    • Author

    • Subject

    • Book ID

    In such a scenario, structures are highly useful. To define a structure, you must use type and struct statements. The struct statement defines a new data type, with multiple members for your program. The type statement binds a name with the type which is a struct in our case.

    package main
    import "fmt"
    // STRUCTS
    func main() {
    rect1 := Rectangle{height: 10, width: 10}
    fmt.Println("Rectangle is", rect1.width, "wide")
    fmt.Println("Area of the rectangle =", rect1.area())
    type Rectangle struct{
    height float64
    width float64
    func (rect *Rectangle) area() float64{
    return rect.width * rect.height


    Go programming provides another data type called interfaces which represents a set of method signatures. The struct data type implements these interfaces to have method definitions for the method signature of the interfaces.

    package main
    import "fmt"
    import "math"
    func main() {
    rect := Rectangle{20, 50}
    circ := Circle{4}
    fmt.Println("Rectangle Area =", getArea(rect))
    fmt.Println("Circle Area =", getArea(circ))
    // An interface defines a list of methods that a type must implement
    // If that type implements those methods the proper method is executed
    // even if the original is referred to with the interface name
    type Shape interface {
    area() float64
    type Rectangle struct{
    height float64
    width float64
    type Circle struct{
    radius float64
    func (r Rectangle) area() float64 {
    return r.height * r.width
    func (c Circle) area() float64 {
    return math.Pi * math.Pow(c.radius, 2)
    func getArea(shape Shape) float64{
    return shape.area()

    Simple Webserver With Go

    Go also provides us with the ability to set up a simple web server in a matter of seconds. It goes to show how robust and powerful Go libraries are.

    package main
    import (
    // http.ResponseWriter assembles the servers response and writes to 
    // the client
    // http.Request is the clients request
    func handler(w http.ResponseWriter, r *http.Request) {
    // Writes to the client
    fmt.Fprintf(w, "Hello World\n")
    func handler2(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Hello Earth\n")
    func main() {
    // Calls for function handlers output to match the directory /
    http.HandleFunc("/", handler)
    // Calls for function handler2 output to match directory /earth
    http.HandleFunc("/earth", handler2)
    // Listen to port 8080 and handle requests
    http.ListenAndServe(":8080", nil)

    That's it for this Golang tutorial blog post. I hope you guys enjoyed reading it, and leave confident enough to practice the fundamentals of Golang on your own. Do stay tuned for more Golang-related blogs!

    Got a question for us? Please mention it in the comments section of "Golang Tutorial" and we will get back to you.

    go, golang, open source, programming languages, tutorial

    Published at DZone with permission of Aryya Paul , DZone MVB. See the original article here.

    Opinions expressed by DZone contributors are their own.

    {{ parent.title || parent.header.title}}

    {{ parent.tldr }}

    {{ parent.urlSource.name }}