Golang Notes

Basics

Packages

every go program is made up of packages, and it starts from: package main,
func main()

packages could be imported, and grouped together using parenthesis
(“factored” import statements)

1
2
import "fmt"
import "math"

same as:

1
2
3
4
import (
  "fmt"
  "math"
)

Only capitalized names are exported, therefore after importing a package, you
can only reference its exported names.

Basic Types

 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
package main

import (
  "fmt"
  "math/cmplx"
)

// bool

// string

// int int8 int16 int32 int 64
// uint uint8 uint16 uint32 uint64 unitptr

// bytes // alias for uint8

// rune // alias for int32, represents a unicode code point

// float32 float64

// complex64 complex128

var (
  ToBe   bool       = false
  MaxInt uint64     = 1<<64 - 1
  z      complex128 = cmplx.Sqrt(-5 + 12i)
)

func main() {
  fmt.Printf("Type: %T Value: %v\n", ToBe, ToBe)
  fmt.Printf("Type: %T Value: %v\n", MaxInt, MaxInt)
  fmt.Printf("Type: %T Value: %v\n", z, z)
}

the int, uint, and uintptr types are usually 32 bits on 32-bit systems and 64
bits on 64-bit systems.

Variables

Two ways to declare a variable:

var
- with or without initializer (implicitly initialized with zero value)
- package or function scope
:= short assignment statements
- only function scope
- must have initializers

With an explicit initializer, no need to provide the type of the variable.

Apart from variables, there are constants, which:

can be declared in package or function level
must have explicit initializers (also constants, value known at compile time)
cannot be reassigned after initialization.

Multiple var or const statements could be grouped together like imports.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
// with initializer
var i, j int = 1, 2
// omit type (type inference)
var i, j = 1, 2
// short variable declarations (also type inference)
a := 3 // int
b := 3.14 // float64
c := 0.1 + 0.2i

// constants
const Pi = 3.14
// numeric constants are high-precision values
const (
  Big = 1 << 100    // 1 << 100
  Small = Big >> 99 // 2
)

Functions

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
// type comes after variable name.
func add(x int, y int) int {
  return x + y;
}

// consecutive named function parameters share a type
func add(x, y int) int {
  return x + y;
}

// function can return any number of results
func swap(x, y string) (string, string) {
  return y, x
}

// naked return: a return without arguments, can harm readability in longer
// functions
func split(sum int) (x, y int) {
  x = sum * 4 / 9
  y = sum - x
  return
}

Methods

Go has no classes, but you can define methods on types. A method is a
function with a special receiver argument.

 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
package main

import (
  "fmt"
  "math"
)

type Vertex struct {
  X, Y float64
}

