Документация по синтаксису GoLang

Русский

English
简体中文
繁體中文

Русский

English
简体中文
繁體中文

Appearance

strings ​

Пакет strings реализует простые функции для работы со строками в кодировке UTF-8. Проще говоря, это пакет инструментов для работы со строками.

Официальная документация: strings package - strings - Go Packages

TIP

Go нативно поддерживает символы UTF8, все операции со строками основаны на UTF8.

Импорт ​

go
import (
   "strings"
)

Ниже будут рассмотрены часто используемые функции на примерах.

Копирование строки ​

go
func Clone(s string) string

Выделяет новую память для копии. Если передана пустая строка, память не выделяется и возвращается пустая строка.

go
func TestClone(t *testing.T) {
   ori := "hello 世界"
   copys := strings.Clone(ori)
   fmt.Println(ori, copys)
   fmt.Println(&ori, &copys)
}
=== RUN   TestClone
hello 世界 hello 世界
0xc00005e5d0 0xc00005e5e0
--- PASS: TestClone (0.00s)
PASS

Сравнение строк ​

go
func Compare(a, b string) int

Сравнивает строки a и b в лексикографическом порядке. Если a>b, возвращает 1; если a<b, возвращает -1; если a=b, возвращает 0.

go
func TestCompare(t *testing.T) {
  fmt.Println(strings.Compare("abc", "abe"))
  fmt.Println(strings.Compare("abcd", "abe"))
  fmt.Println(strings.Compare("abijk", "abe"))
  fmt.Println(strings.Compare("abe", "abe"))
}
=== RUN   TestCompare
-1
-1
1
0
--- PASS: TestCompare (0.00s)
PASS

Содержит ли строка подстроку ​

go
func Contains(s, substr string) bool

Проверяет, содержит ли строка s подстроку substr.

go
func TestContains(t *testing.T) {
  fmt.Println(strings.Contains("abcdefg", "a"))
  fmt.Println(strings.Contains("abcdefg", "abc"))
  fmt.Println(strings.Contains("abcdefg", "ba"))
}
=== RUN   TestContains
true
true
false
--- PASS: TestContains (0.00s)
PASS
go
func ContainsAny(s, chars string) bool

Проверяет, содержится ли любой из символов строки chars в строке s.

go
func TestContainsAny(t *testing.T) {
  fmt.Println(strings.ContainsAny("abcedfg", "bac"))
  fmt.Println(strings.ContainsAny("abcedfg", "gfdecba"))
}
=== RUN   TestContainsAny
true
--- PASS: TestContainsAny (0.00s)
PASS
go
func ContainsRune(s string, r rune) bool

Проверяет, содержит ли строка s символ r.

go
func TestContainsRune(t *testing.T) {
   fmt.Println(strings.ContainsRune("abcedf", 'a'))
   fmt.Println(strings.ContainsRune("abcedf", 'b'))
   fmt.Println(strings.ContainsRune("你好世界", '你'))
}
=== RUN   TestContainsRune
true
true
true
--- PASS: TestContainsRune (0.00s)
PASS

Количество вхождений подстроки ​

go
func Count(s, substr string) int

Возвращает количество вхождений подстроки substr в строке s.

go
func TestCount(t *testing.T) {
  fmt.Println(strings.Count("3.1415926", "1"))
  fmt.Println(strings.Count("there is a girl", "e"))
  fmt.Println(strings.Count("there is a girl", ""))
}
=== RUN   TestCount
2
2
16
--- PASS: TestCount (0.00s)
PASS

Удаление указанной подстроки ​

go
func Cut(s, sep string) (before, after string, found bool)

Удаляет первое вхождение подстроки sep в строке s и возвращает результат.

  • before — строка перед удалённой подстрокой
  • after — строка после удалённой подстроки
  • found — найдена ли подстрока
