Go Strings: Difference between revisions

From NovaOrdis Knowledge Base
Jump to navigation Jump to search
 
(163 intermediate revisions by the same user not shown)
Line 1: Line 1:
=External=
=External=
* String types in the language specification https://golang.org/ref/spec#String_types
* https://golang.org/ref/spec#String_types
* https://go.dev/blog/strings
 
=Internal=
=Internal=
* [[Go Language#Strings|Go Language]]
* [[Character Encoding]]
* [[Character Encoding]]
* [[Go Language#Strings|Go Language]]
* [[Go Integers]]
* [[Python Language String|Python Strings]]
* [[Go Package fmt|<tt>fmt</tt> Package]]


=Overview=
=Overview=
The main "use case" for strings is to hold characters made for printing, things you can see, and read. In Go, strings are read-only slices of bytes that represent Unicode [[Character_Encoding#Code_Point|code points]]. The language, and the standard library treat strings as containers of [[Character_Encoding#Unicode|Unicode]] characters, encoded in the [[Character_Encoding#UTF-8|UTF-8]] [[Character_Encoding#Character_Encoding_Scheme|character encoding scheme]]. UTF-8 is a variable-length encoding which uses one to four bytes per character. While other languages refer to the string's components as "characters", Go refers to the same components as <span id='Rune'></span>"runes", instance of the <code>[[Go_Integers#Rune|rune]]</code> type. They are 32-bit integers that represent Unicode [[Character_Encoding#Code_Point|code points]]. It is OK to refer to them as "characters".


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 represented using the character encoding standard  [[Character_Encoding#Unicode|Unicode]], and by default the [[Character_Encoding#UTF-8|UTF-8]] [[Character_Encoding#Character_Encoding_Scheme|character encoding scheme]]. Go refers to Unicode [[Character_Encoding#Code_Point|code points]] as <span id='Rune'></span>'''runes'''.
Strings are '''immutable'''.


=TO DEPLETE=
A string variable that is not explicitly initialized is implicitly initialized with the [[#Empty_String|empty string]].
==Internal==


* [[Go Concepts - The Type System#Built-in_Types|Built-in Types]]
=Strings as Slices=
Strings are read-only [[Go_Slices#String_as_Slices|slices]] of bytes with a bit of extra syntactic support from the language. Because they are read-only there is no need for [[Go_Slices#Capacity|capacity]], because you cannot grow them, but other than that, they can be handled like read-only slices of bytes. In particular, [[Go_Strings#Slice_Expressions|slice expressions]] can be applied to them. The array underlying a string is hidden. There is no way to access its contents except through the string. An important consequence of this slice-like design for strings is that creating substrings is efficient.


==Overview==
A normal slice of bytes <code>[]byte</code> can be converted to a string with a type conversion:
<syntaxhighlight lang='go'>
b := []byte{98, 108, 117, 101}
s := string(b) // "blue"
</syntaxhighlight>


The pre-declared String [[Go Concepts - Lexical Structure#Pre-Declared_Identifiers|type identifier]] is <tt>string</tt>. String values are (possibly empty) sequences of bytes. String values are ''immutable''.
A string can be converted to a <code>[]byte</code> slice of bytes in the reverse direction:
<syntaxhighlight lang='go'>
s := "red"
b := []byte(s)
</syntaxhighlight>


Uninitialized variable value: <font color=darkkhaki>TO check: <code>""</code> (empty string).</font>
=<span id='String_Variable_Declaration'>Declaration=
The [[Go_Language#Pre-Declared_Types|pre-declared type identifier]] for strings is <code>string</code>.
<syntaxhighlight lang='go'>
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
</syntaxhighlight>


==String Literals==
=<span id='String_Literals'></span>Literals=
A string literal is a string [[Go_Language#Constant|constant]] produced by concatenating characters. Go has two kind of string literals: [[#Interpreted_String_Literals|interpreted string literals]] and [[#Raw_String_Literals|raw string literals]].


A ''string literal'' is a [[Go Concepts - Lexical Structure#Constants|string constant]] obtained from concatenating a sequence of characters.
==<span id='Interpreted_String_Literal'></span>Interpreted String Literals==


===Raw String Literals===
An interpreted string literal is represented in Go code as a sequence of characters enclosed in double quotes. <font color=darkkhaki>Each character is a byte, a rune, an UTF-8 code point</font>. Interpreted strings allow escaping (\n or \t).


Raw string literals are sequences of characters enclosed by backquotes (backticks) <tt>`</tt>. Any other character is taken literally, back slashes have no special meaning and new lines can appear. Carriage return characters inside raw string literals are discarded. The following code:
<syntaxhighlight lang='go'>
s := "something\nsomething else"
println(s)
</syntaxhighlight>
==<span id='Raw_String_Literal'></span>Raw String Literals==


<pre>
Raw string literals, also known as '''raw strings''', are sequences of characters enclosed in backquotes (backticks) <code>`</code>. 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.
var sl = `Example \n \t
 
...
<syntaxhighlight lang='go'>
"something"`
s := `This
fmt.Println(sl);
is an \n \t
</pre>
example of
raw string literal`
 
println(s)
</syntaxhighlight>


will produce:
will produce:


<pre>
<syntaxhighlight lang='text'>
Example \n \t
This
...
is an \n \t
"something"
example of
</pre>
raw string literal
</syntaxhighlight>


===Interpreted String Literals===
A typical pattern to declare string constants in packages is:
<syntaxhighlight lang='go'>
const config = `
something:
  somethingelse:
    - a
    - b
    - c
`
</syntaxhighlight>


Interpreted string literals are character sequences between double quotes, as in <tt>"example"</tt>.
Raw string literals are commonly used to declare SQL statements with embedded quotes:
<syntaxhighlight lang='go'>
sql := `CREATE TABLE IF NOT EXISTS TEST ("ID" int, "NAME" varchar(10))`
</syntaxhighlight>


Interpreted strings allow escaping (\n or \t).
=Empty String=
<syntaxhighlight lang='go'>
emptyString1 := ""
emptyString2 := ``
</syntaxhighlight>


==String Equality==
=Operators=
==<span id='Indexing_Operator'></span>Indexing Operator <tt>[]</tt>==
The indexing operator <code>[[Go_Language#Indexing_Operator|[]]]</code> returns a <code>[[Go Integers#byte|byte]]</code> (<code>[[Go_Integers#byte|uint8]]</code>). It does NOT return a <code>[[Go Integers#rune|rune]]</code>.


String equality is tested with the <tt>[[Go_Concepts_-_Operators#.3D.3D|==]]</tt> operator:
Strings are zero-based indexed. If the index is out of bounds, the runtime generates a run-time panic:
<syntaxhighlight lang='text>
panic: runtime error: index out of range [6] with length 3
</syntaxhighlight >


<pre>
===Slice Expressions===
var s string = "something"
Because strings are in effect [[#Strings_as_Slices|slices of bytes]], [[Go_Slice_Expressions#Overview|slice expressions]] work with them. All the following are valid syntactic constructs:
<syntaxhighlight lang='go'>
"hamburger"[4:8] // returns "urge"
</syntaxhighlight>


if s == "something" then {
==<span id='Concatenation_Operator'></span>Concatenation Operator <tt>+</tt>==
    ...
The concatenation operator <code>[[Go Concepts - Operators#.2B|+]]</code> joins two strings together, producing a new immutable string instance. An attempt to use the concatenation operation between a <code>string</code> and an <code>int</code>, for example, won't work, because the <code>int</code> won't be automatically converted to <code>string</code> the way Java does.
<syntaxhighlight lang='go'>
s := "abc"
s2 := "xyz"
println(s + s2)
</syntaxhighlight>
==<span id='Equality_Operator'></span>Equality Operator <tt>==</tt>==
String equality is tested with the <code>[[Go_Concepts_-_Operators#.3D.3D|==]]</code> operator:
 
<syntaxhighlight lang='go'>
s := "blue"
s2 := "blue"
if s == s2 {
  println("strings are equal")
}
}
</pre>
</syntaxhighlight>
=Reading Strings=
==String Length==
The '''number of bytes''' used to store a string is obtained by invoking the [[Go_Functions#Built-in_Functions|built-in function]] <code>[[Go_Functions#len.28.29|len()]]</code> on the string.
 
Note that <code>len()</code> does NOT necessarily return the number of characters (runes) in the string. If a Unicode character is represented on more than one byte, the <code>len()</code> result will be different from the number of characters in the string.
<syntaxhighlight lang='go'>
s := "A"
println(len(s)) // will display 1
s = "→"
println(len(s)) // will display 3, "→" requires 3 bytes to be encoded in UTF-8
</syntaxhighlight>
 
The '''number of characters''' in a string is returned by <code>utf8.RuneCountInString()</code> function:
<syntaxhighlight lang='go'>
import "unicode/utf8"
// ...
s := "A"
println(utf8.RuneCountInString(s)) // will display 1
s = "→"
println(utf8.RuneCountInString(s)) // will display 1
</syntaxhighlight>
 
The '''number of characters''' in a string can also be obtained by applying <code>len()</code> to the following type conversion:
<syntaxhighlight lang='go'>
s := "A"
println(len([]rune(s))) // will display 1
s = "→"
println(len([]rune(s))) // will display 1
</syntaxhighlight>
 
==Reading Characters from a String==
"Characters" and "runes" are equivalent in this context. The characters are represented internally as <code>rune</code> instances. Note that the indexing operator applied directly to the string does not return characters (<code>rune</code>) but <code>uint8</code>
===Read Individual Characters===
Convert the string to a rune array and use the indexing operator applied to the rune array:
<syntaxhighlight lang='go'>
s := "A→B"
rs := []rune(s)
fmt.Printf("character 0: %c\n", rs[0]) // will display "A"
fmt.Printf("character 1: %c\n", rs[1]) // will display "→"
fmt.Printf("character 2: %c\n", rs[2]) // will display "B"
</syntaxhighlight>


==String Operators and Functions==
Also see [[#Indexing_Operator_.5B.5D|Indexing Operator <tt>[]</tt>]] above.


===Indexing Operator===
===Iterate over Characters===
Use the <code>[[Go_Keyword_range#Overview|range]]</code> keyword to iterated over the string's characters:
<syntaxhighlight lang='go'>
s := "A→B"
for pos, c := range s {
  fmt.Printf("position: %d, character: %c, type: %s\n", pos, c, reflect.TypeOf(c))
}
</syntaxhighlight>
will display:
<syntaxhighlight lang='text'>
position: 0, character: A, type: int32
position: 1, character: →, type: int32
position: 4, character: B, type: int32
</syntaxhighlight>


Indexing operator <tt>[[Go Concepts - Operators#.5B.5D|[]]]</tt> returns a <tt>[[Go Integers#byte|byte]]</tt> (<tt>uint8</tt>)
==Introspecting Characters==
The <code>[[Go_Package_unicode|unicode]]</code> package provides a set of function to introspect characters for specific properties, such as whether they are a digit, a space, a letter, a punctuation character, whether they are lower case or user case, etc. For more details, see:
{{Internal|Go_Package_unicode#Introspecting_Characters|unicode &#124; Introspecting Characters}}


Strings are indexed starting with 0. If the index is out of bounds, the runtime generates a run-time panic:
=String Manipulation and Processing in Go=
==The <tt>strings</tt> Package==
===String Comparison with <tt>Compare()</tt>===
{{External|https://pkg.go.dev/strings#Compare}}
<code>Compare()</code> is a string lexicographical comparison function in the <code>[[Go_Package_strings#Functions|strings]]</code> package.
<syntaxhighlight lang='go'>
import "strings"


<pre>
a := "ABC"
panic: runtime error: index out of range
b := "XYZ"
</pre>
println(strings.Compare(a, b))    // prints -1 for a < b
println(strings.Compare(a, b))    // prints 1 for a > b
println(strings.Compare(a, "ABC")) // prints 0 for a == b
</syntaxhighlight>
===<tt>Contains()</tt>===
{{External|https://pkg.go.dev/strings#Contains}}
A function of the <code>[[Go_Package_strings#Functions|strings]]</code> package that returns true if <code>substr</code> is inside <code>s</code>:
<syntaxhighlight lang='go'>
import "strings"
strings.Contains(s, substr)
</syntaxhighlight>
===<tt>HasPrefix()</tt>===
{{External|https://pkg.go.dev/strings#HasPrefix}}
<code>HasPrefix(s, prefix)</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package that returns true is <code>s</code> starts with the <code>prefix</code>.
===<tt>HasSuffix()</tt>===
{{External|https://pkg.go.dev/strings#HasSuffix}}
<code>HasSuffix()</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package.
===<tt>Index()</tt>, <tt>LastIndex()</tt>===
{{External|https://pkg.go.dev/strings#Index}}
{{External|https://pkg.go.dev/strings#LastIndex}}
<code>Index(s, substr)</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package that searches inside the string <code>s</code> for the substring <code>substr</code> and returns the index of the first occurrence of <code>substr</code> if it exists, or -1 otherwise.


===Concatenation Operator===
<code>LastIndex(s, substr)</code> searches for last index.


[[Go Concepts - Operators#.2B|Concatenation operator +]] concatenates two strings together. Since Go is strong typed, using the concatenation operation between a string and an int, for example, won't work, the int won't be automatically converted to string, Java style.
===<tt>Count()</tt>===
{{External|https://pkg.go.dev/strings#Count}}
<code>Count()</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package.
===<tt>Join()</tt>===
{{External|https://pkg.go.dev/strings#Join}}
<code>Join()</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package.
===<tt>Split()</tt>===
{{External|https://pkg.go.dev/strings#Split}}
<code>Split(s, sep string)</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package. <code>Split()</code> slices the input string <code>s</code> into all substrings separated by the <code>sep</code> separator and returns a slice of the substrings between those separators.


<pre>
If two of the separators occur successively, the result will contain an empty string, corresponding to the position between those separators. If you want to handle consecutive white-spaces as one white-space area, <code>[[#Fields.28.29|Fields()]]</code> is a better option.
"a" + "b"
<br>
</pre>
If <code>s</code> does not contain <code>sep</code> and <code>sep</code> is not empty, <code>Split()</code> returns a slice of length 1 whose only element is <code>s</code>.<br>
If <code>sep</code> is empty, <code>Split</code> splits after each UTF-8 sequence.<br>
If both <code>s</code> and <code>sep</code> are empty, Split returns an empty slice.


===String Length===
The call is is equivalent to <code>SplitN</code> with a count of -1. To split around the first instance of a separator, see <code>Cut()</code>.
<tt>[[Go Built-In Functions Length and Capacity#len.28.29|len()]]</tt>


===Conversion of a <tt>byte</tt> to <tt>string</tt>===
===<tt>Fields()</tt>===
{{External|https://pkg.go.dev/strings#Fields}}
Take a string and breaks it down into tokens (fields) separated by one or more consecutive white space characters. Return a string slice.
<syntaxhighlight lang='go'>
fields := strings.Fields(line) // returns a []string
</syntaxhighlight >
===<tt>FieldsFunc()</tt>===
{{External|https://pkg.go.dev/strings#FieldsFunc}}
<code>FieldsFunc()</code> works similar to <code>[[#Fields()|Fields()]]</code> but it is more flexible in that it allows specifying the field separator(s).
<syntaxhighlight lang='go'>
arg := "A:B"
toks := strings.FieldsFunc(arg, func(r rune) bool {
  return r == ':'
})
// toks will be ["A", "B"]
</syntaxhighlight >
 
===<tt>Replace()</tt>===
{{External|https://pkg.go.dev/strings#Replace}}
<code>Replace(s, old, new, n)</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package that replaces the first <code>n</code> instances of the <code>old</code> substring with the <code>new</code> substring. The string <code>s</code> is not modified, the function returns a new string instance.
===<tt>Repeat()</tt>===
{{External|https://pkg.go.dev/strings#Repeat}}
<syntaxhighlight lang='go'>
s := strings.Repeat(" ", 4)
</syntaxhighlight>


<blockquote style="background-color: #f9f9f9; border: solid thin lightgrey;">
===<tt>ToLower()</tt>===
:[[Go Integers#Conversion_between_bytes_and_strings|Conversion between bytes and strings]]
{{External|https://pkg.go.dev/strings#ToLower}}
</blockquote>
<code>ToLower(s)</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package that changes the whole string to lower case. The original string <code>s</code> is not modified, a new string instance is created and returned.
===<tt>ToUpper()</tt>===
{{External|https://pkg.go.dev/strings#ToUpper}}
<code>ToUpper(s)</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package that changes the whole string to upper case. The original string <code>s</code> is not modified, a new string instance is created and returned.
===<tt>TrimSpace()</tt>===
{{External|https://pkg.go.dev/strings#TrimSpace}}
<code>TrimSpace(s)</code> is a function in the <code>[[Go_Package_strings#Functions|strings]]</code> package that returns a new string with all leading and trailing spaces removed.
===<tt>Trim()</tt>===
{{External|https://pkg.go.dev/strings#Trim}}
<code>Trim()</code> returns a slice of the string s with all leading and trailing Unicode code points contained in cutset removed.
<syntaxhighlight lang='go'>
s := ...
s = strings.Trim(s, "\n")
</syntaxhighlight>


===Reading with a <tt>string</tt> with a <tt>Reader</tt>===
==String Conversions==
===Conversion with <tt>strconv</tt> Functions===
* <code>[[Go_Package_strconv#Atoi.28.29|Atoi()]]</code>
* <code>[[Go_Package_strconv#Itoa.28.29|Itoa()]]</code>
* <code>[[Go_Package_strconv#FormatFloat.28.29|FormatFloat()]]</code>
* <code>[[Go_Package_strconv#ParseFloat.28.29|ParseFloat()]]</code>


<font color=red>
===Conversion of a <tt>byte</tt> to <tt>string</tt>===
{{Internal|Go Integers#Conversion_between_bytes_and_strings|Conversion between bytes and strings}}
==Other String Operations==
===Repeating a Number of Characters===
See <code>[[Go_Strings#Repeat()|strings.Repeat()]]</code> above.
===Padding===
{{Internal|Go_Package_fmt#Padding|<tt>fmt</tt> Padding}}


'''TODO'''
=TO DISTRIBUTE=
<font color=darkkhaki>
==Reading with a <tt>string</tt> with a <tt>Reader</tt>==
TO PROCESS:


<tt>strings.NewReader()</tt>
<tt>strings.NewReader()</tt>
Line 100: Line 311:
See [[Go_Package_strings#NewReader.28.29]]
See [[Go_Package_strings#NewReader.28.29]]


==After Settling this Article, Process This==


TODO: https://go.dev/blog/strings
</font>
</font>

Latest revision as of 22:27, 2 September 2024

External

Internal

Overview

The main "use case" for strings is to hold characters made for printing, things you can see, and read. In Go, strings are read-only slices of bytes that represent Unicode code points. The language, and the standard library treat strings as containers of Unicode characters, encoded in the UTF-8 character encoding scheme. UTF-8 is a variable-length encoding which uses one to four bytes per character. While other languages refer to the string's components as "characters", Go refers to the same components as "runes", instance of the rune type. They are 32-bit integers that represent Unicode code points. It is OK to refer to them as "characters".

Strings are immutable.

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

Strings as Slices

Strings are read-only slices of bytes with a bit of extra syntactic support from the language. Because they are read-only there is no need for capacity, because you cannot grow them, but other than that, they can be handled like read-only slices of bytes. In particular, slice expressions can be applied to them. The array underlying a string is hidden. There is no way to access its contents except through the string. An important consequence of this slice-like design for strings is that creating substrings is efficient.

A normal slice of bytes []byte can be converted to a string with a type conversion:

b := []byte{98, 108, 117, 101}
s := string(b) // "blue"

A string can be converted to a []byte slice of bytes in the reverse direction:

s := "red"
b := []byte(s)

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

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, also known as raw strings, 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

A typical pattern to declare string constants in packages is:

const config = `
something:
  somethingelse:
    - a
    - b
    - c
`

Raw string literals are commonly used to declare SQL statements with embedded quotes:

sql := `CREATE TABLE IF NOT EXISTS TEST ("ID" int, "NAME" varchar(10))`

Empty String

emptyString1 := ""
emptyString2 := ``

Operators

Indexing Operator []

The indexing operator [] returns a byte (uint8). It does NOT return a rune.

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

Slice Expressions

Because strings are in effect slices of bytes, slice expressions work with them. All the following are valid syntactic constructs:

"hamburger"[4:8] // returns "urge"

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")
}

Reading Strings

String Length

The number of bytes used to store a string is obtained by invoking the built-in function len() on the string.

Note that len() does NOT necessarily return the number of characters (runes) in the string. If a Unicode character is represented on more than one byte, the len() result will be different from the number of characters in the string.

s := "A"
println(len(s)) // will display 1
s = "→"
println(len(s)) // will display 3, "→" requires 3 bytes to be encoded in UTF-8

The number of characters in a string is returned by utf8.RuneCountInString() function:

import "unicode/utf8"
// ...
s := "A"
println(utf8.RuneCountInString(s)) // will display 1
s = "→"
println(utf8.RuneCountInString(s)) // will display 1

The number of characters in a string can also be obtained by applying len() to the following type conversion:

s := "A"
println(len([]rune(s))) // will display 1
s = "→"
println(len([]rune(s))) // will display 1

Reading Characters from a String

"Characters" and "runes" are equivalent in this context. The characters are represented internally as rune instances. Note that the indexing operator applied directly to the string does not return characters (rune) but uint8

Read Individual Characters

Convert the string to a rune array and use the indexing operator applied to the rune array:

s := "A→B"
rs := []rune(s)
fmt.Printf("character 0: %c\n", rs[0]) // will display "A"
fmt.Printf("character 1: %c\n", rs[1]) // will display "→"
fmt.Printf("character 2: %c\n", rs[2]) // will display "B"

Also see Indexing Operator [] above.

Iterate over Characters

Use the range keyword to iterated over the string's characters:

s := "A→B"
for pos, c := range s {
  fmt.Printf("position: %d, character: %c, type: %s\n", pos, c, reflect.TypeOf(c))
}

will display:

position: 0, character: A, type: int32
position: 1, character: →, type: int32
position: 4, character: B, type: int32

Introspecting Characters

The unicode package provides a set of function to introspect characters for specific properties, such as whether they are a digit, a space, a letter, a punctuation character, whether they are lower case or user case, etc. For more details, see:

unicode | Introspecting Characters

String Manipulation and Processing in Go

The strings Package

String Comparison with Compare()

https://pkg.go.dev/strings#Compare

Compare() is a string lexicographical comparison function in the strings package.

import "strings"

a := "ABC"
b := "XYZ"
println(strings.Compare(a, b))     // prints -1 for a < b
println(strings.Compare(a, b))     // prints 1 for a > b
println(strings.Compare(a, "ABC")) // prints 0 for a == b

Contains()

https://pkg.go.dev/strings#Contains

A function of the strings package that returns true if substr is inside s:

import "strings"
strings.Contains(s, substr)

HasPrefix()

https://pkg.go.dev/strings#HasPrefix

HasPrefix(s, prefix) is a function in the strings package that returns true is s starts with the prefix.

HasSuffix()

https://pkg.go.dev/strings#HasSuffix

HasSuffix() is a function in the strings package.

Index(), LastIndex()

https://pkg.go.dev/strings#Index
https://pkg.go.dev/strings#LastIndex

Index(s, substr) is a function in the strings package that searches inside the string s for the substring substr and returns the index of the first occurrence of substr if it exists, or -1 otherwise.

LastIndex(s, substr) searches for last index.

Count()

https://pkg.go.dev/strings#Count

Count() is a function in the strings package.

Join()

https://pkg.go.dev/strings#Join

Join() is a function in the strings package.

Split()

https://pkg.go.dev/strings#Split

Split(s, sep string) is a function in the strings package. Split() slices the input string s into all substrings separated by the sep separator and returns a slice of the substrings between those separators.

If two of the separators occur successively, the result will contain an empty string, corresponding to the position between those separators. If you want to handle consecutive white-spaces as one white-space area, Fields() is a better option.
If s does not contain sep and sep is not empty, Split() returns a slice of length 1 whose only element is s.
If sep is empty, Split splits after each UTF-8 sequence.
If both s and sep are empty, Split returns an empty slice.

The call is is equivalent to SplitN with a count of -1. To split around the first instance of a separator, see Cut().

Fields()

https://pkg.go.dev/strings#Fields

Take a string and breaks it down into tokens (fields) separated by one or more consecutive white space characters. Return a string slice.

fields := strings.Fields(line) // returns a []string

FieldsFunc()

https://pkg.go.dev/strings#FieldsFunc

FieldsFunc() works similar to Fields() but it is more flexible in that it allows specifying the field separator(s).

arg := "A:B"
toks := strings.FieldsFunc(arg, func(r rune) bool {
  return r == ':'
})
// toks will be ["A", "B"]

Replace()

https://pkg.go.dev/strings#Replace

Replace(s, old, new, n) is a function in the strings package that replaces the first n instances of the old substring with the new substring. The string s is not modified, the function returns a new string instance.

Repeat()

https://pkg.go.dev/strings#Repeat
s := strings.Repeat(" ", 4)

ToLower()

https://pkg.go.dev/strings#ToLower

ToLower(s) is a function in the strings package that changes the whole string to lower case. The original string s is not modified, a new string instance is created and returned.

ToUpper()

https://pkg.go.dev/strings#ToUpper

ToUpper(s) is a function in the strings package that changes the whole string to upper case. The original string s is not modified, a new string instance is created and returned.

TrimSpace()

https://pkg.go.dev/strings#TrimSpace

TrimSpace(s) is a function in the strings package that returns a new string with all leading and trailing spaces removed.

Trim()

https://pkg.go.dev/strings#Trim

Trim() returns a slice of the string s with all leading and trailing Unicode code points contained in cutset removed.

s := ...
s = strings.Trim(s, "\n")

String Conversions

Conversion with strconv Functions

Conversion of a byte to string

Conversion between bytes and strings

Other String Operations

Repeating a Number of Characters

See strings.Repeat() above.

Padding

fmt Padding

TO DISTRIBUTE

Reading with a string with a Reader

TO PROCESS:

strings.NewReader()

See Go_Package_strings#NewReader.28.29

After Settling this Article, Process This

TODO: https://go.dev/blog/strings