Go
String

Einführung

Syntax

• variableName: = "Hello World" // deklariere eine Zeichenfolge
• variableName: = "Hello World" // deklariert eine unformatierte Zeichenfolge
• variableName: = "Hallo" + "Welt" // verkettet Zeichenketten
• substring: = "Hello World" [0: 4] // Einen Teil der Zeichenfolge erhalten
• letter: = "Hello World" [6] // Holen Sie sich ein Zeichen der Zeichenfolge
• fmt.Sprintf ("% s", "Hello World") // formatiert eine Zeichenfolge

String-Typ

Mit dem string können Sie Text speichern, der aus einer Reihe von Zeichen besteht. Es gibt mehrere Möglichkeiten, Strings zu erstellen. Eine Literalzeichenfolge wird erstellt, indem der Text zwischen Anführungszeichen gesetzt wird.

text := "Hello World"

Da Go-Zeichenfolgen UTF-8 unterstützen, ist das vorige Beispiel vollkommen gültig. Zeichenfolgen enthalten beliebige Bytes, was nicht unbedingt bedeutet, dass jede Zeichenfolge gültige UTF-8-Werte enthält, während Zeichenfolgenliterale immer gültige UTF-8-Sequenzen enthalten.

Der Nullwert von Zeichenfolgen ist eine leere Zeichenfolge "" .

Zeichenfolgen können mit dem Operator + verkettet werden.

text := "Hello " + "World"

Strings können auch mit den Backticks `` definiert werden. Dadurch wird ein Roh-String-Literal erstellt, das bedeutet, dass Zeichen nicht mit Escapezeichen versehen werden.

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

Im vorherigen Beispiel entgeht text1 dem \n Zeichen, das eine neue Zeile darstellt, während text2 das neue text2 direkt enthält. Wenn Sie text1 == text2 vergleichen, ist das Ergebnis true .

Allerdings würde text2 := `Hello\nWorld` das Zeichen \n nicht entgehen, was bedeutet, dass die Zeichenfolge den Text Hello\nWorld ohne eine neue Zeile enthält. text1 := "Hello\\nWorld" wäre gleichbedeutend mit der Eingabe von text1 := "Hello\\nWorld" .

Text formatieren

Package fmt implementiert Funktionen und Format Text drucken Format Verben verwenden. Verben werden mit einem Prozentzeichen dargestellt.

Allgemeine Verben:

%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

Boolean:

%t    // the word true or false

Ganze Zahl:

%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"

Fließkomma und komplexe Bestandteile:

%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

Zeichenfolge und Segment von Bytes (gleichwertig mit diesen Verben behandelt):

%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

Zeiger:

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

Mit den Verben können Sie Zeichenfolgen erstellen, die mehrere Typen verketten:

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)

Die Funktion Sprintf formatiert die Zeichenfolge im ersten Parameter, ersetzt die Verben durch den Wert der Werte in den nächsten Parametern und gibt das Ergebnis zurück. Wie Sprintf die Funktion Printf Formate auch , sondern das Ergebnis der Rücksendung druckt die Zeichenfolge.

String-Paket

• 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
  

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