web-dev-qa-db-fra.com

Comment supprimer les guillemets autour d'une chaîne dans Golang

J'ai une chaîne à Golang qui est entourée de guillemets. Mon but est d'enlever tous les guillemets sur les côtés, mais d'ignorer tous les guillemets à l'intérieur de la chaîne. Comment devrais-je m'y prendre? Mon instinct me dit d'utiliser une fonction RemoveAt comme en C #, mais je ne vois rien de tel dans Go.

Par exemple:

"hello""world"

devrait être converti en:

hello""world

Pour plus de précisions, ceci:

"""hello"""

deviendrait ceci:

""hello""

parce que les extérieurs doivent être enlevés SEULEMENT.

go
7
RamaRaunt

Utilisez une expression slice :

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

S'il existe une possibilité que les guillemets ne soient pas présents, utilisez ceci:

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

exemple de terrain de jeu

21
ThunderCat

Utilisez expressions slice . Vous devez écrire un code robuste qui fournit une sortie correcte pour une entrée imparfaite. Par exemple,

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))
    }
}

Sortie:

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

Vous pouvez tirer parti des tranches pour supprimer le premier et le dernier élément de la tranche.

package main

import "fmt"

func main() {
    str := `"hello""world"`

    if str[0] == '"' {
        str = str[1:]
    }
    if i := len(str)-1; str[i] == '"' {
        str = str[:i]
    }

    fmt.Println( str )
}

Puisqu'une tranche partage la mémoire sous-jacente, cela ne copie pas la chaîne. Il suffit de changer la tranche str pour recommencer un caractère et le terminer plus tôt.

Voici comment les différentes fonctions bytes.Trim fonctionnent.

2
Schwern