Go by Example

From https://gobyexample.com/

Hello World

1
2
3
4
5
6
7
package main
import "fmt"
func main() {
fmt.Println("hello world")
}

Values

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"
func main() {
// golang
fmt.Println("go" + "lang")
// 1+1 = 2
fmt.Println("1+1 =", 1+1)
// 7.0/3/0 = 2.3333333333333335
fmt.Println("7.0/3.0 =", 7.0/3.0)
// false
fmt.Println(true && false)
// true
fmt.Println(true || false)
// false
fmt.Println(!true)
}

Variables

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"
func main() {
// initial
var a string = "initial"
fmt.Println(a)
// 1 2
var b, c int = 1, 2
fmt.Println(b, c)
// true
var d = true
fmt.Println(d)
// 0
var e int
fmt.Println(e)
// short
f := "short"
fmt.Println(f)
}

Constants

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"
import "math"
const s string = "constant"
func main() {
// constant
fmt.Println(s)
const n = 500000000
const d = 3e20 / n
// 6e+11
fmt.Println(d)
// 600000000000
fmt.Println(int64(d))
// -0.28470407323754404
fmt.Println(math.Sin(n))
}

For

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
package main
import "fmt"
func main() {
// 1 \n 2 \n 3
i := 1
for i <= 3 {
fmt.Println(i)
i = i + 1
}
// 7 \n 8 \n 9
for j := 7; j <= 9; j++ {
fmt.Println(j)
}
// loop
for {
fmt.Println("loop")
break
}
// 1 \n 3 \n 5
for n := 0; n <= 5; n++ {
if n%2 == 0 {
continue
}
fmt.Println(n)
}
}

If / Else

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 main() {
// 7 is odd
if 7%2 == 0 {
fmt.Println("7 is even")
} else {
fmt.Println("7 is odd")
}
// 8 is divisible by 4
if 8%4 == 0 {
fmt.Println("8 is divisible by 4")
}
// 9 has 1 digit
if num := 9; num < 0 {
fmt.Println(num, "is negative")
} else if num < 10 {
fmt.Println(num, "has 1 digit")
} else {
fmt.Println(num, "has multiple digits")
}
}

Switch

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
package main
import "fmt"
import "time"
func main() {
// Write 2 as two
i := 2
fmt.Print("Write ", i, " as ")
switch i {
case 1:
fmt.Println("one")
case 2:
fmt.Println("two")
case 3:
fmt.Println("three")
}
// It's a weekday
switch time.Now().Weekday() {
case time.Saturday, time.Sunday:
fmt.Println("It's the weekend")
default:
fmt.Println("It's a weekday")
}
// It's after noon
t := time.Now()
switch {
case t.Hour() < 12:
fmt.Println("It's before noon")
default:
fmt.Println("It's after noon")
}
whatAmI := func(i interface{}) {
switch t := i.(type) {
case bool:
fmt.Println("I'm a bool")
case int:
fmt.Println("I'm an int")
default:
fmt.Printf("Don't know type %T\n", t)
}
}
// I'm a bool
whatAmI(true)
// I'm an int
whatAmI(1)
// Don't know type string
whatAmI("hey")
}

Arrays

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 "fmt"
func main() {
// emp: [0 0 0 0 0]
var a [5]int
fmt.Println("emp:", a)
a[4] = 100
// set: [0 0 0 0 100]
fmt.Println("set:", a)
// get: 100
fmt.Println("get:", a[4])
// len: 5
fmt.Println("len:", len(a))
b := [5]int{1, 2, 3, 4, 5}
// dcl: [1 2 3 4 5]
fmt.Println("dcl:", b)
var twoD [2][3]int
for i := 0; i < 2; i++ {
for j := 0; j < 3; j++ {
twoD[i][j] = i + j
}
}
// 2d: [[0 1 2] [1 2 3]]
fmt.Println("2d: ", twoD)
}

Slices

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
package main
import "fmt"
func main() {
// emp: [ ]
s := make([]string, 3)
fmt.Println("emp:", s)
s[0] = "a"
s[1] = "b"
s[2] = "c"
// set: [a b c]
fmt.Println("set:", s)
// get: c
fmt.Println("get:", s[2])
// len: 3
fmt.Println("len:", len(s))
s = append(s, "d")
s = append(s, "e", "f")
// apd: [a b c d e f]
fmt.Println("apd:", s)
c := make([]string, len(s))
copy(c, s)
// cpy: [a b c d e f]
fmt.Println("cpy:", c)
// sl1: [c d e]
l := s[2:5]
fmt.Println("sl1:", l)
// sl2: [a b c d e]
l = s[:5]
fmt.Println("sl2:", l)
// sl3: [c d e f]
l = s[2:]
fmt.Println("sl3:", l)
// dcl: [g h i]
t := []string{"g", "h", "i"}
fmt.Println("dcl:", t)
// 2d: [[0] [1 2] [2 3 4]]
twoD := make([][]int, 3)
for i := 0; i < 3; i++ {
innerLen := i + 1
twoD[i] = make([]int, innerLen)
for j := 0; j < innerLen; j++ {
twoD[i][j] = i + j
}
}
fmt.Println("2d: ", twoD)
}

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
26
27
28
29
30
package main
import "fmt"
func main() {
m := make(map[string]int)
// map: map[k1:7 k2:13]
m["k1"] = 7
m["k2"] = 13
fmt.Println("map:", m)
// v1: 7
// len: 2
v1 := m["k1"]
fmt.Println("v1: ", v1)
fmt.Println("len:", len(m))
// map: map[k1:7]
delete(m, "k2")
fmt.Println("map:", m)
// prs: false
_, prs := m["k2"]
fmt.Println("prs:", prs)
// map: map[foo:1 bar:2]
n := map[string]int{"foo": 1, "bar": 2}
fmt.Println("map:", n)
}

