strings

Le package strings implémente des fonctions simples pour manipuler les chaînes encodées en UTF-8. En termes simples, c'est un package d'outils pour manipuler les chaînes.

Documentation officielle : strings package - strings - Go Packages

TIP

Go supporte nativement UTF8, toutes les opérations sur les chaînes sont basées sur UTF8.

Import

import (
   "strings"
)

Les fonctions couramment utilisées seront expliquées sous forme d'exemples ci-dessous.

Copier une chaîne

func Clone(s string) string

Alloue une nouvelle mémoire pour la copie. Si une chaîne vide est passée, aucune mémoire n'est allouée et une chaîne vide est retournée.

func TestClone(t *testing.T) {
   ori := "hello monde"
   copys := strings.Clone(ori)
   fmt.Println(ori, copys)
   fmt.Println(&ori, &copys)
}

=== RUN   TestClone
hello monde hello monde
0xc00005e5d0 0xc00005e5e0
--- PASS: TestClone (0.00s)
PASS

Comparer des chaînes

func Compare(a, b string) int

Compare les chaînes a et b dans l'ordre lexicographique. Si a>b, retourne 1, si a<b retourne -1, si a=b retourne 0.

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

Contenir une sous-chaîne

func Contains(s, substr string) bool

Vérifie si une chaîne s contient une sous-chaîne substr

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

func ContainsAny(s, chars string) bool

Vérifie si le code Unicode de n'importe quel caractère dans la chaîne chars se trouve dans la chaîne s. En d'autres termes, vérifie si s contient n'importe quel caractère de chars.

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

func ContainsRune(s string, r rune) bool

Vérifie si la chaîne s contient le caractère r

func TestContainsRune(t *testing.T) {
   fmt.Println(strings.ContainsRune("abcedf", 'a'))
   fmt.Println(strings.ContainsRune("abcedf", 'b'))
   fmt.Println(strings.ContainsRune("bonjour monde", 'm'))
}

=== RUN   TestContainsRune
true
true
true
--- PASS: TestContainsRune (0.00s)
PASS

Nombre d'occurrences d'une sous-chaîne

func Count(s, substr string) int

Retourne le nombre d'occurrences de la sous-chaîne substr dans la chaîne s

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

Supprimer une sous-chaîne spécifiée

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

Supprime la première occurrence de la sous-chaîne sep dans s et retourne le résultat

before - la chaîne avant la sous-chaîne supprimée
after - la chaîne après la sous-chaîne supprimée
found - si la sous-chaîne a été trouvée

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

Égalité insensible à la casse

func EqualFold(s, t string) bool

Retourne si les chaînes s et t sont égales en ignorant la casse

func TestEqualFold(t *testing.T) {
   fmt.Println(strings.EqualFold("bonjour", "bonjour"))
   fmt.Println(strings.EqualFold("Hello", "Hello"))
   fmt.Println(strings.EqualFold("Hello", "hELLO"))
}

=== RUN   TestEqualFold
true
true
true
--- PASS: TestEqualFold (0.00s)
PASS

Diviser une chaîne

func Fields(s string) []string

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

La première divise la chaîne selon les espaces, la seconde divise la chaîne selon la valeur de retour de la fonction f.

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

Rechercher des préfixes et suffixes

func HasPrefix(s, prefix string) bool

func HasSuffix(s, suffix string) bool

La première recherche un préfixe, la seconde recherche un suffixe. Si vous êtes intéressé, vous pouvez consulter le code source, l'implémentation est assez ingénieuse.

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

Position d'une sous-chaîne

Retourne l'index de la première occurrence de la sous-chaîne

func Index(s, substr string) int

Retourne l'index de la première occurrence de n'importe quel caractère de la sous-chaîne

func IndexAny(s, chars string) int

Retourne l'index de la première occurrence du caractère

func IndexRune(s string, r rune) int

Exemple

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

Retourne l'index de la dernière occurrence de la sous-chaîne

func LastIndex(s, substr string) int

Retourne l'index de la dernière occurrence de n'importe quel caractère de la sous-chaîne

func LastIndexAny(s, chars string) int

Exemple

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

Parcourir et remplacer une chaîne

Map retourne une copie de la chaîne s et modifie tous les caractères de s selon la fonction de mappage. Si le mappage retourne une valeur négative, le caractère est supprimé de la chaîne sans être remplacé.

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

Exemple

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

Sortie

text

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

Répéter une chaîne

Copie la chaîne selon le count donné. Si count est négatif, cela provoque une panic

func Repeat(s string, count int) string

Exemple

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

Sortie

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

Remplacer une chaîne

