Golang Examples (Go Examples)

You can embed interfaces in a struct.

package main import "fmt" type Mover interface { Move() } type Car struct { Mover }

But, what is embedded interface? Let's add some more fields to Car and print it with %v.

type Car struct { price int Mover speed int } func main() { var c Car fmt.Printf("%v\n", c) }

It prints,

$ go run main.go {0 <nil> 0}

As it printed out, Car has three fields. Embedded interface is just an anonymous interface fields.

Promoted methods

When interfaces are embedded, their methods are promoted automatically. That means methods of anonymous interface fields are seen as if they are methods of the embedding struct.

When you embed Mover interface in Car,

type Car struct { Mover }

it works as if Cars has Move() methods defined as following.

type Car struct { Mover } // promoted method func (c Car) Move() { c.Mover.Move() }

Note that calling Move() when the anonymous interface field is nil crashes the program.

func main() { var m Mover = Car{} // Field 'Mover' is nil. m.Move() // Crashes. nil dereference. }

Override promoted methods

You can override all or a part of promoted methods if you want.

type Car struct { Mover } type Wheel struct { } func (w Wheel) Move() { fmt.Println("wheel") } // Overrides promoted method func (c Car) Move() { fmt.Println("car") } func main() { var m Mover = Car{Wheel{}} m.Move() // Prints "car" }

Sort package has a good example of promoted method overriding.

Sort.Interface is as follows.

type Interface interface { Len() int Less(i, j int) bool Swap(i, j int) } func Sort(data Interface) { ... }

sort.Reverse returns the reverse ordered data. It uses a struct which embeds sort.Interface and overrides only Less() method.

func Reverse(data Interface) Interface { return &reverse{data} } type reverse struct { Interface // Interface embedding } // Overrides Less() only. No need to override promoted Len() and Swap(). func (r reverse) Less(i, j int) bool { return r.Interface.Less(j, i) }

Make use of interface embedding for test

By embedding interfaces, promoted methods of interfaces satisfies the interfaces even though the anonymous field is nil.

type Mover interface { Move() } type Car struct { Mover } func main() { // Car satisfies Mover interface because it has promoted Move() method. var m Mover = Car{} m.Move() // Crashes. nil dereference. }

If you need to test only a part of the methods, you only need to implement the method needed. In following code, Car implements only Move() method explicitly. Car satisfies MoveStopper interface because it has promoted Stop() method.

Use x/text package to Read Japanese/Korean/Chinese encoded file.

Goncurrent is a Java library which provides the power of channel and select of Golang. Goncurrent works as you expect it to do.

Using channel:

Chan<Integer> ch1 = Chan.create(1) ch1.send(0); ch1.close(); Integer value; value = ch1.receive(); // receives '0' value = ch1.receive(); // receives null

Using select:

When do you think calc1() and calc2() are called.

for { fmt.Println("select start") select { case ch1 <- calc1(): fmt.Println("in case1") case ch2 <- calc2(): fmt.Println("in case2") } fmt.Println("select end") } func calc1() int { fmt.Println("in calc1") return 0 } func calc2() int { fmt.Println("in calc2") return 0 }

If you think calc1() is called 50% of the time when first case statement is chosen, it's wrong. calc1() and calc2() are called everytime upon entering select.

Look at the following code which uses empty struct.

package main import "fmt" type someType struct{} func main() { val1 := new(someType) val2 := new(someType) fmt.Printf("%p\n", val1) fmt.Printf("%p\n", val2) fmt.Println(val1 == val2) // prints true }

Interestingly, the address of val1 and val2 is the same. If you want val1 and val2 to take different addresses, use something like int instread of struct{}

path.Ext() returns a file name extension including a dot if exists.

Add the following line at the top of the source code.

//usr/bin/env go run $0 $@ ; exit

Sample:

$ cat a.go //usr/bin/env go run $0 $@; exit package main import "fmt" func main() { fmt.Println("hello world") } $ chmod a+x a.go $ ./a.go hello world $

Extract a HTTP POSTed zip file. req.Body can't be passed directly to zip.NewReader() as it doesn't implement ReadAt(). Wrap it with bytes.NewReader().

body, err := ioutil.ReadAll(req.Body) if err != nil { // err } r, err := zip.NewReader(bytes.NewReader(body), req.ContentLength) if err != nil { // err } for _, zf := range r.File { dst, err := os.Create(zf.Name) if err != nil { // err } defer dst.Close() src, err := zf.Open() if err != nil { // err } defer src.Close() io.Copy(dst, src) }

Use net/http/cgi.

req.URL.Query() returns a map which implements Get() method.

func someHandler(w http.ResponseWriter, r *http.Request) { query := req.URL.Query() val1 := query.Get("key1") val2 := query.Get("key2")

Strings are URL-decoded automatically in URL.Query().

Use net.InterfaceAddrs().

addrs, err := net.InterfaceAddrs() if err != nil { panic(err) } for i, addr := range addrs { fmt.Printf("%d %v\n", i, addr) }

If you want to know interface names too, use net.Interfaces() to get a list of interfaces first.

Functions to add or remove pkcs#7 padding.

Sometimes, you want to specify a file to read with command line argument. Sometimes, you want to read from stdin. Following is a simple way to do it.

In the following code, B is 0 because A doesn't promote to uint16 or int automatically.

var A byte A = 1; var B int B = int(A << 8)

You need to convert A to int explicitly.

Linux supports three types of unix domain socket addresses. pathname, unnamed and abstract. abstract socket address is very convenient but there's a pitfall of using it in Go.

If you want to use an abstract socket address, its name should starts with '@', not '\0'.

net.UnixAddr{"@myname", "unix"} // address is {'\0','m','y','n','a','m','e' }

If address name starts with '@', Go converts '@' to '\0' and do not append '\0' at the end of the string.

If address name starts with '\0', the resulting address may not be what you want.

There are three types of unix domain socket.

"unix" corresponds to SOCK_STREAM

"unixdomain" corresponds to SOCK_DGRAM

"unixpacket" corresponds to SOCK_SEQPACKET

When you write a "unix" or "unixpacket" server, use ListenUnix().

l, err := net.ListenUnix("unix", &net.UnixAddr{"/tmp/unixdomain", "unix"}) if err != nil { panic(err) } defer os.Remove("/tmp/unixdomain") for { conn, err := l.AcceptUnix() if err != nil { panic(err) } var buf [1024]byte n, err := conn.Read(buf[:]) if err != nil { panic(err) } fmt.Printf("%s\n", string(buf[:n])); conn.Close() }

"unixgram" server uses ListenUnixgram().

conn, err := net.ListenUnixgram("unixgram", &net.UnixAddr{"/tmp/unixdomain", "unixgram"}) if err != nil { panic(err) } defer os.Remove("/tmp/unixdomain") for { var buf [1024]byte n, err := conn.Read(buf[:]) if err != nil { panic(err) } fmt.Printf("%s\n", string(buf[:n])); }

Client is as follows

Do you know what exactly associated template is? It's one of the concepts that confused me a lot. This post explains what associated template is in detail.

I'll use a term "template group" in order to explain what associated template is. The term is not in the official godoc.

template.New()

When you create a template with template.New(),

t1 := template.New("t1")

a template object is created with the name specified. At the same time, a template group is created.

A template group is a object with a FuncMap and a list of Template that the group has. (The list is implemented as a map internally, but it's shown as a list for brevity)

At this point, t1 is not in the template list yet. When you call Parse(),

t1.Parse(...)

"t1" is added to the template list.

Associate a template with t.New()

When you call the following,

t2, err := t1.New("t2").Parse(...) t3, err := t1.New("t3").Parse(...)

it creates the following structure.

t1, t2 and t3 are all members of the same group. They share FuncMap and the template list.

Godoc of t.New(name string) says.

New allocates a new template associated with the given one and with the same delimiters. The association, which is transitive, allows one template to invoke another with a {{template}} action.

It's easy to understand what the godoc means with the above diagram. When templates are associated, they are in the same group.

Name of a Template

Each template has a name. It's not allowed to add more than one templates to the template list by calling Parse().

Template name need to be unique in a group. It's OK to have templates with the same name if they belong to different groups.

tA,err := template.New("t1").Parse(...) tB,err := template.New("t1").Parse(...)

t.Lookup()

t.Lookup(name string) finds the template by name in a group.

You can use any receiver objects to find a template. Following three codes return the same template object.

t1.Lookup("t3") // returns t3 t2.Lookup("t3") // returns t3 t3.Lookup("t3") // returns t3

t.Templates()

t.Templates() returns a copy of the list of templates in the group.

All of the following codes return lists with the same contents.

t1.Templates() t2.Templates() t3.Templates()

Difference between t.Execute() and t.ExecuteTemplate()

t.Execute() uses the template t itself.

t1.Execute(w, obj)

t.ExecuteTemplate() looks up a template by name, and execute the looked-up template.

t1.ExecuteTemplate(w, "t3", obj)

Following three codes are equivalent.

t1.ExecuteTemplate(w, "t3", obj) // = t3.Execute(w, obj) t2.ExecuteTemplate(w, "t3", obj) // = t3.Execute(w, obj) t3.ExecuteTemplate(w, "t3", obj) // = t3.Execute(w, obj)

What template.ParseFiles() does

template.ParseFiles() creates templates and put all of them in a same group.

t, err := template.ParseFiles("a/go.tmpl", "b/lang.tmpl", "c/rocks.tmpl")

creates following structure.

Name of each templates is a base name of the file.