Range

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"
func main() {
nums := []int{2, 3, 4}
sum := 0
for _, num := range nums {
sum += num
}
// sum: 9
fmt.Println("sum:", sum)
// index: 1
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
kvs := map[string]string{"a": "apple", "b": "banana"}
// a -> apple
// b -> banana
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
// key: a
// key: b
for k := range kvs {
fmt.Println("key:", k)
}
// 0 103
// 1 111
for l, c := range "go" {
fmt.Println(l, c)
}
}

Functions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import "fmt"
func plus(a int, b int) int {
return a + b
}
func plusPlus(a, b, c int) int {
return a + b + c
}
func main() {
// 1+2 = 3
res := plus(1, 2)
fmt.Println("1+2 =", res)
// 1+2+3 = 6
res = plusPlus(1, 2, 3)
fmt.Println("1+2+3 =", res)
}

Multiple Return Values

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import "fmt"
func vals() (int, int) {
return 3, 7
}
func main() {
a, b := vals()
// 3
fmt.Println(a)
// 7
fmt.Println(b)
_, c := vals()
// 7
fmt.Println(c)
}

Variadic Functions

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
import "fmt"
func sum(nums ...int) {
fmt.Print(nums, " ")
total := 0
for _, num := range nums {
total += num
}
fmt.Println(total)
}
func main() {
// [1 2] 3
sum(1, 2)
// [1 2 3] 6
sum(1, 2, 3)
// [1 2 3 4] 10
nums := []int{1, 2, 3, 4}
sum(nums...)
}

Closures

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 intSeq() func() int {
i := 0
return func() int {
i += 1
return i
}
}
func main() {
nextInt := intSeq()
// 1
fmt.Println(nextInt())
// 2
fmt.Println(nextInt())
// 3
fmt.Println(nextInt())
// 1
newInt := intSeq()
fmt.Println(newInt())
}

Recursion

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
func fact(n int) int {
if n == 0 {
return 1
}
return n * fact(n-1)
}
func main() {
// 5040
fmt.Println(fact(7))
}

Pointers

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 zeroval(val int) {
val = 0
}
func zeroptr(ptr *int) {
*ptr = 0
}
func main() {
// initlal: 1
i := 1
fmt.Println("initlal:", i)
// zeroval: 1
zeroval(i)
fmt.Println("zeroval:", i)
// zeroprt: 0
zeroptr(&i)
fmt.Println("zeroptr:", i)
// pointer: 0xc082056038
fmt.Println("pointer:", &i)
}

Structs

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"
type person struct {
name string
age int
}
func main() {
// {Bob 20}
fmt.Println(person{"Bob", 20})
// {Alice 30}
fmt.Println(person{name: "Alice", age: 30})
// {Fred 0}
fmt.Println(person{name: "Fred"})
// &{Ann 40}
fmt.Println(&person{name: "Ann", age: 40})
// Sean
s := person{name: "Sean", age: 50}
fmt.Println(s.name)
// 50
sp := &s
fmt.Println(sp.age)
// 52
sp.age = 52
fmt.Println(sp.age)
}

Methods

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 "fmt"
type rect struct {
width, height int
}
func (r *rect) area() int {
return r.width * r.height
}
func (r rect) perim() int {
return 2*r.width + 2*r.height
}
func main() {
// area: 50
// perim: 30
r := rect{width: 10, height: 5}
fmt.Println("area:", r.area())
fmt.Println("perim:", r.perim())
// area: 50
// perim: 30
rp := &r
fmt.Println("area:", rp.area())
fmt.Println("perim:", rp.perim())
}

Interfaces

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
package main
import "fmt"
import "math"
type geometry interface {
area() float64
perim() float64
}
type rect struct {
width, height float64
}
type circle struct {
redius float64
}
func (r rect) area() float64 {
return r.width * r.height
}
func (r rect) perim() float64 {
return 2*r.width + 2*r.height
}
func (c circle) area() float64 {
return math.Pi * c.redius * c.redius
}
func (c circle) perim() float64 {
return 2 * math.Pi * c.redius
}
func measure(g geometry) {
fmt.Println(g)
fmt.Println(g.area())
fmt.Println(g.perim())
}
func main() {
r := rect{width: 3, height: 4}
c := circle{redius: 5}
// {3 4}
// 12
// 14
measure(r)
// {5}
// 78.53981633974483
// 31.41592653589793
measure(c)
}

Errors

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
package main
import "fmt"
import "errors"
func f1(arg int) (int, error) {
if arg == 42 {
return -1, errors.New("can't work with 42")
}
return arg + 3, nil
}
type argError struct {
arg int
prob string
}
func (e *argError) Error() string {
return fmt.Sprintf("%d - %s", e.arg, e.prob)
}
func f2(arg int) (int, error) {
if arg == 42 {
return -1, &argError{arg, "can't work with it"}
}
return arg + 3, nil
}
func main() {
// f1 worked: 10
// f1 failed: cant't work with 42
for _, i := range []int{7, 42} {
if r, e := f1(i); e != nil {
fmt.Println("f1 failed:", e)
} else {
fmt.Println("f1 worked:", r)
}
}
// f2 worked: 10
// f2 failed: 42 - can't work with it
for _, i := range []int{7, 42} {
if r, e := f2(i); e != nil {
fmt.Println("f2 failed:", e)
} else {
fmt.Println("f2 worked:", r)
}
}
// 42
// can't work with it
_, e := f2(42)
if ae, ok := e.(*argError); ok {
fmt.Println(ae.arg)
fmt.Println(ae.prob)
}
}

Goroutines

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 "fmt"
func f(from string) {
for i := 0; i < 3; i++ {
fmt.Println(from, ":", i)
}
}
func main() {
f("direct")
go f("goroutine")
go func(msg string) {
fmt.Println(msg)
}("going")
var input string
fmt.Scanln(&input)
fmt.Println("done")
// direct : 0
// direct : 1
// direct : 2
// goroutine : 0
// going
// goroutine : 1
// goroutine : 2
// <enter>
// done
}

