Primer on Go

Install

https://stackoverflow.com/questions/12843063/install-go-with-brew-and-running-the-gotour

https://golang.org/doc/install#install

Test

cd $HOME/go/src/hello

go build

package main

import "fmt"

func main() {
	fmt.Printf("hello, world\n")
}

./hello

Declaration

Basic

package main

import "fmt"

func main() {

    var message string
    var a, b, c int = 1, 2, 3

    message = "Hello all"
    fmt.Printf(message, a, b, c)
}

and more idiomatically:

package main

import "fmt"

func main() {

    message := string
    a, b, c := 1, 2, 3

    message = "Hello all"
    fmt.Printf(message, a, b, c)
}

Pointers

var greeting *string = &message

fmt.Printf(message, greeting)

*string => pointer to a string

&message => use the memory location of the variable message

so this returns

Hello all%!(EXTRA *string=0xc42007a1c0)

whereas this:

fmt.Printf(message, *greeting)

returns the value. i.e.

Hello all%!(EXTRA string=Hello all)

Basic User Types

type Salutation string

or a more complex example:

type Salutation struct {

name string

greeting string

}

func main() {

var a = Salutation{name: “Bob”, greeting: “Hi” }

fmt.Println(s.greeting, s.name)

}

Getters / Setters and Scope

There are no Getters / Setters.

A capitalised variable is publicly visible from a package. E.g. Salutation.

Lowercase is not visible.

Constants

package main

import "fmt"

type Salutation struct {
    name string
    greeting string
}

const (
    PI = 3.14
    Language = "Go"
    A = iota
    B = iota
    C = iota
)

func main() {
    var s = Salutation{name: "Bob", greeting: "Hi" }

    fmt.Println(s.greeting, s.name)

    fmt.Println(PI, Language, A, B, C)
}

Outputs:

Hi Bob
3.14 Go 2 3 4

Note on iota. This is used in const delarations to increment numbers.

https://github.com/golang/go/wiki/Iota

A better example of using iotais probably this:

package main

import "fmt"

type Salutation struct {
    name string
    greeting string
}

const (
    PI = 3.14
    Language = "Go"
)

type Weekday int

const (
    Sunday Weekday = iota + 1
    Monday
    Tuesday
    Wednesday
    Thursday
    Friday
    Saturday
)

func main() {
    var s = Salutation{name: "Bob", greeting: "Hi" }

    fmt.Println(s.greeting, s.name)

    fmt.Println(Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday)

}

Note the implicit iotain the const for subsequent Weekdays.

Functions

  • Multiple return values
  • Use like any other type
  • Function literals

Note: function literals aka lambdas or closures are functions without a name.

https://programming.guide/go/anonymous-function-literal-lambda-closure.html

E.g. of function declaration:


package main

import "fmt"

type Salutation struct {
    name string
    greeting string
}

func Greet(salutation Salutation) {
    fmt.Println(salutation.greeting)
    fmt.Println(salutation.name)
}

func main() {
    var s = Salutation{name: "Bob", greeting: "Hi" }

    Greet(s)

}

Order of type and variable name

Note the typecomes after the variable name (i.e. opposite to C).

E.g.

func add(x int, y int) int {
  return x + y
}

This is different to C . For why see https://blog.golang.org/gos-declaration-syntax

Also, if function parameters share a type you can leave the type to the end.

E.g.

func add(x, y int) int {
  return x + y
}

Multiple return values

E.g.

func swap(x, y string) (string, string) {
    return y, x
}

 

Exported names

Names are exported if they begin with a capital letter.

i.e. Pi would be exported but pi would not.

Variable declarations

Multiple declarations:

var i, j int = 1, 2

 

Here k has an implicit type of int.

k := 3

Zero values:

0 for numeric

false for Boolean

"" for strings

Type conversions

E.g.

i := 42

f := float64(i)

u := uint(f)

REPL

Handy online REPL here:

https://tour.golang.org/basics/8

Leave a Reply

Your email address will not be published. Required fields are marked *