Why Go?¶

There are gazillions (not that many actually) of programming languages already in the wild. So one could, and rightly so, ask why yet another language? The fact is Go is easy to grok, and fun to use but also efficient and well designed.

Go is a compiled language, i.e. a language that produces machine code that can be executed without the need of an external interpreter like Python, Ruby, Perl and other scripting languages.

In fact, if we were to compare Go to something, it would be a modern C. Yes, that’s a strong statement that calls for a justification. Being a C programmer myself, C has its very own dear place in my heart, a place that won’t be shared by anything else. But Go earned my respect and that of many others thanks to its simplicity, efficiency and smart concepts that this book aims to demonstrate.

Go comes with some new syntax and idioms but not too many. Enough to make things evolve, but not too many to alienate people who are used to some other programming language. This balance, and -I’d dare to say- minimalism are what makes Go fun to learn.

Go has the efficiency of statically-typed languages, yet it provides some easy syntax and concepts that make it as cool as dynamic languages.

Go programs are compiled fast and run fast. Go also natively supports concurrency and communication.

Why this book?¶

This modest work is an introduction to the Go language. It is meant to be easy to understand by everyone and tries to make this learning experience fun and easy. Yes, that’s quite a challenge, but... aude aliquid dignum! [1].

I personally don’t buy the “learn the hard way” method. Learning shouldn’t be hard! Just remember that we’ve learnt how to speak while playing when we were younger and stupider. And Go, or any other language for that matter, is actually a lot easier than any spoken language; there are fewer words, fewer syntax rules, fewer idioms...

So here’s the deal and the only condition for learning with this book: take it easy. Really, consider it as a game.

We will play with data and code, learn something new every time. There will be some diversity, from simple, or even silly things, to some very serious and smart concepts.

Also, almost -if not all- the provided programs can be tested online in the Go Playground simply by copying/pasting them there.

A work in progress¶

This is a personal initiative, I have no deadlines with any publisher. I do this for fun, and during my free time. I will strive to improve it as much as I can. I don’t claim to be perfect —no one is!

So your help, criticism, suggestions are more than welcome. And the more you contribute, the better it will be.

Thanks for your attention, and have fun!

How do programs work?¶

In the programming world there are many families of languages: functional, logic, imperative.

Go, like C, C++, Python, Perl and some others are said to be imperative languages because you write down what the processor should execute. It’s an imperative way to describe tasks assigned to the computer.

An imperative program is a sequence of instructions that the processor executes when the program is compiled and transformed to a binary form that the processor understands.

Think of it as a list of steps to assemble or build something. We said “sequence” because the order of these steps generally matters a LOT! You can’t paint the walls of a house when you haven’t built the walls yet. See? Order matters!

What are variables?¶

When you solve math problems (mind you it won’t be about math this time), you say that the variable x is set to the value 1 for example.

Sometimes you have to solve equations like: 2x + 1 = 5. Solving here means finding out the value of the variable x.

So it’s safe to say that x is a container that can contain different values of a given type.

Think of them as boxes labeled with identifiers that store values.

What is assignation?¶

We assign a value to a variable to say that this variable is equal to this value from the assignation act on, until another assignation changes its value.

1
2
3
4
5

//assign the value 5 to the variable x
x = 5
// Now x is equal to 5. We write this like this: x == 5
x = x + 3 //now, we assign to x its value plus 3
//so now, x == 8

Assignation is the act of storing values inside variables. In the previous snippet, we assigned the value 5 to the variable whose identifier is x (we say simply the variable x) and just after, we assigned to the variable x its own value (5 is what we assigned to it in the previous instruction) plus 3. So now, x contains the value 5+3 which is 8.

What is a type?¶

Each declared variable is of a given type. A type is a set of the values that the variable can store. In other words: A type is the set of values that we can assign to a given variable.

For example: A variable x of the type integer can be used to store integer values: 0, 1, 2, ...

The phrase “Hello world” can be assigned to variables of type string.

So we actually declare variables of a given type in order to use them with values of that type.

What is a constant?¶

A constant is an identifier that is assigned a given value, which can’t be changed by your program.

We declare a constant with a given value.

1
2
3
4
5
6
7
8
9

// Pi is a constant whose value is 3.14
const Pi = 3.14

// Let's use the constant Pi
var x float32 //we declare a variable x of type float32
x = 3 * Pi //when compiled, x == 3 * 3.14

var y float32
y = 4 * Pi //when compiled, y == 4 * 3.14

For example, we can declare the constant Pi to be equal to 3.14. During the execution of the program, the value of Pi won’t and can not be changed. There is no assignation of values to constants.

Constants are useful to make programs easy to read and to maintain. In effect, writing Pi instead of the floating point number 3.14 in many spots of your program make it easier to read.

Also, if we decide to make the ouput of our program that uses Pi more precise, we can change the constant’s declared value once to be 3.14159 instead of the earlier 3.14 and the new value will be used all along when the program is compilled again.

Conclusion¶

Imperative programming is easy. Easy as putting values in boxes. Once you understand this very basic thing, complex (notice, I didn’t say complicated) things can be seen as a composition of simpler things.

Easy and fun. Fun as playing with Lego sets :)

The program¶

This is a tradition. And we do respect some traditions [1]. The very first program one should write when learning a programming language is a small one that outputs the sentence: Hello World.

Ready? Go!

1
2
3
4
5
6
7

package main

import "fmt"

func main() {
    fmt.Printf("Hello, world; καλημ ́ρα κóσμ or こんにちは世界\n")
}

Output:

The details¶

Conclusion¶

Go uses packages (like python’s modules) to organize code. The function main.main (function main located the in main package) is the entry-point of every standalone Go program. Go uses UTF-8 for strings and identifiers and is not limited to the old ASCII character set.

How to declare a variable?¶

There are several ways to declare a variable in Go.

The basic form is:

// declare a variable named "variable_name" of type "type"
var variable_name type

You can declare several variables of the same type in a single line, by separating them with commas.

// declare variables var1, var2, and var3 all of type type
var var1, var2, var3 type

And you can initialize a variable when declaring it too

/* declare a variable named "variable_name" of type "type" and initialize it
    to value*/
    var variable_name type = value

You can even initialize many variables that are declared in the same statement

/* declare a var1, var2, var3 of type "type" and initialize them to value1,
value2, and value3 respectively*/
var var1, var2, var3 type = value1, value2, value3

Guess what? You can omit the type and it will be inferred from the initializers