func (v Vertex) Abs() float64 {
  return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func (v *Vertex) Scale(f float64) {
  v.X = v.X * f
  v.Y = v.Y * f
}

func main() {
  v := Vertex{3, 4}
  v.Scale(10)
  fmt.Println(v.Abs()) // 50
}

The method and its receiver type must be defined in the same package.

1
type MyFloat float64 // define your own float64 type

Pointer Receivers or Arguments

Receiver is just another argument, it can be nil.

If you wanna modify or not copying an argument, you should pass pointer
types.

In general, all methods on a given type should have either value or pointer
receivers, but not a mixture of both.

Type conversions

T(v) converts the value v to the type T.

1
2
3
i := 42
f := float64(i)
u := uint(f)

no implicit conversion in go

Control FLow

For

Go only has for loop, no while loop, each for loop has three basic
components:

init statement
condition statement
post statement (execute after each iteration)

no parentheses, but curly braces {} are always required.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
package main

import "fmt"

func main() {
  sum := 0
  for i := 0; i < 10; i++ {
    sum += i
  }
  fmt.Println(sum)
}

any of the three components can be omitted, if you only have condition or
nothing left, semicolon can be omitted.

1
2
3
4
5
6
7
8
9
sum := 0
// just like while loop
for sum < 1000 {
  sum++
}

for {
  // loop forever
}

you can continue or break inside a loop

If

like for loops, no parentheses (), but curly braces {} are required

can have init statement

1
2
3
4
5
6
7
if i := 0; i != 0 {
  fmt.Println("what?")
} else if i == 0 {
  fmt.Println("got 0")
} else {
  fmt.Println("no way here")
}

Switch

shorter way to write a sequence of if-else statements.
no break or default fallthrough in switch
cases do need not to be constants or integers.
also support init statements like if and for.

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

import (
  "fmt"
  "runtime"
)

func main() {
  fmt.Print("Go runs on ")
  switch os := runtime.GOOS; os {
  case "darwin":
    fmt.Println("OS X.")
  case "linux":
    fmt.Println("Linux.")
  default:
    // freebsd, openbsd,
    // plan9, windows...
    fmt.Printf("%s.\n", os)
  }
}

you can use fallthrough keyword to fallthrough
mutiple statements in a single case:
omit condition is the same as switch true (clean way to write long
if-then-else chains)

 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
package main

import (
  "fmt"
  "time"
)

func main() {
  t := time.Now()

  // same as: switch true
  switch {
  // default will always be last evaluated
  default:
    fmt.Println("default")
  case t.Hour() < 12:
    fmt.Println("morning")
  case t.Hour() < 17, true: // like useing '||', match any
    fmt.Println("afternoon")
    fallthrough
  case false:
    // even condition is false, fallthrough do fallthrough here
    fmt.Println("Are you ok?")
    // cannot put fallthrough in the last case or default
    // fallthrough
  }
}

Defer

a defer statement defers the execution of a function until the surrounding
function returns.

arguments evaluated immediately, but function call is not executed until the
surrounding function returns.

defered function calls are pushed onto a stack, so executed in last-in-first-outo order

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

import "fmt"

func main() {
  fmt.Println("counting")

  for i := 0; i < 10; i++ {
    defer fmt.Println(i)
  }

  fmt.Println("done")
}

Advanced types

Pointers

A pointer holds the memory address of a value.

Go has no pointer arithmetic.

1
2
3
4
var p *int
i := 42
p = &i // referencing
fmt.Println(*p) // dereferencing

Structs

can be defined inside functions

access struct fileds using a dot

struct fields can also be accessed through a struct pointer, without explicit
dereferencing.

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

import "fmt"

func main() {
  type Vertex struct {
    X int
    Y int
  }
  v := Vertex{1, 2}
  p := &v // pointer to a struct
  v.X = 4
  (*p).Y = 6 // dereference the struct first - cumbersum
  p.Y = 5    // without explicit dereference
  fmt.Println(v)
}

struct literal

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

import "fmt"

type Vertex struct {
  X, Y int
}

func main() {
  var (
    v1 = Vertex{1, 2}  // {1, 2}, has type Vertex
    v2 = Vertex{Y: 1}  // {0, 1}
    v3 = Vertex{}      // {0, 0}
    p  = &Vertex{3, 4} // has type *Vertex
  )

  // {1 2} {0 1} {0 0} &{3 4}
  fmt.Println(v1, v2, v3, p)
}

Arrays

[n]T is an array of n values of type T.

Arrays cannot be resized

1
2
3
4
5
6
7
8
package main

import "fmt"

func main() {
  // [1 2 0]
  fmt.Println([3]int{1, 2})
}

Slices

A slice is a dynamically-sezed, flexible view into the elements of an array.

[n]T is an array of type T and length n.

[]T is a slice of type T, it does not store any data, it just describes a
section of the underlying array.

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

import "fmt"

func main() {
  // array literal
  v := [5]int{1, 2}
  // slice literal
  // v := []int{1, 2, 0, 0, 0}
  v1 := v[1:3]
  fmt.Println(cap(v))  // 5
  fmt.Println(cap(v1)) // 4, counting from first element in the slice
  fmt.Println(len(v1)) // 2
  fmt.Println(v1)      // [2 0]
}

When slicing, you may omit the high or low bounds to use their defaults
instead (0 for low, len for high)

making a slice

1
2
3
4
a := make([]int, 5)    // len(a)=5, cap(a)=5
b := make([]int, 0, 5) // len(b)=0, cap(b)=5
b = b[:cap(b)]         // len(b)=5, cap(b)=5
b = b[1:]              // len(b)=4, cap(b)=4

appending to a slice

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
func printSlice(s []int) {
  fmt.Printf("len=%d, cap=%d, addr=%p, %v\n", len(s), cap(s), &s, s)
}

func main() {
  var s []int
  printSlice(s) // len=0, cap=0
  s = append(s, 0)
  printSlice(s) // len=1, cap=1
  s = append(s, 1)
  printSlice(s) // len=2, cap=2
  s = append(s, 1)
  printSlice(s) // len=3, cap=4
  s = append(s, 1, 2, 3)
  printSlice(s) // len=6, cap=8
}

if the backing array is too small to fit all the given values a bigger array
will be allocated. The returned slice will point to the newly allocated
array.

range

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

import "fmt"

var pow = []int{1, 2, 4, 8, 16, 32, 64, 128}

func main() {
  // for i, _ := range pow
  // for i := range pow
  // for _, v := range pow
  for i, v := range pow {
    fmt.Printf("2**%d = %d\n", i, v)
  }
}

Maps

 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
package main

import "fmt"

type Vertex struct {
  X, Y int
}

func main() {
  var v = map[int]Vertex{
    3: {1, 2},
  }
  // x := v[2]
  x, ok := v[2]
  // ok is false
  if !ok {
    fmt.Println("no v[2]")
    fmt.Printf("x is the zero value of Vertex, which is %v\n", x)
  }
  fmt.Println(v[3])
  // insert or update an element
  v[3] = Vertex{3, 4}
  // delete a key
  delete(v, 3)
}

Function Type

Functions are values too, they can be used as funtion arguments and return
values.

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

import "fmt"

func f(fn func(int) string, x int) string {
  return fn(x)
}

func main() {

  myF := func(x int) string {
    return "xy"
  }

  fmt.Println(f(myF, 3))
}

Receiver is actually the first argument of a method:

 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"
  "math"
)

