Documentation
¶
Overview ¶
Additional functions for processing strings in multi-byte sequence.
Index ¶
- func At(str string, i int) string
- func Chunk(str string, length int) []string
- func Index(str string, sub string) int
- func LastIndex(str string, sub string) int
- func Length(str string) int
- func PadEnd(str string, finalLength int, padStr string) string
- func PadStart(str string, finalLength int, padStr string) string
- func Search(str string, pattern string) int
- func Slice(str string, start int, end int) string
- func Substring(str string, start int, end int) string
- func Truncate(str string, length int) string
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func At ¶
Returns the character from the string according to the given index.
If `i < 0`, it returns the character counting from the end of the string.
If the given index doesn't contain a value (boundary exceeded), an empty string will be returned.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "Hello, World!"
str2 := "你好，世界！"
str3 := "Hello, 世界！"
char1 := mbstring.At(str1, 7)
char2 := mbstring.At(str2, 3)
char3 := mbstring.At(str3, 7)
char4 := mbstring.At(str3, 10)
char5 := mbstring.At("", 0) // an empty string always returns an empty string
fmt.Println(char1)
fmt.Println(char2)
fmt.Println(char3)
fmt.Printf("%#v\n", char4)
fmt.Printf("%#v\n", char5)
}
Output: W 世 世 "" ""
func Chunk ¶
Breaks the string into smaller chunks according to the given length.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "foobar"
str2 := "你好世界"
chunks1 := mbstring.Chunk(str1, 2)
chunks2 := mbstring.Chunk(str1, 4)
chunks3 := mbstring.Chunk(str2, 2)
chunks4 := mbstring.Chunk(str2, 3)
fmt.Println(chunks1)
fmt.Println(chunks2)
fmt.Println(chunks3)
fmt.Println(chunks4)
}
Output: [fo ob ar] [foob ar] [你好 世界] [你好世 界]
func Index ¶
Returns the index at which a given sub string can be found in the string, or -1 if it is not present.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "Hello, World!"
str2 := "你好，世界！"
str3 := "Hello, 世界！"
idx1 := mbstring.Index(str1, "World")
idx2 := mbstring.Index(str2, "世界")
idx3 := mbstring.Index(str3, "世界")
idx4 := mbstring.Index(str3, "你好")
idx5 := mbstring.Index("", "")
idx6 := mbstring.Index("", "你好")
fmt.Println(idx1)
fmt.Println(idx2)
fmt.Println(idx3)
fmt.Println(idx4)
fmt.Println(idx5)
fmt.Println(idx6)
}
Output: 7 3 7 -1 0 -1
func LastIndex ¶
Returns the last index at which a given sub string can be found in the string, or -1 if it is not present. The string is searched backwards.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "Hello, World!"
str2 := "你好，世界！Hi, 世界"
str3 := "Hello, 世界！Hi, 世界"
idx1 := mbstring.LastIndex(str1, "o")
idx2 := mbstring.LastIndex(str2, "世界")
idx3 := mbstring.LastIndex(str3, "H")
idx4 := mbstring.LastIndex(str3, "你好")
idx5 := mbstring.LastIndex("", "")
idx6 := mbstring.LastIndex("", "你好")
fmt.Println(idx1)
fmt.Println(idx2)
fmt.Println(idx3)
fmt.Println(idx4)
fmt.Println(idx5)
fmt.Println(idx6)
}
Output: 8 10 10 -1 0 -1
func Length ¶
Returns the number of the characters in the string.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "Hello, World!"
str2 := "你好，世界！"
str3 := "Hello, 世界！"
len1 := mbstring.Length(str1)
len2 := mbstring.Length(str2)
len3 := mbstring.Length(str3)
fmt.Println(len1)
fmt.Println(len2)
fmt.Println(len3)
}
Output: 13 6 10
func PadEnd ¶
Pads the given string with another string (multiple times, if needed) until the resulting string reaches the final length. The padding is applied from the end of the string.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "你好，世界！"
str2 := mbstring.PadEnd(str1, 8, " ")
str3 := mbstring.PadEnd(str1, 8, "*")
str4 := mbstring.PadEnd(str1, 8, "Hi")
str5 := mbstring.PadEnd(str1, 8, "Hola")
str6 := mbstring.PadEnd(str1, 5, "**")
str7 := mbstring.PadEnd(str1, 12, "Hola")
fmt.Printf("%#v\n", str2)
fmt.Println(str3)
fmt.Println(str4)
fmt.Println(str5)
fmt.Println(str6)
fmt.Println(str7)
}
Output: "你好，世界！ " 你好，世界！** 你好，世界！Hi 你好，世界！Ho 你好，世界！ 你好，世界！HolaHo
func PadStart ¶
Pads the given string with another string (multiple times, if needed) until the resulting string reaches the final length. The padding is applied from the start of the string.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "你好，世界！"
str2 := mbstring.PadStart(str1, 8, " ")
str3 := mbstring.PadStart(str1, 8, "*")
str4 := mbstring.PadStart(str1, 8, "Hi")
str5 := mbstring.PadStart(str1, 8, "Hola")
str6 := mbstring.PadStart(str1, 5, "**")
str7 := mbstring.PadStart(str1, 12, "Hola")
fmt.Printf("%#v\n", str2)
fmt.Println(str3)
fmt.Println(str4)
fmt.Println(str5)
fmt.Println(str6)
fmt.Println(str7)
}
Output: " 你好，世界！" **你好，世界！ Hi你好，世界！ Ho你好，世界！ 你好，世界！ HolaHo你好，世界！
func Search ¶
Executes a search for a match between a regular expression and the string, returning the index of the first match in the string.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str := "你好，世界！"
idx1 := mbstring.Search(str, "，\\S+")
idx2 := mbstring.Search(str, "，\\s+")
fmt.Println(idx1)
fmt.Println(idx2)
}
Output: 2 -1
func Slice ¶
Returns a section of the string selected from `start` to `end` (excluded).
If `start < 0`, it will be calculated as `Length(str) + start`.
If `end < 0`, it will be calculated as `Length(str) + end`.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "Hello, World!"
str2 := "你好，世界！"
str3 := "Hello, 世界！"
str4 := mbstring.Slice(str1, 0, 5)
str5 := mbstring.Slice(str2, 3, -1)
str6 := mbstring.Slice(str3, -3, -1)
str7 := mbstring.Slice(str3, -3, -5)
str8 := mbstring.Slice(str3, 5, 3)
fmt.Println(str4)
fmt.Println(str5)
fmt.Println(str6)
fmt.Printf("%#v\n", str7)
fmt.Printf("%#v\n", str8)
}
Output: Hello 世界 世界 "" ""
func Substring ¶
Returns a section of the string selected from `start` to `end` (excluded).
This function is similar to the `Slice()`, except it doesn't accept negative positions.
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "Hello, World!"
str2 := "你好，世界！"
str3 := mbstring.Substring(str1, 0, 5)
str4 := mbstring.Substring(str2, 5, 3)
str5 := mbstring.Substring(str2, 3, 20)
str6 := mbstring.Substring(str2, -1, 5) // negative index will be reset to 0
str7 := mbstring.Substring(str2, 7, -1)
fmt.Println(str3)
fmt.Printf("%#v\n", str4)
fmt.Println(str5)
fmt.Println(str6)
fmt.Printf("%#v\n", str7)
}
Output: Hello "" 世界！ 你好，世界 ""
func Truncate ¶
Truncates the given string to the given length (including the ending `...`).
Example ¶
package main
import (
"fmt"
"github.com/ayonli/goext/stringx/mbstring"
)
func main() {
str1 := "Hello, World!"
str2 := mbstring.Truncate(str1, 15)
str3 := mbstring.Truncate(str1, 12)
str4 := mbstring.Truncate(str1, 10)
str5 := mbstring.Truncate(str1, -1) // 0 or negative length return an empty string
str6 := "你好，世界！Hallo 世界！"
str7 := mbstring.Truncate(str6, 15)
str8 := mbstring.Truncate(str6, 12)
str9 := mbstring.Truncate(str6, 10)
str10 := mbstring.Truncate(str6, -1)
fmt.Println(str2)
fmt.Println(str3)
fmt.Println(str4)
fmt.Printf("%#v\n", str5)
fmt.Println(str7)
fmt.Println(str8)
fmt.Println(str9)
fmt.Printf("%#v\n", str10)
}
Output: Hello, World! Hello, Wo... Hello, ... "" 你好，世界！Hallo 世界！ 你好，世界！Hal... 你好，世界！H... ""
Types ¶
This section is empty.
Source Files