Go
Sträng

Introduktion

Syntax

• variabelnamn: = "Hello World" // förklara en sträng
• variabelnamn: = "Hello World" // förklara en rå bokstavssträng
• variabelnamn: = "Hej" + "Värld" // sammanfogar strängar
• substring: = "Hello World" [0: 4] // få en del av strängen
• letter: = "Hello World" [6] // få ett tecken på strängen
• fmt.Sprintf ("% s", "Hello World") // formaterar en sträng

Sträng typ

string låter dig lagra text, som är en serie tecken. Det finns flera sätt att skapa strängar. En bokstavlig sträng skapas genom att skriva texten mellan dubbla citat.

text := "Hello World"

Eftersom Go-strängar stöder UTF-8 är det föregående exemplet helt giltigt. Strängar har godtyckliga byte vilket inte nödvändigtvis betyder att varje sträng kommer att innehålla giltiga UTF-8 men strängbokstäver kommer alltid att ha giltiga UTF-8-sekvenser.

Nollvärdet för strängar är en tom sträng "" .

Strängar kan sammanlänkas med + operatören.

text := "Hello " + "World"

Strängar kan också definieras med backticks `` . Detta skapar en rå strängbokstav som betyder att tecken inte kommer att undkomma.

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

I föregående exempel text1 \n som representerar en ny rad medan text2 innehåller det nya text2 direkt. Om du jämför text1 == text2 kommer resultatet att vara true .

text2 := `Hello\nWorld` skulle emellertid inte undgå tecknet \n vilket innebär att strängen innehåller texten Hello\nWorld utan en ny rad. Det skulle motsvara att skriva text1 := "Hello\\nWorld" .

Formatera text

Paketet fmt implementerar funktioner för att skriva ut och formatera text med hjälp av formatverb . Verber representeras med ett procenttecken.

Allmänna verb:

%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

Heltal:

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

Flytande och komplexa beståndsdelar:

%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

Sträng och bitbit (behandlas likvärdigt med dessa verb):

%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

Pekare:

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

Med verben kan du skapa strängar som sammanlänker flera typer:

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)

Funktionen Sprintf formaterar strängen i den första parametern och ersätter verberna med värdet på värdena i nästa parametrar och returnerar resultatet. Liksom Sprintf också funktionen Printf men istället för att returnera resultatet skrivs den ut strängen.

strängar 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
  

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