How to use Rune in Golang

What is Rune in Golang? How to use Rune in Golang? This article will give you the answer.

In the past, we only had one character set, and it was called ASCII (American Standard Code for Information Interchange). Back then, we used 7 bits to represent 128 characters, which included uppercase and lowercase English letters, numbers & various punctuation & device control characters. Because of this character limitation, the majority of the population could not use their own custom writing system. To solve that problem, Unicode was "born". Unicode is a superset of ASCII that contains all the characters in the world's writing systems today. It includes accents, diacritics, control codes like tabs and line breaks, assigning each character a standard number called "Unicode Code Point" or in Go, "Rune". The Rune type is an alias for int32.

Points to remember about Runes in Golang

• Always remember, a string is a sequence of bytes, not a Rune. A string can contain Unicode text encoded in UTF-8. But Go source code is encoded in UTF-8, so there is no need to encode the string in UTF-8.
• UTF-8 encodes all Unicode in the range of 1 to 4 bytes, where 1 byte is used for ASCII and the rest for Runes.
• ASCII contains a total of 256 elements, of which, 128 are characters and 0-127 are defined as code points. Here, code point refers to an element that represents a single value.

For example:

♄

This is a Rune with the hexadecimal value ♄.

The True Meaning of Runes

It represents a Rune constant, which is an integer value that identifies a Unicode code point. In Go, a Rune Literal is represented as one or more characters enclosed in parentheses like 'g', '\t', etc. Between the parentheses, you are allowed to place any character except a newline and an unescaped parentheses. Here, the characters enclosed in these parentheses represent the Unicode value of the given character itself, and multi-character strings with a backslash (at the beginning of a multi-character string) encode the values ​​in a different format. In a Rune Literal, all strings that start with a backslash are invalid, only the following single-escaped characters represent special values ​​when you use them with a backslash:

For example:

//Minh họa chương trình Go đơn giản về cách tạo một rune
package main

import (
	"fmt"
	"reflect"
)

func main() {

	// Tạo một rune
	rune1 := 'B'
	rune2 := 'g'
	rune3 := '\a'

	// Hiện rune và kiểu của nó
	fmt.Printf("Rune 1: %c; Unicode: %U; Type: %s", rune1,
							rune1, reflect.TypeOf(rune1))
	
	fmt.Printf("\nRune 2: %c; Unicode: %U; Type: %s", rune2,
							rune2, reflect.TypeOf(rune2))
	
	fmt.Printf("\nRune 3: Unicode: %U; Type: %s", rune3, 
								reflect.TypeOf(rune3))

}

Result:

Rune 1: B; Unicode: U+0042; Type: int32
Rune 2: g; Unicode: U+0067; Type: int32
Rune 3: Unicode: U+0007; Type: int32

Example 2:

Result:

Character: ♛, Unicode:U+265B, Position:0 
Character: ♠, Unicode:U+2660, Position:1 
Character: ♧, Unicode:U+2667, Position:2 
Character: ♡, Unicode:U+2661, Position:3 
Character: ♬, Unicode:U+266C, Position:4