Channels

1
2
3
4
5
6
7
8
9
10
11
package main
import "fmt"
func main() {
messages := make(chan string)
go func() { messages <- "ping" }()
msg := <-messages
fmt.Println(msg)
// ping
}

Channel Buffering

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
func main() {
messages := make(chan string, 2)
messages <- "buffered"
messages <- "channel"
// buffered
fmt.Println(<-messages)
// channel
fmt.Println(<-messages)
}

Channel Synchronization

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"
import "time"
func worker(done chan bool) {
fmt.Print("working...")
time.Sleep(time.Second)
fmt.Println("done")
done <- true
}
func main() {
done := make(chan bool, 1)
go worker(done)
<-done
// working...done
}

Channel Directions

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 ping(pings chan<- string, msg string) {
pings <- msg
}
func pong(pings <-chan string, pongs chan<- string) {
msg := <-pings
pongs <- msg
}
func main() {
pings := make(chan string, 1)
pongs := make(chan string, 1)
ping(pings, "passed message")
pong(pings, pongs)
fmt.Println(<-pongs)
// passed message
}

Select

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"
import "time"
func main() {
c1 := make(chan string)
c2 := make(chan string)
go func() {
time.Sleep(time.Second * 1)
c1 <- "one"
}()
go func() {
time.Sleep(time.Second * 2)
c2 <- "two"
}()
for i := 0; i < 2; i++ {
select {
case msg1 := <-c1:
fmt.Println("received", msg1)
case msg2 := <-c2:
fmt.Println("received", msg2)
}
}
// received one
// reveived two
}

Timeouts

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
package main
import "fmt"
import "time"
func main() {
c1 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
c1 <- "result 1"
}()
// timeout 1
select {
case res := <-c1:
fmt.Println(res)
case <-time.After(time.Second * 1):
fmt.Println("timeout 1")
}
c2 := make(chan string, 1)
go func() {
time.Sleep(time.Second * 2)
c2 <- "result 2"
}()
// result 2
select {
case res := <-c2:
fmt.Println(res)
case <-time.After(time.Second * 3):
fmt.Println("timeout 2")
}
}

Non-Blocking Channel Operations

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
package main
import "fmt"
func main() {
messages := make(chan string)
signals := make(chan bool)
select {
case msg := <-messages:
fmt.Println("received message", msg)
default:
fmt.Println("no message received")
}
msg := "hi"
select {
case messages <- msg:
fmt.Println("sent message", msg)
default:
fmt.Println("no message sent")
}
select {
case msg := <-messages:
fmt.Println("received message", msg)
case sig := <-signals:
fmt.Println("received signal", sig)
default:
fmt.Println("no activity")
}
// no message received
// no message sent
// no activity
}

Closing Channels

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 main() {
jobs := make(chan int, 5)
done := make(chan bool)
go func() {
for {
j, more := <-jobs
if more {
fmt.Println("received job", j)
} else {
fmt.Println("received all jobs")
done <- true
return
}
}
}()
for j := 1; j <= 3; j++ {
jobs <- j
fmt.Println("sent jobs", j)
}
close(jobs)
fmt.Println("sent all jobs")
<-done
// sent jobs 1
// sent jobs 2
// sent jobs 3
// sent all jobs
// received job 1
// received job 2
// received job 3
// received all jobs
}

Range over Channels

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package main
import "fmt"
func main() {
queue := make(chan string, 2)
queue <- "one"
queue <- "two"
close(queue)
for elem := range queue {
fmt.Println(elem)
}
// one
// two
}

Timers

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"
import "time"
func main() {
timer1 := time.NewTimer(time.Second * 2)
<-timer1.C
fmt.Println("Timer 1 expired")
timer2 := time.NewTimer(time.Second)
go func() {
<-timer2.C
fmt.Println("Timer 2 expired")
}()
stop2 := timer2.Stop()
if stop2 {
fmt.Println("Timer 2 stoped")
}
// Timer 1 expired
// Timer 2 stoped
}

Tickers

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"
import "time"
func main() {
ticker := time.NewTicker(time.Millisecond * 500)
go func() {
for t := range ticker.C {
fmt.Println("Tick at", t)
}
}()
time.Sleep(time.Millisecond * 1600)
ticker.Stop()
fmt.Println("Ticker stopped")
// Tick at 2017-01-11 20:29:24.2333714 +0800 CST
// Tick at 2017-01-11 20:29:24.735118 +0800 CST
// Tick at 2017-01-11 20:29:25.2342189 +0800 CST
// Ticker stopped
}

Worker Pools

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
package main
import "fmt"
import "time"
func worker(id int, jobs <-chan int, results chan<- int) {
for j := range jobs {
fmt.Println("worker", id, "started job", j)
time.Sleep(time.Second)
fmt.Println("worker", id, "finished job", j)
results <- j * 2
}
}
func main() {
jobs := make(chan int, 100)
results := make(chan int, 100)
for w := 1; w <= 3; w++ {
go worker(w, jobs, results)
}
for j := 1; j <= 5; j++ {
jobs <- j
}
close(jobs)
for a := 1; a <= 5; a++ {
<-results
}
// worker 3 started job 1
// worker 1 started job 2
// worker 2 started job 3
// worker 3 finished job 1
// worker 3 started job 4
// worker 2 finished job 3
// worker 2 started job 5
// worker 1 finished job 2
// worker 3 finished job 4
// worker 2 finished job 5
}

