Let’s Print Hello World!

Different parts of a Go program

How to Execute a Go Program

In order to execute the program, click the Run button on the Go Playground. Your code will be compiled and executed on Google servers and the output will be displayed on the screen.

To execute your program using the command prompt on Windows, you can use the go run filename.go command. For example, as in shown in Figure 2-4, the command used to run Listing 2-3 is go run main.go. To build applications, run the go build filename.go command. For example, to build the sample program, you’d issue the command go build main.go. To run the compiled version of the program, you’d issue the ./filename command, for example, ./main.

A screenshot displays the command used to run the listing. Go run main. go, and to build an application, run the go-build main. go command.

Interestingly, the compiled application runs faster than the go run command. Building the source code file will result in the creation of a compiled binary file specifically designed to work on your current operating system. Even though it is possible to compile your programs for other operating systems, by default, the compiler will generate the binary compatible with your operating system.

Keywords

Now that you are aware of its keywords, you are ready to learn how to use variables and other data structures in Go.

Variable Data Types

Other than the built-in types, Go also allows programmers to create user-defined data types.

Variable Naming Conventions

A variable name can be made up of letters, digits, and underscores. However, the variable name should begin with either an underscore or a letter. The lower- and uppercase letters are treated differently, because of the case-sensitive nature of the Go language.

Declaring Variables

As Go is statically-typed, it requires you to set the type (explicitly or implicitly) of each variable used in your program during the compilation process. The assigned type cannot be changed at runtime.

In the case of implicit declaration, the variable type is inferred based on the initial value assigned to the variable. Line#20 in Listing 2-4 illustrates implicit declaration. Note that the := operator only works for variable declarations inside of functions. The var keyword has to be used to declare variables outside the functions.

The var statement can also be used to declare a list of variables, as shown in Figure 2-5.

A listicle of a var statement that declares a list of variables in Go - chan, const, goto, interface, struct, defer, case, func, var, select, break, for, go, continue and default among some.

To declare constants, programmers must use the const keyword. Figure 2-6 illustrates how constants can be declared in a Go program.

A screenshot showcases the constants declared in a Go program. aconstantvariable int equals 64, and anotherconstantvariable int equals 64.

Constants are always declared outside of functions. If the name of the constant variable starts with a lowercase letter, that means it’s available for use only by the functions of the program (like the private keyword). The variable is public when its name begins with a capital letter.

Using scanf

Using Scanln

Scan vs Reader Functions

To split space-delimited tokens, you use the Scan functions and to read full lines, you used the reader function.

Using bufio

Buffered I/O is implemented via the bufio package. The bufio package wraps the io.Writer or io.Reader objects and returns a new Writer or Reader object, which has the necessary interface implemented for utility methods. This wrapping also provides textual I/O assistance and buffering.

As illustrated, if you want to ignore a variable in Go, you name it with an underscore.

Now that you know how to use variables and take user input in your Go programs, it is time to learn how to use different math operators in Go.

The Math Package

Dates and Times

Listing 2-11 illustrates the use of the time package for using date and time types. In the example, in Line#10, a variable named now is declared. It will be initialized using the built-in time.Now() function, which returns a timestamp containing the current date, time, and time zone. It is also possible in Go for users to create their own explicit date and time values. Line#14 declares a variable named formatDate, which is initialized using the time.Date() function. The Date() function returns the time in the appropriate zone according to a given location corresponding to the format yyyy-mm-dd hh:mm:ss + nsec nanoseconds. You can also use a formatted version of the daytime value, as shown in Line#18. The Format() function returns a textual representation of the time value formatted as per the layout defined by the argument. This example uses the ANSIC format, but you can refer to the official documentation at https://pkg.go.dev/time#Time.Format for other standard formats.

Since the Parse() function can return an error object, in this example, we added an underscore to ignore the object. The time object has many other useful functions. For example, you can add dates and perform special kinds of formatting, and so on. There are also patterns available that give you complete flexibility in how to format daytime values. The functions and constants in the time package give you all the tools you need to store and manage the date and time values. For more on this topic, refer to the official documentation on the time package at https://pkg.go.dev/time.

Operators Precedence in Go

Operator precedence refers to the criteria that determine the grouping of terms in an expression. It also affects the result of the expression evaluation. Like other programming languages, in Go, there is a pre-defined order of precedence of the operators, where some have higher precedence over the others. For example, the division operator / has higher precedence over the subtraction operator -.

Consider the statement a = 56 + 4 * 8 Here, variable a is assigned the value 88, not 480. This is because the multiply operator * has higher precedence over the addition operator +. Therefore, 4 * 8 is multiplied first and then the obtained result is added to 56.