type Vertex struct {
  X, Y float64
}

func (v Vertex) Abs() float64 {
  return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func (v *Vertex) Scale(f float64) {
  v.X = v.X * f
  v.Y = v.Y * f
}

func f(fn func(Vertex) float64, v *Vertex) {
  fmt.Println(fn(*v))
}

func f2(fn func(*Vertex) float64, v *Vertex) {
  fmt.Println(fn(v))
}

func main() {
  v := Vertex{3, 4}
  f(Vertex.Abs, &v)
  f2((*Vertex).Abs, &v)
  // these two are different function
  // receiver is actually the first argument of method
  fmt.Printf("%T\n", (*Vertex).Scale)
  fmt.Printf("%T\n", v.Scale)
}

A closure is a function value that references variables from outside its
body.

 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 adder() func(int) int {
  sum := 0
  return func(x int) int {
    sum += x
    return sum
  }
}

func main() {
  pos, neg := adder(), adder()
  for i := 0; i < 10; i++ {
    fmt.Println(
      pos(i),
      neg(-2*i),
    )
  }
}

Interfaces

An interface type is a set of method signatures.

An interface value is any type that has implemented those methods
(implemented implicitly, no “implements” keyword).

 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
package main

import (
  "fmt"
  "math"
)

type Abser interface {
  Abs() float64
}

func main() {
  var a Abser
  f := MyFloat(-math.Sqrt2)
  v := Vertex{3, 4}

  a = f  // a MyFloat implements Abser
  a = &v // a *Vertex implements Abser

  // In the following line, v is a Vertex (not *Vertex)
  // and does NOT implement Abser.
  // a = v

  fmt.Println(a.Abs())
}

type MyFloat float64

func (f MyFloat) Abs() float64 {
  if f < 0 {
    return float64(-f)
  }
  return float64(f)
}

type Vertex struct {
  X, Y float64
}

func (v *Vertex) Abs() float64 {
  return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

printing value and type of an interface is the same as printing its
underlying value and type.

 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
package main

import "fmt"

type I interface {
  M()
}

type T struct {
  S string
}

func (t *T) M() {
  if t == nil {
    fmt.Println("<nil>")
    return
  }
  fmt.Println(t.S)
}

func main() {
  var i I

  var t *T
  i = t
  describe(i)
  i.M()

  i = &T{"hello"}
  describe(i)
  i.M()
}

func describe(i I) {
  fmt.Printf("(%v, %T)\n", i, i)
}

The interface that specifies zero methods is known as the empty interface.

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

import "fmt"

func main() {
  var i interface{}
  describe(i)

  i = 42
  describe(i)

  i = "hello"
  describe(i)
}

func describe(i interface{}) {
  fmt.Printf("(%v, %T)\n", i, i)
}

Type assertions

try converting an interface to its underlying value of type T: s := i.(T)

here T must implement methods of i.

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

import "fmt"

func main() {
  var i interface{} = "hello"

  s := i.(string)
  fmt.Println(s)

  s, ok := i.(string)
  fmt.Println(s, ok)

  f, ok := i.(float64)
  fmt.Println(f, ok)

  f = i.(float64) // panic
  fmt.Println(f)
}

 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
package main

import "fmt"

type Vertex struct {
  x, y int
}

// value of type *Vertex can also call method M()
func (Vertex) M() {}

func main() {
  var v Vertex

  var i interface {
    M()
  } = v

  // argument here must implement methods of the interface
  t, ok := i.(*Vertex)
  des(t) // *main.Vertex, <nil>
  chk(t, ok)

  t2, ok := i.(Vertex)
  des(t2) // main.Vertex, {0, 0}
  chk(t2, ok)
}

func des(v interface{}) {
  fmt.Printf("%T, %v\n", v, v)
}

func chk(t interface{}, ok bool) {
  if !ok {
    fmt.Println("type not correct, zero value returned:", t)
  } else {
    fmt.Println("type correct, value is:", t)
  }
}

type switches

 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 do(i interface{}) {
  switch v := i.(type) {
  case int:
    fmt.Printf("Twice %v is %v\n", v, v*2)
  case string:
    fmt.Printf("%q is %v bytes long\n", v, len(v))
  default:
    // here v has the same type as i
    fmt.Printf("I don't know about type %T!\n", v)
  }
}

func main() {
  do(21)
  do("hello")
  do(true)
}

Zero values

variables declared without an explicit initial value are given their zero
value.

0 for numeric types
false for the boolean type
"" (the empty string) for the strings
{<default field values>} for structs
nil for slice (len and cap of a nil slice is 0)
nil for maps
nil for interfaces
nil for pointers

Common Interfaces

Error

When fmt prints values, it looks for the error interface first:

1
2
3
type error interface {
  Error() string
}

if the interface value is not <nil>, the Error() method will be invoked by
fmt to get the error string.

1
2
3
4
5
6
i, err := strconv.Atoi("42")
if err != nil {
  fmt.Printf("couldn't convert number: %v\n", err)
  return
}
fmt.Println("Converted integer:", i)

Do not print the interface value in the Error() method directly, it will cause
infinite loop.

1
2
3
4
5
6
7
type ErrNegativeSqrt float64

func (e ErrNegativeSqrt) Error() string {
  // do not print e directly, infinite loop here
  // fmt.Println(e)
  return fmt.Sprintln("cannot Sqrt negative number: ", float64(e))
}

Reader

the io.Reader interface has a Read method:

1
func (T) Read(b []byte) (n int, err error)

read populates the given byte slice with data and returns the number of bytes
populated and an error value.

it returns an io.EOF error when the stream ends.

 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"
  "io"
  "strings"
)

func main() {
  r := strings.NewReader("Hello, Reader!")

  b := make([]byte, 8)
  for {
    n, err := r.Read(b)
    fmt.Printf("n = %v err = %v b = %v\n", n, err, b)
    fmt.Printf("b[:n] = %q\n", b[:n])
    if err == io.EOF {
      break
    }
  }
}

Image

image.Image defines the Image interface

1
2
3
4
5
type Image interface {
  ColorModel() color.Model
  Bounds() Rectangle
  At(x, y int) color.Color
}

Goroutines

a goroutine is a lightweight thread managed by the Go runtime.

Channels

By default, sends and receives block until the other side is ready. This
allows goroutines to synchronize without explicit locks or condition
variables.

Channels aren’t like files, you don’t usually need to close them. Closing is
only necessary when the receiver must be told there are no more values
coming, such as to terminate a range loop.

 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"

func fib(n int, c chan int) {
  a, b := 0, 1
  for i := 0; i < n; i++ {
    c <- a
    a, b = b, a+b
  }
  close(c)
}

func main() {
  c := make(chan int)
  go fib(10, c)
  for x := range c {
    fmt.Println(x)
  }
  // "ok" is false if there are:
  // 1. no more values to receive
  // 2. and the channel is closed
  // x, ok := <- c
}

Select

select statement lets a goroutine wait on multiple communication
operations.

select blocks until one of its cases can run (by adding a default case,
it won’t block). It chooses one at random if multiple are ready.

 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
package main

import "fmt"

func fibonacci(c, quit chan int) {
  x, y := 0, 1
  for {
    select {
    case c <- x:
      x, y = y, x+y
    case <-quit:
      fmt.Println("quit")
      return
    }
  }
}

func main() {
  c := make(chan int)
  quit := make(chan int)
  go func() {
    for i := 0; i < 10; i++ {
      fmt.Println(<-c)
    }
    quit <- 0
  }()
  fibonacci(c, quit)
}

Mutex

sync.Mutex provides two methods: Lock and Unlock

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
// SafeCounter is safe to use concurrently.
type SafeCounter struct {
  mu sync.Mutex
  v  map[string]int
}

func (c *SafeCounter) Value(key string) int {
  c.mu.Lock()
  // Lock so only one goroutine at a time can access the map c.v.
  defer c.mu.Unlock()
  return c.v[key]
}

Practice

Sqrt

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

import "fmt"

func Sqrt(x float64) (res float64) {
  res = 1.
  diff := 1.
  for diff > 1e-5 || diff < -1e-5 {
    diff = (res*res - x) / (2 * res)
    res -= diff
  }
  return
}

func main() {
  fmt.Println(Sqrt(4))
}

WordCount

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

import (
  "strings"

  "golang.org/x/tour/wc"
)

func WordCount(s string) (m map[string]int) {
  m = make(map[string]int)
  for _, x := range strings.Fields(s) {
    m[x]++
  }
  return m
}

func main() {
  wc.Test(WordCount)
}

Fibonacci closure

 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"

// fibonacci is a function that returns
// a function that returns an int.
func fibonacci() func() int {
  a, b := 0, 1
  return func() int {
    ret := a
    a, b = b, a + b
    return ret
  }
}

func main() {
  f := fibonacci()
  for i := 0; i < 10; i++ {
    fmt.Println(f())
  }
}

Sqrt with Error Handling

 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"
  "math"
)

