In this chapter, I'll cover the basics you'll need for writing programs in GO. Things like using the toolchain, data types, and some handy conversions. I will use plenty of examples in the upcoming sections. It's okay if they do not make sense; we aim for familiarity, not mastery. That said, the best way to learn any programming language is to code along to build muscle memory, so crack open your new installation of Visual Studio Code editor.

Note: Chapter 2. GO Basics source code in case any code causes errors or if you get a little lost.

I. The GO Toolchain

One thing that makes developing with GO so vastly different from Python or Java is that it comes with native toolchain support from the creators of the language for an easy way to manage GO codebases.

In the first chapter, we installed GO, including the toolchain. If you remember, we used 'go build -o' or 'go run main. go' to execute the hello world program, which are commands that are part of the GO toolchain.

We'll briefly tour the few commands you use most when writing GO.

I.a 'go mod'

Go mod is used for dependency management. It makes it such that when you download another GO project, you'll be guaranteed that the code will work and not be broken due to dependencies.

Typically, you'll only need to run it every once in a while.

So here are the two commands you'll need most.

go mod init

You use go mod init to declare that the code you're working on is a module that requires x,y, and z dependencies; the dependencies will be shown within the go.mod that is created.

Typically, you use the format

go mod init github.com/<yourUserName>/nameOfProject.

go mod tidy

Go mod tidy eliminates dependencies that aren't used so that your codebase stays light.

To use it run,

go mod tidy

I.b go get

So, GO requires that the dependencies for a project be installed locally on your machine as you develop and if they aren't then you'll see an error like:

ERROR github.com/pkg/name is not installed.

And to solve it run,

go get github.com/pkg/name

But the catch is that you must have done go mod init first.

I.c 'go fmt'

There are many heated arguments on the internet about how a programming language's codebase should look in terms of format.

But with GO, there is only one option.

Imagine, for some reason, that you can't access Visual Studio Code, or the extension stops working, and the go code you wrote from chapter 1. Setting Up Developer Environment looks like this:

package main 
import "fmt"
func main(){
fmt.Println("Hello, world!")
}

Then to make it GO-compliant, all you'd need to do is,

go fmt main.go

And then your code will look like this.

package main
	 
import "fmt"
	 
func main() {
	fmt.Println("Hello, world!")
}

Although having a linter like the GO extension installed is preferred to this method, it is good to know for odd occasions when you don't have it.

I.d 'go run'

Compiles and runs your GO program all at once very useful when you're working on new code and want instant feedback without having to do 'go build' first.

go run main.go

I.e 'go build'

You'll run this when you've finished your program and want to use it as an executable. When you're done building a Command Line Interface (CLI) tool or a Web App with a server component, you'll want executables.

And what's better is that with, you can specify which operating systems you want it to run on.

go build -o hello env GOOS=target-OS GOARCH=target-architecture

Don't worry if this doesn't make sense right now. Just note that when you want to take your program executable to a different operating system, it is super easy to do by using GOOS and GOARCH environment variables.

I.f 'go test'

Testing your code speeds up the development process and is often a requirement in the professional world, so having support right out of the box is fantastic.

Testing is a complete topic worthy of a book or blog post. If you want to look for an in-depth explanation of it, then read my post GO Test Driven Development

Otherwise, know that if you see _test.go files within a codebase that you can run

go test .

To run the tests for that codebase.

II. Data Types

Computers, unlike humans, need precise instructions. Part of the specificity of the instructions is what data type it is to process.

So, we'll cover the significant data types in the next section that you'll most likely use and encounter while working with GO.

II.a Integers

Integers are your whole numbers, meaning there are no decimal points.

You use the signed integer type if a number can be negative. Otherwise, the unsigned type should be used.

Signed

Imagine you have a program to analyze your bank account balance after paying monthly bills, and you've unfortunately had to think about a case where you are negative money.

You've overspent and might need a credit card, loan, or part of the next paycheck to pay the remainder.

So, in this case, your result could be negative, which tells us to use a signed integer.

First, create a new directory, 'ex1', and then create a new file named 'main.go'.