s est la chaîne source, old est la partie à remplacer, new est la partie de remplacement, n est le nombre de remplacements. Si n est inférieur à 0, cela signifie un nombre illimité de remplacements.

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

Exemple

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

Sortie

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

Fonction pratique de Replace, équivalente à stings.Replace(s,old,new,-1)

func ReplaceAll(s, old, new string) string

Exemple

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

Sortie

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

Séparer une chaîne

Sépare la chaîne s en une tranche de chaînes selon la sous-chaîne sep

func Split(s, sep string) []string

Sépare la chaîne s en une tranche de chaînes selon la sous-chaîne sep, le nombre de séparations est déterminé par n

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

Sépare la chaîne s en une tranche de chaînes contenant sep selon la sous-chaîne sep

func SplitAfter(s, sep string) []string

Sépare la chaîne s en une tranche de chaînes contenant sep selon la sous-chaîne sep, le nombre de séparations est déterminé par n

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

Exemple

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

Sortie

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

Conversion majuscules/minuscules

Convertit une chaîne anglaise en minuscules

func ToLower(s string) string

Convertit en minuscules selon le unicode.SpecialCase de la langue correspondante

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

Convertit une chaîne anglaise en majuscules

func ToUpper(s string) string

Convertit en majuscules selon le unicode.SpecialCase de la langue correspondante

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

Exemple

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

Sortie

=== 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

Rogner une chaîne

Rogner les deux extrémités d'une chaîne, supprime toute sous-chaîne correspondant à cutset

func Trim(s, cutset string) string

Rogner l'extrémité gauche d'une chaîne, supprime toute sous-chaîne correspondant à cutset

func TrimLeft(s, cutset string) string

Rogner le préfixe de l'extrémité gauche d'une chaîne, supprime la sous-chaîne correspondant à cutset, si non correspondant retourne la chaîne s

func TrimPrefix(s, suffix string) string

Rogner l'extrémité droite d'une chaîne, supprime toute sous-chaîne correspondant à cutset

func TrimRight(s, cutset string) string

Rogner le suffixe de l'extrémité droite d'une chaîne, supprime la sous-chaîne correspondant à cutset, si non correspondant retourne la chaîne s

func TrimSuffix(s, suffix string) string

Exemple

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

Sortie

=== 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

StringBuilder

StringBuilder est plus économe en mémoire que la manipulation directe des chaînes.

type Builder struct {
  // champs internes non exposés
}

Exemple

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

Sortie

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

TIP

N'essayez pas de passer Builder par valeur. Par exemple, lorsque vous passez strings.Builder comme paramètre de fonction, le programme va panic

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

Le code interne contient ce passage

type Builder struct {
  addr *Builder //adresse de soi-même
  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")
   }
}

Lorsqu'une copie de valeur de Builder est effectuée, le pointeur de la tranche interne est également copié. Deux Builder écrivent dans la même tranche, c'est pourquoi la copie par valeur n'est pas autorisée.

StringReplacer

Replacer est spécialisé pour remplacer les chaînes

func NewReplacer(oldnew ...string) *Replacer

Exemple

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

Sortie

This is <b>HTML</b>!

StringReader

Reader implémente les interfaces io.Reader, io.ReaderAt, io.ByteReader, io.ByteScanner, io.RuneReader, io.RuneScanner, io.Seeker, et io.WriterTo.

func NewReader(s string) *Reader

Exemple

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

Sortie

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

strings ​

Import ​

Copier une chaîne ​

Comparer des chaînes ​

Contenir une sous-chaîne ​

Nombre d'occurrences d'une sous-chaîne ​

Supprimer une sous-chaîne spécifiée ​

Égalité insensible à la casse ​

Diviser une chaîne ​

Rechercher des préfixes et suffixes ​

Position d'une sous-chaîne ​

Parcourir et remplacer une chaîne ​

Répéter une chaîne ​

Remplacer une chaîne ​

Séparer une chaîne ​

Conversion majuscules/minuscules ​

Rogner une chaîne ​

StringBuilder ​

StringReplacer ​

StringReader ​

strings

Import

Copier une chaîne

Comparer des chaînes

Contenir une sous-chaîne

Nombre d'occurrences d'une sous-chaîne

Supprimer une sous-chaîne spécifiée

Égalité insensible à la casse

Diviser une chaîne

Rechercher des préfixes et suffixes

Position d'une sous-chaîne

Parcourir et remplacer une chaîne

Répéter une chaîne

Remplacer une chaîne

Séparer une chaîne

Conversion majuscules/minuscules

Rogner une chaîne

StringBuilder

StringReplacer

StringReader