text:
This isn't rocket science
Write a program or function that takes in a single-line string. You can assume it only contains printable ASCII. Print or return a string of an ASCII art rocket such as
  |
 /_\
 |E|
 |a|
 |r|
 |t|
 |h|
 |_|
/___\
 VvV

with the input string written from top to bottom on the fuselage. In this case the input was Earth. The height of the rocket (including flames) is always the length of the string plus five.
Each line in the output may have up to two trailing spaces and there may be a single optional trailing newline. The shortest code in bytes wins.
More Examples:
[empty string]

  |
 /_\
 |_|
/___\
 VvV

a

  |
 /_\
 |a|
 |_|
/___\
 VvV

|0

  |
 /_\
 |||
 |0|
 |_|
/___\
 VvV

\/\

  |
 /_\
 |\|
 |/|
 |\|
 |_|
/___\
 VvV

 _ _ [note trailing space]

  |
 /_\
 | |
 |_|
 | |
 |_|
 | |
 |_|
/___\
 VvV

    [4 spaces]

  |
 /_\
 | |
 | |
 | |
 | |
 |_|
/___\
 VvV

SPACEY

  |
 /_\
 |S|
 |P|
 |A|
 |C|
 |E|
 |Y|
 |_|
/___\
 VvV

Leaderboard

var QUESTION_ID=91182,OVERRIDE_USER=26997;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Related. There may be others which are close enough that this counts as a dupe.

Are withespace characters (newline, tab and space) considered as printable ASCII? if yes should we take them into account and how (mainly for tab and newline)

@Sefa Spaces yes. No to other whitespace. As the linked wiki indicates.

D'oh, I saw the title and expected something about brain surgery. :(

And if the bottom points at the sky you will not go to space today.

It's not rocket appliances!

"It worked in Kerbal Space Program..."

Could I enter with PETSCII characters rather than ASCII? See -> https://sta.c64.org/cbm64pet.html

Excel VBA, 142 179 175 160 155 bytes
Instruction:
Set the worksheet of Excel where cell A1 is input and column C as the output. Set the text alignment in column C to center. Write and run the following code in the Immediate Window:
[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+3,3)="VvV":[C:C].HorizontalAlignment=-4108

Ungolfed the code:
Sub R()
    [C1] = "|"
    [C2] = "/_\"
    T = [A1]&"_"

    For i = 1 To Len(T)
        Cells(i + 2, 3) = "|" & Mid(T, i, 1) & "|"
    Next

    Cells(i + 2, 3) = "/__\"
    Cells(i + 3, 3) = "VvV"
    [C:C].HorizontalAlignment = -4108   'Set the text alignment in column C to center
End Sub

Output:

Note: The font and the color are just a personal choice.

15 bytes saved due to edc65's suggestion. Thanks.
5 bytes saved due to Taylor Raine's suggestion. Thanks.

Save 15 bytes adding "_" to T. Like this [C1]="|":[C2]="/_\":T=[A1]&" ":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+4,3)="VvV":Columns(3).HorizontalAlignment=-4108

(ok there is an error in my code and it's too late to edit it. But you get the idea)

@edc65 I don't get the idea. Your code is exactly the same with mine so what should I edit to save 15 bytes?

I edited it some times, look at it again

@edc65 Ahh, I get it. Very clever. Thank you so much :)

154 Bytes: [C:C].HorizontalAlignment=-4108:[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/__\":Cells(i+3,3)="VvV

@Anastasiya-Romanova秀 just in case you did not know, if you end your immediate window function with an unclosed string, VBA does not throw an error so if you move :Cells(i+2,3)="/__\" or :Cells(i+3,3)="VvV" to the end you can drop the terminal " for -1 byte :)

Huh, I think you are missing a _ in the Cells(i+2,3) call - Anyways, an alternate approach, also 154 bytes: [C1]="  |":[C2]=" /_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)=" |"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/___\":Cells(i+3,3)=" VvV":[C:C].Font.Name="Courier

Or you could get it down to 151 bytes, keeping the centering aspect [C:C].HorizontalAlignment=3:[C1]="|":[C2]="/_\":T=[A1]&"_":For i=1To Len(T):Cells(i+2,3)="|"&Mid(T,i,1)&"|":Next:Cells(i+2,3)="/___\":Cells(i+3,3)="VvV

It seems as though this just centers the text rather than outputting a space before the |<insert char here>|

Perl 6, 75 bytes
"  |\n /_\\".say;" |$_|".say for slurp.chomp.comb;" |_|\n/___\\\n VvV".say;

slurp.chomp.comb... Perl is weird.

SLURP!!! CHOMP!!! COMB!! Here comes the Perl monster!

Note that by using a function and concatanation you can cut out a lot: {[~] "  |\n /_\\\n",|(" |$_|\n"for $_.comb)," |_|\n/___\\\n VvV"} 65 bytes

But you can go even lower by borrowing from JS's: https://tio.run/##K0gtyjH7n1upoJamYKvwX9cuprhaSUGhhktBPz4mhkuhWkOpRiW@hkspLb9IoVgvOT83SbNWoQYooh8fD1YRVhamVPvfmqs4EWSIhlJJanFJZl66kqb1fwA

JavaScript (ES6), 54
Straightforward
x=>`  |
 /_\\
 |${[...x+'_'].join`|
 |`}|
/___\\
 VvV`

Test

f=x=>`  |
 /_\\
 |${[...x+'_'].join`|
 |`}|
/___\\
 VvV`

function update() {
  O.textContent=f(I.value)
}

update()
<input id=I value='hello' oninput='update()'>

Actually, 40 bytes
"/___\
 VvV",'_o"|
 |"j'|o" |"+"  |
 /_\

Yes, those newlines are supposed to be there.
Try it online!
Explanation:
Newlines are represented by \n for easier formatting
"/___\\n VvV",'_o"|\n |"j'|o" |"+"  |\n /_\
"/___\\n VvV"                                create the bottom of the rocket
             ,'_o                            get input, append a "_" (for the last section before the jets)
                 "|\n |"j                    insert "|\n |" between every pair of characters
                         '|o                 append "|"
                            " |"+            prepend " |"
                                 "  |\n /_\  create the nose cone

Your program looks depressingly similar to an exploded rocket.

C, 83, 82 bytes
F(char*c){for(puts("  |\n /_\\");*c;printf(" |%c|\n",*c++));puts(" |_|\n/___\\\n VvV");}

Test main:
int main() {
  F("");
  F("a");
  F("|0");
  F("\\/\\");
  F(" _ _ ");
  F("    ");
  F("SPACEY");
}

I worked out my own C solution, and it turned out being exactly yours, character for character.  +1 from me.

On phone and too lazy to SSH, so this is untested, but should work. Saves 2 bytes (if I counted correctly): F(char*c){for(puts("  |\n /_\\");*c;printf(" |%c|\n",*c++),puts(" |_|\n/___\\\n VvV");}

@algmyr saves one byte, actually, because the last puts has to be executed only once, not after every printf. But yes, 1 byte saved, yay!

Right. I'll blame that on golfing when I should have been sleeping.

Is this not 88 bytes?

Python 2, 93 66 62 61 bytes
A FGITW. Can probably be heavily golfed. Suggestions welcome.
Edit: 27 bytes thanks to Mego. 4 bytes thanks to TheBikingViking. 1 byte thanks to user3030010.
Try It Online!
lambda x:r"""  |
 /_\
 |%s|
/___\
 VvV"""%"|\n |".join(x+"_")

PHP, 73 72 69 62 bytes
  |
 /_\
 |<?=join('|
 |',str_split($argv[1]._))?>|
/___\
 VvV

Takes the string to print on the fuselage as the first argument from the command line when the script is called.
Improvements:

Saved a byte by replacing \n with a real LF newline in the first argument of join.
Saved three more bytes by appending the rocket base with a single underscore to the input
Thanks to Ismael Miguel: Saved 7 more bytes by taking advantage of the fact that PHP used to be the "Hypertext preprocessor" so you can output as much text as you want and start the code somewhere in the middle.

Try it online!
This was fun! :-)
Sample calls:
php rocket.php ""
php rocket.php EARTH
php rocket.php "This is a very long rocket"

62 bytes: http://sandbox.onlinephpfunctions.com/code/5c640244e19b43a44c364a971ea796f277e4dbf4

Nice golfing! I totally forgot about that possibility. Thank you!

You're welcome. Also, I saved 2 bytes on the first line. You had 2 extra trailing spaces on it. That was something I wasn't expecting to find, I must say.

I know, that was really dumb but also really hard to spot. I only noticed once I came up with 64 bytes on your improved version and had to find out why.

Haskell, 58 bytes
f s="  |\n /_\\\n |"++((:"|\n |")=<<s)++"_|\n/___\\\n VvV"

Ruby, 57 55 bytes

-2 bytes by @ValueInk
-5 bytes by assuming that there is no newline in the input, as suggested by @manatwork. Newline-less input can be provided for example with echo -n, like echo -n hey | ruby rocket.rb.
puts'  |
 /_\
 |'+gets.chars*'|
 |'+'|
 |_|
/___\
 VvV'

Old version, assumes newline in input:

Ruby, 62 60 bytes
puts'  |
 /_\
 |'+gets.chop.chars*'|
 |'+'|
 |_|
/___\
 VvV'

According to the question owner's comment the input will not contain newline character, so you can remove .chop.

@manatwork neat, thanks :)