go
func TestCut(t *testing.T) {
  show := func(s, sep string) {
    before, after, found := strings.Cut(s, sep)
    fmt.Printf("Cut(%q, %q) = %q, %q, %v\n", s, sep, before, after, found)
  }
  show("Hello world", " ")
  show("Hello world", "world")
  show("Hello world", "Hello")
  show("Hello world", "Hello world")
}
=== RUN   TestCut
Cut("Hello world", " ") = "Hello", "world", true
Cut("Hello world", "world") = "Hello ", "", true
Cut("Hello world", "Hello") = "", " world", true
Cut("Hello world", "Hello world") = "", "", true
--- PASS: TestCut (0.00s)
PASS

Равенство без учёта регистра ​

go
func EqualFold(s, t string) bool

Возвращает, равны ли строки s и t без учёта регистра.

go
func TestEqualFold(t *testing.T) {
   fmt.Println(strings.EqualFold("你好", "你好"))
   fmt.Println(strings.EqualFold("Hello", "Hello"))
   fmt.Println(strings.EqualFold("Hello", "hELLO"))
}
=== RUN   TestEqualFold
true
true
true
--- PASS: TestEqualFold (0.00s)
PASS

Разделение строки ​

go
func Fields(s string) []string
go
func FieldsFunc(s string, f func(rune) bool) []string

Первая функция разделяет строку по пробелам, вторая использует функцию f для определения разделителей.

go
func TestField(t *testing.T) {
   fmt.Printf("%q\n", strings.Fields(" a b c d e f g "))
   fmt.Printf("%q\n", strings.FieldsFunc("a,b,c,d,e,f,g", func(r rune) bool {
      return r == ','
   }))
}
=== RUN   TestField
["a" "b" "c" "d" "e" "f" "g"]
["a" "b" "c" "d" "e" "f" "g"]
--- PASS: TestField (0.00s)
PASS

Поиск префикса и суффикса ​

go
func HasPrefix(s, prefix string) bool
go
func HasSuffix(s, suffix string) bool

Первая функция ищет префикс, вторая — суффикс.

go
func TestPreSuffix(t *testing.T) {
   str := "abbc cbba"
   fmt.Println(strings.HasPrefix(str, "abb"))
   fmt.Println(strings.HasSuffix(str, "bba"))
}
=== RUN   TestPreSuffix
true
true
--- PASS: TestPreSuffix (0.00s)
PASS

Позиция подстроки ​

Возвращает индекс первого вхождения подстроки:

go
func Index(s, substr string) int

Возвращает индекс первого вхождения любого символа из подстроки:

go
func IndexAny(s, chars string) int

Возвращает индекс первого вхождения символа rune:

go
func IndexRune(s string, r rune) int

Пример:

go
func TestIndex(t *testing.T) {
   fmt.Println(strings.Index("abcdefg", "bc"))
   fmt.Println(strings.IndexAny("abcdefg", "cb"))
   fmt.Println(strings.IndexRune("abcdefg", 'g'))
}
=== RUN   TestIndex
1
1
6
--- PASS: TestIndex (0.00s)
PASS

Возвращает индекс последнего вхождения подстроки:

go
func LastIndex(s, substr string) int

Возвращает индекс последнего вхождения любого символа из подстроки:

go
func LastIndexAny(s, chars string) int

Пример:

go
func TestLastIndex(t *testing.T) {
  fmt.Println(strings.LastIndex("abcdefga", "a"))
  fmt.Println(strings.LastIndexAny("abcdefghisa", "ba"))
}

Обход и замена символов ​

Map возвращает копию строки s, изменяя все символы согласно функции отображения. Если функция возвращает отрицательное значение, символ удаляется из строки.

go
func Map(mapping func(rune) rune, s string) string

Пример:

go
func TestMap(t *testing.T) {
   fmt.Println(strings.Map(func(r rune) rune {
      return r - 32
   }, "abcdefghijk"))
   fmt.Println(strings.Map(func(r rune) rune {
      return r + 32
   }, "ABCDEFGHIJK"))
   fmt.Println(strings.Map(func(r rune) rune {
      if r < 'F' {
         return -1
      } else {
         return r
      }
   }, "ABCDEFGHIJK"))
}