New vs Make

It is critical to ensure that complex types, such as maps, are appropriately initialized. To initialize the complex objects in the Go programming language, there are two built-in functions—make and new. Be careful using them, as there is a difference between the two.

The new function only allocates memory for the complex object but does not initialize the memory. When an object, say a map, is allocated using the new function, it only returns the memory address of where that map is located. However, there is zero memory storage associated with the map object. Therefore, when a key-value pair is added to the map, it will throw an error.

Contrary to this, the make function allocates as well as initializes the memory for the map object created using the make function. It returns the memory address, like the new function, and the storage is initialized to non-zero. This means the map object can accept values without throwing errors.

Incorrect Memory Allocation Example

At runtime, Listing 2-13 will make the application crash and an error is thrown, as shown in Figure 2-7. This error is raised because you are attempting to place data in a map that does not have any memory storage initialized.

A screenshot of an output error raised because of attempting to place data in an amp that does not have any memory storage initialized stating invalid operation.

Correct Memory Allocation Example

This time, when you initialize the object with the make function and try to add new entries to the map object, the code will successfully compile and run without errors, as shown in the output in Figure 2-8. Remember that when using complex objects, it is highly important to use the make function for initialization if you need to add data to the object immediately.

A screenshot of the code after the new entries to the map object. The code reads go run mem-allocation-eg.go. map open parenthesis marks:56 close parenthesis.

Memory Deallocation

Memory deallocation is performed in an autonomous fashion by the garbage collector (GC) that comes packaged with the Go runtime. When the garbage collector is triggered while working in the background, it searches for objects that are either out of scope or set to nil, so it may clear away the memory and return it to your memory pool.

In Go version 1.5, the garbage collector was completely reconstructed to have very low latency for effectively reducing the number of pauses that occur while running Go applications. In the latest version, 1.18.3, the performance of the garbage collector while performing memory allocation is much faster and is also almost unnoticeable even on slower computers. For more information on garbage collectors, refer to the official documentation on runtime at https://pkg.go.dev/runtime and the talk release of the garbage collector improvement at https://talks.golang.org/2015/go-gc.pdf.

What Is a Pointer?

Pointers are in essence variables that have the capability of storing memory addresses of other variables. Note that a memory address refers to the direct address of the variable. A pointer can be declared with any data type, however, initializing it, i.e., storing the address of another variable, is not necessary. Similar to high-level languages, Go also supports pointers. Pointers are useful in Go to perform different tasks, for example, without the use of pointers you cannot perform a call by reference.

Declaring Pointers in Go

It should be noted that, irrespective of its type, the inherent data type of value stored in all pointers is the same, i.e., a long hexadecimal number. This represents memory addresses, as all addresses are in the long hexadecimal format. The data type of the variable or constant that a pointer points to is the only differentiation between pointers of different data types. Furthermore, the value of the pointer can also be set to nil manually in the case of strings and automatically if the pointer is not initialized at the time of declaration.

Example

In Listing 2-16, the first line declares a pointer named intPointer with int type. This is a correct way of declaration; however, if you try to print the contents of intPointer in the second line, this will throw a runtime error and the application will crash, as shown in Figure 2-9. This happens because intPointer is not currently initialized to point at anything and is hence nil.

A screenshot showcases the output of a program. The first line declares a pointer named int pointer with int type. The content of the int pointer in the second line shows a runtime error and the application crash.

In the main function, on Line#1, we declare an integer variable with 42 as its value. On Line#2, the ampersand (&) operator is used to assign the direct memory address of the variable value1 to the variable pointer1. Since you are using an ampersand (&) operator, the Go compiler will automatically recognize that pointer1 is a pointer variable used for storing memory addresses. Now, if you print the value stored at the memory pointed by the pointer pointer1, it will be the same as that stored in value1, i.e., 42. In order to print the value stored where the memory address points, the asterisk (*) operator is used, as shown in Lines #3 and #8 of the main function. Similarly, you can use pointers to point to floating-point variables as well. Note that pointer1 is declared and assigned value implicitly, whereas the pointer2 is declared explicitly with a data type.

On Line#1, you access the value stored at the memory location pointed by pointer1 using the asterisk (*) operator, dividing that value by 31 and storing the answer in the same location. As seen in the output, the pointer1 and value1 variables have the same value.

Comparison with Java and C-Style Languages

As in Java or C#, if you have an original variable and a reference variable (pointer) that points to that variable, you can change that value of the original variable either by changing the original variable or by changing the variable that’s pointing to it. However, unlike in Java, the pointer doesn’t have to point at any particular value initially, and you can change it at runtime to point to another value. On the other hand, you’ll find pointers in Go to be very similar and just as valuable in C, C#, and other similar languages.

