Multi-Line JavaScript Strings

Discussion

1. Matt Titchener

   It should be noted the backslash multiline string notation is not part of any ECMAScript standards and can break various minifiers. Otherwise, it’s definitely good to know!
2. tungd

   I think this is quite controversial. Other than issue with minifiers, ‘backslashes’ can cause error if there is any white space after it. I often write multiline string as arrays and join, this way IMO is quite readable.
   
var multiStr = [
"This is the first line",
"This is the second line",
"This is more..."
].join("\n");


   You can also see the intent here wether it’s about construct a real multiline string (with join(“\n”)) or just try to avoid writing a long string (with join(“”)).
3. avetis.kazarian

   /**
* @tungd : +1
*
* Moreover, you can't indent your code or it will add the whitespaces to the string.
*
* e.g:
**/

   "my string \
is long" === "my string is long"; // and not "my string is long"

4. Frank

   See also this performance test from different possibilities; the \ variant is the fastest.
5. The Frosty

   I forgot about this implementation till this morning while I was working on some jQuery forms. Funny I came across this now.
6. David Walsh

   While I understand the concern for minifiers, we don’t write JS for minifiers, we write JS for JS interpreters. JS minifiers need to improve. If the minifier you use doesn’t support this basic pattern, however, feel free to work around it.
7. Jamie

   When I first found out that you could escape newlines, I thought it was a pretty neat way to split a single line of text over several lines. It’s advantages are that it’s faster than concatenation and more readable than having the text spanning one long line that you have to scroll through.

   However, it’s slower, less readable and less maintainable than having the text on one line and just turning on word wrap in your IDE. It’s also error prone, for reasons explained above.

   The most common reason for including large, unbroken chunks of text in a JavaScript file is for the purposes of HTML injection, in which case I would personally include the text in a separate tag, which I then retrieve with innerText and store in a variable. That way, I can format it as HTML, but it won’t get shown on the page, nor get interpreted as JavaScript. Yes, it’s slower, but it’s much more readable and maintainable.
8. Arian Stolwijk

   You can just use the first one, minifiers (at least uglify-js) will change the var a = "foo" + "bar"; into var a = "foobar"; anyway.
9. ChoiZ

   In Google javascript guide, they advise “”+ instead of \ because . «The whitespace at the beginning of each line can’t be safely stripped at compile time; whitespace after the slash will result in tricky errors; and while most script engines support this, it is not part of ECMAScript.»

   http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml?showone=Multiline_string_literals#Multiline_string_literals

   What do you think? Could you please enlighten me?

   Thank you.
10. Joe T.

    @David: i don’t think there’s much case for “improving” minifiers to support the escaped line feed. The structure itself is non-standard, some browsers don’t support it, so minifiers that adhere to the standards are right to reject that method. Besides, your own point defeats itself: it we write JS for JS interpreters, the implication is to write JS for the broadest compatibility possible. Escaped line feeds reduce that compatibility. And minifiers are increasingly essential tools to reduce bandwidth and execution time, so we SHOULD write JS with minifiers as part of the plan.

    Personally, i find it no easier to read an escaped line feed than “a “+ “b “+ … There’s always something interrupting the end of the line. Sure, concatenating strings suffers a performance hit, but at the point it becomes significant, one should ask why such long strings are being statically coded into Javascript.
11. Michael Haren

    Am I missing something? It looks like string literal line continuations _are_ in the spec:

    http://www.ecma-international.org/ecma-262/5.1/#sec-7.8.4

    Maybe it’s relatively new but that’s from 2011…?
12. Michael Haren

    Ah, I read that more closely and now see that the backslash is only valid if it’s part of something else–not by itself like this post describes. My bad.
13. balaphp

    This is code will help to generate html code in javascript:….
14. Elf M. Sternberg

    Michael Haren: The backslash *isn’t* “by itself”; it’s the character right before a newline. However, the spec does specify (ha!) that the newline is *not* a valid character for escape purposes. The only valid escape characters after a backslash are listed explicitly: ‘ ” \ b f n r t v
15. Jack Sparow

    Excellent, your blog’s always a lifesaver, thanks David!
16. joppiesaus

    But! There’s something new coming!

    console.log(`i am a multiline
    string
    and it works
    but not on all browsers
    - yet
    `);
    

    https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings
17. Joe

    Your two examples produce different results. I think many people will be surprised by the amount of whitespace in your multiline example.
18. Diego

    But that’s not a multiline string! That is a multiline string literal representing a single-line string.

    If you want to produce a multiline string (a variable in memory that, upon inspection during execution, contains more than one line of text), you don’t need the trailing backslash but the classic backslash + new line modifier.

    The trailing backslash allows us to introduce line breaks in a string literal, mostly for clarity in the source code, without inserting them in the actual string represented by the literal.

    https://jsfiddle.net/q68cktfq/
19. vance

    This is way outdated. Multiline string literal is accomplished with back tick.

    var mlString = `I am multiline \
    hear me roar`;
    
• blu

  @vance

  `thing
  thing2`
  doesn’t work on iOS 6 tho
20. yunak

    Note that the second string includes line breaks within the string itself.
    If you meant that on the screen, then yes. But in the Javascript string itself, there are
    _no_ line breaks (I mean newlines) inserted automatically (regardless if you run it in
    old Rhino, Nashorn, or modern Node/V8) – at least I don’t see any ‘\n’ in your example.
    Anyway, for cases where I couldn’t use post-ES6 JS features (template literals)
    and I didn’t have to think about compatibility with anything outside, this
    ‘dirty’ hack has worked OK for me so far: https://stackoverflow.com/a/14496573