How to remove quotes from around a string in Golang

I have a string in Golang that is surrounded by quote marks. My goal is to remove all quote marks on the sides, but to ignore all quote marks in the interior of the string. How should I go about doing this? My instinct tells me to use a RemoveAt function like in C#, but I don't see anything like that in Go.

For instance:

"hello""world"

should be converted to:

hello""world

For further clarification, this:

"""hello"""

would become this:

""hello""

because the outer ones should be removed ONLY.

Use a slice expression:

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

If there's a possibility that the quotes are not present, then use this:

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

playground example

strings.Trim() can be used to remove the leading and trailing whitespace from a string. It won't work if the double quotes are in between the string.

// strings.Trim() will remove all the occurrences from the left and right

s := `"""hello"""`
fmt.Println("Before Trim: " + s)                    // Before Trim: """hello"""
fmt.Println("After Trim: " + strings.Trim(s, "\"")) // After Trim: hello

// strings.Trim() will not remove any occurrences from inside the actual string

s2 := `""Hello" " " "World""`
fmt.Println("\nBefore Trim: " + s2)                  // Before Trim: ""Hello" " " "World""
fmt.Println("After Trim: " + strings.Trim(s2, "\"")) // After Trim: Hello" " " "World

Playground link - https://go.dev/play/p/yLdrWH-1jCE

Use slice expressions. You should write robust code that provides correct output for imperfect input. For example,

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

Output:

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

You can take advantage of slices to remove the first and last element of the slice.

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

Since a slice shares the underlying memory, this does not copy the string. It just changes the str slice to start one character over, and end one character sooner.

This is how the various bytes.Trim functions work.

A one-liner using regular expressions...

quoted = regexp.MustCompile(`^"(.*)"$`).ReplaceAllString(quoted,`$1`)

But it doesn't necessarily handle escaped quotes they way you might want.

The Go Playground

Translated from here.