Rate Limiting

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
package main
import "fmt"
import "time"
func main() {
requests := make(chan int, 5)
for i := 1; i <= 5; i++ {
requests <- i
}
close(requests)
limiter := time.Tick(time.Millisecond * 200)
for req := range requests {
<-limiter
fmt.Println("request", req, time.Now())
}
burstyLimiter := make(chan time.Time, 3)
for i := 0; i < 3; i++ {
burstyLimiter <- time.Now()
}
go func() {
for t := range time.Tick(time.Millisecond * 200) {
burstyLimiter <- t
}
}()
burstyRequests := make(chan int, 5)
for i := 1; i <= 5; i++ {
burstyRequests <- i
}
close(burstyRequests)
for req := range burstyRequests {
<-burstyLimiter
fmt.Println("request", req, time.Now())
}
// request 1 2017-01-26 20:50:07.6919452 +0800 CST
// request 2 2017-01-26 20:50:07.8917206 +0800 CST
// request 3 2017-01-26 20:50:08.0921071 +0800 CST
// request 4 2017-01-26 20:50:08.2925082 +0800 CST
// request 5 2017-01-26 20:50:08.4923916 +0800 CST
// request 1 2017-01-26 20:50:08.4923916 +0800 CST
// request 2 2017-01-26 20:50:08.4940956 +0800 CST
// request 3 2017-01-26 20:50:08.4940956 +0800 CST
// request 4 2017-01-26 20:50:08.694855 +0800 CST
// request 5 2017-01-26 20:50:08.8945135 +0800 CST
}

Atomic Counters

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"
import "time"
import "sync/atomic"
func main() {
var ops uint64 = 0
for i := 0; i < 50; i++ {
go func() {
for {
atomic.AddUint64(&ops, 1)
time.Sleep(time.Millisecond)
}
}()
}
time.Sleep(time.Second)
opsFinal := atomic.LoadUint64(&ops)
// ops 31202
fmt.Println("ops", opsFinal)
}

Mutexes

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
package main
import (
"fmt"
"math/rand"
"sync"
"sync/atomic"
"time"
)
func main() {
var state = make(map[int]int)
var mutex = &sync.Mutex{}
var readOps uint64 = 0
var writeOps uint64 = 0
for r := 0; r < 100; r++ {
go func() {
total := 0
for {
key := rand.Intn(5)
mutex.Lock()
total += state[key]
mutex.Unlock()
atomic.AddUint64(&readOps, 1)
time.Sleep(time.Millisecond)
}
}()
}
for w := 0; w < 10; w++ {
go func() {
for {
key := rand.Intn(5)
val := rand.Intn(100)
mutex.Lock()
state[key] = val
mutex.Unlock()
atomic.AddUint64(&writeOps, 1)
time.Sleep(time.Millisecond)
}
}()
}
time.Sleep(time.Second)
// readOps: 61609
readOpsFinal := atomic.LoadUint64(&readOps)
fmt.Println("readOps:", readOpsFinal)
// writeOps: 6197
writeOpsFinal := atomic.LoadUint64(&writeOps)
fmt.Println("writeOps:", writeOpsFinal)
// state: map[1:91 0:88 2:35 3:92 4:20]
mutex.Lock()
fmt.Println("state:", state)
mutex.Unlock()
}

Stateful Goroutines

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
package main
import (
"fmt"
"math/rand"
"sync/atomic"
"time"
)
type readOp struct {
key int
resp chan int
}
type writeOp struct {
key int
val int
resp chan bool
}
func main() {
var readOps uint64 = 0
var writeOps uint64 = 0
reads := make(chan *readOp)
writes := make(chan *writeOp)
go func() {
var state = make(map[int]int)
for {
select {
case read := <-reads:
read.resp <- state[read.key]
case write := <-writes:
state[write.key] = write.val
write.resp <- true
}
}
}()
for r := 0; r < 100; r++ {
go func() {
for {
read := &readOp{
key: rand.Intn(5),
resp: make(chan int)}
reads <- read
<-read.resp
atomic.AddUint64(&readOps, 1)
time.Sleep(time.Millisecond)
}
}()
}
for w := 0; w < 10; w++ {
go func() {
for {
write := &writeOp{
key: rand.Intn(5),
val: rand.Intn(100),
resp: make(chan bool)}
writes <- write
<-write.resp
atomic.AddUint64(&writeOps, 1)
time.Sleep(time.Millisecond)
}
}()
}
time.Sleep(time.Second)
// readOps: 59638
readOpsFinal := atomic.LoadUint64(&readOps)
fmt.Println("readOps:", readOpsFinal)
// writeOps: 6562
writeOpsFinal := atomic.LoadUint64(&writeOps)
fmt.Println("writeOps:", writeOpsFinal)
}

Sorting

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"
import "sort"
func main() {
// Strings: [a b c]
strs := []string{"c", "a", "b"}
sort.Strings(strs)
fmt.Println("Strings:", strs)
// Ints: [2 4 7]
ints := []int{7, 2, 4}
sort.Ints(ints)
fmt.Println("Ints:", ints)
// Sorted: true
s := sort.IntsAreSorted(ints)
fmt.Println("Sorted:", s)
}

Sorting by Functions

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"
import "sort"
type ByLength []string
func (s ByLength) Len() int {
return len(s)
}
func (s ByLength) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
}
func (s ByLength) Less(i, j int) bool {
return len(s[i]) < len(s[j])
}
func main() {
fruits := []string{"peach", "banana", "kiwi"}
sort.Sort(ByLength(fruits))
fmt.Println(fruits)
// [kiwi peach banana]
}

Panic

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import "os"
func main() {
// panic: a problem
panic("a problem")
// goroutine 1 [running]:
// panic(0x491380, 0xc082008200)
// C:/Go/src/runtime/panic.go:481 +0x3f4
// main.main()
// D:/gobyexample/src/t.go:7 +0x6c
// exit status 2
_, err := os.Create("./tmp/file")
if err != nil {
panic(err)
}
}

