957

Does Go have anything similar to Python's multiline strings: 

"""line 1 line 2 line 3"""

If not, what is the preferred way of writing strings spanning multiple lines?

Improve this question
2
  • Ref stackoverflow.com/questions/32042989/… Commented Nov 21, 2019 at 9:01
  • With respect to this question, we can use the idea of that of Java Programming language, which specifically is the same by using the "\n". For example, we have ` package main import "fmt" func main() { fmt.Print("Welcome\nto\nGo Programming Language!\nDo enjoy the day\nfriends") } ` Commented Sep 4, 2024 at 5:56

13 Answers 13

Reset to default
1487

According to the language specification, you can use a raw string literal, where the string is delimited by backticks instead of double quotes.

`line 1 line 2 line 3`
Improve this answer
Sign up to request clarification or add additional context in comments.

11 Comments

As a side note: The 'raw quote' as it is called, does not parse escape sequences. It is therefor the string literal of choice to write regular expression patterns as they usually contain non-standard escape sequences that would make the Go compiler complain of not double-escaped. It keeps the patterns clean and relatively readable.
Need to be careful with this when using endline spaces though. For example if you put a space after line 1 it will be invisible in your editor but present in the string.
@DanieleD That's a slight nonsequitur, but which dialect? Presumably mainly MySQL? stackoverflow.com/a/10574031 Note that by extension of the same argument, it's a pain for embedding markdown, or shell scripts (if you opt to use backtick in place of $(abcd)).
@KyleHeuton: Presumably Daniele D is using the backtick character in his/her SQL queries (as MySQL users often do), and finds it painful to have to represent it as ` + "`" + ` and break copy-and-pastability.
If people are having issues with this for MySQL, note you can always set the session sql mode e.g. SET SESSION sql_mode = 'ANSI_QUOTES'; which will Treat " as an identifier quote character (like the backtick quote character) and not as a string quote character. Then just make sure to use apostrophe ' for string literals which every SQL database I've ever seen does. see dev.mysql.com/doc/refman/5.7/en/…
|
187

You can write:

"line 1" + "line 2" + "line 3"

which is the same as:

"line 1line 2line 3"

Unlike using back ticks, it will preserve escape characters. Note that the "+" must be on the 'leading' line - for instance, the following will generate an error:

"line 1" +"line 2"
Improve this answer

7 Comments

This solution is not analogous to Python's multiline strings. It splits the string literal over multiple lines, but the string itself does not contain multiple lines.
Since this preserves escape characters, new lines can be simply added with \n and is much easier to work with dynamic strings and such. If I am correct, the accepted answer really is for static strings in code to make it look pretty.
Wouldn't that be very inefficient as well? Let the string be 3x a 6 char sequence: 6 + 2*6 +3*6 = 36 chars allocated when optimal would be 18 (since strings are immutable, every time you add two string a new string is created with length of the two strings concatenated).
@N0thing: if there is only string literals, there is no runtime differences as the compiler will optimize. But there is a small (microseconds, or even nanoseconds) difference in compile time.
I believe this is the best way to get a multiline string literal with CRLF line endings
|
72

Use raw string literals for multi-line strings:

func main(){ multiline := `line by line and line after line` }

Raw string literals

Raw string literals are character sequences between back quotes, as in `foo`. Within the quotes, any character may appear except back quote.

A significant part is that is raw literal not just multi-line and to be multi-line is not the only purpose of it.

The value of a raw string literal is the string composed of the uninterpreted (implicitly UTF-8-encoded) characters between the quotes; in particular, backslashes have no special meaning...

So escapes will not be interpreted and new lines between ticks will be real new lines.

