So entfernen Sie Anführungszeichen um eine Zeichenfolge in Golang

Ich habe eine Zeichenfolge in Golang, die von Anführungszeichen umgeben ist. Mein Ziel ist es, alle Anführungszeichen auf den Seiten zu entfernen, aber alle Anführungszeichen im Inneren der Zeichenfolge zu ignorieren. Wie soll ich das machen? Mein Instinkt sagt mir, dass ich eine RemoveAt-Funktion wie in C# verwenden soll, aber in Go sehe ich nichts dergleichen.So entfernen Sie Anführungszeichen um eine Zeichenfolge in Golang

Zum Beispiel:

hello""world

Zur weiteren Klärung dieser:

"hello""world"

sollte umgewandelt werden

"""hello"""

dies werden würde:

""hello""

weil die äußeren NUR entfernt werden sollten. ein

Quelle

2017-05-27 RamaRaunt

Verwendung slice expression:

s = s[1 : len(s)-1]

Wenn eine Möglichkeit gibt es, dass die Anführungszeichen nicht vorhanden sind, dann verwenden:

if len(s) > 0 && s[0] == '"' { 
    s = s[1:] 
} 
if len(s) > 0 && s[len(s)-1] == '"' { 
    s = s[:len(s)-1] 
}

playground example

Quelle

2017-05-27 23:56:33

Sie können die Vorteile von Scheiben nehmen zu entfernen das erste und letzte Element der Scheibe.

Da ein Slice den zugrunde liegenden Speicher teilt, wird die Zeichenfolge nicht kopiert. Es ändert nur die str Scheibe, um ein Zeichen zu beginnen, und endet ein Zeichen früher.

So funktioniert the various bytes.Trim functions arbeiten.

Quelle

2017-05-28 00:05:33 Schwern

Diese Antwort kopiert die Daten zweimal, einmal in der Zeichenfolge [] Byte Konvertierung und einmal im [] Byte String-Konvertierung. –

@ CeriseLimón Danke, ich lerne immer noch die Beziehung zwischen String und [] Byte. Ich hatte eine Seite, die erklärte, wann eine Kopie passieren würde und wann nicht, aber ich habe sie verlegt. Hast du eine Ressource? – Schwern

Das Backing-Array eines Strings ist unveränderlich, und das Backing-Array eines [] Bytes ist veränderbar. Daraus folgt, dass das Hintergrund-Array kopiert werden muss, wenn von einem Typ in einen anderen konvertiert wird. Das heißt, es gibt Fälle, in denen der Compiler beweisen kann, dass während der Lebensdauer der Zeichenfolge keine Änderungen am [] Byte vorgenommen werden. In diesen Fällen teilt die Zeichenfolge das Backing-Array des [] Bytes. Ein solcher Fall ist die Verwendung eines [] Bytes, um einen Wert in einer Map [string] zu suchen: "m [string (p)]". Die von der Konvertierung zurückgegebene Zeichenfolge teilt das Backing-Array mit dem [] Byte p. –

Verwenden Sie slice expressions. Sie sollten robusten Code schreiben, der eine korrekte Ausgabe für fehlerhafte Eingaben liefert. Zum Beispiel

package main 

import "fmt" 

func trimQuotes(s string) string { 
    if len(s) >= 2 { 
     if s[0] == '"' && s[len(s)-1] == '"' { 
      return s[1 : len(s)-1] 
     } 
    } 
    return s 
} 

func main() { 
    tests := []string{ 
     `"hello""world"`, 
     `"""hello"""`, 
     `"`, 
     `""`, 
     `"""`, 
     `goodbye"`, 
     `"goodbye"`, 
     `goodbye"`, 
     `good"bye`, 
    } 

    for _, test := range tests { 
     fmt.Printf("`%s` -> `%s`\n", test, trimQuotes(test)) 
    } 
}

Ausgang:

`"hello""world"` -> `hello""world` 
`"""hello"""` -> `""hello""` 
`"` -> `"` 
`""` -> `` 
`"""` -> `"` 
`goodbye"` -> `goodbye"` 
`"goodbye"` -> `goodbye` 
`goodbye"` -> `goodbye"` 
`good"bye` -> `good"bye`

Quelle

2017-05-28 01:03:01 peterSO

So entfernen Sie Anführungszeichen um eine Zeichenfolge in Golang

Antwort

Verwandte Themen