Go
Draad

Invoering

Syntaxis

• variableName: = "Hello World" // declareer een string
• variableName: = `Hallo wereld` // declareer een onbewerkte letterlijke tekenreeks
• variableName: = "Hallo" + "Wereld" // koppelt tekenreeksen samen
• substring: = "Hallo wereld" [0: 4] // haal een deel van de string
• letter: = "Hallo wereld" [6] // krijg een tekenreeks
• fmt.Sprintf ("% s", "Hello World") // maakt een string op

Stringtype

Met het string kunt u tekst opslaan, wat een reeks tekens is. Er zijn meerdere manieren om tekenreeksen te maken. Een letterlijke tekenreeks wordt gemaakt door de tekst tussen dubbele aanhalingstekens te schrijven.

text := "Hello World"

Omdat Go-strings UTF-8 ondersteunen, is het vorige voorbeeld perfect geldig. Strings bevatten willekeurige bytes, wat niet noodzakelijk betekent dat elke string geldige UTF-8 zal bevatten, maar stringliterals zullen altijd geldige UTF-8-reeksen bevatten.

De nulwaarde van strings is een lege string "" .

Tekenreeksen kunnen worden samengevoegd met de operator + .

text := "Hello " + "World"

Strings kunnen ook worden gedefinieerd met behulp van backticks `` . Dit creëert een onbewerkte letterlijke tekenreeks, wat betekent dat tekens niet worden ontkomen.

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

In het vorige voorbeeld ontsnapt text1 het \n teken dat een nieuwe regel vertegenwoordigt, terwijl text2 het nieuwe lijnteken rechtstreeks bevat. Als u text1 == text2 vergelijkt, is het resultaat true .

text2 := `Hello\nWorld` echter niet aan het \n teken, wat betekent dat de tekenreeks de tekst Hello\nWorld zonder een nieuwe regel. Dit komt overeen met het typen van text1 := "Hello\\nWorld" .

Tekst opmaken

Pakket fmt implementeert functies voor het afdrukken en opmaken van tekst met behulp van opmaakwerkwoorden . Werkwoorden worden weergegeven met een procentteken.

Algemene werkwoorden:

%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

Geheel getal:

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

Drijvende-komma en complexe bestanddelen:

%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

String en segment van bytes (gelijkwaardig behandeld met deze werkwoorden):

%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

Wijzer:

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

Met behulp van de werkwoorden kunt u tekenreeksen maken die meerdere typen samenvoegen:

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)

De functie Sprintf de tekenreeks in de eerste parameter op en vervangt de werkwoorden door de waarde van de waarden in de volgende parameters en retourneert het resultaat. Net als Sprintf wordt de functie Printf ook Sprintf , maar in plaats van het resultaat te retourneren, wordt de tekenreeks afgedrukt.

snaren pakket

• 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
  

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