Go or Golang is a fairly simple but extremely powerful programming language. In this post, we are going to become pros at working with variables and constants in Go.
Variables: Building Blocks
Variables are one of the most essential building blocks of any programming language and this is no different in Go. Variables in Go are easy to pickup and master because there are only a few rules and constraints to worry about.
The biggest one is perhaps the statically typed nature of the language. Developers familiar with typed languages like C# or Java will feel right at home, while those coming from dynamically typed languages like JavaScript may need to make a few adjustments. While Go is a statically typed language, it does introduce a certain degree of flexibility that I think becomes a key benefit as we’ll see in this article.
Cheatsheet TL;DR
If you already know all the nuances of working with variables in Go, but just need a quick refresher, then this section is for you. Here I won’t go into any in-depth explanations, instead I’ll just show you the different ways of working with variables and constants in Go. The goal for this section is to be a quick reference guide.
package main
// Declare variable without setting value
var message string
// Set value
message = "Hello World"
// Declare variable and set value
var message string = "Hello World"
// Declare multiple variables of the same type
var firstName, middleName, lastName string
// Declare and set value for multiple variables of the same type
var firstName, middleName, lastName string = "John", "Fitzgerald", "Kennedy"
// Alternative way to declare multiple variables
var (
firstName string
middleName string
lastName string
)
// Alternative way to declare and set multiple variables
var (
firstName = "John"
middleName = "Fitzgerald"
lastName = "Kennedy"
)
// Declare multiple strings of different types
var (
firstName string
middleName string
age int
)
// Declare and set multiple variables of different types
var (
firstName = "Ado"
middleName = "Kukic"
age = 29
)
// Declare and set a value for a constant
const pi float32 = 3.14
func main(){
// All of the above can be used inside or outside of a function
// All of the below only works inside of a function
// Shorthand variable declaration
name := "Ado Kukic"
// Shorthand multiple variable declaration of same type
firstName, lastName := "Ado", "Kukic"
// Shorthand multiple variable declaration of different types
firstName, lastName, age := "Ado", "Kukic", 29
// Declare a const and let Go infer the type
const answerToLife = 42
// Discard value
firstName, _ := user()
// user() function returns two values
// The first value is set to firstName variable
// The second value is discarded
// Variable redeclaration
// Declare a variable err
err := false
// Declare a variable success, and redeclare the err variable
// Redeclaration can only be done if shorthand notation is used and
// at least one new variable is introduced
success, err := false, true
}
Golang Variables In-Depth
If you are new to Go and want to learn all the ways to work with variables, then you’ve come to the right place. Throughout the next few sections we’ll cover all the intricacies, nuances, and rules for working with variables and constants in Go. Let’s dive right in.
My First Variable In Go
Variables in Go are created with the var keyword followed by the name of the
variable. There are other ways to create variables, but we’re starting with the
basics. Let’s create and print out our first variable in the Go programming
language.
// Every Go program must have a main package
package main
// The "fmt" library exposes a number of useful methods for displaying content in our terminal window
import "fmt"
// The "main" function is executed by default when you run your Go program
func main(){
// Declare a variable called "hello" and set its value to "Hello World"
// Since the value we are setting is a string, the "hello" variable will be of type string
var hello = "Hello World"
// Print the value of "hello" to our terminal window
fmt.Println(hello) // "Hello World"
}
Every example I show will be a fully functional Go program, so to reinforce your learning and get the most out of this article I suggest you either run it locally or on the Go Playground .
Type Inference in Go
Go is a typed programming language. Each variable you declare must have a type associated with it. If you do not explicitly assign a type to a variable in your program, Go will do it for you.
Go has a number of primitive types you would expect such as string, bool,
int, and others . Deeper explanation of
individual types is out of scope for this article, but I will create a
cheatsheet for that as well in the future. Let’s see how we can explicitly
declare a type for our variables in Go.
package main
import "fmt"
func main() {
// Declare a variable and explicitly set it to a type of string
var name string = "Ado"
// Declare a variable of type int
// Since we declared a type we don't have to automatically assign a value to it
var age int
// Assign a value of 29 to the age variable
// We can do this because our Go program knows that the age variable is of type int
age = 29
fmt.Println(name, age) // Ado 29
}
To explicitly set a type for your variables in Go, you simply declare the type after the variable name. If you create a variable with an explicit type and then try to set its value to something not of that type, your program will not compile. Let’s see an example of that.
package main
import "fmt"
func main() {
// Error: cannot use 21 (type int) as type string in assignment
var city string = 21
fmt.Println(city)
}
If you try to run the above code you will get the following error:
cannot use 21 (type int) as type string in assignment because the number 21 is
of type int, while the string city is expecting a string value.
Better Way to Declare Variables with :=
Go has a unique way of declaring variables using the := shorthand notation
which both declares and assigns a variable without needing to use the var
keyword. There are a couple of requirements that must be met before you can use
the := syntax. Your variable must be declared inside of a function.
Let’s see how we can use the := syntax in our Go program.
package main
import "fmt"
func main() {
// Declare a variable "city" of type city and set it's value to "Las Vegas"
// Notice we omit the "var" keyword and type declaration
city := "Las Vegas"
fmt.Println(city) // "Las Vegas"
}
As mentioned before, the shorthand := syntax can only be used inside of a
function. The shorthand notation is the prefered way of declaring variables in
Go as it greatly increases readability. The downside is that the type will be
inferred, so if you create a variable price = 21, the type of price will be
of type int, when you might have meant for it to be a float32 for example.
Multiple Variable Declarations in Go
Up until know we’ve only worked with a small number of variables. Go gives us a couple of handy ways of declaring multiple variables. While we could always just create a new variable on a new line like this:
package main
import "fmt"
func main() {
var firstName string
var lastName string
firstName = "Ado"
lastName = "Kukic"
fmt.Println(firstName, lastName)
}
There are better ways to do it. If all of our variables are of the same type, then we can do the following:
package main
import "fmt"
func main() {
// Declare multiple variables of the same type
// Declare the type of all the variables at the end
var firstName, lastName string
firstName = "Ado"
lastName = "Kukic"
fmt.Println(firstName, lastName)
}
You can also do this with the shorthand syntax:
package main
import "fmt"
func main() {
firstName, lastName, age := "Ado", "Kukic", 29
fmt.Println(firstName, lastName, age) // "Ado Kukic 29"
}
The benefit of the shorthand notation is that now you can mix and match types and Go will, at compile time, figure out the correct types for your variables.
There is one more way of declaring multiple variables with the var keyword.
package main
import "fmt"
func main() {
var (
firstName string
lastName string
age int
)
firstName = "Ado"
lastName = "Kukic"
age = 29
fmt.Println(firstName, lastName, age)
}
With the above approach you could additionally declare and assign the value inside the parentheses and get the same result.
package main
import "fmt"
func main() {
var (
firstName = "Ado"
lastName = "Kukic"
age = 29
)
fmt.Println(firstName, lastName, age)
}
Use It or Lose It
If you’ve run any of the above programs without the fmt.Println function your
program would have failed to execute and you would have gotten an error saying
that you have declared a variable but not used it. In Go, each variable created
must serve a purpose and be used somewhere in the program otherwise the code
will not compile.
You may run into instances where you will need to declare a value but not use
it. In that case, Go has a special variable declaration _ which will simply
the discard the value it receives.
To see a concrete case of where this is useful, let’s say you had a function that returns two different values. This is not uncommon in Go, as functions can return multiple values. So let’s say you run this function, but only care about the first value returned.
package main
import "fmt"
func main() {
firstName, lastName := user()
fmt.Println(firstName, lastName)
}
func user() (string, string) {
return "Ado", "Kukic"
}
If we wanted to just print out the first value returned and updated our code
above to say fmt.Println(firstName) we would get an error saying that we have
declared a variable lastName but havent used it. To fix this, we’ll use the
_ declaration syntax to discard the second value and make our program work.
package main
import "fmt"
func main() {
firstName, _ := user()
fmt.Println(firstName)
}
func user() (string, string) {
return "Ado", "Kukic"
}
In Go, many functions return multiple values and it is very common to see the first value be the data you are hoping to get and the second value be any error that may have occurred. In cases like this, some developers may decide to ignore the error value during early development. While you should always handle all your errors properly, I have been guilty of doing this when trying to quickly prototype, just remember to go back and handle those errors before pushing the code to production.
Variable Initial Values
If you do not assign a value when creating a variable, Go will assign a zero value for the type. Let’s see how this works.
package main
import "fmt"
func main() {
var message string
// Default value: ""
var age int
// Default value: 0
var isValid bool
// Default value: false
}
The default value for any numeric type will be 0. For boolean values the default
is false and for strings it will be an empty string. While the Go programming
language does have a type of nil, a string cannot be of this type.
Variable Redeclaration
The final element of Go variables we’ll look at is variable redecleration. In many programming languages, you cannot redeclare a variable in the same block. While this is generally true in Golang, there is a case in which you can redeclare a variable.
In Go, you are allowed to redeclare a variable if and only if you are doing so
using the := shorthand variable declaration and are introducing at least one
new variable. Let’s see an example of how this works.
package main
import "fmt"
func main(){
// Declare a boolean variable called err
err := false
// Declare two boolean variables, success and err, which will create a new success variable and redeclare the err variable this time setting it to true
success, err := false, true
fmt.Println(success, err)
}
Variable redeclaration is mainly used for error checking in Go. This is due to the nature of the languages design principles when it comes to error handling.
Constants
Variables and constants go hand in hand, so our cheatsheet on variables wouldn’t be complete without discussing constants as well.
In Go, constants work very much the same as variables with the notable exception
that constants cannot be declared with the shorthand := syntax. The other big
exception is that while variables declared in Go must be used or the program
will not compile, constants do not have to be used.
Constants in Go are declared using the const keyword and behave like constants
in most other programming languages meaning that the value placed in the
constant cannot be changed. Once a constant is created, it’s value is well
constant.
package main
import "fmt"
const message string = "You can't change me"
func main() {
const luckyNumber = 7
fmt.Println(message)
}
As you can see in program above, we declared two constants but only used one. As with strings in Go, while we can declare the type explicitly, we can also omit it and let Go infer the type for us.
Unlike the convention in many programming languages where constants are generally declared with all caps, in Go, constants should be declared using mixed caps. The reason for this is that in Go, public/private or exported/unexported variables and functions are denoted by whether or not the first letter in the variable, constant, or function is uppercase or not. If it is, it is exported, if it’s not then it’s treated as a private variable, constant, or function. I’ll go into this more in depth in the cheatsheet on packages.
Conclusion
Go is a wonderful programming language that puts productivity front and center. Variables in Go are easy grasp and master, but also have a number of unique features that greatly improve readability and overall functionality. I hope you found this guide useful and give Go a chance in your next project. :)
Special Thanks
Kale Blakenship for pointing out issues with constants and shorthand declarations.