Вывод:

text
=== RUN   TestMap
ABCDEFGHIJK
abcdefghijk
FGHIJK
--- PASS: TestMap (0.00s)
PASS

Повторение строки ​

Повторяет строку указанное количество раз. Если count отрицательный, вызовет panic.

go
func Repeat(s string, count int) string

Пример:

go
func TestRepeat(t *testing.T) {
   fmt.Println(strings.Repeat("a", 10))
   fmt.Println(strings.Repeat("abc", 10))
}

Вывод:

=== RUN   TestRepeat
aaaaaaaaaa
abcabcabcabcabcabcabcabcabcabc
--- PASS: TestRepeat (0.00s)
PASS

Замена строки ​

s — исходная строка, old — часть для замены, new — замена для old, n — количество замен. Если n < 0, количество замен не ограничено.

go
func Replace(s, old, new string, n int) string

Пример:

go
func TestReplace(t *testing.T) {
   fmt.Println(strings.Replace("Hello this is golang", "golang", "c++", 1))
   fmt.Println(strings.Replace("Hello this is golang", "o", "c", -1))
   fmt.Println(strings.Replace("Hello this is golang", "o", "c", 1))
}

Вывод:

=== RUN   TestReplace
Hello this is c++
Hellc this is gclang
Hellc this is golang
--- PASS: TestReplace (0.00s)
PASS

Удобная функция для Replace, эквивалентна strings.Replace(s, old, new, -1):

go
func ReplaceAll(s, old, new string) string

Пример:

go
func TestReplaceAll(t *testing.T) {
  fmt.Println(strings.ReplaceAll("Hello this is golang", "o", "c++"))
}

Вывод:

=== RUN   TestReplaceAll
Hellc++ this is gc++lang
--- PASS: TestReplaceAll (0.00s)
PASS

Разделение строки ​

Разделяет строку s на срез строк по разделителю sep:

go
func Split(s, sep string) []string

Разделяет строку s на срез строк по разделителю sep, количество разделений определяется n:

go
func SplitN(s, sep string, n int) []string

Разделяет строку s на срез строк, включающий sep:

go
func SplitAfter(s, sep string) []string

Разделяет строку s на срез строк, включающий sep, количество разделений определяется n:

go
func SplitAfterN(s, sep string, n int) []string

Пример:

go
func TestSplit(t *testing.T) {
   fmt.Printf("%q\n", strings.Split("this is go language", " "))
   fmt.Printf("%q\n", strings.SplitN("this is go language", " ", 2))
   fmt.Printf("%q\n", strings.SplitAfter("this is go language", " "))
   fmt.Printf("%q\n", strings.SplitAfterN("this is go language", " ", 2))
}

Вывод:

=== RUN   TestSplit
["this" "is" "go" "language"]
["this" "is go language"]
["this " "is " "go " "language"]
["this " "is go language"]
--- PASS: TestSplit (0.00s)
PASS

Преобразование регистра ​

Преобразует строку в нижний регистр:

go
func ToLower(s string) string

Преобразует строку в нижний регистр согласно unicode.SpecialCase для соответствующего языка:

go
func ToLowerSpecial(c unicode.SpecialCase, s string) string

Преобразует строку в верхний регистр:

go
func ToUpper(s string) string

Преобразует строку в верхний регистр согласно unicode.SpecialCase для соответствующего языка:

go
func ToUpperSpecial(c unicode.SpecialCase, s string) string

Пример:

go
func TestLowerAndUpper(t *testing.T) {
   fmt.Println(strings.ToLower("My name is jack,Nice to meet you!"))
   fmt.Println(strings.ToLowerSpecial(unicode.TurkishCase, "Önnek İş"))
   fmt.Println(strings.ToUpper("My name is jack,Nice to meet you!"))
   fmt.Println(strings.ToUpperSpecial(unicode.TurkishCase, "örnek iş"))
}