And type the following.

// ex1
package main

import "fmt"

func pay(money, bills int) int {
   return money - bills
}

func main() {
   var paycheck, bills int = 4000, 5000
   fmt.Printf("bank account balance: %d\n", pay(paycheck, bills))
}

then run

go run main.go

And you'll see you indeed might have a problem.

Now that you know when you might use signed integers, it is worth mentioning that Go lets you specify how many bits an integer can contain with int8,int16, int32, and int64, but for most readers, int will more than get the job done.

unsigned

Unsigned integers will not be negative, so if we take the same code and swap 'int' with 'uint', you'll see that it breaks.

// ex2
package main

import "fmt"

// changed int to uint
func pay(money, bills uint) uint {
   return money - bills
}
func main() {
   // changed int to uint
   var paycheck, bills uint = 4000, 5000
   fmt.Printf("bank account balance: %d\n", pay(paycheck, bills))
}

It outputs a nonsensical "18446744073709550616" instead of '-1000' as in the previous example.

Just like with 'int', there are uint8, uint16, uint32, and uint64 versions, and just like with 'int' most readers will only need 'uint.'

Floats

Floats are your decimal numbers; by default, they can handle both positive and negative numbers. In general, I'd use a float for the calculation above because very rarely is anything, only whole numbers.

I recommend something other than the float if you're on a project where memory is a concern or if you know that decimals will not appear.

// ex3
package main

import "fmt"

// int -> uint -> float32 if you're coding along
func pay(money, bills float32) float32 {
   return money - bills
}
func main() {
   // int -> uint -> float32
   var paycheck, bills float32 = 4000, 5000.0
   fmt.Printf("bank account balance: %f\n", pay(paycheck, bills))
}

However, there is no 'float' like with 'uint' or 'int', so you must declare either 32bit or 64bit-sized floats. Don't worry float32 will handle most of your use cases.

An explanation about bits is outside this book's scope, and it isn't necessary to write GO code to automate your daily tasks.

II.b string

The data you're reading in this book and often contains within documents is of the 'string' data type. And chances are this is the most common data type you'll be using and seeing.

In GO and many other languages, string types are represented with quotation marks. Like so

// ex4
package main

import "fmt"

func main() {
   var example string = "Hello, world!"
   fmt.Printf("%s", example)
}

II.c booleans

Boolean variables are either true or false, you'll use this when you're checking for conditions in a program, and we'll use them later.

// ex5
package main

import "fmt"

func main() {
   //Default value will be false
   var a bool
   fmt.Printf("a's value is %t\n", a)
}

III. String Concatenation

String concatenation is the idea of adding two strings together to make one string, and as such, it uses the '+' symbol.

// ex6
package main

import "fmt"

func main() {
   var s1 string = "Hello "
   var s2 string = "world!"
   fmt.Printf("%s", s1+s2)
}

IV. Variables

We've used variables throughout the examples, as shown by the 'var' keyword. Think of a variable like an empty box that you have left over from moving.

Before you move, you put stuff inside of it, and if you are of the well-organized type, you might even have the same type in one box.

For example, if packing a box for the kitchen, you might have a box labeled 'kitchen-glasses', and within all glasses from your cabinets.

So, only one data type goes into the variable, as only glasses go into the kitchen-glasses box.

And this is how GO expects you to use variables in a very organized manner.

However, there is a trick that you can use to avoid having to type 'var' and the type the data is explicitly, and that's the ':=', which is called the short declaration operator. But you can only do it within functions.

Here's what I mean:

// ex7
package main

import "fmt"

func pay(money, bills int) int {
   return money - bills
}
func main() {
   // var, int -> :=
   paycheck, bills := 4000, 5000
   fmt.Printf("bank account balance: %d\n", pay(paycheck, bills))
}

So, the 'main()' is a 'func'; hence, we can use the ':=', which is generally the preferred way to save on words. In codebases, less is more.

IV.a Assignment statements

Unlike the ':=' that we previously discussed, an assignment statement uses '=', which we used in all the examples, and it requires us to use 'var' and the data type after the variable name.

