Pointers in Go

In this post, we are going to look at pointers in Go. Pointers appear in lower level programming languages. These features let us get closer to the hardware. We can see where the data is being stored in our memory. Slices, in fact, are pointers to arrays in Go. So when we mutate the length of a slice in Go, it reassigns itself to a different array behind the scenes.

Putting Our Nose on the Hardware.

We can use this type of behavior to our advantage with smaller data structures. Pointers in Go allow us to manipulate data without having to pass it from one place to another. As a consequence, we can use them when we are dealing with multiple threads and more complex data structures. We can also use them in functions. Let’s look at an example.

In this example, we have two functions, one that uses a pointer and one that doesn’t. Neither of these functions have return statements. Therefore, there is no effect from re-assigning the variable inside of the first function. The second function has an effect on our variable in main because we are passing a memory location rather then a value.

We can’t directly use arithmetic on pointers in Go. This is a consequence of Go having garbage collection. However, once we assign a value to a pointer it will continue to point to that value for the pointer’s lifetime. The only exception to this guarantee is in the case of nil pointers.

pointers-memoryPointing with Pointers

To fully understand pointers, we need to first understand how variables look behind the scenes. All variables are like boxes. Inside of these boxes are values. These boxes need to be stored somewhere, however, and that place is the memory. Because variables can have different types, the boxes also have different sizes.

In Go, we can create variables that contain these memory addresses. Basically, theses variables are pointing to the location where the boxes are being held. That is why, we call these variables pointers.

In Go, when we pass a variable to a function, we are copying the box with the value into that function. This means that the new copy of that box has a different location in the memory. If we use a pointer instead of just a normal parameter, we can pass the original box into the function. This is why in our pointer function above, we see the variable value change without a return statement.

Now that we have a grasp of pointers, lets take a look at a simple example.

Notice that in this example we use the * and the & signs for different reasons. The & before a variable lets us assign a pointer to the memory address of the variable. The * before a pointer lets us see what the pointer is pointing at. As we get deeper into Go and start to look at interfaces and structs, we will start to see pointers more and more. These other data types will help us understand why pointers are so powerful. 


In this post, we looked at pointers in Go. We went over the basic idea of pointers as references to memory and we looked at how go treats variables on the hardware side.  In our next few posts we will start to look at structs and interfaces and then continue on to Go-routines and channels.  

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.