If you use single quote strings, you should be able to replace both your \\  with \ . (In single quoted strings, characters aren't escaped, except for \'.

brainfuck, 179 bytes
>-[-[-<]>>+<]>-..[->+>++++<<]>>----.<<++++++++++.>.>>>+[-[--<]>>--]<.[-<+<++>>]<<+.---.<,[<<<.>.>.>.<.>,]<<<.[->>>+<<<]>.>.>>+++.<<.>.>>.<...---.<.<<.>>>------.[-<<<+<+>>>>]<<<.<.

Try it online!

@user00001 This phrase is used by all Muslims worldwide, not just the terrorist. Do you really think that the terrorists represent all Muslims?

@user00001 however, this phrase "Allahu akbar" is still in use in Muslim communities. The reaction probably depends on the tone in which it is shouted though. If it was shouted in a normal tone, people would probably assume that someone had had an accident and was shouting in pain. A bunch of us would probably rush towards the noise to see if we could help. // If it were in a rude tone, and you happened to be wearing a loose jacket, and you were doing something suspicious,  you'd...

Retina, 44 37 bytes
7 bytes thanks to Martin Ender.
$
_
.
¶ |$0|
$
¶/___\¶ VvV
^
  |¶ /_\

Try it online!

leaves a gap on a row at the bottom :( for "Space, the final frontier."

@xQbert Works for me, can you attach a TIO link?

odd, it works fine for me now...  ah my error had a newline at the end.

Retina is the only language I know which adding a trailing newline can completely change the program.

Jelly, 37 36 bytes
;”_⁾ |;Ð€ŒB;“/___\“ VvV”“  |“ /_\”;Y

Same score as existing entry, but uses a fun new feature - ŒB, the vectorised version of ŒḄ, known as bounce. Bouncing is running through a list to its end and then back x[:-1]+x[::-1] e.g.: bounce("codegolf") == "codegolflogedoc".
-1 byte thanks to Dennis (use the vectorised version of bounce)
How?
;”_⁾ |;Ð€ŒB;“/___\“ VvV”“  |“ /_\”;Y - argument: a string, S
                        “  |“ /_\”   - the top of the rocket ["  |", " /_\"]
;”_                                  - concatenate to make S=S+"_"
   ⁾ |;                              - concatenate to make c=" |"+c
       Ð€                            - map over right argument i.e. for c in S
         ŒB                          - bounce! With vectorisation c[:-1]+c[::-1]
                                       e.g. " |B" -> " |B| "
           ;                         - concatenate with
            “/___\“ VvV”             - the bottom of the rocket ["/___\", " VvV"]
                                  ;  - concatenate the top with everything else
                                   Y - join with line feeds

Test it on TryItOnline

ŒB is short for ŒḄ€.

Pyke, 40 37 35 bytes
(Updated to work with latest version)
\_+2" ||
"m:"/___\
 VvV"+R"  |
 /_\

Try it here!

PowerShell v2+, 59 55 51 bytes
"  |
 /_\"
$args|% t*y|%{" |$_|"}
" |_|
/___\
 VvV"

Try it online!
Abuses the default Write-Output at end of execution to stick a newline between each element, since these are all just literal strings on the pipeline. The only "tricky" bit is a loop through each element of the input $args as a char-array to get the body of the rocket.
Uses literal newlines as pointed out by ConnorLSW to save some bytes.
-4 more bytes thanks to Veskah.

you can put actual newlines in the string to save 3, the shell and ise execute fine without the \r

t*y trick to save 4 bytes

R, 163 bytes
v=c();l="\n";for(i in 1:nchar(a<-scan(,"")))v=c(v,paste0(" |",strsplit(a,"")[[1]][i],"|",l,collapse=""));cat("  |",l," /_\\",l,v," |_|",l,"/___\\",l," VvV",sep="")

Ungolfed :
v=c()     #Empty vector
l="\n"    #Line break

for(i in 1:nchar(a<-scan(,"")))                  #For the number of character of the input
    v=c(v, paste0(" |",strsplit(a,"")[[1]][i],"|","\n",collapse=""))
    #This part cut the input into its letters, paste each letter between `|`'s,
    #and a line break

cat("  |",l," /_\\",l,v," |_|",l,"/___\\",l," VvV",sep="") #Puts everything in the STDOUT,
                                                           #with spaces where needed

I don't really like the fact I had to put some spaces in the last line, but hey !

V, 41, 39 bytes
ys$_òlé
òÎá|I |
Hr/$r\YO  |GpX2á_o VvV

Try it online!
Note that for some reason, the online interpreter was producing unexpected results, so I pushed a debug version to the online interpreter that runs a lot slower. It should produce the correct results now.
Since this program contains unprintable characters, here is a hexdump:
0000000: 7973 245f f26c e90a f2ce e17c 4920 7c0a  ys$_.l.....|I |.
0000010: 4872 2f24 725c 594f 2020 7c1b 4770 5832  Hr/$r\YO  |.GpX2
0000020: e15f 6f20 5676 56                        ._o VvV

Nice but it doesn't handle the spaces in "Space, the final frontier" quite right.

PHP, 108 100 88 bytes
-8 bytes thanks to business cat
-12 bytes thanks to YetiCGN
echo'  |
 /_\\
';foreach(str_split($argv[1])as$c){echo" |$c|
";}echo' |_|
/___\\
 VvV';

pretty straightforward
Ideone

You can save a lot of bytes by using foreach(str_split($a)as$c) instead of the other for loop. Also, you could put the $c directly in the string if you use double quotes: echo" |$c| ....";

@BusinessCat True, thanks the double quotes wasn't working with the array style thought due to the brackets not being interpreted

What about regular expression? function f($a){echo'  |.␤ /_\\␤',preg_replace('/./',' |$0|␤',$a),' |_|␤/___\\␤ VvV';}

Why even put a function around it? Replacing $a with $argv[1] and running from command line makes it much shorter.

@manatwork It's probably a valid alternative, but since i don't understand it and it's not the in the same spirit as mine, I will let you post it.

C#, 106 97 80 74 bytes
s=>$@"  |
 /_\
 |{string.Join("|\n |",s.ToCharArray())}|
 |_|
/___\
 VvV";

I don't have C# 6 to try the above but I believe it will work
Saved 7 bytes thanks to Kevin Cruijssen
Thanks to manatwork for pointing me in the right direction to save 17 bytes
Saved 6 bytes thanks to milk

+1. Btw, trailing whitespaces are optional, so you can change it to: using System.Linq;s=>$("  |\n /_\\\n{string.Join("",s.Select(c=>" |"+c+"|\n"))} |_|\n/___\\\n VvV"); (100 bytes)

@KevinCruijssen I was just in the process of updating this after your comments to my previous answer :) Thanks for the help

You can save some characters by using a single string literal inside Select: " |"+c+"|\n" → c+"|\n |" together with moving the  | from after {} before it.

@manatwork I can't seem to get that to work

@manatwork Doesn't matter, got it to work and saved even more bytes

-1 byte with LINQ to use s.Cast<char>() instead of s.ToCharArray(). More importantly, -6 bytes by using verbatim strings (@ fyi- after the $ for interpolated verbatim string) to replace \n with newlines and \\ with \, plus then you can even see the rocket in the source.

@milk adding linq means I have to add using System.Linq which is more bytes. Replacing new lines with new lines is still the same count but @ can save me one byte anyway thanks

New line is 1 byte compared to \n's 2 bytes. So you'll save 5 more bytes by replacing them with new lines. Yes, if you're using Visual Studio then by default new lines will be 2 bytes, but you can open the source file in a hex editor (Visual Studio has one) and delete the carriage return characters. The output will still be the same.

@milk Ahhh okay me being daft, thanks

If u add the using 'using static System.String;' you can write Join instead of string.Join. C# 6.0 for the win.

C,  131 , 121 bytes
#define P printf
main(){char s[99],*p=s;gets(s);P("  |\n /_\\\n");while(*p)P(" |%c|\n",*p++);P(" |_|\n/___\\\n VvV\n");}

You can remove three characters by moving p=s into the initialization, and using p inside scanf : main(){char s[99],*p=s;scanf("%s",p);P("  |\n /_\\\n");while(*p)P(" |%c|\n",*p++);P(" |_|\n/___\\\n VvV\n");}

ok.... i don't know why "scanf("%s", &s)" instead of "scanf("%s", s)"  print at end the correct result... at end because scanf not gets spaces i prefer the danger gets()...

Please don't vandalize your posts.  Thank you!

114 bytes

@ceilingcat If was possible the definition [#define P printf(" |] it would be less than 114...

PowerShell, 70 bytes
"  |`n /_\`n$(([char[]]$a|%{" |$_|"})-join("`n"))`n |_|`n/___\`n VvV

Set $a to input.
If it has to take input other than a variable it can be piped in:
"Hello World"|%{"  |`n /_\`n$(([char[]]$_|%{" |$_|"})-join("`n"))`n |_|`n/___\`n VvV "}

Example:
  |
 /_\
 |H|
 |e|
 |l|
 |l|
 |o|
 | |
 |W|
 |o|
 |r|
 |l|
 |d|
 |_|
/___\
 VvV

Mathematica, 50 bytes
"  |
 /_\\
 |"<>(#<>"|
 |"&/@#)<>"_|
/___\\
 VvV"&

Anonymous function. Takes a list of characters as input and returns a string as output.

05AB1E, 50 47 43 37 bytes
I'_J"  |
 /_\"svy" |ÿ|"}"/___\
 VvV"»

Try it online!
Saved 9 bytes thanks to Adnan.

String can also accept newlines in 05AB1E :p, like this.

@Adnan Nice, thanks! Any idea how to better get around the empty input?

I was thinking about an approach with IðJ at the beginning of the program, which also includes the basis of the fuselage.

@Adnan Great idea. I tried that with « earlier without much luck. This is much better though.

Removing U and replacing X with s also saves a byte :).

@Adnan: yep, was just looking at that. Thanks!

Jelly, 38 37 bytes
;”_“|“|¶”jÐ€“  |¶“/_\¶”;K;“/___\¶ VvV

Try it online!
Same idea as with my Pyth answer, but this can probably be golfed.

Lua, 83, 92 bytes
function f(x)return'  |\n /_\\\n'..x:gsub('(.)',' |%1|\n')..' |_|\n/___\\\n VvV'end
print('  |\n /_\\\n'..(arg[1] and arg[1]:gsub('(.)',' |%1|\n') or '')..' |_|\n/___\\\n VvV')

If I add no input to your answer. It does not work.

Gema, 50 characters
\A=  |\n\ /_\\\n
?=\ |?|\n
\Z=\ |_|\n/___\\\n\ VvV

Sample run:
bash-4.3$ echo -n gema | gema '\A=  |\n\ /_\\\n;?=\ |?|\n;\Z=\ |_|\n/___\\\n\ VvV'
  |
 /_\
 |g|
 |e|
 |m|
 |a|
 |_|
/___\
 VvV

You're missing the  |_| before the base of the rocket I think

Ouch. Dumb miss. Thank you @TheLethalCoder.

+1 for introducing me to a new (to me) (non-golfing) language.

BASH 84 70
Saved 14 thanks to manatwork
(cat&&echo _)|sed 's~.~ |&|\n~g;1s~^~  |\n /_\\\n~;$s~$~/___\\\n VvV~'

Over half of the bytes are for adding the nose, and engine.

Why the grep?  (cat&&echo _)|sed 's~.~ |&|\n~g;1s~^~  |\n /_\\\n~;$s~$~/___\\\n VvV~'. Actually I see no reason to use cat and echo either. Would be shorter transformed into pure sed solution.

With pure sed, you don't get any output if you don't have input

Doh. You are right. Sorry, I forgot that part of requirement.

@manatwork I forgot about it in my first try too.

For future reference, avoid using  tags. Use 4 spaces preceding the code in the future, as this auto-escapes Markdown formatting. I have maintained the current formatting due to the strikethrough, but you can just leave that in edit history as well for those curious to look at it.

@Syxer Thanks! I wasn't sure what the standard was in regards to striking or just removing.

Additionally if you keep the solution alone in its code block, Code Golf UserScript Enhancement Pack and similar scripts can insert correct length beside it. For example saying your code has 71 characters – you forgot to remove the \ added by Syxer to avoid _ being interpreted as italic markdown.

MATLAB, 94 bytes
@(s)char(['  |';' /_\';arrayfun(@(x)[' |' x '|'],s,'UniformOutput',0)';' |_|';'/___\';' VvV'])

Anonymous function

Not sure about MATLAB, but in Octave you can replace false with 0 to save 4 bytes.

Java 10, 102 99 81 bytes
a->{var r="  |\n /_\\\n |";for(var c:a)r+=c+"|\n |";return r+"_|\n/___\\\n VvV";}

3 bytes saved thanks to @Jules.
Try it online.
Explanation:
a->{                      // Method with character-array parameter and String return-type
  var r="  |\n /_\\\n |"; //  Result-String, starting with the top part:
                          //   |
                          //  /_\
                          //  |
  for(var c:a)            //  Loop over each character in the input-array:
    r+=c                  //   Append the character to the result-String,
        +"|\n |";         //   with trailing:
                          //    |
                          //  |
  return r                //  Return the result-String,
   +"_|\n/___\\\n VvV";}  //  appended with bottom part:
                          //   _|
                          // /___\
                          //  VvV

Couldn't you make a reference to System.out.println with a shorter name and call that?

@Trey Keown System.out.println is part of the test code, not the submission.

You can put  " |" onto the end of the 'r' initializer, then inside the loop move it to after the appended string, then you don't need at all in the string appended after the loop.  I think this would save you 5 bytes.

@Jules Thanks! Changed it, and it saves 3 bytes (not sure how you got to a save of 5, though).

GolfScript, 61 51 bytes
My first code golf, I hope it is good enough.
"  |
 /_\\
"\1/.,{" |"\(\"|
"\}\*" |_|
/___\\
 VvV"

Explanation
"  |\n /_\\\n"   # Push the rocket's head
\                # Swap the head with the user's string
1/               # The string is converted into an array
.,               # Push array length
{" |"\           # Push the rocket's body and swap
(\               # Array's first element cut out
"|\n"\           # Push rocket's body and swap
}\*              # Repeat for array length times
" |_|\n/___\\\n VvV" # Push rocket's bottom

Try it online!

Vim, 41 39 bytes
Here the <End> is literally the "End" key.
i <End>_:s/./ |&|\r/g
/___\
 VvVggxo /_\

Unprintables so:
i <End>_^O:s/./ |&|\r/g
/___\
 VvV^[ggxo /_\^[

Charcoal, 22 bytes
↷¦|_θ__←v↖V→/↑_↑⊕Ｌθ/‖Ｂ

Try it online!
Needs trailing newline in input, due to how Charcoal input works.

V, 47 46 39 37 35 bytes
A_Ó./ |&|\r
a/___\
 VvVHO  |
 /_\

Try it online!
This is my first time trying to golf something. There is probably room for improvement since I don't know V, only vim.
Hexdump:
00000000: 415f 1bf3 2e2f 207c 267c 5c72 2f67 0a61  A_.../ |&|\r/g.a
00000010: 2f5f 5f5f 5c0a 2056 7656 1b48 4f20 207c  /___\. VvV.HO  |
00000020: 0a20 2f5f 5c                             . /_\

Welcome to PPCG!

Excel 2016+, 73 bytes
An anonymous worksheet function that takes input from cell A1 and outputs to the calling cell
="  |
 /_\
 |"&Concat(Mid(A1,Sequence(Len(A1)),1)&"|
 |")&"_|
/___\
 VvV"

Vyxal C, 30 24 bytes
`|/__`:ḣṫ⁰p\|vp÷„Ḣ‛VvWøM

Try it Online!
-5 bytes thanks to allxy
How?
`|/__`:ḣṫ⁰p\|vp÷„Ḣ‛VvWøM
`|/__`                     # Push string "|/__"
      :                    # Duplicate
       ḣ                   # Head extract, push a[0] and a[1:]
        ṫ                  # Tail extract, push a[:-1] and a[-1] (stack: a[0], a[1:-1], a[-1])
         ⁰p                # Prepend the input to this a[-1]
           \|vp            # For each character, prepend "|"
               ÷           # Dump, push all contents to the stack
                „          # Rotate stack left once
                 Ḣ         # Remove head
                  ‛Vv      # Push string "Vv"
                     W     # Wrap stack into a list
                      øM   # Flip brackets and palindromise each
                           # C flag centers and joins on newlines

28 and you can save more with the C flag.

C, 128 97 94 bytes
#define P printf(
r(char*s){for(P"  |\n /_\\\n");*s;P" |%c|\n",*s++));P" |_|\n/___\\\n VvV");}

Un-golfed:
#define P printf(
/* Knock off a few bytes by abusing the preprocessor */

r(char*s) { /* Function r (for rocket) accepting a string */
    for( /* For loop */
        P "  |\n /_\\\n"); /* BEFORE entering loop, print the top part */
        *s; /* Loop until the null at the end of the string is encountered */
        P " |%c|\n",*s++) /* Print a middle section for each char */
    );
    P " |_|\n/___\\\n VvV"); /* Print the bottom part */
}

After realizing that I have completely forgotten about puts() due to its usual uselessness (I always use printf()), I finally got it under 90 bytes, only to realize that someone else had beaten me to it:
r(char*s){for(puts("  |\n /_\\");*s;printf(" |%c|\n",*s++));puts(" |_|\n/___\\\n VvV");}

Welcome to Code Golf, and nice answer!

Pyth, 38 bytes
j++"  |
 /_\\"jR_B" |"+Q\_"/___\\
 VvV

Try it online. Test suite.

Also 38 bytes: %." |¼v¤<½ózÓa9Êh"jXL2" ||"+z\_

Scala, 97 94 77 bytes
print("  |\n /_\\\n"+args(0).map{" |"+_+"|\n"}.mkString+" |_|\n/___\\\n VvV")

Python 3, 78 75 Bytes
w="  |\n /_\\"
for i in input(): w+="\n |"+i+"|"
w+="\n |_| \n/___\\ \n VvV"
print(w)

Thanks @ValueInk for spotting that I could lose 3 bytes by clearing the input function of arguments.

Asking adding a character to print when asking for input input(">") is wholly unnecessary and you could save bytes by just calling input()

@ValueInk thanks, I had forgotten that you could leave the input command blank.

Kotlin, 68 bytes
{"""  |
 /_\${it.replace(Regex("."),"\n |\$0|")}
 |_|
/___\
 VvV"""}

Pretty straightforward. Uses multiline string and a regex replacement. This is a lambda with (String)->String type. Test:
fun main(args: Array<String>) {
    val function : (String)->String = {"""  |
 /_\${it.replace(Regex("."),"\n |\$0|")}
 |_|
/___\
 VvV"""}
    println(function(" _ _ "))
}

S.I.L.O.S, 157 154 143 bytes
pL   |
def p print : lbl L Line
pL  /_\
loadL :
a = 256
:a
x = get a
if x c
GOTO e
:c
p  |
pChar x
pL |
a + 1
if x a
:e
pL  |_|
pL /___\
p  VvV

It should be fairly readable. Feel free to try it online!

@LeakyNun :( just out of curiosity how can you see null bytes so I can self-debug next time.

@LeakyNun oh ok, I found the issue. Its all fixed up now

143 bytes

Swift, 99 byte
let f:(String)->String={$0.characters.reduce("  |\n /_\\\n"){$0+" |\($1)|\n"}+" |_|\n/___\\\n VvV"}

Use like this:
print(f("Some String"))

Result:
  |
 /_\
 |S|
 |o|
 |m|
 |e|
 | |
 |S|
 |t|
 |r|
 |i|
 |n|
 |g|
 |_|
/___\
 VvV

R, 116 bytes
Golfed
write(c("  |"," /_\\",sapply(strsplit(scan(,""),"")[[1]],function(y)paste0(" |",y,"|"))," |_|","/___\\"," VvV"),1,1)

Ungolfed
write(                                             # Write to console
      x = c("  |"," /_\\",                         # Add in stock rocket part
        sapply(X = strsplit(scan(,""),"")[[1]],    # Take in rocket part specification, split string, loop over all specs
               FUN = function(y) {
                 paste0(" |",y,"|"))               # Custom build rocket body
                },
        " |_|","/___\\"," VvV"),                   # Add stock parts
      file = 1,                                    # Print to console
      ncolumns = 1)

  |
 /_\
 |s|
 |t|
 |r|
 |s|
 |p|
 |l|
 |i|
 |t|
 |!|
 |_|
/___\
 VvV

GNU sed, 54 49 48 bytes
This was my first answer to a challenge on this site. The solution is simple, mainly printing, so I spent some time making sure that it can't be golfed anymore.
s:.:\n |&|:g
s::  |& /_\\&:
a\ |_|\n/___\\\n VvV

Try it online!
Fast forward half a year later, I rewrote the script, used a trick for good measure and golfed it down to 1 byte shorter. Now that's progress!
Explanation: the pattern space at each step is mentioned for clarity, given the input example "GO"
s:.:\n |&|:g
   # turn each input char into a section of the rocket (\n |G|\n |O|)
s::  |& /_\\&:
   # 's::' is a trick; the search part is actually the one from the previous 's'
   #command, i.e. a char. Only the first char, '\n', the modifier 'g' is not
   #inherited. The replace part is the head of the rocket. (  |\n /_\\n |G|\n |O|)
a\ |_|\n/___\\\n VvV
   # append the tail of the rocket, plus implicit printing at the end

  |
 /_\
 |G|
 |O|
 |_|
/___\
 VvV

Lua, 69 68 bytes
print([[  |
 /_\
]]..(...):gsub('.',' |%0|\n')..[[ |_|
/___\
 VvV]])

Should work with Lua 5.1 - 5.3 (tested with 5.3).
I don't have enough rep to comment on nolan's answer, but this is quite similar.
I'm using [[long string]] syntax to save a few bytes by avoiding needing to escape newlines and backslashes.
gsub doesn't need to specify a capture because %0 can be used. (Actually, %1 still works without a capture as well, but this isn't strictly documented.)
I also trimmed away the input validation; not sure why it was there -- an empty string input (as opposed to empty input) will work fine. Handling a missing arg[1] can be done more briefly just by (arg[1]or''):gsub(...) anyway, although at this point it is briefer just to switch to io.read() and get the input from stdin. Anyway, ... is a shorter way to get command-line input (even if parens are needed).

Perl 6, 51 bytes
{"  |
 /_\\
 {("|$_|
"for |.comb,'_')}/___\\
 VvV"}

A lambda that takes a string as argument, and returns a string.
try it online

R, 101 bytes
This is an improvement on Frédéric's answer. I eliminated the variable definition, the for-loop, and the need for the sep="" argument.
cat("  |\n /_\\\n",sapply(strsplit(scan(,""),""),function(x)paste0("|",x,"|\n")),"|_|\n/___\\\n VvV")

Ungolfed:
cat("  |\n /_\\\n",                      # Print top of rocket
    sapply(
      strsplit(scan(,""),""),            # Take stdin and convert to list of chars
      function(x)paste0("|",x,"|\n")),   # Print letters
    ,"|_|\n/___\\\n VvV")                # Print bottom and FLAMES

I'm sure that there is still some improvement possible.

Needs "  |\n /_\\\n", but never thought about hard coding \n

@Vlo Thanks, that's fixed now. (It is correct in my ungolfed/explained version, so I must have just pasted the wrong version in the first instance. The byte count is unchanged, thankfully.)

Dyalog APL, 50 bytes
↑'/___\' ' VvV',⍨'  |' ' /_\',↓' ','|',⍨'|',⍪⍞,'_'

OK, so it may not be the shortest submission, but it is the only one that carries the name of a real rocket manufacturer:
  |
 /_\
 |A|
 |P|
 |L|
 |_|
/___\
 VvV

TryAPL online!

><>, 60 bytes
'  |'a' /_\'av
a$v?(0:i'|| '<
'r\~'_'$a'/___\'a' VvV
 o>l?!;

Pretty simple really. lots of strings, the newlines are annoying.
Try it online
  |
 /_\
 |>|
 |<|
 |>|
 |_|
/___\
 VvV

Perl, 51 bytes
50 bytes code + 1 for -p.
s/./$&|
 |/g;s~^~  |
 /_\\
 |~;s~$~_|
/___\\
 VvV~

Usage
perl -pe 's/./$&|
 |/g;s~^~  |
 /_\\
 |~;s~$~_|
/___\\
 VvV~' <<< earth
  |
 /_\
 |e|
 |a|
 |r|
 |t|
 |h|
 |_|
/___\
 VvV

perl -pe 's/./$&|
 |/g;s~^~  |
 /_\\
 |~;s~$~_|
/___\\
 VvV~' <<< ''
  |
 /_\
 |_|
/___\
 VvV

perl -pe 's/./$&|
 |/g;s~^~  |
 /_\\
 |~;s~$~_|
/___\\
 VvV~' <<< '0|'
  |
 /_\
 |0|
 |||
 |_|
/___\
 VvV

Dart, 80 bytes
g(s)=>'  |\n /_\\\n${s.split('').map((s)=>' |$s|\n').join()} |_|\n/___\\\n VvV';

Running it through
main()=>print(g("Jasper"));

Gives:
  |
 /_\
 |J|
 |a|
 |s|
 |p|
 |e|
 |r|
 |_|
/___\
 VvV

CJam, 38 bytes
"  |
 /_\
 |"q'_+"|
 |"*"|
/___\
 VvV"

Try it online!
Explanation
Nothing fancy, pretty straightforward.
"  |\n /_\\n |"                              Push the top of the rocket
               q'_+                          Push the input and append an underscore
                   "|\n |"*                  Join the characters of the input with the sides
                           "|\n/___\\n VvV"  Push the bottom of the rocket

Common Lisp, 85 74 bytes
(lambda(s)(format t"  |
 /_\\
~{ |~a|
~} |_|
/___\\
 VvV"(coerce s'list)))

Try it online!(I added some bytes to call this anonymous function)
For changing part we take input as string.
~{ |~a|         ;we loop through all characters of string
    ~}          ;printing characters from list
(coerce s'list) ;string is converted into list of characters later used by above loop

Keg, 52 characters
?(\|'\| \
)\\\_\/ \
\|  ^\
 \|\_\|\
\/\_\_\_\\\
 VvV

Only tricky point is that Keg has no strings, the input is pushed to stack character by character. So the processing order is: read input (?) and turn it into middle section, append top section reversed, reverse them all (^), append bottom section.
(Note that the interpreter (TIO implementation?) does not support absolutely no input. Empty input is specified as single newline, which will not be processed anyway.)
Try it online!

MathGolf, 36 bytes
ù  |ÿ /_\è'_▐û |\+mñn'/ÿ___\+ÿ VvV]n

Input as a list of characters.
Try it online.
Explanation:
ù  |          # Push string "  |"
ÿ /_\         # Push string " /_\"
è             # Push the inputs as string-array
 '_▐         '# Append a trailing "_"
    û |\+     # Prepend " |" in front of each string
         mñ   # Palindromize each string in the list
           n  # Join it with newline delimiter
'/           '# Push string "/"
  ÿ___\       # Append string "___\": "/___\"
ÿ VvV         # Push string " VvV"
]             # Wrap the entire stack into a list
 n            # Join it with newline delimiter
              # (after which the entire stack is output implicitly)

C - 84 Bytes
f(char*s){puts("  |\n /_\\");while(*s)printf(" |%c|\n", *s++);puts(" |_|\n/___\\\n VvV");}

Ungolfed
f(char* s)
{
    puts("  |\n /_\\");

    while(*s)
        printf(" |%c|\n", *s++);

    puts(" |_|\n/___\\\n VvV");
}

Explanation
Function that receives a string prints it into the ascii-rocket. Tested on GCC, generates some warnings if not compiled with -std=c89.

K (ngn/k), 65 60 bytes
`0:"  |\n /_\\";{`0:" |",x,"|"}'$1:0;`0:" |_|\n/___\\\n VvV"

Try it online!
-5 bytes thanks to Razetime!
First ever K answer! May not be perfect, but it's pretty good!
Explaination:
`0:"  |\n /_\\" / Print the top of the rocket
{`0:" |",x,"|"} / Print " |$x|"
'$1:0; / For each character in the user input
/ Note: ';' is important because without it
/ the console will also output `(:: :: ...)`
`0:" |_|\n/___\\\n VvV" / Print the end of the rocket

since s is only used once, you can inline it: try it! Also, 0:  returns a list of lines, while 1: returns a single string. I've changed that as well.

good job on your first K answer. I will try and give a few more golfing suggestions later.

Haskell, 67 63 59 bytes
(++"_|\n/___\\\n VvV").("  |\n /_\\\n |"++).(>>=(:"|\n |"))

Thanks to Damien it's now essentially the same as xnor's answer, just in point-free notation. Ideone it!

I never use concatMap. You should use >>= or =<<instead. concatMap f s is the same as f=<<s or s>>=f

C#, 130 111 95 bytes
s=>{var a="  |\n /_\\\n";foreach(var c in s)a+=" |"+c+"|\n";a+=" |_|\n/___\\\n VvV";return a;};

Saved 16 bytes thanks to Kevin Cruijssen

Trailing whitespaces are optional, so a="  |  \n"; can be a="  |\n";. Same applies to a few other lines. Also, why the a+="111";a+="222";a+="333";? You can just do this once: a+="111222333";. Total becomes: s=>{var a="  |\n  /_\\\n";for(int i=0;i<s.Length;)a+=" |"+s[i++]+"|\n";return a+" |_|\n/___\\\n VvV";}; (103 bytes) Also, I'm not entirely sure, but isn't a foreach with characters shorter than your for-loop?

Batch, 128 bytes
@echo off
set s=%1_
echo   ^|
echo  /_\
:l
echo  ^|%s:~0,1%^|
set s=%s:~1%
if not "%s%"=="" goto l
echo /___\
echo  VvV

Javascript (using external lib - Enumerable) (84 bytes)
n=>" |\n /_\\\n"+_.From(n).WriteLine(x=>" |"+x+"|")+(n?"\n":'')+" |_|\n/___\\\n VvV"

Link to lib: https://github.com/mvegh1/Enumerable
Code explanation: Pretty straight forward. Just boilerplates the rocketship template (top and bottom), and concats the fuselage string in the middle. Whats eating up a lot of bytes is the check if the input is truthy, because for an empty string it's wrong to add a newline to the beginning of the bottom template
I love how the native JS answer blows this away...

Perl, 65 60 bytes
say'  |
 /_\\';say" |$_|"for split'',<>;say' |_|
/___\
 VvV'

Needs -E to use say, input should be piped in in order to not have a trailing newline. Notice that there's a space at the beginning of the second and fourth lines. Takes advantage of being able to use literal new lines in Perl to save a byte over using \n in each of the cases
Thanks to @manatwork for saving 5 bytes!

I'm afraid you did the same mistake as I did – you forgot the |_|.

@manatwork Nope! the s/\n/_/ adds it in since input in Perl comes with a new line character at the end, I'm swapping it for the underscore and it's handled as an additional character in the loop

Strange. I get the output without it: http://pastebin.com/QB2qMuSE Oh, I see, this is newline dependent. As  the question owner wrote that will be no newline in input, I tried without.

Oh! Instead of piping in the input, execute the file and then type the input (followed by pressing enter to end the input). The enter from that is what gets translated to the _. Alternately, replace the first newline with $ in order to be able to pipe in input (but not enter it manually) for the same byte count

Interesting choice, given it would be shorter without that newline handling: http://pastebin.com/QXRFdJwU

I guess I've just always assumed that passing input had to be done manually and I was forced to deal with the new line. If I'm allowed to use echo to pass it in though, that's definitely the better solution

Neoscript, 76 bytes
{s|"  |
 /_\\
"+(s as Array):map({e|" |"+e+"|
"}):fuse()+" |_|
/___\\
 VvV"}

{s|...} declare a lambda and as is the casting operator.

MUMPS: 94 bytes
To get some more variety in here. I tried to solve this in C by declaring main as an array of integers that were compiled machine code but it was still too big, especially on a 64 bit machine.
r
 r x w !,"  |",!," /_\",! f i=1:1:$L(x) w " |",$E(x,i),"|",!
 w " |_|",!,"/___\",!," VvV" q

MATL, 47 42 41 bytes
95h"' |'@yPhh]v'   /|_ \'2ew'/ _V_v_V\'2e

Try it online!

Clojure (83 bytes)
#(str "  |\n /_\\\n |" (clojure.string/join "|\n |" (str % \_)) "|\n/___\\\n VvV")

And here's a rocket for you:
  |
 /_\
 |W|
 |e|
 |l|
 |c|
 |o|
 |m|
 |e|
 | |
 |t|
 |a|
 | |
 |E|
 |a|
 |r|
 |f|
 |_|
/___\
 VvV

Javascript (ES5), 109 89 Bytes)
function(n){s=" |\n /_\\\n |";for(i=0;c=n[i++];)s+=c+"|\n |";return s+"_|\n/___\\\n VvV"}

Ungolfed:
function a(n){
var str="  |\n /_\\\n";
for(var i=0;i<n.length;i++){
str+=" |"+n[i]+"|\n";
}
return str+" |_|\n/___\\\n VvV";
}

EDIT: Saved 20 Bytes thanks to manatwork!

You have a small bug: the flame is not centered. That will cost you 1 character, but there are a couple of them you can remove: user shorter variable name; do not enclose the single instruction repeated by for in braces; increment the counter when you use it, instead of for's 3rd parameter; rearrange the strings to use a single string literal in the loop; test whether string end is reached by current character, not by .length; and anonymous functions are acceptable: function(n){s="  |\n /_\\\n |";for(i=0;c=n[i++];)s+=c+"|\n |";return s+"_|\n/___\\\n VvV"}.

Java 8, 132 109 107 96 Bytes
i->"  |\n /_\\ \n"+i.chars().mapToObj(c->" |"+(char)c+"|")
                            .collect(joining("\n"))+"\n |_|\n/___\\\n VvV"

How do you run this? This doesn't seem to be a complete method...

@JopV. Yes it's a lambada expression, this is a Function<String, String> in Java-8 to be applied on any string value. Correct me if I have mistaken.

Your submission shouldn't have whitespace added (you can include a separate readable version with spaces). Also it looks like you're using a static import of java.util.stream.Collectors.joining, so that statement should be included in your submission and byte count. And please mention that lambda type in your solution.

Racket 82 bytes
(display"  |\n /_\\\n")(for((i s))(printf" |~a|~n"i))(display" |_|\n/___\\\n VvV")

Ungolfed:
(define (f s)
  (display "  |\n /_\\\n")
  (for((i s))
    (printf " |~a|~n"i))
  (display" |_|\n/___\\\n VvV"))

Testing:
(f "Racket")

Output: A Rocket by Racket!
  |
 /_\
 |R|
 |a|
 |c|
 |k|
 |e|
 |t|
 |_|
/___\
 VvV

Python 3, 83 Bytes
s=input("")
print("  | \n /_\\")
for c in s:print(" |"+c+"|")
print("/___\\\n VvV")

72 bytes.

Excel VBA, 105 103 102 84 82 Bytes
Anonymous VBE Immediate Window function that takes input of type Variant/String from cell [A1] and outputs a rocket to the VBE immdiate window
Golfed:
?"  |":?" /_\":For i=0To[Len(A1)]:?" |"Mid([A1&"_"],i+1,1)"|":Next:?"/___\":?" VvV

Output:
[A1]="NASA.XLSM"
?"  |":?" /_\":For i=0To[Len(A1)]:?" |"Mid([A1&"_"],i+1,1)"|":Next:?"/___\":?" VvV
  |             '  <- Output
 /_\
 |N|
 |A|
 |S|
 |A|
 |.|
 |X|
 |L|
 |S|
 |M|
 |_|
/___\
 VvV

Perl 5, 55+1 (-p flag)=56 bytes
s/(.)/\n |$1|/g;$_="  |  \n /_\\ $_ |_| \n/___\\\n VvV"

Takes string as a single line (with trailing newline) from stdin.

SOGL V0.12, 27 24 bytes
yQŗ4δ⁾≥‘π0ρ9³‘OΓ,{Ƨ |ΚΓO

Try it Here!

05AB1E, 27 bytes
S'|ì»"|
/_
ÿ
|_
/__
Vv".∞.c

Try it online!
Explanation
S          # Split input into seperate characters
 '|ì»      # Prepend '|' to each and join by newline
     "|    # Half the rocket, where 'ÿ' is replaced by the processed input
/_
ÿ
|_
/__
Vv"
   .∞.c    # Intersected mirror and centralize

Google Sheets, 61 59 Bytes
Anonymous worksheet function that takes input from range [A1] and outputs a rocket to the calling cell
="  |
 /_\
"&RegExReplace(A1&"_","(.)"," |$1|
")&"/___\
 VvV

Example Output given [A1]="Google
  |
 /_\
 |G|
 |o|
 |o|
 |g|
 |l|
 |e|
 |_|
/___\
 VvV

Jstx, 42 bytes
♀◘ááⁿ▄εá»▀▄84♀☺áⁿE►âD85♀►áⁿ▀ⁿ▄ε»▀▀▀▄▄εá╓÷╓

Explanation
♀◘ááⁿ▄εá»▀▄         # Push literal   |\n /_\
8                   # Print the first stack value, then a newline.
4                   # Enter an iteration block over the first stack value and push the iteration element register at the begining of each loop.
♀☺áⁿ                # Push literal  |
E                   # Push the difference of the second and first stack values.
►â                  # Push literal |
D                   # Push the sum of the second and first stack values.
8                   # Print the first stack value, then a newline.
5                   # End an iteration block.
♀►áⁿ▀ⁿ▄ε»▀▀▀▄▄εá╓÷╓ # Push literal  |_|\n/___\\n VvV

Try it online!

Pip, 71 69 64 61 bytes
f:"|"u:C95Ps.s.fP" /_\"Fi,#a{Ps.f.a@i.f}P" |_|"P"/___\"" VvV"

Try it online!
[Try it online!][TIO-jyx4p3hj]
f:"|"
u:C95
a:q
Ps.s.f
P" /_\"
F i ,#a{
    Ps.f.a@i.f     make the fuselage
}
P" |_|"
P"/___\"
" VvV"

nothing fancy happening here.

Oracle SQL, 77 bytes
select'  |
 /_\
'||regexp_replace(x,'(.)',' |\1|
')||' |_|
/___\
 VvV'from t;

It works with an assumption that input string is stored in a table t(x), e.g.
with t(x) as (select 'Earth' from dual)

Test in SQL*Plus
SQL> set pages 0
SQL> with t(x) as (select 'Earth' from dual)
  2  select'  |
  3   /_\
  4  '||regexp_replace(x,'(.)',' |\1|
  5  ')||' |_|
  6  /___\
  7   VvV'from t;
  |
 /_\
 |E|
 |a|
 |r|
 |t|
 |h|
 |_|
/___\
 VvV

Python 3.7, 79 77 Bytes
o='  | \n /_\\\n'
for c in input()+"_":o+=f' |{c}|\n'
print(o+'/___\\\n VvV')

-2 bytes thanks to Value Ink

Welcome to PPCG! I think you can save 2 bytes by iterating through input()+"_" so you don't have to manually put in the bottom of the rocket shaft. Try it online!

C#, 159 bytes
public class P{public static void Main(string[]a){var f="";foreach (char c in a[0]){f+=" |"+c+"|\n";}System.Console.Write(@"  |
 /_\
"+f+@" |_|
/___\
 VvV");}}

Try Online

Suggest foreach(var c in a[0])f+=" |"+c+"|\n"; instead of foreach (char c in a[0]){f+=" |"+c+"|\n";}

Ruby, 85 bytes
puts"  |\n /_\\";gets.split('').append('_').each{|a|puts" |#{a}|"};puts"/___\\\n VvV"
Attempt This Online!

70 bytes

JavaScript 63
s=>`  |\n /_\\\n${(s+'_').replace(/./g," |$&|\n")}/___\\\n VvV`

executed using s("test") for example.

SpecBAS - 95 bytes
1 input a$: ?"  |"'" /_\"
2 for i=1 to len a$:? " |";a$(i);"|":next i
3 ?" |_|"'"/___\"'" VvV"

The apostrophe moves the cursor down a line, and ? is shorthand for PRINT

R, 148 bytes
f=function(b){cat("  |\n /_\\\n |",paste(as.character(unlist(strsplit(c(b,"_"),''))),collapse='|\n |'),"|\n/___\\\n VvV",sep="")}
f(commandArgs(T))

If above code is in sample.R file then run from command line
Rscript sample.R "GOKUL"

Output:
  |
 /_\
 |G|
 |O|
 |K|
 |U|
 |L|
 |_|
/___\
 VvV

GNU sed, 53 bytes
1i\  |\n /_\\
s:.: |&|\n:g;s:$: |_|:g;$a\/___\\\n VvV

With GNU sed, you can omit the initial \ for the a command, so it is one byte less:
1i\  |\n /_\\
s:.: |&|\n:g;s:$: |_|:g;$a/___\\\n VvV

sed, 51 bytes
s/$/_/
s/./ |&|\n/g
s!.*!  |\n /_\\\n&/___\\\n VvV!

Each line from stdin produces a new rocket on stdout.

Dart, 110 106 bytes
r(var s){s=s+'_';var o='  |\n /_\\\n',i=0;while(i<s.length)o=o+' |'+s[i++]+'|\n';return o+'/___\\\n VvV';}

Try it out
EDIT: Saved 4 bytes, thanks!

Do not declare i separately as int, just enumerate it at var.

@manatwork What do you mean? How would you not have to declare i?

You have, but var is fine for i too: var o='  |\n /_\\\n',i=0.

Ah, thanks! I didn't know Dart had that!

dc, 55 bytes
Building a rocket with the desck calculator:
?[  |
 /_\
]n[[ |]nn[|
]nz0<R]sRz0!=R[ |_|
/___\
 VvV]p

Because dc interprets input as commands, our string's characters are assumed to be already on the stack and the code is acting more like a function accessing its arguments.
Example run:
me@LCARS:/PPCG$ dc -f rocket_science.dc
[A][S][A][N] #the stack is LIFO, so the arguments (characters) are in reverse order
  |
 /_\
 |N|
 |A|
 |S|
 |A|
 |_|
/___\
 VvV

RProgN, 59 Bytes
'  |
 /_\' p '.' ' |%1|
' R "
$" '' R p ' |_|
/___\
 VvV' p

Explination
'  |        #
 /_\'       # Build the top of the rocket
p           # Print it.
            # Input is taken implicitly.
'.' ' |%1|  # v
' R         # Replace each character with " |ITSELF|" followed by a newline.
"           # v
$" '' R  # Snip the last newline.
p           # Print the new body.
            #
' |_|       #
/___\       #
 VvV'       # Build the lower segment.
 p          # Print.

Try it Online!

Crystal, 89 bytes
x=gets.to_s.chomp;y="  |
 /_\\
";x.each_char{|c|y+=" |#{c}|
"};puts y+" |_|
/___\\
 VvV"

Ungolfed:
input = gets
if !input
  STDERR.puts "Couldn't get input from stdin!"
  exit 1
end
puts <<-'END'
  |
 /_\
END
input.chomp.each_char do |char|
  puts " |#{char}|\n"
end
puts <<-'END'
/___\
 VvV
END

Example usage
Input: Hello, world!
Output:
  |
 /_\
 |H|
 |e|
 |l|
 |l|
 |o|
 |,|
 | |
 |w|
 |o|
 |r|
 |l|
 |d|
 |!|
 |_|
/___\
 VvV

Actual newlines instead of \n to save 1 byte per newline
String#each_char instead of String#chars.each to save 1 byte
Temporary y variable instead of multiple puts calls to save a few bytes
As Crystal is statically typed and gets can return nil, I had to find a way to workaround that. not_nil! raises an exception on runtime if the value is nil and otherwise just returns it, however, the Nil class also implements to_s (that returns a 0-length string) which is 4 characters (as opposed to 8). String also implements to_s (just returns itself), so this is a 4 characters shorter way to shut the compiler up.

Pyth, 44 bytes
js[c2"  |  /_\\"m:" |_|"\_dzc3" |_| /___\ VvV

Try it online!

Perl 5, 47 46 + 1 (-n) = 47 bytes
s/./ |$&|
/g;say"  |
 /_\\
$_ |_|
/___\\
 VvV"

Try it online!

Jq 1.5, 47 bytes
"  |
 /_\\"," |\((./"")[])|"," |_|
/___\\
 VvV"

Expanded
 "  |
  /_\\"             # Head

," |\((./"")[])|"   # Expand |x| with \(interpolation) for each
                    # value from (./"") split of input string by ""
," |_|
 /___\\
  VvV"              # Tail

Try it online!

Ruby, 53 bytes
->s{'  |
 /_\
 |'+(s+?_).chars*'|
 |'+'|
/___\
 VvV'}

Try it online!

J, 52 46 45 bytes
2 4|.'___\/','VvV',' |','/_\','|'(,.,.[),&'_'

Try it online!

Bean, 51 bytes

xxd-style hexdump:

00000000: 56d8 8100 d7d0 80c3 cf20 5da3 7800 2080  VØ..×Ð.ÃÏ ]£x. .
00000010: 7b56 5881 0158 8102 a0a0 fc8a a0af dfdc  {VX..X..  ü. ¯ßÜ
00000020: 8aa0 7cfc 8aa0 7cfc 8aaf dfdf dfdc 8aa0  . |ü. |ü.¯ßßßÜ.
00000030: d6f6 56                                  ÖöV

Try it online!
Equivalent JavaScript (ES6), 51 bytes
`  |
 /_\\
 |${[...a,'_'].join`|
 |`}|
/___\\
 VvV`

Explanation
A full program taking the implicit first line of input as a, it pushes the string '_' onto the array to build the last section of the fuselage. This answer is essentially a compilation of edc65's answer into Bean.

><>, 52 bytes
" ||"i:0(?\$a
__/"a$"_"~/>o<"  |"a" /_\"ar"VvV "a"\_

Try It Online
Adds everything to the stack before printing.

SNOBOL4 (CSNOBOL4), 126 bytes
	OUTPUT('O',6)
	O ='  |'
	O =' /_\'
	S =INPUT '_'
R	S LEN(1) . X REM . S	:F(O)
	O =' |' X '|'	:(R)
O	O ='/___\'
	O =' vVv'
END

Try it online!
Input requires a single trailing newline.

Yabasic, 86 bytes
A script that takes input from STDIN and output to the console.
Input""s$
?"  |
 /_\\"
For i=0To Len(s$)?" |",Mid$(s$+"_",i+1,1),"|"Next
?"/___\
 VvV"

Try it online!

I think you can save three bytes by putting the entire for loop onto one line.

@JonathanFrech You are absolutely right - I can't believe I missed that.

Pascal (FPC), 130 bytes
var s:string;c:char;begin writeln('  |'#10' /_\');read(s);for c in s do writeln(' |',c,'|');writeln(' |_|'#10'/___\'#10' VvV')end.

Try it online!
Colouring doesn't work correctly because of \' :)
#10 represents character with ascii code 10 which is a newline.
Basic program flow here: write the top of the rocket, read input, print a row for each character in input (for ... in loop added by FPC), write the bottom of the rocket.

Perl 5, 46 + 3 (-nlF flag) = 49 bytes
say'  |
 /_\
',(map" |$_|
",@F,_),'/___\
 VvV'

Try it online.

perl6 - 69
say "  |\n /-\\\n |{@*ARGS.comb.join("|\n |")}|\n |_|\n/___\\\n VvV"

Welcome! Consider adding an explanation of your program to those who may not understand it. Also consider adding a link to an online interpreter, such as TIO. Code-only answers are usually automatically flagged as low-quality.

33, 75 69 bytes
-6 bytes because I remembered \n is a thing.
"  |\n /_\\"pi1bzst' | |'j[2ktNpNitclz1aztstcjz]" |_|\n/___\\\n VvV"p

Try it online hopefully coming soon
Explanation:
"  |\n /_\\"pi                     | Print the first part of the rocket
-----------------------------------|
1bzs                               | Get the first command-line argument
            j[       clz1aztstcjz] | For each character in it
     t' | |'  2k                   | - Put it in the fuselage "| |"
                NpNi               | - If it is not null, print it (Null checking is due to the way loops work in 33)
-----------------------------------|
" |_|\n/___\\\n VvV"p              | Print the bottom of the rocket

GolfScript, 53 bytes
"  |\n /_\\"n@0$1/\;{" |"\"|\n"}/" |_|\n/___\\\n VvV"

Try it online!
"  |\n /_\\"n        ascii art
@                    rotate so input is on top
0$1/                 split input into elements of size 1
\;                   swap top elements, pop top (input)
{" |"\"|\n"}/        now the top element is the input array so for each we push the left pipe, swap, then push the right pipe
" |_|\n/___\\\n VvV" ascii art

Python 3, 86 bytes
code-golf:
n=input();print('  |\n / \ ')
for l in n:print(' |'+l+'|')
print(' |_|\n/___\ \n VvV')

normal:
n = input()
print('  |')
print(' / \')

for l in n:
    print(' |' + l + '|')

print(' |_|')
print('/___\')
print(' VvV')
```

05AB1E, 25 bytes
'|„/_©¤IìS'|ì`®¤«„Vv».º.c

Try it online or verify all test cases.
Explanation:
'|      '# Push string "|"
„/_      # Push string "/_"
   ©     # Store it in variable `®` (without popping)
¤        # Get the last character of this string (without popping the string itself): "_"
 Iì      # Prepend the input in front of this "_"
         #  i.e. "Bob" → "Bob_"
   S     # Convert it to a list of characters
         #  → ["B","o","b","_"]
    '|ì '# Prepend a "|" in front of each character
         #  → ["|B","|o","|b","|_"]
       ` # Push all those strings separated to the stack
®        # Push variable `®`: "/_"
 ¤«      # Append it's last character to itself: "/__"
„Vv      # Push string "Vv"
»        # Now join all strings on the stack by newlines
         #  → "|
         #     /_
         #     |B
         #     |o
         #     |b
         #     |_
         #     /__
         #     Vv"
 .º      # Intersected mirror this entire string (towards the right)
         #  → "|
         #     /_\
         #     |B|
         #     |o|
         #     |b|
         #     |_|
         #     /___\
         #     VvV"
   .c    # And then centralize the string (adding leading spaces where necessary)
         #  → "  |
         #      /_\
         #      |B|
         #      |o|
         #      |b|
         #      |_|
         #     /___\
         #      VvV"
         # (after which the result is output implicitly)

SNOBOL4 (CSNOBOL4), 133 bytes
	OUTPUT('O',6)
	O ='  |'
	O =' /_\'
	I =INPUT
S	I LEN(1) . X REM . I	:F(E)
	O =' |' X '|'	:(S)
E	O =' |_|'
	O ='/___\'
	O =' VvV'
END

Try it online!
Always funny to see the shape of the rocket in these answers.
Only interesting thing here is OUTPUT('O',6), which sets O to be the OUTPUT variable into unit number 6, which is STDOUT.

Python 3, 81 bytes
lambda x:"  |\n /_\\\n%s/___\\\n VvV"%''.join([" |%s|\n"%t for t in list(x+'_')])

Try it online!

Stax, 25 bytes
æ¢ïÆn£╗ù♂»Σ√m3,^╝}.Σ8Æ╤º⌡

Run and debug it

GNU AWK, 74 bytes
BEGIN{RS=".|";print"  |\n /_\\"}END{print" |_|\n/___\\\n VvV"}$0=" |"RT"|"

Try it online!
AWK was made for this kind of problem.
The BEGIN pattern do things before the input is read. Changing the default RS variable to ".|" makes AWK read the input one character at a time (i.e., as the /./ regex).
RT is exclusive to GNU AWK, being the text of the RS captured by the regex.
The END pattern do things after the input is finished.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Exploded view of a string
Don't you love those exploded-view diagrams  in which a machine or object is taken apart into its smallest pieces?

Let's do that to a string!
The challenge
Write a program or function that

inputs a string containing only printable ASCII characters;
dissects the string into groups of non-space equal characters (the "pieces" of the string);
outputs those groups in any convenient format, with some separator between groups.

For example, given the string
Ah, abracadabra!

the output would be the following groups:

!
,
A
aaaaa
bb
c
d
h
rr

Each group in the output contains equal characters, with spaces removed. A newline has been used as separator between groups. More about allowed formats below.
Rules
The input should be a string or an array of chars. It will only contain printable ASCII chars (the inclusive range from space to tilde). If your language does not support that, you can take the input in the form of numbers representing ASCII codes.
You can assume that the input contains at least one non-space character.
The output should consist of characters (even if the input is by means of ASCII codes). There has to be an unambiguous separator between groups, different than any non-space character that may appear in the input.
If the output is via function return, it may also be an array or strings, or an array of arrays of chars, or similar structure. In that case the structure provides the necessary separation.
A separator between characters of each group is optional. If there is one, the same rule applies: it can't be a non-space character that may appear in the input. Also, it can't be the same separator as used between groups.
Other than that, the format is flexible. Here are some examples:

The groups may be strings separated by newlines, as shown above.
The groups may be separated by any non-ASCII character, such as  ¬. The output for the above input would be the string:
!¬,¬A¬aaaaa¬bb¬c¬d¬h¬rr

The groups may be separated by n>1 spaces (even if n is variable), with chars between each group separated by a single space:
!  ,    A   a a a a a    b b  c       d   h  r r

The output may also be an array or list of strings returned by a function:
['!', 'A', 'aaaaa', 'bb', 'c', 'd', 'h', 'rr']

Or an array of char arrays:
[['!'], ['A'], ['a', 'a', 'a', 'a', 'a'], ['b', 'b'], ['c'], ['d'], ['h'], ['r', 'r']]

Examples of formats that are not allowed, according to the rules:

A comma can't be used as separator (!,,,A,a,a,a,a,a,b,b,c,d,h,r,r), because the input may contain commas.
It's not accepted to drop the separator between groups (!,Aaaaaabbcdhrr) or to use the same separator between groups and within groups (! , A a a a a a b b c d h r r).

The groups may appear in any order in the output. For example: alphabetical order (as in the examples above), order of first appearance in the string, ... The order need not be consistent or even deterministic.
Note that the input cannot contain newline characters, and A and a are different characters (grouping is case-sentitive).
Shortest code in bytes wins.
Test cases
In each test case, first line is input, and the remaining lines are the output, with each group in a different line.

Test case 1:

Ah, abracadabra!
!
,
A
aaaaa
bb
c
d
h
rr

Test case 2:

\o/\o/\o/
///
\\\
ooo

Test case 3:

A man, a plan, a canal: Panama!
!
,,
:
A
P
aaaaaaaaa
c
ll
mm
nnnn
p

Test case 4:

"Show me how you do that trick, the one that makes me scream" she said
""
,
S
aaaaa
cc
dd
eeeeeee
hhhhhh
ii
kk
mmmm
n
ooooo
rr
ssss
tttttt
u
ww
y

If we use non-ASCII symbols like "¬" as separator, can it be counted as 1 byte?

@LeakyNun No, it will be counted as it corresponds depending on the encoding used for the source code, as usual

Is a trailing newline after the last group acceptable?

Is a leading newline of output acceptable?

@DJMcMayhem Sure. That can't be mistaken with any input char

Argh! Im too late to this party. A patch to SILOS was written at 12:00 AM this morning, It now can actually accept multiline string input. but it now would be noncepeting with this feature

@RohanJhunjhunwala Can't you take input as an array of ASCII codes? I included that specially for you!

@LuisMendo ok I will.

Your third and fourth output format examples step from 5 'a's to 4 'a's.

@Delioth Thanks! Corrected

I think the proper term for this is "knolling": https://en.wikipedia.org/wiki/Knoll_(verb)

@LuisMendo I'm almost there, One clarification can I output unpaced groups that have no members? Essentially my output is separated with n >= 1 new lines where n is variable

@LuisMendo I did it!

@RohanJhunjhunwala Well done! :-) Yes, several newlines as separators is fine

Jelly, 5 bytes
ḟ⁶ṢŒg

Try it online!
It does return an array, just that when it is printed to STDOUT, the separator is gone.
This is indeed a function that can be called as such (in Jelly, each line is a function).
ḟ⁶ṢŒg
ḟ⁶      filter out spaces
  Ṣ     sort
   Œg   group

Python 3.5+, 77 46 44 41 bytes
lambda s:[a*s.count(a)for a in{*s}-{' '}]

Pretty simple. Goes through the unique characters in the string by converting it to a set (using Python 3.5's extended iterable unpacking), then uses a list comprehension to construct the exploded diagrams by counting the number of times each character occurs in the string with str.count. We filter out spaces by removing them from the set.
The order of the output may vary from run to run; sets are unordered, so the order in which their items are processed, and thus this answer outputs, cannot be guaranteed.
This is a lambda expression; to use it, prefix lambda with f=.
Try it on Ideone! Ideone uses Python 3.4, which isn't sufficient.
Usage example:
>>> f=lambda s:[a*s.count(a)for a in{*s}-{' '}]
>>> f('Ah, abracadabra!')
[',', 'A', 'aaaaa', 'd', '!', 'bb', 'h', 'c', 'rr']

Saved 3 bytes thanks to @shooqie!

Congrats on 1k!

In Python >3.5 you can do {*s} for set(s).

Retina, 13 bytes
O`.
!`(\S)\1*

The sorting is very easy (it's a builtin), it's separating the letters that takes 9 bytes. Try it online!
The first line sOrts all matches of the regex . (which is every character), giving us  !,Aaaaaabbcdhrr.
Match is the default stage for the last line of a program, and ! makes it print a linefeed-separated list of matches of the regex. The regex looks for one or more instances of a non-space character in a row.

What does the ! Do?

@Downgoat It prints a linefeed-separated list of all matches of the regex, instead of the default count.

Perl 6, 28 bytes
*.comb(/\S/).Bag.kv.map(*x*)

Note that Bag like a Hash or Set is unordered so the order of results is not guaranteed.
Explanation:
# Whatever lambda ｢*｣

# grab the characters
*.comb(
  # that aren't white-space characters
  /\S/
)
# ("A","h",",","a","b","r","a","c","a","d","a","b","r","a","!")

# Turn into a Bag ( weighted Set )
.Bag
# {"!"=>1,","=>1,"A"=>1,"a"=>5,"b"=>2,"c"=>1,"d"=>1,"h"=>1,"r"=>2}

# turn into a list of characters and counts
.kv
# ("!",1,",",1,"A",1,"a",5,"b",2,"c",1,"d",1,"h",1,"r",2)

# map over them 2 at a time
.map(
  # string repeat the character by the count
  * x *
)
# ("!",",","A","aaaaa","bb","c","d","h","rr")

Vim, 50, 46 bytes
i <esc>:s/./&\r/g
:sor
qq:%s/\v(.)\n\1/\1\1
@qq@qD

Explanation/gif will come later.

For once, Emacs & vim solutions look alike.

Brachylog, 14 7 bytes
7 bytes thanks to Fatalize.
:@Sxo@b

Try it online!
:@Sxo@b
:@Sx     remove spaces
    o    sort
     @b  group

7 bytes using x to remove @S (space). I believe this output format (list of strings) is valid

Pyth, 6
.gk-zd

Try it here or run a Test Suite.
Pretty simple, -zd removes spaces from the input, and .gk groups each remaining element by its value. Unfortunately, I haven't found a way to make use of auto-fill variables. Note that the output is shown as Python strings, so certain characters (read: backslashes) are escaped. If you want it to be more readable, add a j to the beginning of the code.

Haskell, 38 bytes
f s=[filter(==c)s|c<-['!'..],elem c s]

Basically nimi's solution, but explicitly checking only letters appearing in the string.

JavaScript (ES6), 41 bytes
s=>[...s].sort().join``.match(/(\S)\1*/g)

Wouldn't this also cause an entry "     " to exist in the returned array, as well? Not sure if that's allowed

@ValueInk Bah, I thought about that when I started, but promptly forgot. Fixed now.

Umm, how is join() being called with those double backkticks ?

@TejasKale That's an ES6 template string. When you prefix a method to a template string, it passes the template as an array to the method, so in this case, it ends up calling .join(['']). join then converts that to the (empty) string and uses that to join the array elements. Not all methods convert their parameter to string, but this technique is handy on those that do.

2sable, 7 bytes
Code:
Úð-vyÃ,

Explanation:
Ú       # Uniquify the string, aabbcc would result into abc
 ð-     # Remove spaces
   vy   # For each character...
     Ã  #   Keep those in the string, e.g. 'aabbcc', 'a' would result into 'aa'
      , #   Pop and print with a newline

Uses the CP-1252 encoding. Try it online!

That doesn't sound like Dennis at all :-P

Haskell, 40 bytes
f x=[v:w|d<-['!'..],v:w<-[filter(==d)x]]

Usage example: f "Ah, abracadabra!"-> ["!",",","A","aaaaa","bb","c","d","h","rr"].
The pattern v:w matches only list with at least one element, so all characters not in the input are ignored.
Also 40 bytes:
import Data.List
group.sort.filter(>' ')

@ThreeFx: But group is from Data.List, too. Anyway, I think this syntax is ghci only and needs the REPL, so it's a language of it's own. I want to stick with standard Haskell.

C# 125 98 Bytes
using System.Linq;s=>s.GroupBy(c=>c).Where(g=>g.Key!=' ').Select(g=>new string(g.Key,g.Count())));

Explanation
//Using anonymous function to remove the need for a full signature
//And also allow the implicit return of an IEnumerable
s =>

    //Create the groupings
    s.GroupBy(c => c)

    //Remove spaces
    .Where(g=> g.Key!=' ')

    //Generate a new string using the grouping key (the character) and repeating it the correct number of times
    .Select(g => new string(g.Key, g.Count()));

Thanks to @TheLethalCoder who suggested the use of an anonymous function, which also allowed me to remove the ToArray call and just implicitly return an IEnumerable which collectively saves 27 bytes

You can save 18 bytes (if I counted correctly) by compiling it to a Func<string, string[]> i.e. s=>s.GroupBy....

@TheLethalCoder are you sure that is acceptable in place of a function, I've always been wary of that because it adds quite a bit of extra boilerplate to be able to execute it, and with the argument for requiring the Linq using it just seems... well wrong.

Heres a recent example where I do it... http://codegolf.stackexchange.com/a/91075/38550 it'll remove all your boilerplate, as long as functions are allowed

@TheLethalCoder OK thats good enough for me. :) It also allowed me to remove the ToArray call

R, 198 189 96 95 bytes
for(i in unique(a<-strsplit(gsub(" ","",readline()),"")[[1]]))cat(rep(i,sum(a==i)),"\n",sep="")

Ungolfed :
a<-strsplit(gsub(" ","",readline()),"")[[1]] #Takes the input from the console

for(i in unique(a)) #loop over unique characters found in variable a

cat(rep(i,sum(a==i)),"\n",sep="") # print that character n times, where n was the number of times it appeared

This solution is currently not entirely working, when \ are involved.
Now it is !
Thank a lot you to @JDL for golfing out 102 bytes !

@JDL : Please suggest edits in the comments. Your changes are really interesting, but it's kinda rude to change someone else's code like that.

apologies for that, but I didn't have 50 reputation at the time and couldn't make comments. Will do in future though!

@JDL : Fair enough !

Try assigning the variable inside a function: for(i in unique(a=strsplit(gsub(" ","",readline()),"")[[1]]))cat(rep(i,sum(a==i)),"\n",sep="") — saves 2 bytes.

@AndreïKostyrka : It doesn't save bytes in this form because you have to put the whole a=strsplit(...) part between brackets: basically does a -2+2 difference. However, using  <- will save 1 byte !

Yep, that was my fault; the old a variable was saved in the workspace, causing tha faulty code to work normally.

It works out slightly better to use %in% rather than gsub and rep. You should check out my answer ;)

Ruby, 41 + 1 = 42 bytes
+1 byte for -n flag.
gsub(/(\S)(?!.*\1)/){puts$1*$_.count($1)}

Takes input on stdin, e.g.:
$ echo 'Ah, abracadabra!' | ruby -ne 'gsub(/(\S)(?!.*\1)/){puts$1*$_.count($1)}'
A
h
,
c
d
bb
rr
aaaaa
!

><>, 49 bytes
i:0(?v
84}0~/&{!*
v!?: <}/?=&:&:<
>&1+&}aol1-?!;^

Very spaciously wasteful in the output, but i assume is still allowed given the lenience of the rules
Explanation:
i:0(?v           Collects text from input
84}0~/&{!*       adds 32 (first ascii starting at space) to register and 0 to stack
v!?: <}/?=&:&:<  checks all characters to the current register, if equal:
       o         prints the character and continues looping
>&1+&}aol1-?!;^  when all characters are checked, adds 1 to register, prints a newline,
                 checks the stack length to halt the program if 0, and starts looping again