Вывод:

=== RUN   TestLowerAndUpper
my name is jack,nice to meet you!
önnek iş
MY NAME IS JACK,NICE TO MEET YOU!
ÖRNEK İŞ
--- PASS: TestLowerAndUpper (0.00s)
PASS

Обрезка строки ​

Обрезает строку с обеих сторон, удаляя любые совпадающие символы из cutset:

go
func Trim(s, cutset string) string

Обрезает строку слева, удаляя любые совпадающие символы из cutset:

go
func TrimLeft(s, cutset string) string

Обрезает префикс слева, удаляя совпадающий cutset, если не совпадает — возвращает строку s:

go
func TrimPrefix(s, suffix string) string

Обрезает строку справа, удаляя любые совпадающие символы из cutset:

go
func TrimRight(s, cutset string) string

Обрезает суффикс справа, удаляя совпадающий cutset, если не совпадает — возвращает строку s:

go
func TrimSuffix(s, suffix string) string

Пример:

go
func TestTrim(t *testing.T) {
  fmt.Println(strings.Trim("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimLeft("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimRight("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimPrefix("!!this is a test statement!!", "!!!"))
  fmt.Println(strings.TrimSuffix("!!this is a test statement!!", "!!!"))
}

Вывод:

=== RUN   TestTrim
this is a test statement
this is a test statement!!
!!this is a test statement
!!this is a test statement!!
!!this is a test statement!!
--- PASS: TestTrim (0.00s)
PASS

Построитель строк Builder ​

Builder более эффективен по памяти, чем прямая работа со строками.

go
type Builder struct {
  // Внутренние поля не доступны извне
}

Пример:

go
func TestBuilder(t *testing.T) {
   builder := strings.Builder{}
   builder.WriteString("hello")
   builder.WriteString(" world")
   fmt.Println(builder.Len())
   fmt.Println(builder.String())
}

Вывод:

=== RUN   TestBuilder
11
hello world
--- PASS: TestBuilder (0.00s)
PASS

TIP

Не следует передавать Builder как значение, например, в качестве параметра функции. Программа вызовет panic:

strings: illegal use of non-zero Builder copied by value

Внутри имеется следующий код:

go
type Builder struct {
  addr *Builder // адрес самого себя
  buf  []byte
}

func (b *Builder) copyCheck() {
   if b.addr == nil {
      b.addr = (*Builder)(noescape(unsafe.Pointer(b)))
   } else if b.addr != b {
      panic("strings: illegal use of non-zero Builder copied by value")
   }
}

При копировании значения Builder также копируется указатель внутреннего среза, и оба Builder при записи строки оперируют одним и тем же срезом. Это и есть причина, почему копирование значений запрещено.

Заменитель строк Replacer ​

Replacer используется для замены строк:

go
func NewReplacer(oldnew ...string) *Replacer

Пример:

go
func TestReplacer(t *testing.T) {
  r := strings.NewReplacer("<", "<", ">", ">")
  fmt.Println(r.Replace("This is <b>HTML</b>!"))
}

Вывод:

This is <b>HTML</b>!

Читатель строк Reader ​

Reader реализует интерфейсы io.Reader, io.ReaderAt, io.ByteReader, io.ByteScanner, io.RuneReader, io.RuneScanner, io.Seeker и io.WriterTo.

go
func NewReader(s string) *Reader

Пример:

go
func TestReader(t *testing.T) {
   reader := strings.NewReader("abcdefghijk")
   buffer := make([]byte, 20, 20)
   read, err := reader.Read(buffer)
   if err != nil {
      log.Panic(err)
   }
   fmt.Println(read)
   fmt.Println(string(buffer))
}

Вывод:

=== RUN   TestReader
11
abcdefghijk
--- PASS: TestReader (0.00s)
PASS

Golang by www.golangdev.cn edit

MIT Licensed | Copyright © 2023-present