Displaying IP addresses in Go using Stringer interface

Your first variant is unnecessary detailed and hard to read:

• an IPv4 address consists of exactly 4 digit groups
• 4 is a small number, maybe it's worth to inline the for loop
• the for loop treats the case k == 0 specially
• the += operator for strings allocates a new string each time
• the code is much longer than the description in the task "join the four numbers with dots"

Your second variant is short, easy to grasp and probably efficient enough for all practical cases.

func (ip IPAddr) String() string {
    return fmt.Sprintf("%v.%v.%v.%v", ip[0], ip[1], ip[2], ip[3])
}

You can replace the %v with %d to make it more specific, since the arguments are integer values.

The main reason for choosing this variant is readability. The format string shows at a glance how the formatted string will look like.

If you want to write the fastest possible code, you should probably allocate a byte array of size 3+1+3+1+3+1+3 and append each number and dot individually, without using a loop at all.

an exercise from the Go Tour website

I found two ways to achieve the goal but I am wondering if there is no other clean way of doing it.

Example 1 with range.

Example 2 with a simple fmt.Sprintf

Another way (Example 3):

package main

import (
    "fmt"
    "strconv"
)

type IPAddr [4]byte

func (ip IPAddr) String() string {
    s := make([]byte, 0, (1+3)*len(IPAddr{}))
    for i, b := range ip {
        if i > 0 {
            s = append(s, '.')
        }
        s = strconv.AppendInt(s, int64(b), 10)
    }
    return string(s)
}

func main() {
    hosts := map[string]IPAddr{
        "loopback":  {127, 0, 0, 1},
        "googleDNS": {8, 8, 8, 8},
    }
    for name, ip := range hosts {
        fmt.Printf("%v: %v\n", name, ip)
    }
}

Playground: https://play.golang.org/p/HQPd8cVAg-U

Output:

loopback: 127.0.0.1
googleDNS: 8.8.8.8

Yet another way (Example 4):

package main

import (
    "fmt"
    "net"
)

type IPAddr [4]byte

func (ip IPAddr) String() string {
    return net.IP(ip[:]).String()
}

func main() {
    hosts := map[string]IPAddr{
        "loopback":  {127, 0, 0, 1},
        "googleDNS": {8, 8, 8, 8},
    }
    for name, ip := range hosts {
        fmt.Printf("%v: %v\n", name, ip)
    }
}

Playground: https://play.golang.org/p/p3XKFFMBVI-

Output:

loopback: 127.0.0.1
googleDNS: 8.8.8.8

Go programmers strongly believe in meaningful code metrics. For example, performance.

A Go benchmark for Example 1:

$ go test string1_test.go -bench=. -benchmem

string1_test.go:

package main

import (
    "fmt"
    "testing"
)

type IPAddr [4]byte

func (ip IPAddr) String() string {
    rs := ""
    for k, v := range ip {
        if k == 0 {
            rs += fmt.Sprintf("%v", v)
            continue
        }
        rs += fmt.Sprintf(".%v", v)
    }
    return rs
}

func BenchmarkString1(b *testing.B) {
    hosts := map[string]IPAddr{
        "loopback":  {127, 0, 0, 1},
        "googleDNS": {8, 8, 8, 8},
    }
    for N := 0; N < b.N; N++ {
        for name, ip := range hosts {
            fmt.Sprintf("%v: %v\n", name, ip)
        }
    }
}

Running the same benchmark for all four examples:

BenchmarkString1-8    841730   1412 ns/op   176 B/op   19 allocs/op
BenchmarkString2-8   1228399    931 ns/op   128 B/op    8 allocs/op
BenchmarkString3-8   1765022    626 ns/op   128 B/op    8 allocs/op
BenchmarkString4-8   1984806    574 ns/op   128 B/op    8 allocs/op

Examples 1 and 2 are inefficient.