Arrays in Go

As with other C-style languages, Go supports the array data structure. Arrays in Go are used to store sequential fixed-size collections of elements, noticeably of the same type. Even though an array is usually referred to as a storage of a collection of items, it can also be considered a collection of variables having identical types. Furthermore, arrays are consecutive memory locations, whereby the first element of the array corresponds to the lowest address and the last element to the highest address. It is also possible to access any particular element of an array through the index number. The index numbers of an array range from 0 to size-1, as illustrated in Figure 2-10. As per the figure, to access the element in the second index (i.e., the third element), you use array_name[2], which would yield the value 11.

A tabular representation shows the arrays in Go. It has access to elements 1, 2, 3, 4 to n and index 0, 1, 2, 3 to n.

Accessing Array Elements

Individual elements of an array can be accessed through the use of indexes with array names. This is achieved by wrapping the index number of the required element within square brackets [], placed right after the name of the array. For example, to assign value to a single element of an array, the following statement can be used

balance[4] = 50.0

This statement assigns the value on the right side of the assignment operator to the element at the forth index of the array named balance. As the index number in arrays starts with 0, this statement assigns the value 50.0 to the fifth element in the array. Note, the first index of an array is also known as the base index, whereas the last index will always be arraySize-1. Also note that the = operator is used to assign values to individual elements and not the := operator, as the data type of the array has already been defined. Figure 2-11 is a pictorial representation of the concepts discussed here.

A tabular representation of the concept of data stored in arrays. The balance of elements from 0 to 4 is 1000.0, 2.0, 3.4, 7.0, and 50.0.

Example

Listing 2-20 shows an example that includes all of the concepts discussed so far.

package main

import (

        "fmt"

)

