Basic Concepts

Question 1

Packages

Answer 1

Programs start running in package main.
package main

import (
“fmt”
“math/rand”
)

func main() {
}

Question 2

Imports

Answer 2

import (
    "fmt"
    "math"
)
-OR-
import "fmt"
import "math"

Question 3

Exported names

Answer 3

After importing a package, you can refer to the names it exports.

In Go, a name is exported if it begins with a capital letter.

Question 4

Functions

Answer 4

func add(x int, y int) int {
    return x + y
}
-OR-
When two or more consecutive named function parameters share a type, you can omit the type from all but the last.

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

Question 5

Multiple results

Answer 5

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

Question 6

Named results

Answer 6

If the result parameters are named, a return statement without arguments returns the current values of the results.

func split(sum int) (x, y int) {
    x = sum * 4 / 9
    y = sum - x
    return
}

Question 7

Variables

Answer 7

var x, y, z int

var c, python, java bool

Question 8

Variables with initializers

Answer 8

A var declaration can include initializers, one per variable.

If an initializer is present, the type can be omitted; the variable will take the type of the initializer.

var x, y, z int = 1, 2, 3
var c, python, java = true, false, “no!”

Question 9

Short variable declarations
:=
Inside or outside available?

Answer 9

Inside a function, the := short assignment statement can be used in place of a var declaration with implicit type.

Outside a function, every construct begins with a keyword (var, func, and so on) and the := construct is not available.

func main() {
    var x, y, z int = 1, 2, 3
    c, python, java := true, false, "no!"

fmt.Println(x, y, z, c, python, java) }

Question 10

Go’s basic types are

Answer 10

bool

string

int int8 int16 int32 int64
uint uint8 uint16 uint32 uint64 uintptr

byte // alias for uint8

rune // alias for int32
     // represents a Unicode code point

float32 float64

complex64 complex128

Question 11

Constants

Answer 11

Constants are declared like variables, but with the const keyword.

Constants can be character, string, boolean, or numeric values.

Constants cannot be declared using the := syntax.

const Pi = 3.14

Question 12

Numeric Constants

Answer 12

Numeric constants are high-precision values.

An untyped constant takes the type needed by its context.

const (
Big = 1 &laquo_space;100
Small = Big&raquo_space; 99
)

Question 13

For Loop

Answer 13

Go has only one looping construct, the for loop.

The basic for loop looks as it does in C or Java, except that the ( ) are gone (they are not even optional) and the { } are required.

sum := 0
for i := 0; i < 10; i++ {
    sum += i
}

Question 14

For continued

Answer 14

As in C or Java, you can leave the pre and post statements empty.

sum := 1
for ; sum < 1000; {
    sum += sum
}

Question 15

For is Go’s “while”

Answer 15

At that point you can drop the semicolons: C’s while is spelled for in Go.

sum := 1
for sum < 1000 {
    sum += sum
}

Question 16

Forever

Answer 16

for {

}

Question 17

if statement

Answer 17

The if statement looks as it does in C or Java, except that the ( ) are gone and the { } are required.

    if x < 0 {
        return sqrt(-x) + "i"
    }

Question 18

If with a short statement

Answer 18

Like for, the if statement can start with a short statement to execute before the condition.

Variables declared by the statement are only in scope until the end of the if.

if v := math.Pow(x, n); v < lim {
    return v
}

Question 19

If and else

Answer 19

Variables declared inside an if short statement are also available inside any of the else blocks.

func pow(x, n, lim float64) float64 {
    if v := math.Pow(x, n); v < lim {
        return v
    } else {
        fmt.Printf("%g >= %g\n", v, lim)
    }
    // can't use v here, though
    return lim
}