func main(){ multiline := `line by line \n and line \n after line` // \n will be just printed. // But new lines are there too. fmt.Print(multiline) }

Concatenation

Possibly you have long line which you want to break and you don't need new lines in it. In this case you could use string concatenation.

func main(){ multiline := "line " + "by line " + "and line " + "after line" fmt.Print(multiline) // No new lines here }

Since " " is interpreted string literal escapes will be interpreted.

func main(){ multiline := "line " + "by line \n" + "and line \n" + "after line" fmt.Print(multiline) // New lines as interpreted \n }
Improve this answer

1 Comment

in Perl constructions look a way better!
48

From String literals:

  • raw string literal supports multiline (but escaped characters aren't interpreted)
  • interpreted string literal interpret escaped characters, like '\n'.

But, if your multi-line string has to include a backquote (`), then you will have to use an interpreted string literal:

`line one line two ` + "`" + `line three line four`

You cannot directly put a backquote (`) in a raw string literal (``xx\).
You have to use (as explained in "how to put a backquote in a backquoted string?"):

 + "`" + ...
Improve this answer

Comments

17

Go and multiline strings

Using back ticks you can have multiline strings:

package main import "fmt" func main() { message := `This is a Multi-line Text String Because it uses the raw-string back ticks instead of quotes. ` fmt.Printf("%s", message) }

Instead of using either the double quote (“) or single quote symbols (‘), instead use back-ticks to define the start and end of the string. You can then wrap it across lines.

If you indent the string though, remember that the white space will count.

Please check the playground and do experiments with it.

Improve this answer

1 Comment

Is there a way to ident such strings? In Perl I can format them in a pretty way, but I can not find anything close to it in Go.
10

Creating a multiline string in Go is actually incredibly easy. Simply use the backtick (`) character when declaring or assigning your string value.

package main import ( "fmt" ) func main() { // String in multiple lines str := `This is a multiline string.` fmt.Println(str + "\n") // String in multiple lines with tab tabs := `This string will have tabs in it` fmt.Println(tabs) }
Improve this answer

Comments

7

For those use cases where readability is more important than performance then i'd suggest this simple method:

func multiline(parts ...string) string { return strings.Join(parts, "\n") }

This is how you use it:

multiline( "this", "is a", "multiline", "text", ),

It generates:

"this\nis a\nmultiline\ntext"

basically

This is a multiline text

Why i like it more than the backticks?

Because you can keep things aligned and easy to read:

// With backticks aYmlList := `- first_name: John last_name: Doe - first_name: John last_name: McClane` // With multiline method aYmlList := multiline( "- first_name: John", " last_name: Doe", "- first_name: John", " last_name: McClane", )
Improve this answer

3 Comments

You can use the below method too: package main import "fmt" func main() { fmt.Print("Welcome\nto\nGo Programming Language!\nDo enjoy the day\nfriends") }
you can do lot of things in one single line in go :D but are they readable?
I like this solution because you can use either backticks or double quotes (helpful for large regular expressions). For backticks only, you could write a helper that removes a newline at the beginning and, per line, the whitespace all lines have in common. But then you can’t use double quotes.
5

You can put content with `` around it, like 

var hi = `I am here, hello, `
Improve this answer

Comments

4

You have to be very careful on formatting and line spacing in go, everything counts and here is a working sample, try it https://play.golang.org/p/c0zeXKYlmF

package main import "fmt" func main() { testLine := `This is a test line 1 This is a test line 2` fmt.Println(testLine) }
Improve this answer

Comments

3

you can use raw literals. Example 

s:=`stack overflow`
Improve this answer

Comments

3

For me, I need to use ` grave accent/backquote and just write a simple test

+ "`" + ...

is ugly and inconvenient

so I take a characterfor example: 🐬 U+1F42C to replace it

a demo

myLongData := `line1 line2 🐬aaa🐬 line3 ` // maybe you can use IDE to help you replace all ` to 🐬 myLongData = strings.ReplaceAll(myLongData, "🐬", "`")

Go Playground

Performance and Memory Evaluation

+ "`" v.s. replaceAll(, "🐬", "`")

package main import ( "strings" "testing" ) func multilineNeedGraveWithReplaceAll() string { return strings.ReplaceAll(`line1 line2 line3 🐬aaa🐬`, "🐬", "`") } func multilineNeedGraveWithPlus() string { return `line1 line2 line3` + "`" + "aaa" + "`" } func BenchmarkMultilineWithReplaceAll(b *testing.B) { for i := 0; i < b.N; i++ { multilineNeedGraveWithReplaceAll() } } func BenchmarkMultilineWithPlus(b *testing.B) { for i := 0; i < b.N; i++ { multilineNeedGraveWithPlus() } }

cmd

go test -v -bench=. -run=none -benchmem　　　　see more testing.B

output

goos: windows goarch: amd64 pkg: tutorial/test cpu: Intel(R) Core(TM) i7-6700 CPU @ 3.40GHz BenchmarkMultilineWithReplaceAll BenchmarkMultilineWithReplaceAll-8 12572316 89.95 ns/op 24 B/op 1 allocs/op BenchmarkMultilineWithPlus BenchmarkMultilineWithPlus-8 1000000000 0.2771 ns/op 0 B/op 0 allocs/op PASS ok tutorial/test 7.566s

Yes, The + "`" has a better performance than the other.

Improve this answer

2 Comments

That is going to be slow (unless you do it just once). It would be much better to use separate strings and concatenate, because the compiler is likely to do it at compile time between literal strings.
Hi @Alexis Wilke, thanks for the heads up. It's much better than people who vote down and don't leave any comments. I added performance and memory evaluation to decide which one to use according to their needs.
2

For me this is what I use if adding \n is not a problem.

fmt.Sprintf("Hello World\nHow are you doing today\nHope all is well with your go\nAnd code")

Else you can use the raw string

multiline := `Hello Brothers and sisters of the Code The grail needs us. `
Improve this answer

Comments

1

I use the + with an empty first string. This allows a somehow readable format and it works for const.

const jql = "" + "cf[10705] = '%s' and " + "status = 10302 and " + "issuetype in (10002, 10400, 10500, 10501) and " + "project = 10000"
Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.