Scope in Go

When we talk about scope in any programming language, we are referring to how the code can access variables. Scope defines where a variable can be accessed based on how it is declared. Scope in Go is fairly simplistic. In this post, we will be talking about scope in Go.

Go has three specific types of variables: local variables, global variables and formal parameters. First of all, local variables are found inside of a block or function. Also, global variables are found outside of all functions. Finally, formal parameters are the variables in function definitions.


Local Variables

Local variables are the most common type in Go. They can only be used by the statements that are in the block of code in which they were made. This is to say that local variables are not accessible by functions outside of their own. Look at the example below.

These variables are bound to the main function. They can’t be accessed by a function or block of code outside of the main function.

Global Variables

Global variables are typically defined outside of all functions and at the top of the program. This style of defining a variable at the top is idiomatic in Go. Global variables have a lifetime that last as long as the program runs. They also can be accessed by any function in the program that follows their declaration.

In this program, both of the functions have access to our global variable. This has its advantages and disadvantages. Consequently, any function has access to this variable which means any function can change this variable.

scopeFormal Function Parameters

Finally, we have formal parameters. These variables are treated like local variables and they gain preference over global variables. Therefore, if the global variable shares the name of a formal function parameter the formal parameter will be used. So, Let us look at an example of this.

In this somewhat nonsensical program, we have three variables that share the name, g. One is a global variable, one is a local variable and the other is a formal parameter. We are also calling the references for these variables to show that they are different. This reference notation is something we will look at closer in our next post. For now, all you need to know is that the three values are different from one another. Furthermore, each time we print the reference to g out, we are calling a different block of memory. 


In this post, we looked at scope in Go. We looked at local variables, global variables and formal functional parameters in Go. We touched briefly on pointers and references in this post as well. In our next posts, we will be going over Pointers and References in Go. 

Arrays and Slices in Go

We’ve looked at strings, numbers, and boolean values in Go. Now, we can take a look at more complex types in Go. The two main types that we are going to look at are Arrays and Slices in Go. Slices are used more in Go than arrays but slices are an abstraction on top of arrays in Go.

Arrays in Go

In Go, an array is a sequence of elements with a specific length. Both the type of the elements and the length are part of an array’s type information in Go. If we make a default array of ints of length five; the array will contain five zeros. Arrays are mutable in Go but only the elements can be changed. The length of an array in Go is fixed after declaration. We can change these elements using the index for the array.

In the examples above, you can see that we can define arrays, change their values, and can use the short declaration operator. Note that the index of an array starts at 0 and ends at the length minus one. An array of length five doesn’t have an element at index five. We also can’t use a negative index in an array in Go. 


Slices in Go

Having fixed sized arrays might seem a little limiting but this is why we have slices in Go. A slice in Go does not include the length in its type information. This means that the slice is actually a dynamically sized piece of data. This is part of why slices are used much more in Go programs. A slice literal is the same as an array literal without the length information.

In the example above, we create an array then use two slices to reference to it. When we change one of the values of one of the slices it also changes that value in the array and the other slice. This happens because slices are references to arrays. When you create a slice in Go, you are creating an array in the memory and referencing it. The slice itself does not hold any data, it just describes an underlying array. This is true even when you create and manipulate a slice without first creating an array. 

go_slicesBecause slices are references to arrays, they also have a capacity. The capacity of a slice is the length of the underlying array. Other slices can also reference the same underlying array like in the example above. You can use the len() and the cap() functions to find the length and capacity of a slice. You can also add values to a slice using a function append(). When you append a slice above its capacity, a new array will be created in memory for the slice to reference. We can also use the make keyword to create slices.

In our example above, we use the make keyword to create two slices. We then create an array and point to it with a third slice. After that, we append three more values to this slice. We then change one of the original indexes to prove that it is no longer pointing at the original array. If you want a more technical explanation about slices then look at this google blog article: Go Slices.

Multidimensional Data

We can also make multidimensional arrays and slices in Go. A multidimensional Array or Slice is an Array of Arrays or a Slice of Slices.  You can denote these multidimensional structures using multiple brackets. Here are a few quick examples.

In our first example, we just define a two-dimensional array of zeroes.  In our second example, we build a two-dimensional slice by creating and appending two slices to our original slice.  Multidimensional arrays and slices can be extremely useful in Go. One easy way to create multidimensional arrays or slices is to use nested for loops. 


In this post, we talked about arrays and slices in Go. We talked about how slices are references for arrays and how arrays have a fixed length in Go. We also talked about how Go manages its memory for arrays and slices. In the end, we looked at multidimensional arrays and slices in Go. In our next few posts, we will look at maps, embedded maps and then functions in Go.

Manipulating Strings in Go

Strings are a pretty standard primitive type in most programming languages. They give the programmer the ability to output messages and store data. Today, we are going to look at strings and string manipulation in Go. We are also going to take a look at some of the print and input functions in Go.

Defining Strings in Go

Strings in Go are defined using double quotes "". You can’t use single quotes '' in Go because this is reserved for single characters or runes. A string by definition is a collection of characters surrounded by double quotes. In Go, we can do many cool things with strings such as regex, data storage, output, debugging, etc.


You may have noticed that in our Hello world program from the last post we imported a library called fmt. The fmt library gives us access to I/O in Go. This library gives us access to different print functions as well as scanner functions. We can use these print functions to print out to our terminal/console. We can also use the scanner functions to take in input from the command line.

Using I/O for Input and Output

The program above allows us to take in an input and then output "Hello, Input!" to the screen. In the program, we are using two different print functions and a scanner function. We are also making use of a reference and a string variable.

The fmt.Println() function will print the string or arguments that are in the parenthesis out then automatically create a new line. We could also get this behavior by changing that function to fmt.Print("\n"). The \n character set is what is called a newline character. The backslash is the escape character and the “n” is what tells it to create a new line. The fmt.Scanln() function lets us scan the input until the user hits the enter key or creates a new line.

Formatting Strings in Go

The fmt.Printf() function stands for print format. It allows us to format the string inside of the function. You may have noticed the use of a %s pair of characters. This is telling the string that we want to format that area of the string by inputting the value of a string variable, in this case, input. There are many other two letter codes that we can use to format strings in Go.


As you can see above, there are many different ways to format strings and the values being passed into those strings via the fmt.printf() function. All of the print functions in the fmt library are called variadic functions. Variadic functions in Go let the user input as many arguments into them as they want. We will talk about this more later but for now it is worth mentioning at least.

A Brief Word on References and Pointers

There is at least one more thing worth looking at from this piece of code which is the line: fmt.Scanln(&input). The reason this line is so important to look at is because we are using something called a reference in place of the normal variable input. In many low-level programming languages, we have something called a pointer and something else called a reference. The and & sign right before the input variable inside of the Scanln() function indicates that we are referencing the variable called input. The & operator finds the address of a variable and we assign the input to this variable. We will talk further about references when we get to pointers later down the line.


In this post, we looked at strings in Go. We also looked at how we can manipulate these strings and we looked at the basic I/O library in Go. We briefly talked about variadic functions, references and pointers as well. In our next posts, we will talk about logical operators, Loops and basic control flow in Go.