Go Strings

External

• https://golang.org/ref/spec#String_types

Internal

• Character Encoding
• Go Language
• Go Integers

Overview

The main "use case" for strings is to hold characters made for printing, things you see, and read.

In Go, strings are sequence of bytes that represent characters, encoded using the character encoding standard Unicode, and, by default, the UTF-8 character encoding scheme. Go refers to Unicode code points as runes. For the rune type, also see integral types.

Strings are immutable.

A string variable that is not explicitly initialized is implicitly initialized with the empty string.

String Variable Declaration

The pre-declared type identifier for strings is string.

var s string                // string type declaration without initialization
s = "example 1"             // initialization after declaration
var s2 string = "example 2" // variable initialization in declaration
var s3 = "example 3"        // variable initialization with type inference
s4 := "example 4"           // short variable declaration

String Literals

A string literal is a string constant produced by concatenating characters. Go has two kind of string literals: interpreted string literals and raw string literals.

Interpreted String Literals

An interpreted string literal is represented in Go code as a sequence of characters enclosed in double quotes. Each character is a byte, a rune, an UTF-8 code point. Interpreted strings allow escaping (\n or \t).

s := "something\nsomething else"
println(s)

Raw String Literals

Raw string literals are sequences of characters enclosed in backquotes (backticks) `. All characters between the pair of matching backticks is taken literally, back slashes have no special meaning and new lines can appear. Carriage return characters inside raw string literals are discarded.

s := `This
is an \n \t
example of 
raw string literal`

println(s)

will produce:

This
is an \n \t
example of 
raw string literal

Empty String

emptyString1 := ""
emptyString2 := ``

Operators

Indexing Operator []

The indexing operator [] returns a byte (uint8)

Strings are zero-based indexed. If the index is out of bounds, the runtime generates a run-time panic:

panic: runtime error: index out of range [6] with length 3

Concatenation Operator +

The concatenation operator + joins two strings together, producing a new immutable string instance. An attempt to use the concatenation operation between a string and an int, for example, won't work, because the int won't be automatically converted to string the way Java does.

s := "abc"
s2 := "xyz"
println(s + s2)

Equality Operator ==

String equality is tested with the == operator:

s := "blue"
s2 := "blue"
if s == s2 {
  println("strings are equal")
}

String Manipulation and Processing in Go

String Length

TO PROCESS:

len()

Conversion of a byte to string

TO PROCESS:

Conversion between bytes and strings

Reading with a string with a Reader

TO PROCESS:

strings.NewReader()

See Go_Package_strings#NewReader.28.29