E.g.

// ex8
package main

import "fmt"

func main() {
   var example string = "Gentle reminder"
   fmt.Printf("%s", example)
}

In this, we are saying that example is a variable of the typed string, and we are assigning the string "Gentle reminder" to be stored within it.

Naming Conventions

Typically, GO programmers prefer short, concise variable names with no '_' or '-', called camelcase and kebob case, respectively.

So, you'll see terms for variables being as few characters as possible and function names like so:

// ex9
package main

import "fmt"

func getUserName() string {
   return "Reader"
}
func main() {
   n := getUserName()
   fmt.Printf("Hello Dear %s", n)
}

Naming things like this is the opposite of Python's preference for names like 'name_of_user = get_user_name(),' which encourages spelling things out as much as possible.

V. Type Conversions

Imagine you have data in a document of '1.99' and want to use it as a float for some calculation. Sometimes, you'll find variables and want to change them to another type. Doing so is called casting or conversion in programming speak, and it is probably most familiar with string data.

Here are a few to keep in mind as you work with GO.

golang string to int

// ex10
package main

import (
   "fmt"
   "reflect"
   "strconv"
)

func main() {
   strVar := "100"
   intVar, err := strconv.Atoi(strVar)
   fmt.Println(intVar, err, reflect.TypeOf(intVar))
}

int to string

// ex11
package main

import (
   "fmt"
   "strconv"
)

func main() {
   i := 10
   s1 := strconv.FormatInt(int64(i), 10)
   s2 := strconv.Itoa(i)
   fmt.Printf("%v, %v\n", s1, s2)
}

golang bytes array to string

// ex12
package main

import "fmt"

func main() {
   s := string([]byte{65, 66, 67, 226, 130, 172})
   fmt.Println(s)
}

golang bool to string

// ex13
package main

import (
   "fmt"
)

func main() {
   B := true
   str := fmt.Sprintf("%v", B)
   fmt.Println(str)
}

VI. Comparisons

They are rarely used alone and typically go with control-flow or conditional statements, which we'll go over later, but I'm showing them here to build familiarity.

equal to

Compares whether or not two values stored in variables are equal.

// ex14
package main

import (
   "fmt"
)

func main() {
   fmt.Println("let's see if these two identical strings evaluate to equal")
   s1 := "hi"
   s2 := "hi"
   // okay, I showed a little conditional flow here
   if s1 == s2 {
      fmt.Printf("yes, they are!")
   }
}

not equal to

// ex15
package main

import (
   "fmt"
)

func main() {
   fmt.Println("let's see if these two non-identical strings evaluate to equal")
   s1 := "hi"
   s2 := "these are not the droids you're looking for"
   // okay, I showed a little conditional flow here
   if s1 != s2 {
      fmt.Printf("They're not the same string!")
   }
}

greater than

// ex16
package main

import (
   "fmt"
)

func main() {
   bills := 13642.32
   paycheck := 10000.00
   if bills > paycheck {
      fmt.Printf("Maybe I should update my resume...")
   }
}

less than

// ex17
package main

import (
   "fmt"
)

func main() {
   paycheck := 13642.32
   bills := 10000.00
   if bills < paycheck {
      fmt.Printf("alright, alright, alright")
   }
}

greater than or equal to

// ex18
package main

import (
   "fmt"
)

func main() {

   bills := 13642.32
   paycheck := 10000.00
   if bills >= paycheck {
      fmt.Printf("I'll never gonna financially recover from this")
   }
}

less than or equal to

// ex19
package main

import (
   "fmt"
)

func main() {
   paycheck := 13642.32
   bills := 10000.00
   if bills <= paycheck {
      fmt.Printf("seems risky.")
   }
}

Conclusion

Wow, that was a lot of examples. Congrats on making it this far. Know that as you code along, you are getting more and more comfortable with go! But it's also tiring learning so many new things at once, so make sure to have a snack and rest before heading on to the next chapter.

Now that all of the basics of GO are in place, we can move on to introducing flow control or logic to our programs. So see you in Chapter 3. with, of course, plenty of examples!