type ErrNegativeSqrt float64

func (e ErrNegativeSqrt) Error() string {
  // float64(e) here is important
  // fmt.Sprint(e) will cause infinite loop!
  return fmt.Sprint("cannot Sqrt negative number:", float64(e))
}

func Sqrt(x float64) (float64, error) {
  if x < 0 {
    return x, ErrNegativeSqrt(x)
  }
  return math.Sqrt(x), nil
}

func main() {
  fmt.Println(Sqrt(2))
  fmt.Println(Sqrt(-2))
}

rot13Reader

 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
package main

import (
  "io"
  "os"
  "strings"
)

type rot13Reader struct {
  r io.Reader
}

func (rot13reader rot13Reader) Read(b []byte) (int, error) {
  n, err := rot13reader.r.Read(b)
  if err != nil {
    return 0, io.EOF
  }
  for i := 0; i < n; i++ {
    switch c := b[i]; {
    case c >= 'A' && c <= 'Z':
      b[i] = 'A' + (b[i]-'A'+13)%26
    case c >= 'a' && c <= 'z':
      b[i] = 'a' + (b[i]-'a'+13)%26
    }
  }
  return n, nil
}

func main() {
  s := strings.NewReader("Lbh penpxrq gur pbqr!")
  r := rot13Reader{s}
  io.Copy(os.Stdout, &r)
}