fit some things in pretty tight, even using jumps to get around some functions so i could run the pointer vertically.
Basically this puts each ASCII character on its own newline, and if none of that character exists, the line will be blank
Try it online
Edit: i was wrong there was an error in the code what would cause it to never complete if there was a space in the input

Swift, 105 91 bytes
Thanks to @NobodyNada for 14 bytes :)
Yeah, I'm pretty new to Swift...
func f(a:[Character]){for c in Set(a){for d in a{if c==d && c != " "{print(c)}}
print("")}}

Characters within a group are separated by a single newline. Groups are separated by two newlines.

You can save 13 bytes by taking input as a [Character] instead of a String, since the rules say "The input should be a string or an array of chars."  Also, print("") can be replaced with just print().

@NobodyNada print without arguments didn't work for some reason but the [Character] suggestion was solid. Thanks!

82 bytes. And I know it's been years; that link should be for Swift 2.2, which came out in March 2016.

PowerShell v2+, 44 bytes
[char[]]$args[0]-ne32|group|%{-join$_.Group}

Takes input $args[0] as a command-line argument literal string. Casts that as a char-array, and uses the -not equal operator to pull out spaces (ASCII 32). This works because casting has a higher order precedence, and when an array is used as the left-hand operator with a scalar as the right-hand, it acts like a filter.
We pass that array of characters to Group-Object, which does exactly what it says. Note that since we're passing characters, not strings, this properly groups with case-sensitivity.
Now, we've got a custom object(s) that has group names, counts, etc. If we just print that we'll have a host of extraneous output. So, we need to pipe those into a loop |%{...} and each iteration -join the .Group together into a single string. Those resultant strings are left on the pipeline, and output is implicit at program completion.
Example
PS C:\Tools\Scripts\golfing> .\exploded-view-of-substrings.ps1 'Programming Puzzles and Code Golf'
PP
rr
ooo
gg
aa
mm
i
nn
u
zz
ll
ee
s
dd
C
G
f

