Monday, November 9, 2020

The main keywords in a Go program

Learning Go? Understand the main keywords you'll need to write Go programs

Once you understand the main reasons to use Go, installed Go on your Windows, Linux or Mac, and built your first program in Go, it's time to dive into the details of the language. On this tutorial we will continue studying our first program in Go to understand some of the important concepts of the language.

If you recall our previous post, in Go, a typical hello world written is as: 

package main

import "fmt"

func main(){
    fmt.Println("Hello World")

Since we already learned how to build and run our first Go program today we'll review each line of our program to understand some of the keywords you'll use while developing in Go.

package main

Any Go program (or project) should one and only have one main function, but multiple files can be present on the same package, in our case, package main. We'll learn more about packages in the future but to keep it simple, what we want you to know for now is that, to create your own program in Go, you should have a function names main() in a packaged named main.

import "fmt"

The next line is import "fmt". There are two important keywords here:

  1. import: tells the compiler that we want to import an external dependency into our project
  2. fmt: the name of our dependency

The import keyword

It's common for our programs to depend on other functionality. In Go, external functionality is wrapped in packages and the import keyword is used to do so. In our example, we imported fmt to have access to the standard output as we'll see next.

The fmt package

Now stop for a second and think: how did our first program in Go printed a line to the console? The answer is that, that functionality was provided by the Println function of the fmt package which contains the code necessary to interact with the output of our console. We'll learn more about it next.

fmt stands for formatting and is the default package for input and output and it's documentation is available here. In our example, it was used to grant access to the Println function required to print contents in our terminal. We'll learn more about it later.

func main() {

Next we enter our main function. In Go, you declare a function as func <functionName>.

Another important point to note is that, as previously explained, in order to be executed, every Go program has to have one - and only one - main function. It's also common (and recommended but not mandatory) to name the file that contains the main function as main.go.

The { is the operator Go utilizes to create blocks. You'll see it being closed in the last two lines

fmt.Println("Hello World")

Once our program initializes this is the first thing that gets executed is the line fmt.Println("Hello World"). There are 3 important things in this line:

  1. fmt.Println: we're calling the function Println from the fmt package
  2. We're passing the string "Hello World" to it.

Since Go is not an object-oriented language, everything is a function. And accessing the functions of our packages is nothing more than: pkg_name.Function_Name.

If you want to learn more about the package fmt, check this page.  

The { and } operators

The { and } operators wrap functions, conditional statements and in our example were used to wrap the main function logic.


On this post we continued our introduction to Go basics and provided a line-by-line explanation of the our first program in Go. But wait! There's a lot more to learn about those keywords that we'll explain in future articles. 


See Also

Any comment about this page? Please contact us on Twitter

Featured Article

Raw String Literals in Go

Learn what are Raw String Literals in Go and how to use them On a previous posts we discussed Runes, Variables and Strings in ...

Popular Posts