Kezunlin's Blog

Live and Learn

0%

your first golang tutorial

Posted on Edited on In

go tutorial

versions:

  • go: 1.13.1

install

1
2
3
4
5
6
7
8
9
wget https://dl.google.com/go/go1.13.1.linux-amd64.tar.gz
sudo tar -C /usr/local -xzf go1.13.1.linux-amd64.tar.gz

ll /usr/local/go

vim ~/.bashrc
export PATH=$PATH:/usr/local/go/bin

source ~/.bashrc

zsh uses env profile ~/.zshrc, bash use env profile ~/.bashrc.

check version

1
2
go version
go version go1.13.1 linux/amd64

uninstall

just delete /usr/local/go

set GOPATH

Create your workspace directory, $HOME/go.

The GOPATH environment variable specifies the location of your workspace. If no GOPATH is set, it is assumed to be $HOME/go on Unix systems.

Note that GOPATH must not be the same path as your Go installation.

issue the commands

1
2
3
4
5
6
7
8
9
10
11
12
13
14
vim .bashrc 
# for golang
export GOPATH=$HOME/go
export PATH=/usr/local/go/bin:$GOPATH:$PATH

source .bashrc

#go env -w GOPATH=$HOME/go

$ echo $GOPATH 
/home/kezunlin/go

$ go env GOPATH
/home/kezunlin/go

code organization

  • Go programmers typically keep all their Go code in a single workspace.
  • A workspace contains many version control repositories (managed by Git, for example).
  • Each repository contains one or more packages.
  • Each package consists of one or more Go source files in a single directory.
  • The path to a package’s directory determines its import path.

like this 

bin/
    hello                          # command executable
    outyet                         # command executable
src/
    github.com/golang/example/
        .git/                      # Git repository metadata
        hello/
            hello.go               # command source
        outyet/
            main.go                # command source
            main_test.go           # test source
        stringutil/
            reverse.go             # package source
            reverse_test.go        # test source
    golang.org/x/image/
        .git/                      # Git repository metadata
        bmp/
            reader.go              # package source
            writer.go              # package source
    ... (many more repositories and packages omitted) ...

Note that symbolic links should not be used to link files or directories into your workspace.

An import path is a string that uniquely identifies a package.

go example

your first program

1
2
3
mkdir -p $GOPATH/src/github.com/kezunlin/hello
cd $GOPATH/src/github.com/kezunlin/hello
vim hello.go

hello.go

1
2
3
4
5
6
7
package main

import "fmt"

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

build and run 

1
2
3
go build
./hello
hello, world

install and clean binary files

1
2
3
4
5
# install hello to $HOME/go/bin
go install  

# clean $HOME/go/bin/*
go clean -i

~/go/src$ go build github.com/kezunlin/hello/
~/go/src$ go install github.com/kezunlin/hello/

your first library

stringutil library

1
2
3
mkdir -p $GOPATH/src/github.com/kezunlin/stringutil
cd $GOPATH/src/github.com/kezunlin/stringutil
vim reverse.go

reverse.go

1
2
3
4
5
6
7
8
9
10
11
// Package stringutil contains utility functions for working with strings.
package stringutil

// Reverse returns its argument string reversed rune-wise left to right.
func Reverse(s string) string {
    r := []rune(s)
    for i, j := 0, len(r)-1; i < len(r)/2; i, j = i+1, j-1 {
        r[i], r[j] = r[j], r[i]
    }
    return string(r)
}
package <name>

where name is the package’s default name for imports. (All files in a package must use the same name.)
executable commands must always use package main.

build library

1
2
3
go build github.com/kezunlin/stringutil
#This won't produce an output file. Instead it saves 
#the compiled package in the local build cache.

use stringutil in hello.go

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

import (
    "fmt"
    "github.com/kezunlin/stringutil"
)

func main() {
    fmt.Printf("hello, world\n")
    fmt.Println(stringutil.Reverse("!oG ,olleH"))
}

build and install

1
2
3
4
5
6
go build github.com/kezunlin/hello
go install github.com/kezunlin/hello

~/go/bin$ ./hello 
hello, world
Hello, Go!

folder structure

1
2
3
4
5
6
7
8
9
10
11
12
13
tree .
.
├── bin
│   └── hello
└── src
    └── github.com
        └── kezunlin
            ├── hello
            │   └── hello.go
            └── stringutil
                └── reverse.go

6 directories, 3 files

testing

You write a test by creating a file with a name ending in _test.go that contains functions named TestXXX with signature func (t *testing.T). The test framework runs each such function; if the function calls a failure function such as t.Error or t.Fail, the test is considered to have failed.

  • file name: xxx_test.go
  • function name: TextXXX
  • error: t.Error or t.Fail

reverse_test.go

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

import "testing"

func TestReverse(t *testing.T) {
	cases := []struct {
		in, want string
	}{
		{"Hello, world", "dlrow ,olleH"},
		{"Hello, 世界", "界世 ,olleH"},
		{"", ""},
	}
	for _, c := range cases {
		got := Reverse(c.in)
		if got != c.want {
			t.Errorf("Reverse(%q) == %q, want %q", c.in, got, c.want)
		}
	}
}

test ok

1
2
$ go test github.com/kezunlin/stringutil
ok  	github.com/kezunlin/stringutil 0.165s

test error 

--- FAIL: TestReverse (0.00s)
    reverse_test.go:16: Reverse("Hello, 世界2") == "2界世 ,olleH", want "界世 ,olleH"
FAIL
exit status 1
FAIL    github.com/kezunlin/stringutil  0.003s

remote packages

1
2
3
$ go get github.com/golang/example/hello
$ $GOPATH/bin/hello
Hello, Go examples!

go commands

1
2
3
4
5
6
7
8
9
go help gopath 
go help importpath 
go help test

go build
go install 
go clean

go get # fetch,build and install

Reference

History

  • 20191011: created.