Trusted answers to developer questions
Trusted Answers to Developer Questions

Related Tags

go

The difference between bytes and runes in Go

Anjana Shankar

Grokking Modern System Design Interview for Engineers & Managers

Ace your System Design Interview and take your career to the next level. Learn to handle the design of applications like Netflix, Quora, Facebook, Uber, and many more in a 45-min interview. Learn the RESHADED framework for architecting web-scale applications by determining requirements, constraints, and assumptions before diving into a step-by-step design process.

What is a byte?

A byte takes 8 bits of storage. In Go, it is equivalent to the data type uint8. It is used to represent an ASCII character.

package main
import "fmt"
func main() {
// Declaration and assignment
var a1 byte = 97
var a2 byte = 'b'
// Printing without character formatting
fmt.Println(a1)
fmt.Println(a2)
// Printing with character formatting
fmt.Printf("%c\n", a1)
fmt.Printf("%c\n", a2)
}
Declaring characters using byte datatype

Explanation

  • Line 1: We declare the package name.
  • Line 2: We import the standard package fmt.
  • Line 6: We assign 97 to a1 which is the ASCII equivalent of 'a'.
  • Line 7: We assign a character b to a2.
  • Lines 10–11: We print the two variables a1 and a2 without character formatting. The output without character formatting is the ASCII equivalent code of the characters.
  • Lines 14–15: We print the two variables with character formatting.

What is a rune?

A rune takes 4 bytes or 32 bits for storage. It is an int32 equivalent. Runes are used to represent the Unicode characters, which is a broader set than ASCII characters. These Unicode characters are encoded in the UTF-8 format.

package main
import (
"fmt"
"reflect"
)
func main() {
// Shorthand declaration and assignment
a1 := 97
a2 := 'b'
a3 := '♬'
// Printing the value, unicode equivalent and type of the variable
fmt.Printf("Value: %c, Unicode: %U, Type: %s\n", a1, a1, reflect.TypeOf(a1))
fmt.Printf("Value: %c, Unicode: %U, Type: %s\n", a2, a2, reflect.TypeOf(a2))
fmt.Printf("Value: %c, Unicode: %U, Type: %s\n", a3, a3, reflect.TypeOf(a3))
}
Declaring characters using rune datatype

Explanation

  • Line 1: We declare the package name.
  • Lines 2–5: We import the standard packages fmt and reflect.
  • Line 9: We assign 97 to a1 which is the ASCII equivalent of 'a'.
  • Line 10: We assign character b to a2.
  • Line 11: We assign the Unicode character to a3.
  • Lines 14–16: We print the values, the Unicode equivalent, and the type of the three variables a1, a2 and a3.

Output

The type of a1 is int. This is because we had assigned an integer 97 to it. The type of both a2 and a3 is int32. This is because the default type of character value is a rune.

Comparison of byte and rune

Byte

Rune

It takes 8 bits to store a value.

It takes 32 bits to store a value.

Byte is equivalent to uint8.

Rune is equivalent to int32.

Declaration: var a2 byte = 'b'

Declaration: var a2 rune = 'b'

It has to be declared explicitly.

It is the default type of a character.

Is a string a byte or a rune?

A string is a read-only slice of bytes effectively. When we iterate over a string using a for loop, we iterate over a slice of bytes. However, each value is decoded as a rune when we use a for range loop.

package main
import (
"fmt"
"reflect"
)
func main() {
s := "hello"
// for loop
for i := 0; i < len(s); i++ {
fmt.Printf("Value: %c, Unicode: %U, Type: %s\n", s[i], s[i], reflect.TypeOf(s[i]))
}
fmt.Println()
// for range
for _, value := range s {
fmt.Printf("Value: %c, Unicode: %U, Type: %s\n", value, value, reflect.TypeOf(value))
}
}
String — rune or byte

Explanation

  • Line 1: We declare the package name.
  • Lines 3–6: We import the standard packages fmt and reflect.
  • Line 9: We declare a string s and assign "hello" to it.
  • Lines 12–13: We iterate over the string s using a for loop. Since it is printing one character at a time, the type of each element printed is uint8.
  • Lines 19–20: We iterate over the string s using a for range loop. Here the value is by default of type rune.

The difference in the representation can be seen from the output of the execution of the above code.

Conclusion

A byte and a rune are both used to represent a character in Go. The default type for character value is a rune.

RELATED TAGS

go

Grokking Modern System Design Interview for Engineers & Managers

Ace your System Design Interview and take your career to the next level. Learn to handle the design of applications like Netflix, Quora, Facebook, Uber, and many more in a 45-min interview. Learn the RESHADED framework for architecting web-scale applications by determining requirements, constraints, and assumptions before diving into a step-by-step design process.

Keep Exploring