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

Zsh, 6 bytes

<<'
'

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

Bash, 20 bytes

exec tail -n+2 "$0"

*nix shell script, 21 bytes

#!/usr/bin/tail -n+2

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.

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!

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.