Defer

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
package main
import "os"
import "fmt"
func main() {
f := createFile("./tmp/defer.txt")
defer closeFile(f)
writeFile(f)
// creating
// writing
// closing
}
func createFile(p string) *os.File {
fmt.Println("creating")
f, err := os.Create(p)
if err != nil {
panic(err)
}
return f
}
func writeFile(f *os.File) {
fmt.Println("writing")
fmt.Fprintln(f, "data")
}
func closeFile(f *os.File) {
fmt.Println("closing")
f.Close()
}

Collection Functions

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
package main
import "fmt"
import "strings"
func Index(vs []string, t string) int {
for i, v := range vs {
if v == t {
return i
}
}
return -1
}
func Include(vs []string, t string) bool {
return Index(vs, t) >= 0
}
func Any(vs []string, f func(string) bool) bool {
for _, v := range vs {
if f(v) {
return true
}
}
return false
}
func All(vs []string, f func(string) bool) bool {
for _, v := range vs {
if !f(v) {
return false
}
}
return true
}
func Filter(vs []string, f func(string) bool) []string {
vsf := make([]string, 0)
for _, v := range vs {
if f(v) {
vsf = append(vsf, v)
}
}
return vsf
}
func Map(vs []string, f func(string) string) []string {
vsm := make([]string, len(vs))
for i, v := range vs {
vsm[i] = f(v)
}
return vsm
}
func main() {
// 2
var strs = []string{"peach", "apple", "pear", "plum"}
fmt.Println(Index(strs, "pear"))
// false
fmt.Println(Include(strs, "grape"))
// true
fmt.Println(Any(strs, func(v string) bool {
return strings.HasPrefix(v, "p")
}))
// false
fmt.Println(All(strs, func(v string) bool {
return strings.HasPrefix(v, "p")
}))
// [peach apple pear]
fmt.Println(Filter(strs, func(v string) bool {
return strings.Contains(v, "e")
}))
// [PEACH APPLE PEAR PLUM]
fmt.Println(Map(strs, strings.ToUpper))
}

String Functions

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"
import s "strings"
var p = fmt.Println
func main() {
p("Contains: ", s.Contains("test", "es"))
p("Count: ", s.Count("test", "t"))
p("HasPrefix:", s.HasPrefix("test", "te"))
p("HasSuffix:", s.HasSuffix("test", "st"))
p("Index: ", s.Index("test", "e"))
p("Join: ", s.Join([]string{"a", "b"}, "-"))
p("Repeat: ", s.Repeat("a", 5))
p("Replace: ", s.Replace("foo", "o", "0", -1))
p("Replace: ", s.Replace("foo", "o", "0", 1))
p("Split: ", s.Split("a-b-c-d-e", "-"))
p("ToLower: ", s.ToLower("TEST"))
p("ToUpper: ", s.ToUpper("test"))
p()
p("Len: ", len("hello"))
p("Char: ", "hello"[1])
// Contains: true
// Count: 2
// HasPrefix: true
// HasSuffix: true
// Index: 1
// Join: a-b
// Repeat: aaaaa
// Replace: f00
// Replace: f0o
// Split: [a b c d e]
// ToLower: test
// ToUpper: TEST
//
// Len: 5
// Char: 101
}

String Formatting

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
package main
import "fmt"
import "os"
type point struct {
x, y int
}
func main() {
p := point{1, 2}
// {1 2}
fmt.Printf("%v\n", p)
// {x:1 y:2}
fmt.Printf("%+v\n", p)
// main.point{x:1, y:2}
fmt.Printf("%#v\n", p)
// main.point
fmt.Printf("%T\n", p)
// true
fmt.Printf("%t\n", true)
// 123
fmt.Printf("%d\n", 123)
// 1110
fmt.Printf("%b\n", 14)
// !
fmt.Printf("%c\n", 33)
// 1c8
fmt.Printf("%x\n", 456)
// 78.900000
fmt.Printf("%f\n", 78.9)
// 1.234000e+08
fmt.Printf("%e\n", 123400000.0)
// 1.234000E+08
fmt.Printf("%E\n", 123400000.0)
// "string"
fmt.Printf("%s\n", "\"string\"")
// "\"string\""
fmt.Printf("%q\n", "\"string\"")
// 6865782074686973
fmt.Printf("%x\n", "hex this")
// 0xc082008260
fmt.Printf("%p\n", &p)
// | 12| 345|
fmt.Printf("|%6d|%6d|\n", 12, 345)
// | 1.20| 3.45|
fmt.Printf("|%6.2f|%6.2f|\n", 1.2, 3.45)
// |1.20 |3.45 |
fmt.Printf("|%-6.2f|%-6.2f|\n", 1.2, 3.45)
// | foo| b|
fmt.Printf("|%6s|%6s|\n", "foo", "b")
// |foo |b |
fmt.Printf("|%-6s|%-6s|\n", "foo", "b")
// a string
s := fmt.Sprintf("a %s", "string")
fmt.Println(s)
// an error
fmt.Fprintf(os.Stderr, "an %s\n", "error")
}

Regular Expressions

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"
import "bytes"
import "regexp"
func main() {
// true
match, _ := regexp.MatchString("p([a-z]+)ch", "peach")
fmt.Println(match)
// true
r, _ := regexp.Compile("p([a-z]+)ch")
fmt.Println(r.MatchString("peach"))
// peach
fmt.Println(r.FindString("peach punch"))
// [0 5]
fmt.Println(r.FindStringIndex("peach punch"))
// [peach ea]
fmt.Println(r.FindStringSubmatch("peach punch"))
// [0 5 1 3]
fmt.Println(r.FindStringSubmatchIndex("peach punch"))
// [peach punch pinch]
fmt.Println(r.FindAllString("peach punch pinch", -1))
// [[0 5 1 3] [6 11 7 9] [12 17 13 15]]
fmt.Println(r.FindAllStringSubmatchIndex("peach punch pinch", -1))
// [peach punch]
fmt.Println(r.FindAllString("peach punch pinch", 2))
// true
fmt.Println(r.Match([]byte("peach")))
// p([a-z]+)ch
r = regexp.MustCompile("p([a-z]+)ch")
fmt.Println(r)
// a <fruit>
fmt.Println(r.ReplaceAllString("a peach", "<fruit>"))
// a PEACH
in := []byte("a peach")
out := r.ReplaceAllFunc(in, bytes.ToUpper)
fmt.Println(string(out))
}

