Which approach is better, and does it matter?

[Juk (Jos)]

I’m a beginner that studied 2 books about Go, and I’d say I know the coding a bit. But something that I still struggle with (also from a confidence standpoint) is choosing amongst different options.

Say for instance I want to reverse a string. I found/wrote at least 3 ways to do that today:

func reverseString(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func reverseString2(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)
}

func reverseString3(s string) string {
	size := len(s)
	buf := make([]byte, size)
	for start := 0; start < size; {
		r, n := utf8.DecodeRuneInString(s[start:])
		start += n
		utf8.EncodeRune(buf[size-start:], r)
	}
	return string(buf)
}

My questions:

• How do I know or can tell which of these approaches is ‘the best’?
• Does it matter which approach I use? (Given how performance-oriented Go is, I’d say yes.)
• And from a broader perspective: how to deal with these ambiguous situations as a beginner?

[Yamil_Bracho]

First you have to determine how to measure your options. Speed ? Memory consumption ? ease of programming ?

HTH,
Yamil

[badu (Bogdan Dinu)]

The best approach would be the one in which you don’t convert from string to []byte and back, meaning reverseString3.

[Juk (Jos)]

@Yamil_Bracho

First you have to determine how to measure your options. Speed ? Memory consumption ? ease of programming ?

Good question. But I don’t really know. I don’t expect the speed of the three options to be very different. The same for the memory. So I’d suspect that ease of programming outweighs those other factors?

@badu

The best approach would be the one in which you don’t convert from string to byte and back, meaning reverseString3.

Ah I didn’t knew that. Thanks. Are the []rune arrays (and their operations) from the first two options are much more expensive than calling two additional methods? (DecodeRuneInString(), EncodeRune()).

[Juk (Jos)]

Just made my first benchmark test in trying to figure it out.

These are the results on my pc:

C:\Go practice\strings\stringtest>go test -bench=. -benchmem
goos: windows
goarch: amd64
BenchmarkReverseString-4         2000000               967 ns/op             208 B/op          2 allocs/op
BenchmarkReverseString2-4        2000000               987 ns/op             208 B/op          2 allocs/op
BenchmarkReverseString3-4        2000000               731 ns/op              96 B/op          2 allocs/op
PASS
ok      _/C_/Go_practice/strings/stringtest   8.121s

The third option is indeed quicker as @badu already knew. The first and second option are the same.

So from a performance perspective the third option is not good. But from a code readability I think this option is most difficult. So the ease of programming that Yamil pointed out is less good.

[badu (Bogdan Dinu)]

Indeed, you should prefer readability over performance, until you are being asked to improve it. However, when being asked to improve performance, one should know which is the pedal-to-the-metal

[Juk (Jos)]

Thanks for your help and insights.

Have a nice day!

[disintegration (Grigory Dryapak)]

Please be aware that the third function may panic if the string contains an invalid UTF-8 byte sequence, e.g.:

reverseString3("\x80")

https://play.golang.org/p/h5D0kaOZ6w_E

[Juk (Jos)]

@disintegration

the third function may panic if the string contains an invalid UTF-8 byte sequence

Thank you, that’s a very good catch. Much appreciated that you took the time to comment.