func main(){

        /*declaring and initializing an array "array1" of size 3 and type as floating-point*/

        var array1 = []float32{10.5, 5.2, 2.88}

        var array2 [10]int

        var i, j int

        //Initializing elements of the array

        for i =0; i < 10; i++{

               array2[i] = i + 50 //setting element at location i to i+50

        }

        //Print the value of each elements of array1

        fmt.Println("Elements stored in Array1")

        for j =0; j <3; j++{

               fmt.Printf("Element[%d] = %f ", j, array1[j])

        }

        //Print the value of each elements of array2

        fmt.Println("Elements stored in Array2)

        for j =0; j <10; j++{

               fmt.Printf("Element[%d] = %d ", j, array2[j])

        }

        fmt.Println("Size of array1: ", len(array1))

        fmt.Println("Size of array2: ", len(array2))

}

Listing 2-20

Basic Program Illustrating the Use of Arrays in Go

/*Output:

$ go run array-1.go

Elements stored in Array1

Element[0] = 10.500000

Element[1] = 5.200000

Element[2] = 2.880000

Elements stored in Array1

Element[0] = 50

Element[1] = 100

Element[2] = 150

Element[3] = 200

Element[4] = 250

Element[5] = 300

Element[6] = 350

Element[7] = 400

Element[8] = 450

Element[9] = 500 */

Slices in Go

In Go, a slice is a layer of abstraction placed on top of the array data structure. The runtime allocates the necessary memory and constructs the array in the background when you define a slice, but only returns the slice. Furthermore, similar to arrays, all elements of a slice are of the same type. Even though arrays can simultaneously hold multiple data items of the same kind, there is no way to dynamically increase its size or extract a sub-array from it using any built-in functions. Slices get around these drawbacks. Slices are commonly utilized in Go and they provide various utility methods that are required with arrays.

Defining Maps

Adding Entries to a Map Object

To add an entry into the map object, use this general format: map_variable_name[key] = value. Note that because the map is an unordered collection of items, the order in which the items will be displayed is not always guaranteed.

Deleting Entries from a Map Object

In Go, to delete a map’s entry (i.e., a key-value pair stored in the map), you use a built-in function called delete(). The delete() function takes two arguments—the map whose entry is to be deleted and the key to delete. The general format to achieve this is delete(map_variable, key).

Iterating Over Stored Values in a Map Object

The first line declares a slice named keys of string type with a size equal to that of the map object named states. Then a for loop is used to iterate over the keys stored in the map object and store them into the keys slice. After that, to sort the keys slice, you use the sort() function that is available in the sort package. In this example, the initial key-value pairs stored in the states map were [CA:California NY:New York WA:Washington]

Example

Defining a Structure

After defining a structure type in your code, multiple variables of this struct type can be declared. The general format for doing so is variable_name := structure_variable_type {value1, value2...value n}

Accessing Members of a Structure

Passing Structures as Function Arguments

Pointers to Structures

Just as you can define pointers that can be used for pointing (storing) to other constants or variables, you can also define pointers to structures in Go. For example, a pointer variable named struct_pointer of the type Books can be declared using the var struct_pointer *Books statement. The struct_pointer variable can then be used to store addresses of structure variables. The ampersand (&) operator gets the direct address of a structure variable, for example, struct_pointer = &Book1. Furthermore, the member access operator (.) accesses the members of a structure where the pointer is pointing, such as struct_pointer.title

Example

The struct type in Go is a data structure that has similar purpose and function as the struct type in C and as classes in Java. Structs can encapsulate data and methods. However, unlike Java, Go does not have an inheritance model, that is, there is no concept of a super() function or substructures. Each structure is independent with its own fields for data management and optionally its own methods. Remember that struct in Go is a custom type. Note that the structure name starts with a capital letter, e.g., Book, to ensure that it can be used in other parts of the applications, i.e., exported, similar to public access specifiers in C-style languages. On the other hand, if a lowercase initial character is used, the struct type will be private and cannot be exported for use in other parts of the application.

If Statement

Switch Statement

In Go, the fallthrough keyword is used in the case block of the switch statement. If the fallthrough keyword is present in any case block, it will transfer the program’s control flow to the next case, whether or not the current case evaluated to true.

For Statement

The goto Statement

To summarize, Go supports the use of continue, break, and goto statements. Go also supports looping with a variety of coding patterns and adds features to the for statement to make it concise and readable.

Defining a Function

Here, the func keyword instructs the compiler about the start of a function declaration and function_name represents the function’s name. Function signature is referred to as the function’s name and input parameter list combined. Also, parameters are used as placeholders. Values passed to the function when it is invoked are called function arguments and these parameters are also referred to as formal parameters. A function’s parameter list defines the type, order, and total count parameters it will take as input. It is possible that a function may have no parameters and hence the parameters are optional. return_type is used to define the data type of value(s) the function may return. Here again, the return_type is optional if the function does not return anything. The body of the function contains multiple statements that together define the task it has to perform.

Doing Function Calls in Go

In order to create a function in Go, it is necessary to provide its definition as well, which defines what task the function should perform. In order to use a function, it has to be called from the program. When a function call is made from a program, the control flow is transferred to it. When the called function finishes the defined task or a return statement is encountered or the closing brace of the function is reached, the control flow returns to the program where the initial call was made.

Return More than One Value from Functions

Passing Arguments to Functions

You must declare all of the variables that would accept the values passed to the function as its arguments. This set of variables are also known as a function’s formal parameters. Note that the scope of all of the formal parameters of a function is local to it only, i.e., they are accessible only within the scope of that particular function. Furthermore, the formal parameters are only created upon entering the function and are destroyed when it exits.

There are two ways to pass arguments to a function—call by value and call by reference. When the call by value way of passing arguments is used, it basically copies the value of the passed argument into the formal parameters of the called function. Any changes made to the formal parameters inside the respective function have no effect on the value of the argument that was passed with function call.

On the other hand, the call by reference technique copies the direct address of the passed argument into the formal parameters of the called function. As the direct address is copied and used to access the actual argument, any changes made to the formal parameters inside the respective function will also be reflected in the argument passed with the function call. To ensure that a function cannot change the value of the passed arguments, by default, call by value is used to pass arguments to functions in the Go programming language.

Methods

Note that when you pass the dog object to a function as the receiver, a copy is made of it, i.e. this is pass by value and not reference. If you want it to be a reference, you can use pointers. But within the function, this is a brand new copy of the object. So when you modify the sound field, you are not modifying the version that was created in the main function. The ability to create custom methods for your own types makes the Go programming language behave more like a fully object-oriented language. Even without the sort of type inheritance that you find in C++ and Java, a struct can have as many different methods as it needs to accomplish your application’s requirements.

Write Text Files

The example in Listing 2-55 shows you how to write to a file in Go. The checkError() will be used for error checking throughout this program. The function will check the object passed to it and if the object is not nil, i.e., an error has occurred performing some operation in the main program, the function will crash the application and display the error message.

In the main() function, the content variable holds the string value you want to write to the fromString.txt file. On Line#2, in the main() function, we create a file reference named file, which is basically a variable that will be used as a reference to the file. Along with this, we also specify a variable called err to store error messages returned by the os.Create() function. The Create() function takes the location of the file to which the data should be written. Furthermore, it creates the named file if it doesn’t exist or truncates it if it already exists. Here, the ./ means the file is in the same directory as the application.

Output:

Wrote a file with 14 characters

A screenshot of a program output reads Hello from Go.

Read Text Files