Table of Contents

• Basics of string
• Conversions to and from a string type
• Normalize new lines (CRLF -> LF)

Basics of string tutorial

Text strings are conventionally interpreted as UTF-8-encoded sequences of Unicode code points (runes)

• In Go, a string is in effect a read-only slice of bytes.
• A string holds arbitrary bytes.
• So, indexing a string yields its bytes, not its characters.
• Source code in Go is defined to be UTF-8 text; no other representation is allowed.
• So, When we write a string literal "hi", it is encoded as UTF-8 text and stored in bytes.

• Go strings are always UTF-8, but they are not: only string literals are UTF-8.

• In Go, the Unicode code points are called runes.

• The Go language defines the word rune as an alias for the type int32, so programs can be clear when an integer value represents a code point.

• Strings are immutable. As such, a string s and a substring like s[7:] may safely share the same data, so the substring operation is also cheap.
• A raw string literal is written `...`, using backquotes instead of double quotes.

• Fortunately, Go’s range loop, when applied to a string, performs UTF-8 decoding implicitly.

Conversions to and from a string type discussion

string('a')       // "a"
string(-1)        // "\ufffd" == "\xef\xbf\xbd"
string(0xf8)      // "\u00f8" == "ø" == "\xc3\xb8"
type MyString string
MyString(0x65e5)  // "\u65e5" == "日" == "\xe6\x97\xa5"

string([]byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'})   // "hellø"
string([]byte{})                                     // ""
string([]byte(nil))                                  // ""

type MyBytes []byte
string(MyBytes{'h', 'e', 'l', 'l', '\xc3', '\xb8'})  // "hellø"

string([]rune{0x767d, 0x9d6c, 0x7fd4})   // "\u767d\u9d6c\u7fd4" == "白鵬翔"
string([]rune{})                         // ""
string([]rune(nil))                      // ""

type MyRunes []rune
string(MyRunes{0x767d, 0x9d6c, 0x7fd4})  // "\u767d\u9d6c\u7fd4" == "白鵬翔"

[]byte("hellø")   // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}
[]byte("")        // []byte{}

MyBytes("hellø")  // []byte{'h', 'e', 'l', 'l', '\xc3', '\xb8'}

[]rune(MyString("白鵬翔"))  // []rune{0x767d, 0x9d6c, 0x7fd4}
[]rune("")                 // []rune{}

MyRunes("白鵬翔")           // []rune{0x767d, 0x9d6c, 0x7fd4}

Normalize new lines (CRLF -> LF) howto

func Normalize(b []byte) []byte {
    // Win -> Unix: replace CR LF with LF
    b = bytes.Replace(b, []byte("\r\n"), []byte("\n"), -1)
    // Mac -> Unix: replace CF with LF
    b = bytes.Replace(b, []byte("\r"), []byte("\n"), -1)
    return b
}