/* declare and initialize var1, var2 and var3 and initialize them
respectively to value1, value2, and value3. /
var var1, var2, var3 = value1, value2, value3

Even shorter, inside a function body (let me repeat that: only inside a function body) you can even drop the keyword var and use the := instead of =

// omit var and type, and use ':=' instead of '=' inside the function body
func test(){
    var1, var2, var3 := value1, value2, value3
}

Don’t worry. It’s actually easy. The examples with the builtin types, below, will illustrate both of these forms. Just remember that, unlike the C way, in Go the type is put at the end of the declaration and -should I repeat it?- that the := operator can only be used inside a function body.

The builtin types¶

1
2
3
4
5
6
7
8

//Example snippet
var active bool //basic form
var enabled, disabled = true, false //type omitted, variables initialized
func test(){
    var available bool //general form
    valid := false //type and var omitted, and variable initialized
    available = true //normal assignation
}

1
2
3
4
5
6
7
8
9

//Example snippet
var i int32 //basic form with a int32
var x, y, z = 1, 2, 3 //type omitted, variables initialized
func test(){
    var pi float32 //basic form
    one, two, three := 1, 2, 3 //type and var omitted, variables initialized
    c := 10+3i // a complex number, type infered and keyword 'var' omitted.
    pi = 3.14 // normal assignation
}

1
2
3
4
5
6
7
8

//Example snippet
var french_hello string //basic form
var empty_string string = "" // here empty_string (like french_hello) equals ""
func test(){
    no, yes, maybe := "no", "yes", "maybe" //var and type omitted
    japanese_hello := "Ohaiou"  //type inferred, var keyword omitted
    french_hello = "Bonjour" //normal assignation
}

Constants¶

In Go, constants are -uh- constant values created at compile time, and they can be: numbers, boolean or strings.

The syntax to declare a constant is:

const constant_name = value

Some examples:

1
2
3
4

//example snippet
const i = 100
const pi = 3.14
const prefix = "go_"

Facilities¶

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//example snippet
import "fmt"
import "os"

const i = 100
const pi = 3.14
const prefix = "go_"

var i int
var pi = float32
var prefix string

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

//example snippet with grouping
import(
    "fmt"
    "os"
)

const(
    i = 100
    pi = 3.14
    prefix = "go_"
)

var(
    i int
    pi = float32
    prefix string
)

1
2
3
4
5
6
7

//example snippet
const(
    x = iota //x == 0
    y = iota //y == 1
    z = iota //z == 2
    w // implicitely w == iota, therefore: w == 3
)

How to declare a pointer?¶

For any given type T, there is an associated type *T for pointers to variables of type T.

Example:

1
2
3
4
5
6
7

var i int
var hello string
var p *int //p is of type *int, so p is a pointer to variables of type int

//we can assign to p the address of i like this:
p = &i //now p points to i (i.e. p stores the address of i
hello_ptr := &hello //hello_ptr is a pointer variable of type *string and it points hello

How to access the value of a pointed-to variable?¶

If Ptr is a pointer to Var then Ptr == &Var. And *Ptr == Var.

In other words: you precede a variable with the & operator to obtain its address (a pointer to it), and you precede a pointer by the * operator to obtain the value of the variable it points to. And this is called: dereferencing.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main
import "fmt"

func main() {
    hello := "Hello, mina-san!"
    //declare a hello_ptr pointer variable to strings
    var hello_ptr *string
    // make it point our hello variable. i.e. assign its address to it
    hello_ptr = &hello
    // and int variable and a pointer to it
    i := 6
    i_ptr := &i //i_ptr is of type *int

    fmt.Println("The string hello is: ", hello)
    fmt.Println("The string pointed to by hello_ptr is: ", *hello_ptr)
    fmt.Println("The value of i is: ", i)
    fmt.Println("The value pointed to by i_ptr is: ", *i_ptr)
}

Output:

And that is all! Pointers are variables that store other variables addresses, and if a variable is of type int, its pointer will be of type *int, if it is of type float32, its pointer is of type *float32 and so on...

Why do we need pointers?¶

Since we can access variables, assign values to them using only their names, one might wonder why and how pointers are useful. This is a very legitimate question, and you’ll see the answer is quite simple.

Suppose that your program as it runs needs some to store some results in some new variables not already declared. How would it do that? You’ll say: I’ll prepare some variables just in case. But wait, what if the number of new variables differs on each execution of your program?

The answer is runtime allocation: your program will allocate some memory to store some data while it is running.

Go has a built-in allocation function called new which allocates exactly the amount of memory required to store a variable of a given type, and after it allocates the memory, it returns a pointer.

You use it like this: new(Type) where Type is the type of the variable you want to use.

Here’s an example to explain the new function.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main
import "fmt"

func main() {
    sum := 0
    var  double_sum *int //a pointer to int
    for i:=0; i<10; i++{
        sum += i
    }
    double_sum = new(int) //allocate memory for an int and make double_sum point to it
    *double_sum = sum*2 //use the allocated memory, by dereferencing double_sum
    fmt.Println("The sum of numbers from 0 to 10 is: ", sum)
    fmt.Println("The double of this sum is: ", *double_sum)
}

Another good reason, that we will see when we will study functions is that passing parameters by reference can be useful in many cases. But that’s a story for another day. Until then, I hope that you have assimilated the notion of pointers, but don’t worry, we will work with them gradually in the next chapters, and you’ll see that the fear some people have about them is unjustified.

Comments¶

You probably noticed in the example snippets given in previous chapters, some comments. Didn’t you? Go has the same commenting conventions as in C++. That is:

• Single line comments: Everything from // until the end of the line is a comment.
• bloc comments: Everything betwwen /* and */ is a comment.

1
2
3
4
5
6
7
8

//Single line comment, this is ignored by the compiler.
/* Everything from the beginning of this line until the keyword 'var' on
line 4 is a comment and ignored by the compiler. */
var(
    integer int
    pi = float32
    prefix string
)

Semicolons¶

If you’ve programmed with C, or C++, or Pascal, you might wonder why, in the previous examples, there weren’t any semicolons. In fact, you don’t need them in Go. Go automatically inserts semicolons on every line end that looks like the end of a statement.

And this makes the code a lot cleaner, and easy on the eyes.

The only place you will typically see semicolons is separating the clauses of for loops and the like; they are not necessary after every statement.

Note that you can use semicolons to separate several statements written on a single line.

The one surprise is that it’s important to put the opening brace of a construct such as an if statement on the same line as the if; if you don’t, there are situations that may not compile or may give the wrong result [1]

Ok let’s begin, now.

The if statement¶

Perhaps the most well-known statement type in imperative programming. And it can be summarized like this: if condition met, do this, else do that.

In Go, you don’t need parenthesis for the condition.

1
2
3
4
5

if x > 10 {
    fmt.Println("x is greater than 10")
} else {
    fmt.Println("x is less than 10")
}

You can also have a leading initial short statement before the condition too.

1
2
3
4
5
6

// Compute the value of x, and then compare it to 10.
if x := computed_value(); x > 10 {
    fmt.Println("x is greater than 10")
} else {
    fmt.Println("x is less than 10")
}

You can combine multiple if/else statements.

1
2
3
4
5
6
7

if integer == 3 {
    fmt.Println("The integer is equal to 3")
} else if integer < 3 {
    fmt.Println("The integer is less than 3")
} else {
    fmt.Println("The integer is greater than 3")
}

The for statement¶

The for statement is used to iterate and loop. Its general syntax is:

1
2
3

for expression1; expression2; expression3{
    ...
}

Gramatically, expression1, expression2, and expression3 are expressions, where expression1, and expression3 are used for assignements or function calls (expression1 before starting the loop, and expression3 at the end of every iteration) and expression2 is used to determine whether to continue or stop the iterations.

An example would be better than the previous paragraph, right? Here we go!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

package main
import "fmt"

func main(){
    sum := 0;
    for index:=0; index < 10 ; index++ {
        sum += index
    }
    fmt.Println("sum is equal to ", sum)
}

In the code above we initalize our variable sum to 0. The for loop by is begun by initializing the variable index to 0 (index:=0).

Next the for loop’s body is executed (sum += i) while the condition index < 10 is true.

At the end of each iteration the for loop will execute the index++ expression (eg. increments index).

You might guess that the output from the previous program would be:

And you would be correct! Because the sum is 0+1+2+3+4+5+6+7+8+9 which equals 45.

Question:

Is it possible to combine lines 5 and 6 into a single one, in the previous program? How?

Actually expression1, expression2, and expression3 are all optional. This means you can omit, one, two or all of them in a for loop. If you omit expression1 or expression3 it means they simply won’t be executed. If you omit expression2 that’d mean that it is always true and that the loop will iterate forever – unless a break statement is encountered.

Since these expressions may be omitted, you can have something like:

1
2
3
4
5

//expression1 and expression3 are omitted here
sum := 1
for ; sum < 1000;  {
    sum += sum
}

Which can be simplified by removing the semicolons:

1
2
3
4
5

//expression1 and expression3 are omitted here, and semicolons gone.
sum := 1
for sum < 1000 {
    sum += sum
}

Or when even expression2 is omitted also, we can have something like:

1
2
3
4

//infinite loop, no semicolons at all.
for {
    fmt.Println("I loop for ever!")
}

break and continue¶

With break you can stop loops early. i.e. finish the loop even if the condition expressed by expression2 is still true.

