Excel, 1 byte

'

Ungolfed version

'        <-- print the following text,
             and exit the current formula

Jolf, 6 bytes

a Lq6(

Explanation

a Lq6(
a       print
  L 6   all but the first 6 characters of
   q    the source code
     (  and exit

Perl, 30 21 bytes

print<DATA>
__DATA__

Trailing newline. This makes use of a Perl feature which allows arbitrary data to be appended to the source file, which can then be read via the DATA filehandle. When we give a filehandle as an argument to print, it's given a list context, which causes the filehandle to return a list of all the lines in the file, newlines included (likewise, a newline on the final line will be omitted). Then print implicitly concatenates them all, undoing the splitting into lines and giving us the exact original string regardless of where the newlines were.

brainfuck (Unreadable Brainfuck), 9 bytes

,+[-.,+]!

Append the input to the end. There isn't a trailing newline, this time.

Looking for languages which would accept input appended to the end of the program, brainfuck seemed like a distinct possibility; many brainfuck interpreters written in esolangs take both the program and the program's input from standard input, and thus need some way to tell between them. There's a convention that's used in this case that a ! character differentiates between the program and the input, a trick that's often used to write short brainfuck programs like ,[.,]!Hello, world!; this basically creates a different dialect of brainfuck in which ! has a different meaning from normal.

In theory, therefore, we could just find one of these interpreters and give it a cat program in order to fulfil the spec. There's a major subtlety, though; brainfuck typically uses 256 values for each cell, there are 256 octets, and one needs to be used for EOF. So if we want to be able to echo all 256 octets literally, we can't detect EOF at all and will need to end the program some other way. In other words, we need to find an implementation that either gives the 256 octets and EOF 257 different values, or that crashes on EOF.

Enter Unreadable. There's a brainfuck interpreter in Unreadable that predates this challenge, and which accepts input after an !; additionally, unlike most brainfuck interpreters, it uses bignum cells and -1 for EOF, allowing EOF to be distinguished from the other 256 possible octets. Thus, by use of Unreadable Brainfuck as the specific interpreter for the program, we can solve the challenge in just 9 bytes, via writing a brainfuck cat program that halts on EOF=-1.

Is it possible to do better? Well, we could try the following 7-byte program, which attempts to output EOF at the end of the string before it breaks out of the loop:

+[,.+]!

The behaviour of this program depends on the behaviour of the Unreadable interpreter on error conditions (thus, it depends not only on the implementation of brainfuck, but on the implementation used to run the implementation of brainfuck). Unfortunately, the Unreadable interpreter I use outputs errors on standard output, meaning that this saving doesn't work. If anyone knows of an Unreadable interpreter that exits on an attempt to output EOF, or silently skips the attempt, let me know; that would be a seven-byte solution right there.

Zsh, 6 bytes

<<'
'

There is a trailing newline. The string is inserted at the end of the program.

Bash, 20 17 bytes

Thanks to Adam for removing 3 bytes.

exec sed 1d "$0"

*nix shell script, 21 14 bytes

Thanks to Adam for removing 7 bytes.

#!/bin/sed 1d

Dyalog APL, 11 bytes

The following is the body of the function f:

2↓⎕CR'f'⋄→

There is a trailing newline, after which anything may be inserted.

2↓ drop the first two lines (header and this line) of

⎕CR'f' the Character Representation of f

⋄ then

→ quit

Ruby, 20 bytes

print *DATA
__END__

Input goes at the end (after the trailing newline). The DATA idiom is one of many that Ruby stole from Perl.

Try it on eval.in: https://eval.in/684370

gs2, 4 bytes

╥¶=☼

Uses CP437 encoding. The string goes at the end. ╥ gets the source code, ¶ pushes 4, = drops that many leading characters, and ☼ exits.

Try it online!

Perl 6, 23 bytes

print $=finish
=finish

The string is placed starting on the newline after =finish.

PHP 94 bytes

<?$f=fopen(__FILE__,'rb');fseek($f,93);while(false!==($c=fgetc($f)))echo$c;__halt_compiler();

Place your string after the final semicolon.

Yay for obscure features I guess? __halt_compiler() does exactly what you'd expect from the name. The prior code just opens the file and writes any bytes after that last semicolon to stdout. NUL, BEL etc come out fine. Unicode literals (♪) get screwed up on Windows but I think that's just Windows cmd failing at unicode.

Mathematica 8 Bytes

Print@""

The Mathematica Front End automatically detects escape sequences and asks you to decide when you paste inside of existing quotes whether or not to escape characters. The default option will result in the desired behavior, so clicking yes or simply hitting the enter key is all that's needed.

PHP, 48 bytes

<?=substr(file_get_contents(__FILE__),48);die;?>STRING HERE

JavaScript + HTML5 DOM - 163 Bytes

<html><body><script>fetch(location).then((r)=>r.text().then((t)=>console.log(t.slice(145,t.lastIndexOf("</b")))));document.body.remove()</script></body></html>

You may insert anything you like directly before the closing body tag. This works by fetching the page source and stripping the opening code and the closing tags.

The real kicker was figuring out how to escape an infinite loop. Putting while(true){} in the page blocks all callbacks forever, freezing the execution, and JavaScript has no way of pausing the main thread. However, code that no longer exists never runs, so the document body commits seppuku in the very last command, deleting itself while it waits for its clone to load.

Yeah, it's long and roundabout, but the mere fact that it's possible in JS is kind of amazing.

RProgN, 19 Bytes

Q 19 Q L sub exit 

Note the trailing space.

Insert any text after that chunk and it will be printed.

Based off of Lynn's gs2 answer.

Try it Online!

Python 2, 133 bytes, non-competing

import sys,traceback
try:a=lambda:'STRING HERE'
except:print repr(traceback.extract_tb(sys.exc_info()[2])[-1][2][:-1])
else:print a()

Everything but newlines, sadly.

This answer was submitted to show that (surprisingly) it is at least partially possible in Python and other "normal" languages.

Bash, 17 bytes

tail -n+3 $0
exit
<string here>

Developed independently of jimmmy23013's answer.

Befunge 93, 79 30 28 bytes

(Bytes from string obviously not included)

Note: All the code listed here will fail if the the user types a \n character, i.e. presses the enter key. There's not an easy (or really a hard way) around this (but I'll look into it).

Try it Online!

Although I like the idea of having all the code at the end, The bounding box in Befunge 93 becomes an issue quickly, so here is a version that has all the code at the beginning, and also saves 2 bytes due to the lack of #s.

8>+::1gv
v#p1\+2<String Goes Here>
<v1,-2g1:

Try it Online!

30 byte version with code at the end:

<String Here>0#pg#02#\-#+,#21#g+#0: #:<:1

Edit: I was able to significantly cut down on the byte number by printing each character directly from the loop. I am pretty fond of my old code, though, so I'll leave it up.

Try it Online!

Initially I though befunge would be relatively easy, as the get action let me access the ASCII values in cells directly, but problems arise because we don't know how long a String is. So I made a one line loop at the end of the string that counted up its length, which had to be able to exit when it got to the end of the string, and thus the loop, and be able to make it back to other code.

It's easiest to see how this one works if you paste the code in this interpreter, and run it at different speeds.

There is no trailing endline.

79 bytes:

v v
<03StringGoesHere>1#p1g1p#11#+1#*g#41#8+#::#g11#pp#0:#\6#*5#* #2<56:p1133
1:<+1,g1:_@#-g1

The String goes between the 3 and the >.

Edit: Fixed code to work with a 0 length String.