Mathematica, 36 bytes
Built-in functions Gather and Characters do most of the work here.
Gather@Select[Characters@#,#!=" "&]&

Pyth, 5 bytes
.gksc

Try it here!
Takes input as a Python string (i.e. wrapped in quotes, escaped quotes and slashes as necessary).
Explanation:
    c    Split (implied) input on whitespace
   s     Sum together
.gk      Group by value

If you guarantee at least one space in the input, there's a 4-byte solution:
t.gk

Try it here!
Explanation:
 .gk (Q)  groups the characters in the string by their value
           this sorts them by their value, which guarantees that spaces are first
t         Remove the first element (the spaces)

Dyalog APL, 11 bytes
Function returning list of strings.
(⊂∩¨∪)~∘' '

(⊂∩¨∪) the intersection of the entirety and its unique characters
~∘' ' except spaces
TryAPL online!

Thunno 2, 3 bytes
ðoÑ

Try it online!
ðo removes spaces from the string. Ñ is a built-in for "group by". There is no body so it just groups identical characters together.

I don't think spaces are allowed to be one of the groups (by requirement #2).

@chunes thanks for the heads-up. It should be fixed now.

JavaScript (Node.js), 59 bytes
Here's some JS solutions without regex. Uses linebreak as separators between groups.
s=>[...s].sort().map(c=>b==(b=c)?c:`
`+c,b=0).join``.trim()

Try it online!

Alternative that might not be supported by some browsers because of at(-1) (62 bytes) :
s=>[...s].sort().map(c=>a+=a.at(-1)==c?c:`
`+c,a="")&&a.trim()

Try it:

f=s=>[...s].sort().map(c=>a+=a.at(-1)==c?c:`
`+c,a="")&&a.trim()

;[
  `Ah, abracadabra!`,
  `\\o/\\o/\\o/`,
  `A man, a plan, a canal: Panama!`,
  `"Show me how you do that trick, the one that makes me scream" she said`
].forEach(s=>console.log(f(s)))

Alternative funny solution (67 bytes) :
s=>[...s].sort().map(a=c=>c!=' '?a[c]=[a[c]]+c:0)&&Object.values(a)

Try it online!

><> (Fish), 53 50 46 bytes
l'~')?v0
v?(0:i<]r+1r[
\~rvol-1
^?:<;?('!'l~oa

Try it
Finally beat the current fish answer. Note the link pre-populates the stack to make it faster but this is unnecessary for the correctness of the program.
Each element of the stack stores how often the nth character appears in the input.

The top row pushes ord('~') 0s to the stack.
The second row reads the input. Use [r1+r] to get the nth element of the stack, add 1 to it, then put it back into place.
The left (red) half of the third row reverses the stack so the higher valued items are on the top. Now we know that the length of the stack is the character code of the count the top element represents. This allows very convenient printing.
The left (grey) half of the bottom row checks if the count of the nth character is 0. If so go to the right half of the third row.
The right (blue) half of the bottom row prints a line break ao. Then pops the top of the stack. If we now have less than ord('!') items on the stack only spaces remain and we exit (since we shouldn't print spaces)
The right half of the third row runs if there is more than one occurrence of the top character. If so, we subtract one occurrence, then print the length of the stack as a character.

K (ngn/k), 11 10 bytes
-1 byte from @doug's improvement
{.x" "_=x}

Try it online!
Returns characters in order of appearance in original input.

=x group the input, returning a dictionary mapping distinct values to the indices in which they appear in the input
" "_ remove the space character
.x index back into the input using the indices returned above, and return just the values of the dictionary (i.e. the list of repeated characters)

Couldn't this be {.x" "_=x}?

Yep! A nice simplification, thanks!

Japt -R, 6 bytes
ñ x ó¥

Try it

R, 65 bytes
cat(strrep(z<-names(y<-table(strsplit(readline(),""))),y)[z>" "])

Attempt This Online!
Full program that accepts input by reading a line from the terminal, and outputs a space-separated string of character-groups.  The input & output are chosen to be directly comparable to the earlier R answers of Billywob and Frédéric.
Nevertheless, we could also golf a little further within the original rules, by writing a function that accepts input as an array of characters, and outputs an array of strings:
R, 49 bytes
function(x)strrep(z<-names(y<-table(x)),y)[z>" "]

Attempt This Online!
Note that this could be further shortened to 42 bytes using a version of R that is more-recent than the challenge to allow us to exchange function for \.

Processing, 109 bytes
void s(char[] x){x=sort(x);char l=0;for(char c:x){if(c!=l)println();if(c!=' '&&c!='\n'&&c!='\t')print(c);l=c;}}

Its the brute force approach, sort the array, then loop through it.  If it doesn't match the last character printed, print a newline first.  If it is whitespace, skip the printing step.

Octave, 61 bytes
@(x)mat2cell(y=strtrim(sort(x)),1,diff(find([1 diff(+y) 1])))

This is an anoymous function that takes a string as input and outputs a cell arrray of strings.
Try at Ideone.
How it works

sort sorts the input string. In particular, spaces will be at the beginning.
strtrim removes leading spaces.
diff(+y) computes consecutive differences between characters (to detect group boundaries)...
... so diff(find([1 diff(+y) 1]) gives a vector of group sizes.
mat2cell then splits the sorted string into chunks with those sizes.

Javascript (using external Library - Enumerable) (78 67 bytes)
 n=>_.From(n).Where(y=>y!=' ').GroupBy(x=>x).WriteLine(y=>y.Write())

Link to lib: https://github.com/mvegh1/Enumerable
Code explanation: This is what Enumerable was made to do! Load the string into the library, which converts it to a char array. Filter out the white space entries. Group by char. Write each group to a line, according to the specified predicate. That predicate says to join all the elements of the current group into a string, without a delimiter.

Perl6, 48 47 45
slurp.comb.Bag.kv.map:{$^a.trim&&say $a x$^b}

Thanks to manatwork for the improvements.

Not a big improvement, but $a.trim seems to do it for the condition.

Seems the logical operators still not need spaces around them, so  $^a.trim&&say $a x$^b works. (Sorry for adding the hints byte by byte, but this is my first try on Perl6.)

Little typo, you accidentally removed the opening {.

Bash + coreutils, 53 50 45 bytes
sed 's: ::g;s:\(.\)\1*:& :g'<<<`fold -1|sort`

There is no separator between the characters of a group and the groups are separated by space. There is one trailing group separator, but as I understood that's acceptable.
Run:
./explode_view.sh <<< '\o /\ o /\ o k'

Output:
// \\\ k ooo

MATL, 7 bytes
Xz!t7XQ

MATL Online Demo

Ruby, 35 bytes
->s{(?!..?~).map{|x|s.scan x}-[[]]}

Tried to turn the problem upside down to save some bytes.
Instead of starting with the string, start with the possible character set.

Japt -R, 3 bytes
¸¬ü

Try it
¸¬ü     :Implicit input of string
¸       :Split on spaces
 ¬      :Join
  ü     :Group & sort
        :Implicit output joined with newlines

Arturo, 26 bytes
$=>[sort&--` `|chunk=>[&]]

Try it!
Takes input as a list of characters.
$=>[           ; a function where input is assigned to &
    sort       ; sort
    &--` `     ; input with spaces removed
    |          ; then
    chunk=>[&] ; split into groups of equal contiguous characters
]              ; end function

Zsh, 35 bytes
Try it online!
for x (${(us::)1// })<<<${1//[^$x]}

Input via argument $1. Expression ${(us::)1// } splits $1 to array of unique chars, and removes spaces. Iterate over the unique array. For each x, print $1, removing non-x chars.
45 bytes: A=(${(s::)1});for x (${(u)A})<<<${(Mj::)A#$x}

Scala, 53 bytes
def?(s:String)=s.filter(_!=' ').groupBy(identity).map{_._2.mkString}

When run with REPL:
scala> ?("Ah, abracadabra!")
res2: scala.collection.immutable.Iterable[String] = List(!, A, aaaaa, ,, bb, c, h, rr, d)

scala> print(res2.mkString("\n"))
!
A
aaaaa
,
bb
c
h
rr
d

EDIT:
Forgot to filter spaces

Clojure, 46
#(partition-by identity(sort(re-seq #"\S" %)))

Long and descriptive function names for simplest of things, yeah.

PHP, 67 bytes
Space as separator
PHP5 using deprecated ereg_replace function.
for(;++$i<128;)echo ereg_replace("[^".chr($i)."]","",$argv[1])." ";

PHP7, 73 bytes
for(;++$i<128;)echo str_repeat($j=chr($i),substr_count($argv[1],$j))." ";

Using built in is worse :(
foreach(array_count_values(str_split($argv[1]))as$a=>$b)echo str_repeat($a,$b)." ";

Perl, 31 bytes
Includes +1 for -p
Run with input on STDIN:
explode.pl <<< "ab.ceaba.d"

explode.pl:
#!/usr/bin/perl -p
s%.%$&x s/\Q$&//g.$/%eg;y/
//s

If you don't care about spurious newlines inbetween the lines the following 24 bytes version works too:
#!/usr/bin/perl -p
s%.%$&x s/\Q$&//g.$/%eg

Oracle SQL 11.2, 123 bytes
SELECT LISTAGG(c)WITHIN GROUP(ORDER BY 1)FROM(SELECT SUBSTR(:1,LEVEL,1)c FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))GROUP BY c;

Un-golfed
SELECT LISTAGG(c)WITHIN GROUP(ORDER BY 1)
FROM (SELECT SUBSTR(:1,LEVEL,1)c FROM DUAL CONNECT BY LEVEL<=LENGTH(:1))
GROUP BY c

S.I.L.O.S 265
The (non competing) code better input format is at the bottom, feel free to try it online!
def : lbl
loadLine :
a = 256
:a
:s
x = get a
z = x
z - 32
z |
if z u
a + 1
GOTO s
:u
if x c
GOTO e
:c
b = x
b + 512
c = get b
c + 1
set b c
a + 1
if x a
:e
a = 512
b = 768
l = 10
:Z
j = a
j - b
if j z
z = get a
c = a
c - 512
:3
if z C
printChar l
a + 1
GOTO Z
:C
printChar c
z - 1
GOTO 3
:z

Input for the above is a series of command line arguments representing ascii values, terminated with a zero.Try it online!.

For a more reasonable method of input we must up the byte count (and use features that were nonexistent before the writing of this challenge).

For 291 bytes we get the following code.
\
def : lbl
loadLine :
a = 256
:a
:s
x = get a
z = x
z - 32
z |
if z u
a + 1
GOTO s
:u
if x c
GOTO e
:c
b = x
b + 512
c = get b
c + 1
set b c
a + 1
if x a
:e
a = 512
b = 768
l = 10
:Z
j = a
j - b
if j z
z = get a
c = a
c - 512
:3
if z C
printChar l
a + 1
GOTO Z
:C
printChar c
z - 1
GOTO 3
:z

Feel free to test this version online!. The backslash is unnecessary but is there to show the important leading line feed.

ARM machine code on Linux, 60 bytes
Hex Dump:
b590 4c0d f810 2b01 b11a 58a3 3301 50a3 e7f8 6222 2704 2001 f1ad 0101 2201 237f 5ce5 b135 700b df00 3d01 d8fc 250a 700d df00 3b01 d8f4 bd90 000200bc

This function basically creates an array of size 128, and whenever it reads a character from the input string it increment's the value at that characters position. Then it goes back through the array and prints each character array[character] times.
Ungolfed Assembly (GNU syntax):
.syntax unified
.bss @bss is zero-initialized data (doesn't impact code size)
countArray:
    .skip 128 @countArray[x] is the number of occurances of x

.text
.global expStr
.thumb_func
expstr:
    @Input: r0 - a NUL-terminated string.
    @Output: Groups of characters to STDOUT
    push {r4,r7,lr}
    ldr r4,=countArray @Load countArray into r4
    readLoop:
        ldrb r2,[r0],#1 @r2=*r0++
        cbz r2,endReadLoop @If r2==NUL, break
        ldr r3,[r4,r2] @r3=r4[r2]
        adds r3,r3,#1 @r3+=1
        str r3,[r4,r2] @r4[r2]=r3
        b readLoop @while (true)
    endReadLoop:
    @Now countArray[x] is the number of occurances of x.
    @Also, r2 is zero
    str r2,[r4,#' ] @'<character> means the value of <character>
    @What that just did was set the number of spaces found to zero.
    movs r7,#4 @4 is the system call for write
    movs r0,#1 @1 is stdout
    sub r1,sp,#1 @Allocate 1 byte on the stack
    @Also r1 is the char* used for write
    movs r2,#1 @We will print 1 character at a time
    movs r3,#127 @Loop through all the characters
    writeLoop:
        ldrb r5,[r4,r3] @r5=countArray[r3]
        cbz r5,endCharacterLoop @If we're not printing anything, go past the loop
        strb r3,[r1] @We're going to print byte r3, so we store it at *r0
        characterLoop:
            swi #0 @Make system call
            @Return value of write is number of characters printed in r0
            @Since we're printing one character, it should just return 1, which
            @means r0 didn't change.
            subs r5,r5,#1
            bhi characterLoop
        @If we're here then we're done printing our group of characters
        @Thus we just need to print a newline.
        movs r5,#10 @r5='\n' (reusing r5 since we're done using it as a loop counter
        strb r5,[r1]
        swi #0 @Print the character

        endCharacterLoop:
        subs r3,r3,#1
        bhi writeLoop @while (--r3)
    pop {r4,r7,pc}
.ltorg @Store constants here

Testing script (also assembly):
.global _start
_start:
    ldr r0,[sp,#8] @Read argv[1]
    bl expstr @Call function
    movs r7,#1 @1 is the system call for exit
    swi #0 @Make system call

Ruby, 46 bytes
Try it online!
->s{(s.chars-[' ']).uniq.map{|c|c*s.count(c)}}

My original full program version, 48 bytes after adding the n flag:
p gsub(/\s/){}.chars.uniq.map{|c|c*$_.count(c)}

Can you replace .count(c) with .count c ?

@Cyoce no, because the * operator is present nearby so the parser will complain.

s.chars-[' ']|[] inside the brackets would avoid the uniq

@GB It would, but if we're chaining it to map then it needs extra parens, and ((s.chars-[' '])|[]).map has the same number of characters as (s.chars-[' ']).uniq.map. And the other, shorter way to check unique characters (via regex) is already covered by @Jordan in another answer

It works inside the brackets, you don't need extra brackets because precedence of '-' is higher.

Python, 107
Could be shortened by lambda, but later
x=sorted(input())
i=0
while i<len(x):x[i:]=['  '*(x[i]!=x[i-1])]+x[i:];i-=~(x[i]!=x[i-1])
print("".join(x))

CJam, 10 bytes
{S-$e`::*}

An unnamed block that expects the string on top of the stack and replaces it with a list of strings.
Try it online!
Explanation
S-  Remove spaces.
$   Sort.
e`  Run-length encode, gives pairs [R C], where R is the run-length and
    C is the character.
::* Repeat the C in each pair R times.

Pyke, 16 9 bytes
d-}F/i*d+

Try it here!

Common Lisp, 123
(lambda(s &aux(w(string-trim" "(sort s'char<))))(princ(elt w 0))(reduce(lambda(x y)(unless(char= x y)(terpri))(princ y))w))

Ungolfed:
(lambda (s &aux (w (string-trim " " (sort s 'char<))))
  (princ (elt w 0))
  (reduce
    (lambda (x y)
      (unless (char= x y) (terpri))
      (princ y))
  w))

Not the most golf friendly language. This could probably be modified to return list of lists instead of printing string.

Emacs, 36 keystrokes
C-SPACE C-EM-xsort-rTABRETURN.RETURN.RETURNC-AC-M-S-%\(\(.\)\2*\)RETURN\1C-QC-JRETURN!
Result
A man, a plan, a canal: Panama! -->
!
,,
:
A
P
aaaaaaaaa
c
ll
mm
nnnn
p

Explanation

C-SPACE C-E
M-x sort-rTAB RETURN .RETURN .RETURN
C-A
C-M-S-% \(\(.\)\2*\)RETURN\1 C-Q C-JRETURN !

Select the input line;
Call sort-regexp-fields with arguments . and .;

Argument #1: Regexp scpecifying records to sort
Argument #2: Regexp scpecifying key within records

Return at line start;
Apply regexp substitution \(\(.\)\2*\) -> \1\n on all matches.

Elixir, 70 bytes
def f(s), do: '#{s}'|>Enum.group_by(&(&1))|>Map.delete(32)|>Map.values

PowerShell, 65
@TimmyD has the shorter answer but I don't have enough rep to comment. Here's my answer in 65 bytes.
I didn't think to use group and I didn't know that you could stick -join in front of something instead of -join"" on the end and save two characters (using that would make my method 63).
([char[]]$args[0]-ne32|sort|%{if($l-ne$_){"`n"};$_;$l=$_})-join""

My method sorts the array, then loops through it and concatenates characters if they match the preceding entry, inserting a newline if they do not.

Clojure (55 bytes)
(defn f[s](map(fn[[a b]](repeat b a))(frequencies s)))

Test Cases:
(f "Ah, abracadabra!")
;;=> ((\space) (\!) (\A) (\a \a \a \a \a) (\b \b) (\c) (\d) (\h) (\,) (\r \r))

(f "\\o/\\o/\\o/")
;;=> ((\\ \\ \\) (\o \o \o) (\/ \/ \/))

(f "A man, a plan, a canal: Panama!")
;;=> ((\space \space \space \space \space \space) (\!) (\A) (\a \a \a \a \a \a \a \a \a) (\c) (\, \,) (\l \l) (\m \m) (\n \n \n \n) (\P) (\p) (\:))

(f "\"Show me how you do that trick, the one that makes me scream\" she said")
;;=> ((\space \space \space \space \space \space \space \space \space \space \space \space \space \space) (\a \a \a \a \a) (\" \") (\c \c) (\d \d) (\e \e \e \e \e \e \e) (\h \h \h \h \h \h) (\i \i) (\k \k) (\,) (\m \m \m \m) (\n) (\o \o \o \o \o) (\r \r) (\S) (\s \s \s \s) (\t \t \t \t \t \t) (\u) (\w \w) (\y))

Java 8, 121 120 110 103 Bytes
s->s.chars().distinct().filter(c->c!=32)
    .forEach(c->out.println(s.replaceAll("[^\\Q"+(char)c+"\\E]","")))

Above lambda can be consumed with Java-8 Consumer. It fetches distinct characters and replaces other characters of the String to disassemble each character occurrence.

R, 67 bytes
Even though there's already an R-answer by @Frédéric I thought my solution deserves it's own answer because it's conceptually different.
for(i in unique(x<-strsplit(readline(),"")[[1]]))cat(x[x%in%i]," ")

The program prints the ascii characters in order of appearence in the string where groups are separated by two white spaces and chars within groups by one white space. A special case is if the string has whitespaces in itself, then at one specific place in the output there will be 4+number of white spaces in string white spaces separating two groups E.g:
Ah, abracadabra! => A  h  ,     a a a a a  b b  r r  c  d  !
Ungolfed
Split up the code for clarity even though assignment is done within the unique functions and changed to order of evaluation:
x<-strsplit(readline(),"")[[1]]) # Read string from command line and convert into vector

for(i in unique(x){              # For each unique character of the string, create vector
  cat(x[x%in%i]," ")             # of TRUE/FALSE and return the elements in x for which
}                                # these are matched

C, 178
#define F for
#define i8 char
#define R return
z(i8*r,i8*e,i8*a){i8*b,c;F(;*a;++a)if(!isspace(c=*a)){F(b=a;*b;++b)if(r>=e)R-1;else if(*b==c)*b=' ',*r++=c;*r++='\n';}*r=0;R 0;}

z(outputArray,LastPointerOkinOutputarray,inputArray) return -1 on error 0 ok
Note:Modify its input array too...
#define P printf
main(){char a[]="A, 12aa99dd333aA,,<<", b[256]; z(b,b+255,a);P("r=%s\n", b);}

/*
 178
 r=AA
 ,,,
 1
 2
 aaa
 99
 dd
 333
 <<
 */

Racket 243 bytes
(let*((l(sort(string->list s)char<?))(g(λ(k i)(list-ref k i))))(let loop((i 1)(ol(list(g l 0))))(cond((= i(length l))
(reverse ol))((equal?(g l(- i 1))(g l i))(loop(+ 1 i)(cons(g l i)ol)))(else(loop(+ 1 i)(cons(g l i)(cons #\newline ol)))))))

Ungolfed:
(define (f s)
  (let*((l (sort (string->list s) char<?))
        (g (λ (k i)(list-ref k i))) )
    (let loop ((i 1)
               (ol (list (g l 0))))
      (cond
        ((= i (length l)) (reverse ol))
        ((equal? (g l (- i 1)) (g l i))
         (loop (+ 1 i) (cons (g l i) ol)))
        (else (loop (+ 1 i) (cons (g l i) (cons #\newline ol))))
        ))))

Testing:
(display (f "Ah, abracadabra!"))

Output:
(
 !
 ,
 A
 a a a a a
 b b
 c
 d
 h
 r r)

Nibbles, 1.5 bytes (3 nibbles)
=~|

=~|     # full program
=~|$$$  # with implicit args added;
  |     # filter
   $    # the input
    $   # by itself (=remove spaces),
=~      # now group the remaining characters by
     $  # themselves

05AB1E, 4 bytes
ðK{γ

Outputs as a list.
Try it online or verify all test cases.
ðK could alternatively be ðм or #J for the same byte-count.
Explanation:
ðK    # Remove all spaces from the (implicit) input-string
  {   # Sort the remaining characters
   γ  # Group adjacent equal characters together in substrings
      # (after which the resulting list is output implicitly)

ðм    # (Vectorized) remove all spaces from the (implicit) input-string

#     # Split the (implicit) input-string by spaces (no-op if the input doesn't contain
      # any spaces)
 J    # Join this list back together to a string (or no-op, by joining the stack
      # consisting of just the single string if the input didn't contained any spaces)

Bash +coreutils, 55 bytes
for x in `fold -1|tee a|sort|uniq`;{ grep $x a|rs -g0;}

Try it online!

Factor, 37 bytes
[ " " without [ ] collect-by values ]

Attempt This Online!

" " without remove spaces
[ ] collect-by group letters by letter
values discard the keys

Javascript (ES5): 50 48 bytes
As a function:
function(i){return i.split("").sort().join(" ")}

The important code, replace the empty string with the search string (29 bytes):
"".split("").sort().join(" ")

PowerShell - 86
I imagine I could get this smaller, but I'll work on it later. This assumes that $d contains the string to explode.
$s="";$i=0;[Array]::Sort(($a=$d-split""));$a|%{$s+=$_;if($a[++$i]-cne$_){$s+="`n"}};$s

Assuming the input is in a pre-defined variable is not an allowed input method.

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/