JSON

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
package main
import "os"
import "fmt"
import "encoding/json"
type Response1 struct {
Page int
Fruits []string
}
type Response2 struct {
Page int `json:"page"`
Fruits []string `json:"fruits"`
}
func main() {
// true
bolB, _ := json.Marshal(true)
fmt.Println(string(bolB))
// 1
intB, _ := json.Marshal(1)
fmt.Println(string(intB))
// 2.34
fltB, _ := json.Marshal(2.34)
fmt.Println(string(fltB))
// "gopher"
strB, _ := json.Marshal("gopher")
fmt.Println(string(strB))
// ["apple", "peach", "pear"]
slcD := []string{"apple", "peach", "pear"}
slcB, _ := json.Marshal(slcD)
fmt.Println(string(slcB))
// {"apple":5,"lettuce":7}
mapD := map[string]int{"apple": 5, "lettuce": 7}
mapB, _ := json.Marshal(mapD)
fmt.Println(string(mapB))
// {"Page":1,"Fruits":["apple","peach","pear"]}
res1D := &Response1{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res1B, _ := json.Marshal(res1D)
fmt.Println(string(res1B))
// {"page":1,"fruits":["apple","peach","pear"]}
res2D := &Response2{
Page: 1,
Fruits: []string{"apple", "peach", "pear"}}
res2B, _ := json.Marshal(res2D)
fmt.Println(string(res2B))
// map[num:6.13 strs:[a b]]
byt := []byte(`{"num": 6.13, "strs": ["a", "b"]}`)
var dat map[string]interface{}
if err := json.Unmarshal(byt, &dat); err != nil {
panic(err)
}
fmt.Println(dat)
// 6.13
num := dat["num"].(float64)
fmt.Println(num)
// a
strs := dat["strs"].([]interface{})
str1 := strs[0].(string)
fmt.Println(str1)
// {1 [apple peach]}
// apple
str := `{"page": 1, "fruits": ["apple", "peach"]}`
res := Response2{}
json.Unmarshal([]byte(str), &res)
fmt.Println(res)
fmt.Println(res.Fruits[0])
// {"apple":5,"lettuce":7}
enc := json.NewEncoder(os.Stdout)
d := map[string]int{"apple": 5, "lettuce": 7}
enc.Encode(d)
}

Time

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
package main
import "fmt"
import "time"
func main() {
p := fmt.Println
now := time.Now()
// 2017-01-27 17:10:19.5024236 +0800 CST
p(now)
then := time.Date(2017, 1, 11, 17, 03, 58, 651387237, time.UTC)
// 2017-01-11 17:03:58.651387237 +0000 UTC
p(then)
// 2017
p(then.Year())
// January
p(then.Month())
// 11
p(then.Day())
// 17
p(then.Hour())
// 3
p(then.Minute())
// 58
p(then.Second())
// 651387237
p(then.Nanosecond())
// UTC
p(then.Location())
// Wednesday
p(then.Weekday())
// true
p(then.Before(now))
// false
p(then.After(now))
// false
p(then.Equal(now))
diff := now.Sub(then)
// 376h6m20.851036363s
p(diff)
// 376.1057919545453
p(diff.Hours())
// 22566.347517272716
p(diff.Minutes())
// 1.353980851036363e+06
p(diff.Seconds())
// 1353980851036363
p(diff.Nanoseconds())
// 2017-01-27 09:10:19.5024236 +0000 UTC
p(then.Add(diff))
// 2016-12-27 00:57:37.800350874 +0000 UTC
p(then.Add(-diff))
}

Epoch

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"
import "time"
func main() {
now := time.Now()
secs := now.Unix()
nanos := now.UnixNano()
// 2017-01-27 17:17:49.0002965 +0800 CST
fmt.Println(now)
millis := nanos / 1000000
// 1485508669
fmt.Println(secs)
// 1485508669000
fmt.Println(millis)
// 1485508669000296500
fmt.Println(nanos)
// 2017-01-27 17:17:49 +0800 CST
fmt.Println(time.Unix(secs, 0))
// 2017-01-27 17:17:49.0002965 +0800 CST
fmt.Println(time.Unix(0, nanos))
}

Time Formatting / Parsing

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"
import "time"
func main() {
p := fmt.Println
t := time.Now()
// 2017-01-27T17:29:51+08:00
p(t.Format(time.RFC3339))
t1, e := time.Parse(time.RFC3339, "2017-01-11T17:23:23+00:00")
// 2017-01-11 17:23:23 +0000 +0000
p(t1)
// 5:51PM
p(t.Format("3:05PM"))
// Fri Jan 27 17:53:53 2017
p(t.Format("Mon Jan _2 15:05:05 2006"))
// 2017-01-27T17:53:53.075142+08:00
p(t.Format("2006-01-02T15:05:05.999999-07:00"))
form := "3 05 PM"
t2, e := time.Parse(form, "8 51 PM")
// 0000-01-01 20:00:51 +0000 UTC
p(t2)
// 2017-01-27T17:39:23-00:00
fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
t.Year(), t.Month(), t.Day(),
t.Hour(), t.Minute(), t.Second())
ansic := "Mon Jan _2 15:05:05 2006"
_, e = time.Parse(ansic, "8:51PM")
// parsing time "8:51PM" as "Mon Jan _2 15:05:05 2006": cannot parse "8:51PM" as "Mon"
p(e)
}