Implement Image interface

 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

import (
  "image"
  "image/color"

  "golang.org/x/tour/pic"
)

type Image struct {
  w, h int
}

func (img Image) ColorModel() color.Model {
  return color.RGBAModel
}

func (img Image) Bounds() image.Rectangle {
  return image.Rect(0, 0, img.w, img.h)
}

func (img Image) At(x, y int) color.Color {
  return color.RGBA{uint8(x + y), uint8(x + y), 255, 255}
}

func main() {
  m := Image{100, 100}
  pic.ShowImage(m)
}

Web Crawler

  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
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
package main

import (
  "fmt"
  "sync"
)

type Fetcher interface {
  // Fetch returns the body of URL and
  // a slice of URLs found on that page.
  Fetch(url string) (body string, urls []string, err error)
}

type url2Dep struct {
  mu sync.Mutex
  mp map[string]int
}

func (u *url2Dep) insertUrl(url string, dep int) {
  u.mu.Lock()
  defer u.mu.Unlock()
  u.mp[url] = dep
}

func (u *url2Dep) getDep(url string) (int, bool) {
  u.mu.Lock()
  defer u.mu.Unlock()
  dep, ok := u.mp[url]
  return dep, ok
}

// Crawl uses fetcher to recursively crawl
// pages starting with url, to a maximum of depth.
func Crawl(u *url2Dep, url string, depth int, fetcher Fetcher) {
  defer wg.Done()
  if depth <= 0 {
    return
  }
  if dep, ok := u.getDep(url); !ok || dep < depth {
    u.insertUrl(url, depth)
  } else {
    fmt.Printf("visited: %s\n", url)
    return
  }
  body, urls, err := fetcher.Fetch(url)
  if err != nil {
    fmt.Println(err)
    return
  }
  fmt.Printf("found: %s %q\n", url, body)
  for _, nextUrl := range urls {
    wg.Add(1)
    go Crawl(u, nextUrl, depth-1, fetcher)
  }
}