1
2
3
4
5
6

for index := 10; index>0; index-- {
    if index < 5{
        break
    }
    fmt.Println(index)
}

The previous snippet says: loop from 10 to 0 printing the numbers (line 6); but if i<5 then break (stop) the loop! Hence, the program will print the numbers: 10, 9, 8, 7, 6, 5.

continue, on the other hand will just break the current iteration and skips to the next one.

1
2
3
4
5
6

for index := 10; index > 0; index-- {
    if index == 5 {
        continue
    }
    fmt.Println(index)
}

Here the program will print all the numbers from 10 down to 1, except 5! Because on line 3, the condition if index == 5 will be true so continue will be executed and the fmt.Println(index) (for index == 5) won’t be run.

The switch statement¶

Sometimes, you’ll need to write a complicated chain of if/else tests. And the code becomes ugly and hard to read and maintain. The switch statement, makes it look nicer and easier to read.

Go’s switch is more flexible than its C equivalent, because the case expression need not to be constants or even integers.

The general form of a switch statement is

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// General form of a switch statement:
switch sExpr {
    case expr1:
        some instructions
    case expr2:
        some other instructions
    case expr3:
        some other instructions
    default:
        other code
}

The type of sExpr and the expressions expr1, expr2, expr3... type should match. i.e. if var is of type int the cases expressions should be of type int also!

Of course, you can have as many cases you want.

Multiple match expressions can be used, each separated by commas in the case statement.

If there is no sExpr at all, then by default it’s bool and so should be the cases expressions.

If more than one case statements match, then the first in lexical order is executed.

The default case is optional and can be anywhere within the switch block, not necessarily the last one.