Random Numbers

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
package main
import "fmt"
import "time"
import "math/rand"
func main() {
// 81,87
fmt.Print(rand.Intn(100), ",")
fmt.Print(rand.Intn(100))
fmt.Println()
// 0.6645600532184904
fmt.Println(rand.Float64())
// 7.1885709359349015,7.123187485356329
fmt.Print((rand.Float64()*5)+5, ",")
fmt.Print((rand.Float64() * 5) + 5)
fmt.Println()
// 96,16
s1 := rand.NewSource(time.Now().UnixNano())
r1 := rand.New(s1)
fmt.Print(r1.Intn(100), ",")
fmt.Print(r1.Intn(100))
fmt.Println()
// 2,16
s2 := rand.NewSource(83)
r2 := rand.New(s2)
fmt.Print(r2.Intn(100), ",")
fmt.Print(r2.Intn(100))
fmt.Println()
// 2,16
s3 := rand.NewSource(83)
r3 := rand.New(s3)
fmt.Print(r3.Intn(100), ",")
fmt.Print(r3.Intn(100))
fmt.Println()
}

Number Parsing

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"
import "strconv"
func main() {
// 1.234
f, _ := strconv.ParseFloat("1.234", 64)
fmt.Println(f)
// 123
i, _ := strconv.ParseInt("123", 0, 64)
fmt.Println(i)
// 456
d, _ := strconv.ParseInt("0x1c8", 0, 64)
fmt.Println(d)
// 789
u, _ := strconv.ParseUint("789", 0, 64)
fmt.Println(u)
// 135
k, _ := strconv.Atoi("135")
fmt.Println(k)
// strconv.ParseInt: parsing "wat": invalid syntax
_, e := strconv.Atoi("wat")
fmt.Println(e)
}

URL Parsing

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"
import "net"
import "net/url"
func main() {
s := "postgres://user:pass@host.com:5432/path?k=v#f"
// postgres
u, err := url.Parse(s)
if err != nil {
panic(err)
}
fmt.Println(u.Scheme)
// user:pass
fmt.Println(u.User)
// usr
fmt.Println(u.User.Username())
p, _ := u.User.Password()
// pass
fmt.Println(p)
// host.com:5432
fmt.Println(u.Host)
host, port, _ := net.SplitHostPort(u.Host)
// host.com
fmt.Println(host)
// 5432
fmt.Println(port)
// /path
fmt.Println(u.Path)
// f
fmt.Println(u.Fragment)
// k=v
fmt.Println(u.RawQuery)
m, _ := url.ParseQuery(u.RawQuery)
// map[k:[v]]
fmt.Println(m)
// v
fmt.Println(m["k"][0])
}

SHA1 Hashes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main
import "fmt"
import "crypto/sha1"
func main() {
s := "sha1 this string"
h := sha1.New()
h.Write([]byte(s))
bs := h.Sum(nil)
// sha1 this string
fmt.Println(s)
// cf23df2207d99a74fbe169e3eba035e633b65d94
fmt.Printf("%x\n", bs)
}

Base64 Encoding

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main
import "fmt"
import b64 "encoding/base64"
func main() {
data := "abc123!?$*&()'-=@~"
sEnc := b64.StdEncoding.EncodeToString([]byte(data))
// YWJjMTIzIT8kKiYoKSctPUB+
fmt.Println(sEnc)
sDec, _ := b64.StdEncoding.DecodeString(sEnc)
// abc123!?$*&()'-=@~
fmt.Println(string(sDec))
uEnc := b64.URLEncoding.EncodeToString([]byte(data))
// YWJjMTIzIT8kKiYoKSctPUB-
fmt.Println(string(uEnc))
uDec, _ := b64.URLEncoding.DecodeString(uEnc)
// abc123!?$*&()'-=@~
fmt.Println(string(uDec))
}

Reading Files

1
2
echo 'hello' > /tmp/dat
echo 'go' >> /tmp/dat
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
package main
import (
"bufio"
"fmt"
"io"
"io/ioutil"
"os"
)
func check(e error) {
if e != nil {
panic(e)
}
}
func main() {
dat, err := ioutil.ReadFile("/tmp/dat")
check(err)
// hello
// go
fmt.Print(string(dat))
f, err := os.Open("/tmp/dat")
check(err)
b1 := make([]byte, 5)
n1, err := f.Read(b1)
check(err)
// 5 bytes: hello
fmt.Printf("%d bytes: %s\n", n1, string(b1))
o2, err := f.Seek(6, 0)
check(err)
b2 := make([]byte, 2)
n2, err := f.Read(b2)
check(err)
// 2 bytes @ 6: go
fmt.Printf("%d bytes @ %d: %s\n", n2, o2, string(b2))
o3, err := f.Seek(6, 0)
check(err)
b3 := make([]byte, 2)
n3, err := io.ReadAtLeast(f, b3, 2)
check(err)
// 2 bytes @ 6: go
fmt.Printf("%d bytes @ %d: %s\n", n3, o3, string(b3))
_, err = f.Seek(0, 0)
check(err)
r4 := bufio.NewReader(f)
b4, err := r4.Peek(5)
check(err)
// 5 bytes: hello
fmt.Printf("5 bytes: %s\n", string(b4))
f.Close()
}