var wg sync.WaitGroup

func main() {
  u := url2Dep{mp: make(map[string]int)}
  wg.Add(1)
  go Crawl(&u, "https://golang.org/", 4, fetcher)
  wg.Wait()
}

// fakeFetcher is Fetcher that returns canned results.
type fakeFetcher map[string]*fakeResult

type fakeResult struct {
  body string
  urls []string
}

func (f fakeFetcher) Fetch(url string) (string, []string, error) {
  if res, ok := f[url]; ok {
    return res.body, res.urls, nil
  }
  return "", nil, fmt.Errorf("not found: %s", url)
}

// fetcher is a populated fakeFetcher.
var fetcher = fakeFetcher{
  "https://golang.org/": &fakeResult{
    "The Go Programming Language",
    []string{
      "https://golang.org/pkg/",
      "https://golang.org/cmd/",
    },
  },
  "https://golang.org/pkg/": &fakeResult{
    "Packages",
    []string{
      "https://golang.org/",
      "https://golang.org/cmd/",
      "https://golang.org/pkg/fmt/",
      "https://golang.org/pkg/os/",
    },
  },
  "https://golang.org/pkg/fmt/": &fakeResult{
    "Package fmt",
    []string{
      "https://golang.org/",
      "https://golang.org/pkg/",
    },
  },
  "https://golang.org/pkg/os/": &fakeResult{
    "Package os",
    []string{
      "https://golang.org/",
      "https://golang.org/pkg/",
    },
  },
}