Go Basics

Resources: http://golang.org/

Install and Setup

sudo apt-get install golang

http://golang.org/doc/code.html discusses setting up the GOLANG environment variable and your code repository

mkdir -p $HOME/projects/go/src
export GOPATH=$HOME/projects/go (add this to .profile too)

Hello World

// hello.go
package main

import (   
    "fmt"
    "os"
    "strings"
)

func main() {
    who := "World!"  
    if len(os.Args) > 1 { /* os.Args[0] is "hello" or "hello.exe" */  
        who = strings.Join(os.Args[1:], " ")  
    }
    fmt.Println("Hello", who)  
}

Commands

godoc -http=:8000                 # host docs at http://localhost:8000
go build                          # create binary file in local directory
go install                        # create binary file in $GOPATH/bin
go run                            # just run it, disposing of binary
go get github.com/nsf/gocode      # grab a remote package and install it to $GOPATH/bin
go get -u github.com/nsf/gocode   # update to latest version of remote package

Packages

• Every file should begin with a package statement.
• A package may be defined across several files.
• Code execution begins with a main() function inside package main

Comments

// for end-of-line
/* for multiline */

Constants and Variables

count, err = fmt.Println(x) // get number of bytes printed and error
count, _ = fmt.Println(x)   // get number of bytes printed; discard error
_, err = fmt.Println(x)     // discard number of bytes printed; get error
fmt.Println(x)              // ignore return values
const limit = 512        // constant; type-compatible with any number
const top uint16 = 1421  // constant; type: uint16
start := -19             // variable; inferred type: int
end := int64(9876543210) // variable; type: int64
var i int                // variable; value 0; type: int
var debug = false        // variable; inferred type: bool
checkResults := true     // variable; inferred type: bool
stepSize := 1.5          // variable; inferred type: float64
acronym := "FOSS"        // variable; inferred type: string
i, j := 56, 67   // multiple assignment

Enumerations

const Cyan = 0     // one-per-line
const Magenta = 1
const Yellow = 2

const (            // grouped
    Cyan    = 0
    Magenta = 1
    Yellow  = 2
)

const (            // using iota
    Cyan    = iota // 0
    Magenta        // 1
    Yellow         // 2
)

type BitFlag int   // different example
const (
    Active  BitFlag = 1 << iota            // (1 << 0 == 1)
    Send    // Implicitly BitFlag = 1 << iota (1 << 1 == 2)
    Receive // Implicitly BitFlag = 1 << iota (1 << 2 == 4)
)
flag := Active | Send

Numeric type conversions

const factor = 3 // factor is compatible with any numeric type
i := 20000       // i is of type int by inference
i *= factor
j := int16(20)   // j is of type int16; same as: var j int16 = 20
i += int(j)      // Types must match so conversion is required
k := uint8(0)    // Same as: var k uint8
k = uint8(i)     // Succeeds, but k's value is truncated to 8 bits ✗
fmt.Println(i, j, k) // Prints: 60020 20 116

func Uint8FromInt(x int) (uint8, error) {
    if 0 <= x && x <= math.MaxUint8 {
        return uint8(x), nil
    }
    return 0, fmt.Errorf("%d is out of the uint8 range", x)
}

Types

Boolean

bool (true or false)

Integer

byte (synonym for uint8)
int (int32 or int64)
int8, int16, int32, int64
rune (synonym for int32, used for UTF-8 code points)
uint (uint32 or uint64)
uint8, uint16, uint32, uint64
uintptr (uint that stores a pointer)

Bitwise Operations on Integers

x & y	// The bitwise AND of x and y
x | y	// The bitwise OR of x and y
x ^ y	// The bitwise XOR of x and y
x &^ y	// The bitwise clear (AND NOT) of x and y
x << u	// The result of left-shifting x by unsigned int u shifts
x >> u	// The result of right-shifting x by unsigned int u shifts

Floating-Point

float32, float64
complex64, complex128

f := 3.2e5                       // type: float64
x := -7.3 - 8.9i                 // type: complex128 (literal)
y := complex64(-18.3 + 8.9i)     // type: complex64 (conversion) 
z := complex(f, 13.2)            // type: complex128 (construction) 
fmt.Println(x, real(y), imag(z)) // Prints: (-7.3-8.9i) -18.3 13.2

Strings

text1 := "\"what's that?\", he said" // Interpreted string literal
text2 := `"what's that?", he said`   // Raw string literal
radicals := "√ \u221A \U0000221a"    // radicals == "√ √ √"
book := "The Spirit Level" +                     // String concatenation
        " by Richard Wilkinson"
book += " and Kate Pickett"                      // String append
fmt.Println("Josey" < "José", "Josey" == "José") // String comparisons

Efficient String Append

var buffer bytes.Buffer
for {
    if piece, ok := getNextValidString(); ok {
        buffer.WriteString(piece)
    } else {
        break
    }
}
fmt.Print(buffer.String(), "\n")

Anatomy of a string

s := "naïve"
fmt.Println(s, len(s))     // prints "naïve 6"

Slicing Strings

line := "røde og gule sløjfer"
i := strings.Index(line, " ")     // Get the index of the first space
firstWord := line[:i]             // Slice up to the first space
j := strings.LastIndex(line, " ") // Get the index of the last space
lastWord := line[j+1:]            // Slice from after the last space
fmt.Println(firstWord, lastWord)  // Prints: røde sløjfer

Anatomy of a string with whitespace

line := "rå tørt\u2028vær"
i := strings.IndexFunc(line, unicode.IsSpace)     // i == 3
firstWord := line[:i]
j := strings.LastIndexFunc(line, unicode.IsSpace) // j == 9
_, size := utf8.DecodeRuneInString(line[j:])      // size == 3
lastWord := line[j+size:]                         // j + size == 12
fmt.Println(firstWord, lastWord)                  // Prints: rå vær