Writing Files

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
package main
import (
"bufio"
"fmt"
"io/ioutil"
"os"
)
func check(e error) {
if e != nil {
panic(e)
}
}
func main() {
d1 := []byte("hello\ngo\n")
err := ioutil.WriteFile("/tmp/dat1", d1, 0644)
check(err)
f, err := os.Create("/tmp/dat2")
check(err)
defer f.Close()
d2 := []byte{115, 111, 109, 101, 10}
n2, err := f.Write(d2)
check(err)
// wrote 5 bytes
fmt.Printf("wrote %d bytes\n", n2)
n3, err := f.WriteString("writes\n")
// wrote 7 bytes
fmt.Printf("wrote %d bytes\n", n3)
f.Sync()
w := bufio.NewWriter(f)
n4, err := w.WriteString("buffered\n")
// wrote 9 bytes
fmt.Printf("wrote %d bytes\n", n4)
w.Flush()
}
1
2
3
4
5
6
7
cat /tmp/dat1
# hello
# go
cat /tmp/dat2
# some
# writes
# buffered

Line Filters

1
2
3
4
5
echo 'hello' > /tmp/lines
echo 'filter' >> /tmp/lines
cat /tmp/lines | go run line-filters.go
# HELLO
# FILTER
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main
import (
"bufio"
"fmt"
"os"
"strings"
)
func main() {
scanner := bufio.NewScanner(os.Stdin)
for scanner.Scan() {
ucl := strings.ToUpper(scanner.Text())
fmt.Println(ucl)
}
if err := scanner.Err(); err != nil {
fmt.Fprintln(os.Stderr, "error:", err)
os.Exit(1)
}
}

Command-Line Arguments

1
2
go build command-line-arguments.go
./command-line-arguments a b c d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package main
import "fmt"
import "os"
func main() {
argsWithProg := os.Args
argsWithoutProg := os.Args[1:]
arg := os.Args[3]
// [./command-line-arguments a b c d]
fmt.Println(argsWithProg)
// [a b c d]
fmt.Println(argsWithoutProg)
// c
fmt.Println(arg)
}

Command-Line Flags

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
package main
import "fmt"
import "flag"
func main() {
wordPtr := flag.String("word", "foo", "a string")
numPtr := flag.Int("numb", 19, "an int")
boolPtr := flag.Bool("fork", false, "a bool")
var svar string
flag.StringVar(&svar, "svar", "bar", "a string var")
flag.Parse()
fmt.Println("word:", *wordPtr)
fmt.Println("numb:", *numPtr)
fmt.Println("fork:", *boolPtr)
fmt.Println("svar:", svar)
fmt.Println("tail:", flag.Args())
}
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
go build command-line-flags.go
./command-line-flags -word=opt -numb=7 -fork -svar=flag
# word: opt
# numb: 7
# fork: true
# svar: flag
# tail: []
./command-line-flags -word=opt
# word: opt
# numb: 19
# fork: false
# svar: bar
# tail: []
./command-line-flags -word=opt a1 a2 a3
# word: opt
# numb: 19
# fork: false
# svar: bar
# tail: [a1 a2 a3]
./command-line-flags -word=opt a1 a2 a3 -numb=7
# word: opt
# numb: 19
# fork: false
# svar: bar
# tail: [a1 a2 a3 -numb=7]
./command-line-flags -h
# Usage of ./command-line-flags:
# -fork=false: a bool
# -numb=19: an int
# -svar="bar": a string var
# -word="foo": a string
./command-line-flags -wat
# flag provided but not defined: -wat
# Usage of ./command-line-flags:
# -fork=false: a bool
# -numb=19: an int
# -svar="bar": a string var
# -word="foo": a string

Environment Variables

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package main
import "fmt"
import "os"
import "strings"
func main() {
os.Setenv("FOO", "1")
fmt.Println("FOO:", os.Getenv("FOO"))
fmt.Println("BAR:", os.Getenv("BAR"))
fmt.Println()
for _, e := range os.Environ() {
pair := strings.Split(e, "=")
fmt.Println(pair[0])
}
}
1
2
3
4
5
6
7
8
9
10
11
go run environment-variables.go
# FOO: 1
# BAR:
#
# ...
BAR=2 go run environment-variables.go
# FOO: 1
# BAR: 2
#
# ...

Spawning Processes

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
package main
import "fmt"
import "io/ioutil"
import "os/exec"
func main() {
dateCmd := exec.Command("date")
dateOut, err := dateCmd.Output()
if err != nil {
panic(err)
}
fmt.Println("> date")
fmt.Println(string(dateOut))
grepCmd := exec.Command("grep", "hello")
grepIn, _ := grepCmd.StdinPipe()
grepOut, _ := grepCmd.StdoutPipe()
grepCmd.Start()
grepIn.Write([]byte("hello grep\ngoodbye grep"))
grepIn.Close()
grepBytes, _ := ioutil.ReadAll(grepOut)
grepCmd.Wait()
fmt.Println("> grep hello")
fmt.Println(string(grepBytes))
lsCmd := exec.Command("bash", "-c", "ls -a -l -h")
lsOut, err := lsCmd.Output()
if err != nil {
panic(err)
}
fmt.Println("> ls -a -l -h")
fmt.Println(string(lsOut))
}

Exec'ing Processes

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package main
import "syscall"
import "os"
import "os/exec"
func main() {
binary, lookErr := exec.LookPath("ls")
if lookErr != nil {
panic(lookErr)
}
args := []string{"ls", "-a", "-l", "-h"}
env := os.Environ()
execErr := syscall.Exec(binary, args, env)
if execErr != nil {
panic(execErr)
}
}

Signals

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 "syscall"
import "os"
import "os/signal"
import "fmt"
func main() {
sigs := make(chan os.Signal, 1)
done := make(chan bool, 1)
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
go func() {
sig := <-sigs
fmt.Println()
fmt.Println(sig)
done <- true
}()
fmt.Println("awaiting signal")
<-done
fmt.Println("exiting")
// awaiting signal
// ^C
// interrupt
// exiting
}

Exit

1
2
3
4
5
6
7
8
9
10
package main
import "fmt"
import "os"
func main() {
defer fmt.Println("!")
os.Exit(3)
// exit status 3
}