Go
Chaîne

Introduction

Syntaxe

• variableName: = "Hello World" // déclare une chaîne
• variableName: = `Hello World` // déclare une chaîne littérale brute
• variableName: = "Bonjour" + "Monde" // concatène les chaînes
• sous-chaîne: = "Hello World" [0: 4] // récupère une partie de la chaîne
• lettre: = "Hello World" [6] // obtient un caractère de la chaîne
• fmt.Sprintf ("% s", "Hello World") // formate une chaîne

Type de chaîne

Le type de string vous permet de stocker du texte, qui est une série de caractères. Il existe plusieurs façons de créer des chaînes. Une chaîne littérale est créée en écrivant le texte entre guillemets doubles.

text := "Hello World"

Parce que les chaînes Go prennent en charge UTF-8, l'exemple précédent est parfaitement valide. Les chaînes contiennent des octets arbitraires, ce qui ne signifie pas nécessairement que chaque chaîne contiendra un code UTF-8 valide, mais les chaînes de caractères contiendront toujours des séquences UTF-8 valides.

La valeur zéro des chaînes est une chaîne vide "" .

Les chaînes peuvent être concaténées à l'aide de l'opérateur + .

text := "Hello " + "World"

Les chaînes peuvent également être définies en utilisant les backticks `` . Cela crée un littéral de chaîne brut, ce qui signifie que les caractères ne seront pas échappés.

text1 := "Hello\nWorld"
text2 := `Hello
World`

Dans l'exemple précédent, text1 échappe au caractère \n qui représente une nouvelle ligne alors que text2 contient directement le nouveau caractère de ligne. Si vous comparez text1 == text2 le résultat sera true .

Cependant, text2 := `Hello\nWorld` n'échapperait pas au caractère \n , ce qui signifie que la chaîne contient le texte Hello\nWorld sans nouvelle ligne. Ce serait l'équivalent de taper text1 := "Hello\\nWorld" .

Formatage du texte

Le package fmt implémente des fonctions pour imprimer et formater du texte à l'aide de verbes de format. Les verbes sont représentés avec un signe de pourcentage.

Verbes généraux:

%v    // the value in a default format
      // when printing structs, the plus flag (%+v) adds field names
%#v   // a Go-syntax representation of the value
%T    // a Go-syntax representation of the type of the value
%%    // a literal percent sign; consumes no value

Booléen:

%t    // the word true or false

Entier:

%b    // base 2
%c    // the character represented by the corresponding Unicode code point
%d    // base 10
%o    // base 8
%q    // a single-quoted character literal safely escaped with Go syntax.
%x    // base 16, with lower-case letters for a-f
%X    // base 16, with upper-case letters for A-F
%U    // Unicode format: U+1234; same as "U+%04X"

Composants à virgule flottante et complexes:

%b    // decimalless scientific notation with exponent a power of two,
      // in the manner of strconv.FormatFloat with the 'b' format,
      // e.g. -123456p-78
%e    // scientific notation, e.g. -1.234456e+78
%E    // scientific notation, e.g. -1.234456E+78
%f    // decimal point but no exponent, e.g. 123.456
%F    // synonym for %f
%g    // %e for large exponents, %f otherwise
%G    // %E for large exponents, %F otherwise

Chaîne et tranche d'octets (traitées de manière équivalente avec ces verbes):

%s    // the uninterpreted bytes of the string or slice
%q    // a double-quoted string safely escaped with Go syntax
%x    // base 16, lower-case, two characters per byte
%X    // base 16, upper-case, two characters per byte

Aiguille:

%p    // base 16 notation, with leading 0x

En utilisant les verbes, vous pouvez créer des chaînes concaténant plusieurs types:

text1 := fmt.Sprintf("Hello %s", "World")
text2 := fmt.Sprintf("%d + %d = %d", 2, 3, 5)
text3 := fmt.Sprintf("%s, %s (Age: %d)", "Obama", "Barack", 55)

La fonction Sprintf formate la chaîne dans le premier paramètre en remplaçant les verbes par la valeur des valeurs dans les paramètres suivants et renvoie le résultat. Comme Sprintf , la fonction Printf également mais au lieu de retourner le résultat, elle imprime la chaîne.

paquet de chaînes

• strings.Contains

  fmt.Println(strings.Contains("foobar", "foo")) // true
  fmt.Println(strings.Contains("foobar", "baz")) // false
  

• strings.HasPrefix

  fmt.Println(strings.HasPrefix("foobar", "foo")) // true
  fmt.Println(strings.HasPrefix("foobar", "baz")) // false
  

• strings.HasSuffix

  fmt.Println(strings.HasSuffix("foobar", "bar")) // true
  fmt.Println(strings.HasSuffix("foobar", "baz")) // false
  

• strings.Join

  ss := []string{"foo", "bar", "bar"}
  fmt.Println(strings.Join(ss, ", ")) // foo, bar, baz
  

• strings.Replace

  fmt.Println(strings.Replace("foobar", "bar", "baz", 1)) // foobaz
  

• strings.Split

  s := "foo, bar, bar"
  fmt.Println(strings.Split(s, ", ")) // [foo bar baz]
  

• strings.ToLower

  fmt.Println(strings.ToLower("FOOBAR")) // foobar
  

• strings.ToUpper

  fmt.Println(strings.ToUpper("foobar")) // FOOBAR
  

• strings.TrimSpace

  fmt.Println(strings.TrimSpace("  foobar  ")) // foobar
  

Plus: https://golang.org/pkg/strings/ .