Go
Strunowy

Wprowadzenie

Składnia

• zmiennaName: = „Hello World” // deklaruj ciąg
• variableName: = `Hello World` // deklaruj nieprzetworzony ciąg literału
• variableName: = „Hello” + „World” // łączy ciągi znaków
• substring: = "Hello World" [0: 4] // pobierz część ciągu
• letter: = "Hello World" [6] // pobierz znak ciągu
• fmt.Sprintf („% s”, „Hello World”) // formatuje ciąg

Typ łańcucha

Typ string pozwala przechowywać tekst, który jest ciągiem znaków. Istnieje wiele sposobów tworzenia ciągów. Dosłowny ciąg jest tworzony przez pisanie tekstu między podwójnymi cudzysłowami.

text := "Hello World"

Ponieważ łańcuchy Go obsługują UTF-8, poprzedni przykład jest całkowicie poprawny. Ciągi zawierają dowolne bajty, co niekoniecznie oznacza, że każdy ciąg będzie zawierał poprawne UTF-8, ale literały ciągów zawsze będą zawierać prawidłowe sekwencje UTF-8.

Wartość zerowa ciągów jest pustym ciągiem "" .

Ciągi mogą być łączone za pomocą operatora + .

text := "Hello " + "World"

Ciągi znaków można również zdefiniować za pomocą backticków `` . Tworzy to dosłowny ciąg znaków, co oznacza, że znaki nie będą uciekane.

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

W poprzednim przykładzie text1 unika znaku \n który reprezentuje nowy wiersz, podczas gdy text2 zawiera bezpośrednio nowy znak wiersza. Jeśli text1 == text2 wynik będzie true .

Jednak text2 := `Hello\nWorld` nie text2 := `Hello\nWorld` \n co oznacza, że łańcuch zawiera tekst Hello\nWorld bez nowej linii. Byłoby to równoważne wpisaniu tekstu text1 := "Hello\\nWorld" .

Formatowanie tekstu

Pakiet fmt implementuje funkcje drukowania i formatowania tekstu przy użyciu czasowników formatujących. Czasowniki są reprezentowane przez znak procentu.

Czasowniki ogólne:

%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

Liczba całkowita:

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

Zmienne zmiennoprzecinkowe i złożone składniki:

%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

Ciąg i kawałek bajtów (traktowane równorzędnie z tymi czasownikami):

%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

Wskaźnik:

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

Używając czasowników, możesz tworzyć ciągi łączące wiele typów:

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)

Funkcja Sprintf formatuje ciąg w pierwszym parametrze, zastępując czasowniki wartością wartości w kolejnych parametrach i zwraca wynik. Podobnie jak Sprintf , funkcja Printf również formatuje, ale zamiast zwracać wynik, drukuje ciąg.

pakiet ciągów

• 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
  

Więcej: https://golang.org/pkg/strings/ .