Unlike certain other languages, each case block is independent and code does not “fall through” (each of the case code blocks are like independent if-else-if code blocks. There is a fallthrough statement that you can explicitly use to obtain fall through behavior if desired.)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Simple switch statement example:
i := 10
switch i {
    case 1:
        fmt.Println("i is equal to 1")
    case 2, 3, 4:
        fmt.Println("i is equal to 2, 3 or 4")
    case 10:
        fmt.Println("i is equal to 10")
    default:
        fmt.Println("All I know is that i is an integer")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Switch example without sExpr
index := 10
switch {
    case index < 10:
        fmt.Println("The index is less than 10")
    case index > 10, index < 0:
        fmt.Println("The index is either bigger than 10 or less than 0")
    case index == 10:
        fmt.Println("The index is equal to 10")
    default:
        fmt.Println("This won't be printed anyway")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

//switch example with fallthrough
integer := 6
switch integer {
case 4:
    fmt.Println("The integer was <= 4")
    fallthrough
case 5:
    fmt.Println("The integer was <= 5")
    fallthrough
case 6:
    fmt.Println("The integer was <= 6")
    fallthrough
case 7:
    fmt.Println("The integer was <= 7")
    fallthrough
case 8:
    fmt.Println("The integer was <= 8")
    fallthrough
default:
    fmt.Println("default case")
}

The problem¶

Let’s say that we have to write a program to retrieve the maximum value of two integers A and B. That’s easy to do with a simple if statement, right?

1
2
3
4
5
6

//compare A and B and say wich is bigger
if A > B {
    fmt.Print("The max is A")
} else {
    fmt.Print("The max is B")
}

Now, imagine that we have to make such a comparison many times in our program. Writing the previous snippet every time becomes a real chore, and error-prone. This is why we need to encapsulate this snippet in a code block, give it a name and then call this code block every time we need to know the max of two numbers. This code block is what we call a function.

A function is a code block that takes some items and returns some results.

If you’ve ever done some electronics, you’d see that functions really look like electronic circuits or chips. Need to amplify a signal? Take an amplifier chipset. Need to filter? Use a filter chipset and so on...

Your job as a software developer will be much easier, and far more fun once you start to think of a complex project as a set of modules for which the input is from the output of another module. The complexity of the solution will be reduced, and the debugging will be made easier also.

Let’s see how to apply this sort of design to the following problem: suppose we have a function MAX(A, B) which takes two integers {A, B} and returns a single integer output M which is the larger value of both A and B:

By reusing the function MAX we can compute the maximum value of three values: A, B and C as follows:

This is a very simple example actually. In practice you probably should write a MAX3 function that takes 3 input integers and returns a single integer, instead of reusing the function MAX.

Of course, you can inject the output of a function into another if and only if the types match.

How to do this in Go?¶

The general syntax of a function is:

1
2
3
4
5
6

func funcname(input1 type1, input2 type2) (output1 type1, output2 type2) {
    //some code and processing here
    ...
    //return the results of the function
    return value1, value2
}

The details:

• The keyword func is used to declare a function of name funcname.
• A function may take as many input parameters as required. Each one followed by its type and all separated by commas.
• A function may return many result values.
• In the previous snippet, result1 and result2 are called named result parameters, if you don’t want to name the return parameters, you can instead specify only the types, separated with commas.
• If your function returns only one output value, you may omit the parenthesis arround the output declaration portion.
• If your function doesn’t return any value, you may omit it entirely.

Some examples to better understand these rules:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main
import "fmt"

//return the maximum between two int a, and b.
func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func main() {
    x := 3
    y := 4
    z := 5

    max_xy := max(x, y) //calling max(x, y)
    max_xz := max(x, z) //calling max(x, z)

    fmt.Printf("max(%d, %d) = %d\n", x, y, max_xy)
    fmt.Printf("max(%d, %d) = %d\n", x, z, max_xz)
    fmt.Printf("max(%d, %d) = %d\n", y, z, max(y,z)) //just call it here
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main
import "fmt"

//return A+B and A*B in a single shot
func SumAndProduct(A, B int) (int, int) {
    return A+B, A*B
}

func main() {
    x := 3
    y := 4

    xPLUSy, xTIMESy := SumAndProduct(x, y)

    fmt.Printf("%d + %d = %d\n", x, y, xPLUSy)
    fmt.Printf("%d * %d = %d\n", x, y, xTIMESy)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

//look how we grouped the import of packages fmt and math
import(
    "fmt"
    "math"
)

//A function that returns a bool that is set to true of Sqrt is possible
//and false when not. And the actual square root of a float64
func MySqrt(f float64) (squareroot float64, ok bool){
    if f > 0 {
        squareroot, ok = math.Sqrt(f), true
    } else {
        squareroot, ok = 0, false
    }
    return squareroot, ok
}

func main() {
    for index := -2.0; index <= 10; index++ {
        squareroot, possible := MySqrt(index)
        if possible {
            fmt.Printf("The square root of %f is %f\n", index, squareroot)
        } else {
            fmt.Printf("Sorry, no square root for %f\n", index)
        }
    }
}

1
2
3
4
5
6
7
8
9

import "math"

//return A+B and A*B in a single shot
func MySqrt(floater float64) (squareroot float64, ok bool){
    if floater > 0 {
        squareroot, ok = math.Sqrt(f), true
    }
    return squareroot, ok
}

1
2
3
4
5
6
7
8
9

import "math"

//return A+B and A*B in a single shot
func MySqrt(floater float64) (squareroot float64, ok bool) {
    if floater > 0 {
        squareroot, ok = math.Sqrt(f), true
    }
    return // Omitting the output named variables, but keeping the "return".
}

Parameters by value, and by reference¶

When passing an input parameter to a function, it actually recieves a copy of this parameter. So, if the function changes the value of this parameter, the original variable’s value won’t be changed, because the function works on a copy of the original variable’s value.

An example to verify the previous paragraph:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main
import "fmt"

//simple function that returns 1 + its input parameter
func add1(a int) int {
    a = a+1 // we change the value of a, by adding 1 to it
    return a //return the new value
}

func main() {
    x := 3

    fmt.Println("x = ", x) // Should print "x = 3"

    x1 := add1(x) //calling add1(x)

    fmt.Println("x+1 = ", x1) // Should print "x+1 = 4"
    fmt.Println("x = ", x) // Will print "x = 3"
}

You see? The value of x wasn’t changed by the call of the function add1 even though we had an explicit a = a+1 instruction on line 6.

The reason is simple: when we called the function add1, it recieved a copy of the variable x and not x itself, hence it changed the copy’s value, not the value of x itself.

I know the question you have in mind: “What if I wanted the value of x to be changed by calling the function?”

And here comes the utility of pointers: Instead of writing a function that has an int input parameter, we should give it a pointer to the variable we want to change! This way, the function has access to the original variable and it can change it.

Let’s try this.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package main
import "fmt"

//simple function that returns 1 + its input parameter
func add1(a *int) int { // Notice that we give it a pointer to an int!
    *a = *a+1 // We dereference and change the value pointed by a
    return *a // Return the new value
}

func main() {
    x := 3

    fmt.Println("x = ", x) // Will print "x = 3"

    x1 := add1(&x) // Calling add1(&x) by passing the address of x to it

    fmt.Println("x+1 = ", x1) // Will print "x+1 = 4"
    fmt.Println("x = ", x) // Will print "x = 4"
}

Now, we have changed the value of x!

How is passing a reference to functions is useful? You may ask.

• The first reason is that passing a reference makes function cooperation on a single variable possible. In other words, if we want to apply several functions on a given variable, they will all be able to change it.
• A pointer is cheap. Cheap in terms of memory usage. We can have functions that operate on a big data value for example. Copying this data will, of course, require memory on each call as it is copied for use by the function. In this way, a pointer takes much less memory. Yo! Remember, it’s just an address! :)

Function’s signatures¶

Like with people, names don’t matter that much. Do they? Well, yes, let’s face it, they do matter, but what matters most is what they do, what they need, what they produce (Yeah you! Get back to work!).

In our previous example, we could have called our function add_one instead of add1, and that would still work as long as we call it by its name. What really matters in our function is:

1. Its input parameters: how much? which types?
2. Its output parameters: how much, which type?
3. Its body code: What does the function do?

We can rewrite the function’s body to work differently, and the main program would continue to compile and run without problems. But we can’t change the input and output parameters in the function’s declaration and still use its old parameters in the main program.

In other words, of the 3 elements we listed above, what matters even more is: what input parameters does the function expect, and what output parameters does it return.

These two elements are what we call a function signature, for which we use this formalism:

func (input1 type1 [, input2 type2 [, ...]]) (output1 OutputType1 [, output2 OutputType2 [,...]])

Or optionally with the function’s name:

func function_name (input1 type1 [, input2 type2 [, ...]]) (output1 OutputType1 [, output2 OutputType2 [,...]])

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

//The signature of a function that takes an int and returns and int
func (int x) x int

//takes two float and returns a bool
func (float32, float32) bool

// Takes a string returns nothing
func (string)

// Takes nothing returns nothing
func()

The problem¶

Go comes with some primitive types: ints, floats, complex numbers, booleans, and strings. Fair enough, but you’ll notice as you start to write complex programs that you’ll need more advanced forms of data.

Let’s begin with an example.

In the previous chapter, we wrote the MAX(A, B int) function to find out the bigger value between two integers A, and B. Now, suppose that A, and B are actually the ages of persons whose names are respectively Tom and Bob. We need our program to output the name of the older person, and by how many years he is older.

Sure, we still can use the MAX(A, B int) function by giving it as input parameters, the ages of Tom and Bob. But it’d be nicer to write a function Older for people. And not for integers.

People! I said people! Thus the need to create a custom type to represent people, and this type will be used for the input parameters of the Older function we’d like to write.

Structs¶

In Go, as in C and other languages, we can declare new types that act as containers for attributes or fields of some other types. For example, we can create a custom type called person to represent the attributes of a person. In our example these attributes will be the person’s name and age.

A type like this is called a struct, which is short for structure.

1
2
3
4

type person struct {
    name string // Field name of type string.
    age int // Field age of type int.
}

1
2
3
4
5
6

type person struct {
    name string
    age int
}

var P person // P will be a variable of type person. How quaint!

1
2
3

P.name = "Tom" // Assign "Tom" to P's name field.
P.age = 25 // Set P's age to 25 (an int).
fmt.Println("The person's name is %s", P.name) // Access P's name field.

1
2
3

//declare a variable P of type person and initialize its fields
//name to "Tom" and age to 25.
P := person{"Tom", 25}

1
2
3
4

//declare a variable P of type person and initialize its fields
//name to "Tom" and age to 25.
//Order, here, doesn't count since we specify the fields.
P := person{age:24, name:"Tom"}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package main
import "fmt"

// We declare our new type
type person struct {
    name string
    age int
}

// Return the older person of p1 and p2
//   and the difference in their ages.
func Older(p1, p2 person) (person, int) {
    if p1.age>p2.age { // Compare p1 and p2's ages
        return p1, p1.age-p2.age
    }
    return p2, p2.age-p1.age
}

func main() {
    var tom person

    tom.name, tom.age = "Tom", 18

    // Look how to declare and initialize easily.
    bob := person{age:25, name:"Bob"} //specify the fields and their values
    paul := person{"Paul", 43} //specify values of fields in their order

    tb_Older, tb_diff := Older(tom, bob)
    tp_Older, tp_diff := Older(tom, paul)
    bp_Older, bp_diff := Older(bob, paul)

    fmt.Printf("Of %s and %s, %s is older by %d years\n",
                tom.name, bob.name, tb_Older.name, tb_diff)

    fmt.Printf("Of %s and %s, %s is older by %d years\n",
                tom.name, paul.name, tp_Older.name, tp_diff)

    fmt.Printf("Of %s and %s, %s is older by %d years\n",
                bob.name, paul.name, bp_Older.name, bp_diff)
}

Arrays¶

An array of size n is a block of n consecutive objects of the same type. That is a finite set of indexed objects, where you can enumerate them: object number 1, object number 2, etc...

In fact, in Go as in C and other languages, the indexing starts from 0, so you actually say: object number 0, object number 1... object number n-1

Here’s how to declare an array of 10 ints, for example:

1
2

//declare an array A of 10 ints
var A [10]int

And here’s how to declare an array of 10 persons:

1
2

//declare an array A of 10 persons
var people [10]person

We can access the x ^th element of an array A, with the syntax: A[x]. Specifically we say: A[0], A[1], ..., A[n].

For example, the name of the 3 ^rd person is:

1
2
3
4
5
6
7
8
9

// Declare an array A of 10 persons:
var people [10]person

// Remember indices start from 0!
third_name := people[2].name //use the dot to access the third 'name'.

// Or more verbosely:
third_person := people[2]
thirdname := third_person.name

The idea now is to write a function Older10 that takes an array of 10 persons as its input, and returns the older person in this array.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

package main
import "fmt"

//Our struct
type person struct {
    name string
    age int
}

//return the older person in a group of 10 persons
func Older10(people [10]person) person {
    older := people[0] // The first one is the older for now.
    // Loop through the array and check if we could find an older person.
    for index := 1; index < 10; index++ { // We skipped the first element here.
        if people[index].age > older.age { // Current's persons age vs olderest so far.
            older = people[index] // If people[index] is older, replace the value of older.
        }
    }
    return older
}

func main() {
    // Declare an example array variable of 10 person called 'array'.
    var array [10]person

    // Initialize some of the elements of the array, the others are by
    // default set to person{"", 0}
    array[1] = person{"Paul", 23};
    array[2] = person{"Jim", 24};
    array[3] = person{"Sam", 84};
    array[4] = person{"Rob", 54};
    array[8] = person{"Karl", 19};

    older := Older10(array) // Call the function by passing it our array.

    fmt.Println("The older of the group is: ", older.name)
}

Output:

We could have declared and initialized the variable array of the main() function above in a single shot like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Declare and initialize an array A of 10 person.
array := [10]person  {
    person{"", 0},
    person{"Paul", 23},
    person{"Jim", 24},
    person{"Sam", 84},
    person{"Rob", 54},
    person{"", 0},
    person{"", 0},
    person{"", 0},
    person{"Karl", 10},
    person{"", 0}}

This means that to initialize an array, you put its elements between two braces, and you separate them with commas.

We can even omit the size of the array, and Go will count the number of elements given in the initialization for us. So we could have written the above code as:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// Declare and initialize an array of 10 persons, but let the compiler guess the size.
array := [...]person  { // Substitute '...' instead of an integer size.
    person{"", 0},
    person{"Paul", 23},
    person{"Jim", 24},
    person{"Sam", 84},
    person{"Rob", 54},
    person{"", 0},
    person{"", 0},
    person{"", 0},
    person{"Karl", 10},
    person{"", 0}}

Specifically note the ellipsis [...].

Some things to keep in mind:

• Arrays are values. Assigning one array to another, copies all of the elements of the right hand array to the left hand array. That is: if A, and B are arrays of the same type, and we write: B = A, then B[0] == A[0], B[1] == A[1]... B[n-1] == A[n-1].
• When passing an array to a function, it is copied. i.e. The function recieves a copy of that array, and not a reference (pointer) to it.
• Go comes with a built-in function len that returns variables sizes. In the previous example: len(array) == 10.

Multi-dimensional arrays¶

You can think to yourself: “Hey! I want an array of arrays!”. Yes, that’s possible, and often used in practice.

We can declare a 2-dimensional array like this:

1
2

//declare and initialize an array of 2 arrays of 4 ints
double_array := [2][4]int {[4]int{1,2,3,4}, [4]int{5,6,7,8}}

This is an array of (2 arrays (of 4 int)). We can think of it as a matrix, or a table of two lines each made of 4 columns.

The previous declaration may be simplified, using the fact that the compiler can count arrays’ elements for us, like this:

1
2

//simplify the previous declaration, with the '...' syntax
double_array := [2][4]int {[...]int{1,2,3,4}, [...]int{5,6,7,8}}

Guess what? Since Go is about cleaner code, we can simplify this code even further:

1
2

//über simpifikation!
double_array := [2][4]int {{1,2,3,4}, {5,6,7,8}}

Cool, eh? Now, we can combine multiple fields of different types to create a struct and we can have arrays of, as many as we want, of objects of the same type, and pass it as a single block to our functions. But this is just the begining! In the next chapter, we will see how to create and use some advanced composite data types with pointers.

What is a slice?¶

You’d love to have arrays without specifying sizes, right? Well, that is possible in a manner of speaking, we call ‘dynamic arrays’ in Go slices.

A slice is not actually a ‘dynamic array’ but rather a reference (think pointer) to a sub-array of a given array (anywhere from empty to all of it). You can declare a slice just like you declare an array, omitting the size.

1
2

//declare a slice of ints
var array []int // Notice how we didn't specify a size.

As we see in the above snippet, we can declare a slice literal just like an array literal, except that we leave out the size number.

1
2

//declare a slice of ints
slice := []byte {'a', 'b', 'c', 'd'} // A slice of bytes (current size is 4).

We can create slices by slicing an array or even an existing slice. That is taking a portion (a ‘slice’) of it, using this syntax array[i:j]. Our created slice will contain elements of the array that start at index i and end before j. (array[j] not included in the slice)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

// Declare an array of 10 bytes (ASCII characters). Remember: byte is uint8.
var array [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

// Declare a and b as slice of bytes
var a_slice,b_slice []byte

// Make the slice "a_slice" refer to a "portion" of "array".
a_slice = array[2:5]
// a_slice is now a portion of array that contains: array[2], array[3] and array[4]

// Make the slice "b_slice" refer to another "portion" of "array".
b_slice = array[3:5]
// b_slice is now a portion of array that contains: array[3], array[4]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// Declare an array of 10 bytes (ASCII characters). Remember: byte is uint8
var array [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
//declare a and b as slice of bytes
var a_slice,b_slice []byte

// Examples of slicing
a_slice = array[4:8]
// means: a_slice contains elements of array from array[4] to array[7]: e,f,g,h
a_slice = array[6:7]
// means: a_slice contains ONE element of array and that is array[6]: g

// Examples of shorthands
a_slice = array[:3] // means: a_slice = array[0:3] thus: a contains: a,b,c
a_slice = array[5:] // means: a_slice = array[5:9] thus: a contains: f,g,h,i,j
a_slice = array[:] // means: a_slice = array[0:9] thus: a contains all array elements.

// Slice of a slice
a_slice = array[3:7] // means: a_slice contains elements form 3 to 6 of array: d,e,f,g
b_slice = a_slice[1:3] //means: b_slice contains elements a[1], a[2] i.e the chars e,f
b_slice = a_slice[:3] //means: b_slice contains elements a[0], a[1], a[2] i.e the chars: d,e,f
b_slice : a_slice[:] //mens: b_slice contains all elements of slice a: d,e,f,g

Slices and functions¶

Say we need to find the biggest value in an array of 10 elements. Good, we know how to do it. Now, imagine that our program has the task of finding the biggest value in many arrays of different sizes! Aha! See? One function is not enough for that, because, remember, the types: [n]int and [m]int are different! They can not be used as an input of a single function.

Slices fix this quite easily! In fact, we need only write a function that accepts a slice of integers as an input parameter, and create slices of arrays.

Let’s see the code.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main
import "fmt"

// Return the biggest value in a slice of ints.
func Max(slice []int) int{ // The input parameter is a slice of ints.
    max := slice[0] // The first element is the max for now.
    for index := 1; index < len(slice); index++ {
        if slice[index]>max{ // We found a bigger value in our slice.
            max = slice[index]
        }
    }
    return max
}

func main() {
    // Declare three arrays of different sizes, to test the function Max.
    A1 := [10]int {1,2,3,4,5,6,7,8,9}
    A2 := [4]int {1,2,3,4}
    A3 := [1]int {1}

    // Declare a slice of ints.
    var slice []int

    slice = A1[:] // Take all A1 elements.
    fmt.Println("The biggest value of A1 is", Max(slice))
    slice = A2[:] // Take all A2 elements.
    fmt.Println("The biggest value of A2 is", Max(slice))
    slice = A3[:] // Take all A3 elements.
    fmt.Println("The biggest value of A3 is", Max(slice))
}

Output:

You see? Using a slice as the input parameter of our function made it reusable and we didn’t had to rewrite the same function for arrays of different sizes. So remember this: whenever you think of writing a function that takes an array as its input, think again, and use a slice instead.

Let’s see other advantages of slices.

Slices are references¶

We stated earlier that slices are references to some underlying array (or another slice). What exactly does that mean? It means that slicing an array or another slice doesn’t simply copy some of the array’s elements into the new slice, it instead make the new slice point to the element of this sliced array similar to the way pointers operate.

In other words: changing an element’s value in a slice will actually change the value of the element in the underlying array to which the slice points. This changed value will be visible in all slices and slices of slices containing the array element.

Let’s see an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

package main
import "fmt"

func PrintByteSlice(name string, slice []byte){
    fmt.Printf("%s is : [", name)
    for index :=0; index < len(slice)-1; index ++{
        fmt.Printf("%q,", slice[i])
    }
    fmt.Printf("%q]\n", slice[len(slice)-1])
}

func main(){
    // Declare an array of 10 bytes.
    A := [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}

    //declare some slices.
    slice1 := A[3:7] // Slice1 == {'d', 'e', 'f', 'g'}
    slice2 := A[5:] // Slice2 == {'f', 'g', 'h', 'i', 'j'}
    slice3 := slice1[:2] // Slice3 == {'d', 'e'}

    // Let's print the current content of A and the slices.
    fmt.Println("\nFirst content of A and the slices")
    PrintByteSlice("A", A[:])
    PrintByteSlice("slice1", slice1)
    PrintByteSlice("slice2", slice2)
    PrintByteSlice("slice3", slice3)

    // Let's change the 'e' in A to 'E'.
    A[4] = 'E'
    fmt.Println("\nContent of A and the slices, after changing 'e' to 'E' in array A")
    PrintByteSlice("A", A[:])
    PrintByteSlice("slice1", slice1)
    PrintByteSlice("slice2", slice2)
    PrintByteSlice("slice3", slice3)

    // Let's change the 'g' in slice2 to 'G'.
    slice2[1] = 'G' // Remember that 1 is actually the 2nd element in slice2!
    fmt.Println("\nContent of A and the slices, after changing 'g' to 'G' in slice2")
    PrintByteSlice("A", A[:])
    PrintByteSlice("slice1", slice1)
    PrintByteSlice("slice2", slice2)
    PrintByteSlice("slice3", slice3)
}

Output:

Let’s talk about the PrintByteSlice function a little bit. If you analyze its code, you’ll see that it loops until before len(slice)-1 to print the element slice[i] followed by a comma. At the end of the loop, it prints slice[len(slice)-1] (the last item) with a closing bracket instead of a comma.

PrintByteSlice works with slices of bytes, of any size, and can be used to print arrays content also, by using a slice that contains all of its elements as an input parameter. This proves the utility of the advice before: always think of slices when you’re about to write functions for arrays.

Until now, we’ve learned that slices are truly useful as input parameters for functions which expect blocks of a variable size of consecutive elements of the same type. We have learned also that slices are references to portions of an array or another slice.

That is not all. Here’s an awesome feature of slices.

Slices are resizable¶

One of our concerns with arrays is that they’re inflexible. Once you declare an array, its size can’t change. It won’t shrink nor grow. How unfortunate!

Slices can grow or shrink.

How so? Conceptually, a slice is a struct of three fields:

• A pointer to the first element of the array where the slice begins.
• A length which is an int representing the total number of elements in the slice.
• A capacity which is an int representing the number of available elements.

1
2
3
4
5

type Slice struct {
    base *elementType //the pointer
    len int //length
    cap int //capacity
}

Schematically, since you love my diagrams.

1
2
3

// Declare an array of 10 bytes.
array := [10]byte {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j'}
slice := A[4:8]

The picture above is a representation of a slice that starts from the 5th element of the array. It contains exactly 4 elements (its length) and can contain up to 6 elements on the same underlying array (its capacity) starting from the first element of the slice.

To make things even easier, Go comes with a built-in function called make, which has the signature: func make([]T, len, cap) []T.

Where T stands for the element type of the slice to be created. The make function takes a type, a length, and an optional capacity. When called, make allocates an array and returns a slice that refers to that array.

The optional capacity parameter, when omitted, defaults to the specified length. These parameters can be inspected for a given slice, using the built-in functions: - len(slice) which returns a slice’s length, and - cap(slice) which returns a slice’s capacity.

Example:

1
2
3
4
5

var slice1, slice2 []int
slice1 = make([]int, 4, 4) // slice1 is []int {0, 0, 0, 0}
slice2 = make([]int``,`` 4) // slice2 is []int {0, 0, 0, 0}
// Note: cap == len == 4 for slice2
// cap(slice2) == len(slice2) == 4

The zero value of a slice is nil. The len and cap functions will both return 0 for a nil slice.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import "fmt"

func main() {
    var slice []int
    fmt.Println("Before calling make")
    if slice==nil {fmt.Println("slice == nil")}
    fmt.Println("len(slice) == ", len(slice))
    fmt.Println("cap(slice) == ", cap(slice))

    // Let's allocate the underlying array:
    fmt.Println("After calling make")
    slice = make([]int, 4)
    fmt.Println("slice == ", slice)
    fmt.Println("len(slice) == ", len(slice))
    fmt.Println("cap(slice) == ", cap(slice))

    // Let's change things:
    fmt.Println("Let's change some of its elements: slice[1], slice[3] = 2, 3")
    slice[1], slice[3] = 2, 3
    fmt.Println("slice == ", slice)
}

Output:

We may find ourselves wondering “Why use make instead of new that we discussed when we studied pointers?”

Let’s discuss the reason why we use make and not new to create a new slice:

Recall that new(T) allocates memory to store a variable of type T and returns a pointer to it. Thus new(T) returns *T, right?

So for example if we had used new([]int) to create a slice of integers, new will allocate the internal structure discussed above and that will consist of a pointer, and two integers (length and capacity). new will then return us a pointer of the type *[]int – which... let’s face it... is not what we need!

What we do need is a function which:

• Returns the actual structure not a pointer to it. i.e. returns []int not *[]int.
• Allocates the underlying array that will hold the slice’s elements.

Do you see the difference? make doesn’t merely allocate enough space to host the structure of a given slice (the pointer, the length and the capacity) only, it allocates both the structure and the underlying array.

Back to our resizability of slices. As you may guess, shrinking a slice is really easy! All we have to do is reslice it and assign the new slice to it.

Now, let’s see how – using only what we have learned until now – we grow a slice. A very simple, straight forward way of growing a slice might be:

1. make a new slice
2. copy the elements of our slice to the one we created in 1
3. make our slice refer to the slice created in 1

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package main
import "fmt"

func PrintIntSlice(name string, slice []int){
    fmt.Printf("%s == [", name)
    for index := 0; index < len(slice)-1; index++ {
        fmt.Printf("%d,", slice[index])
    }
    fmt.Printf("%d]\n", slice[len(slice)-1])
}


func GrowIntSlice(slice []int, add int) []int {
    new_capacity := cap(slice)+add
    new_slice := make([]int, len(slice), new_capacity)
    for index := 0; index < len(slice); index++ {
        new_slice[index] = slice[index]
    }
    return new_slice
}

func main(){
    slice := []int {0, 1, 2, 3}

    fmt.Println("Before calling GrowIntSlice")
    PrintIntSlice("slice", slice)
    fmt.Println("len(slice) == ", len(slice))
    fmt.Println("cap(slice) == ", cap(slice))

    // Let's call GrowIntSlice
    slice = GrowIntSlice(slice, 3) //add 3 elements to the slice

    fmt.Println("After calling GrowIntSlice")
    PrintIntSlice("slice", slice)
    fmt.Println("len(slice) == ", len(slice))
    fmt.Println("cap(slice) == ", cap(slice))

    // Let's two elements to the slice
    // So we reslice the slice to add 2 to its original length
    slice = slice[:len(slice)+2] // We can do this because cap(slice) == 7
    slice[4], slice[5] = 4, 5
    fmt.Println("After adding new elements: slice[4], slice[5] = 4, 5")
    PrintIntSlice("slice", slice)
    fmt.Println("len(slice) == ", len(slice))
    fmt.Println("cap(slice) == ", cap(slice))
}

Output:

Let’s discuss this program a little bit.

First, the PrintIntSlice function is similar to the PrintByteSlice function we saw earlier. Except that we improved it to support nil slices.

Then the most important one is GrowIntSlice which takes two input parameters: a []int slice and an int add that represents the amount of elements to add to the capacity.

GrowIntSlice first makes a new slice with a new_capacity that is equal the original slice’s capacity plus the add parameter.

Then it copies elements from slice to new_slice in the highlighted loop in lines 16, 17 and 18.

And finally, it returns the new_slice as an output.

The approach you may be used to or that first comes to mind is often implemented as a built-in Go function provided for you already. This is most definitely one such example. There is a built-in Go function called copy which takes two arguments: source and destination, and copies elements from the source to the destination and returns the number of elements copied.

The signature of copy is: func copy(dst, src []T) int

So we can replace the lines 16, 17, 18 with this very simple one:

1
2

// Instead of lines 16, 17, 18 of the previous source:
copy(new_slice, slice) // Copy elements from slice to new_slice

You know what? Let’s write another example and use the copy function in it.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

package main
import "fmt"

func PrintByteSlice(name string, slice []byte){
    fmt.Printf("%s is : [", name)
    for index := 0; index < len(slice)-1; index++ {
        fmt.Printf("%q,", slice[index])
    }
    fmt.Printf("%q]\n", slice[len(slice)-1])
}

func Append(slice, data[]byte) []byte {
    length := len(slice)
    if length + len(data) > cap(slice) {  // Reallocate
        // Allocate enough space to hold both slice and data
        newSlice := make([]byte, l+len(data))
        // The copy function is predeclared and works for any slice type.
        copy(newSlice, slice)
        slice = newSlice
    }
    slice = slice[0:length+len(data)]

    copy(slice[length:length+len(data)], data)
    return slice
}

func main() {
    hello := []byte {'H', 'e', 'l', 'l', 'o'}
    world := []byte {' ', 'W', 'o', 'r', 'l', 'd'}
    fmt.Println("Before calling Append")
    PrintByteSlice("hello", hello)
    PrintByteSlice("world", world)

    fmt.Println("After calling Append")
    Append(hello, world)
    PrintByteSlice("hello", hello)
    PrintByteSlice("world", world)
}

Output:

Appending to a slice is a very common operation and as such Go has a built-in function called append that we will see in details very soon.

Phew, that was a long chapter, eh? We’ll stop here for now, go out, have a nice day, and see you tomorrow for another interesting composite type. If you are completely enthralled thus far by this exquisite book then do yourself a favor before continuing and go get a tea or coffee and take a nice 10 minute break.

How to declare a map?¶

The syntax of a map type is: map[keyType] valueType.

For example:

1
2
3

// A map that associates strings to int
// eg. "one" --> 1, "two" --> 2...
var numbers map[string] int //declare a map of strings to ints

You can access and assign a value to an entry of this map using the square bracket syntax as in arrays or slices, but instead of an int index you use a key of type keyType.

As with slices, since maps are reference types, we can make them using the make function: make(map[string]float32).

When used with maps, make takes an optional capacity parameter.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// A map that associates strings to int
// eg. "one" --> 1, "two" --> 2...
var numbers map[string] int //declare a map of strings to ints
numbers = make(map[string]int)
numbers["one"] = 1
numbers["ten"] = 10
numbers["trois"] = 3 //trois is "three" in french. I know that you know.
//...
fmt.Println("Trois is the french word for the number: ", numbers[trois])
// Trois is the french word for the number: 3. Also a good time.

We now have the idea: it’s like a table with two columns: in the left column we have the key, and on the right column we have its associated value.

Some things to notice:

• There is no defined notion of order. We do not access a value by an index, but rather by a key instead.
• The size of a map is not fixed like in arrays. In fact, just like a slice, a map is a reference type.
• Doing for example numbers["coffees_I_had"] = 7 will actually add an entry to this table, and the size of the map will be incremented by 1.
• As in slices and arrays, the built-in function len will return the number of keys in a map (thus the number of entries).
• Values can be changed, of course. numbers["coffees_I_had"] = 12 will change the int value associated with the string “coffes_I_had”.

Literal values of maps can be expressed using a list of colon-separated key:value pairs. Let’s see an example of this:

1
2
3
4
5
6
7
8
9

// A map representing the rating given to some programming languages.
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
// This is equivalent to writing more verbosely
var rating = map[string]float32
rating = make(map[string]float)
rating["C"] = 5
rating["Go"] = 4.5
rating["Python"] = 4.5
rating["C++"] = 2 //Linus would put 1 at most. Go ask him

1
2
3
4
5
6

//let'ss ay a translation dictionary
m = make(map[string][string])
m["Hello"] = "Bonjour"
m1 = m
m1["Hello"] = "Salut"
// Now: m["Hello"] == "Salut"

1
2
3
4

//A map representing the rating given to some programming languages.
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
csharp_rating := rating["C#"]
//csharp_rating == 0.00

1
2
3
4
5
6
7
8
9

//A map representing the rating given to some programming languages.
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
csharp_rating, ok := rating["C#"]
//would print: We have no rating associated with C# in the map
if ok {
    fmt.Println("C# is in the map and its rating is ", csharp_rating)
} else {
    fmt.Println("We have no rating associated with C# in the map")
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// A map representing the rating given to some programming languages.
rating := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }
map["C++"] = 1, false // We delete the entry with key "C++"
cpp_rating, ok := rating["C++"]
// Would print: We have no rating associated with C++ in the map
if ok {
    fmt.Println("C++ is in the map and its rating is ", cpp_rating)
} else {
    fmt.Println("We have no rating associated with C++ in the map")
}

The range clause¶

For maps (and arrays, and slices, and other stuff which we’ll see later), Go comes with a facinating alteration of the syntax for the “for statement”.

This syntax is as follow:

1
2
3
4
5

for key, value := range m {
    // In each iteration of this loop, the variables key and value are set
    // to the current key/value in the map
    ...
}

Let’s see a complete example to understand this better.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main
import "fmt"

func main(){
    // Declare a map literal
    ratings := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }

    // Iterate over the ratings map
    for key, value := range ratings {
        fmt.Printf("%s language is rated at %g\n", key, value)
    }
}

Output:

If we don’t need the value in our for statement, we can omit it like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main
import "fmt"

func main(){
    // Declare a map literal.
    ratings := map[string]float32 {"C":5, "Go":4.5, "Python":4.5, "C++":2 }

    fmt.Print("We rated these languages: ")

    // Iterate over the ratings map, and print the languages names.
    for key := range ratings {
        fmt.Print(key, ",")
    }
}

Output:

Exercise: Modify the program above to replace the last comma in the list by a period. That is, output: “We rated these languages: C++,C,Go,Python.”

This “for statement” form is also available for arrays and slices where instead of a key we have an index.

Let’s rewrite a previous example using this new tool:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

package main
import "fmt"

// Return the biggest value in a slice of ints.
func Max(slice []int) int { // The input parameter is a slice of ints.
    max := slice[0] //the first element is the max for now.
    for index, value := range slice { // Notice how we iterate!
        if value > max { // We found a bigger value in our slice.
            max = value
        }
    }
    return max
}

func main() {
    // Declare three arrays of different sizes, to test the function Max.
    A1 := [10]int {1,2,3,4,5,6,7,8,9}
    A2 := [4]int {1,2,3,4}
    A3 := [1]int {1}

    //declare a slice of ints
    var slice []int

    slice = A1[:] // Take all A1 elements.
    fmt.Println("The biggest value of A1 is", Max(slice))
    slice = A2[:] // Ttake all A2 elements.
    fmt.Println("The biggest value of A2 is", Max(slice))
    slice = A3[:] // Ttake all A3 elements.
    fmt.Println("The biggest value of A3 is", Max(slice))
}

Output:

Look carefully at line 6. We used a range over a slice of ints. i is an index and it goes from 0 to len(s)-1 and value is an int that goes from s[0] to s[len(s)-1].

Notice also how we didn’t use the index i in this loop. We didn’t need it.

The blank identifier¶

Whenever a function returns a value you don’t care about, or a range returns an index that you don’t care about, you can use the blank identifier _ (underscore) This predeclared identifier can be assigned any value of any type, and it will be discarded.

We could have written the Max(s []int)int function like this:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

// Return the biggest value in a slice of ints.
func Max(slice []int) int { // The input parameter is a slice of ints.
    max := slice[0]
    for _, value := range slice { // Notice how we use _ to "ignore" the index.
        if value > max {
            max = value
        }
    }
    return max
}

Also, say, we have a function that returns two or more values of which some are unimportant for us. We can “ignore” these output results using the blank identifier.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

// A function that returns a bool that is set to true of Sqrt is possible
// and false when not. And the actual square root of a float64
func MySqrt(floater float64) (squareroot float64, ok bool) {
    if floater > 0 {
        squareroot, ok = math.Sqrt(f), true
    } else {
        squareroot, ok = 0, false
    }
    return squareroot, ok
}
//...
r,_ = MySqrt(v) //retrieve the square root of v, and ignore its faisability

That’s it for this chapter. We learned about maps ; how to make them, how to add, change, and delete key/value pairs from them. How to check if a given key exists in a given map. And we also learned about the blank identifier ‘_‘ and the range clause.

Yes, the range clause, especially, is a control flow construct that should belong in the chapter about control flow, but we didn’t yet know about arrays, slices or maps, at that time. This is why we deferred it until this chapter.

The next chapter will be about things that we didn’t mention about functions in the chapter about functions for the same reason: lack of prior exposure, or simply because I wanted the chapter to be light so we can make progress with advanced data structures.

Anyways, you’ll see, it will be fun! See you in the next chapter! :)

Variadic functions¶

Do you remember when I made you cringe at the idea of writing a function Older100 that will not accept less than 100 persons? structs as its input?

Well I lied a little bit, but it was a good lie. I duct-taped you to a chair with that blindfold on with the best of intentions, I swear! It was an excellent reason to learn about arrays, and later about slices! Relax... it’s for your own safety! ;)

The truth is: you can have functions that accept a variable number of input parameters of the same type. They’re called variadic functions.

These functions can be declared like this:

func function_name(args ...inputType) (output1 OutputType1 [, output2 OutputType2 [, ...]])

There’s no difference from the way we learned to declare functions, except the three dots (called an ellipses) thing:...inputType which says to the function that it can recieve a variable number of parameters all of them of type inputType.

How does this work? Easy: In fact, the args identifier you see in the input parameter is actually a slice which contains all of the parameters passed in ( which should all be of type inputType).

A slice! Yay! So we can, in the function’s body, iterate using range to get all the parameters! Yes, that’s the way you do it. You play the guitar on the mtv... er, sorry. I got a case of Mark Knopfler fever.

Let’s see an example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

package main
import "fmt"

// Our struct representing a person
type person struct {
    name string
    age int
}

// Return true, and the older person in a group of persons
// Or false, and nil if the group is empty.
func Older(people ...person) (bool, person) { // Variadic function.
    if(len(people) == 0){return false, person{}} // The group is empty.
    older := people[0] // The first one is the older FOR NOW.
    // Loop through the slice people.
    for _, value := range people{ // We don't need the index.
        // Compare the current person's age with the oldest one so far
        if value.age > older.age {
            older = value //if value is older, replace older
        }
    }
    return true, older
}

func main(){

    // Two variables to be used by our program.
    var(
        ok bool
        older person
    )

    // Declare some persons.
    paul := person{"Paul", 23};
    jim := person{"Jim", 24};
    sam := person{"Sam", 84};
    rob := person{"Rob", 54};
    karl := person{"Karl", 19};

    // Who is older? Paul or Jim?
    _, older = Older(paul, jim) //notice how we used the blank identifier
    fmt.Println("The older of Paul and Jim is: ", older.name)
    // Who is older? Paul, Jim or Sam?
    _, older = Older(paul, jim, sam)
    fmt.Println("The older of Paul, Jim and Sam is: ", older.name)
    // Who is older? Paul, Jim , Sam or Rob?
    _, older = Older(paul, jim, sam, rob)
    fmt.Println("The older of Paul, Jim, Sam and Rob is: ", older.name)
    // Who is older in a group containing only Karl?
    _, older = Older(karl)
    fmt.Println("When Karl is alone in a group, the older is: ", older.name)
    // Is there an older person in an empty group?
    ok, older = Older() //this time we use the boolean variable ok
    if !ok {
        fmt.Println("In an empty group there is no older person")
    }
}

Output:

Look how we called the function Older with 2, 3, 4, 1 and even no input parameters at all. We could have called it with 100 persons if we wanted to.

Variadic functions are easy to write and can be handy in a lot of situations. By the way, I promised to tell you about the built-in function called append that makes appending to slices easier! Now, I can tell you more, because, guess what? The built-in append function is a variadic function!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

package main
import "fmt"

func main(){
    slice := []int {1, 2, 3}
    fmt.Println("At first: ")
    fmt.Println("slice = ", slice)
    fmt.Println("len(slice) = ", len(slice))
    fmt.Println("Let's append 4 to it")
    slice = append(slice, 4)
    fmt.Println("slice = ", slice)
    fmt.Println("len(slice) = ", len(slice))
    fmt.Println("Let's append 5 and 6 to it")
    slice = append(slice, 5, 6)
    fmt.Println("slice = ", slice)
    fmt.Println("len(slice) = ", len(slice))
    fmt.Println("Let's append 7, 8, and 9 to it")
    slice = append(slice, 7, 8, 9)
    fmt.Println("slice = ", slice)
    fmt.Println("len(slice) = ", len(slice))
}

1
2
3
4
5

// Two slices of ints
a_slice := []int {1, 2, 3}
b_slice := []int {10, 11, 12}
a_slice = append(a_slice, b_slice...) // Note the syntax: the slice followed by three dots
// a_slice == {1, 2, 3, 10, 11, 12}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main
import "fmt"

func delete(i int, slice []int) []int{
    switch i {
        case 0: slice = slice[1:]
        case len(slice)-1: slice = slice[:len(slice)-1]
        default: slice = append(slice[:i], slice[i+1:]...)
    }
    return slice
}

func main(){
    slice := []int {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    fmt.Println("In the beginning...")
    fmt.Println("slice = ", slice)
    fmt.Println("Let's delete the first element")
    slice = delete(0, slice)
    fmt.Println("slice = ", slice)
    fmt.Println("Let's delete the last element")
    slice = delete(len(slice)-1, slice)
    fmt.Println("slice = ", slice)
    fmt.Println("Let's delete the 3rd element")
    slice = delete(2, slice)
    fmt.Println("slice = ", slice)
}

1
2
3
4
5

//simpler delete
func delete(i int, slice []int) []int{
    slice = append(slice[:i], slice[i+1:]...)
    return slice
}

Recursive functions¶

Some algorithmic problems can be thought of in a beautiful way using recursion!

A function is said to be recursive when it calls itself within it’s own body. For example: the Max value in a slice is the maximum of the Max value of two sub-slices of the same slice, one starting from 0 to the middle and the other starting from the middle to the end of the slice. To find out the Max in each sub-slice we use the same function, since a sub-slice is itself a slice!

Enough talk already, let’s see this wonderous beast in action!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main
import "fmt"

//Recursive Max
func Max(slice []int) int{
    if len(slice) == 1 {
        return slice[0] //there's only one element in the slice, return it!
    }

    middle := len(slice)/2 //the middle index of the slice
    //find out the Max of each sub-slice
    m1 := Max(slice[:middle])
    m2 := Max(slice[middle:])
    //compare the Max of two sub-slices and return the bigger one.
    if m1 > m2 {
        return m1
    }
    return m2
}

func main(){
    s := []int {1, 2, 3, 4, 6, 8}
    fmt.Println("Max(s) = ", Max(s))
}

Output:

Another example: How to invert the data in a given slice of ints? For example, given s := []int {1, 2, 3, 4, 5}, we want our program to modify s to be {5, 4, 3, 2, 1}.

A recursive strategy to do this involves first swapping the first and the last elements of s and then inverting the slice between these elements, i.e. the one from the 2nd element to the one just before the last one.

Let’s write it:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

package main
import "fmt"

func Invert(slice []int){
    length := len(slice)
    if length > 1 { // Only a slice of 2 or more elements can be inverted
        slice[0], slice[length-1] = slice[length-1], slice[0] // Swap first and last ones
        Invert(slice[1:length-1]) // Invert the slice in between
    }
}

func main(){
    slice := []int {1, 2, 3, 4, 5}
    fmt.Println("slice = ", slice)
    Invert(slice)
    fmt.Println("Invert(slice) = ", slice)
}

Output:

Exercise Recursive absurdity! The SUM of the ints in a given slice is equal to the first element plus the SUM of the subslice starting from the second element. Go and write this program.