Shell – Shebang starting with `//`

osxshebangshellshell-scriptslash

I'm confused about following script (hello.go).

//usr/bin/env go run $0 $@ ; exit

package main
import "fmt"
func main() {
    fmt.Printf("hello, world\n")
}

It can execute. (on MacOS X 10.9.5)

$ chmod +x hello.go
$ ./hello.go
hello, world

I haven't heard about shebang starting with //. And it still working when I insert a blank line at the top of the script. Why does this script work?

Best Answer

It isn't a shebang, it is just a script that gets run by the default shell. The shell executes the first line

//usr/bin/env go run $0 $@ ; exit

which causes go to be invoked with the name of this file, so the result is that this file is run as a go script and then the shell exits without looking at the rest of the file.

But why start with // instead of just / or a proper shebang #! ?

This is because the file need to be a valid go script, or go will complain. In go, the characters // denote a comment, so go sees the first line as a comment and does not attempt to interpret it. The character # however, does not denote a comment, so a normal shebang would result in an error when go interprets the file.

This reason for the syntax is just to build a file that is both a shell script and a go script without one stepping on the other.

Related Solutions

Shell – Distance of a command from a shebang

To find out, I created two shell files. Each starts with a shebang line and ends with the sole command date. long.sh has 10,000 comment lines while short.sh has none. Here are the results:

$ time short.sh 
Wed Nov 12 18:06:02 PST 2014

real    0m0.007s
user    0m0.000s
sys     0m0.004s

$ time long.sh
Wed Nov 12 18:06:05 PST 2014

real    0m0.013s
user    0m0.004s
sys     0m0.004s

The difference is non-zero but not enough for you to notice.

Let's get more extreme. I created very_long.sh with 1 million comment lines:

$ time very_long.sh
Wed Nov 12 18:14:45 PST 2014

real    0m1.019s
user    0m0.928s
sys     0m0.088s

This has a noticeable delay.

Conclusion

10,000 comment lines has a small effect. A million comment lines cause a significant delay.

How to create `long.sh` and `very_long.sh`

To create the script long.sh, I used the following awk command:

echo "date" | awk 'BEGIN{print "#!/bin/bash"} {for (i=1;i<=10000;i++) print "#",i} 1' >long.sh

To create very_long.sh, I only needed to modify the above code slightly:

echo "date" | awk 'BEGIN{print "#!/bin/bash"} {for (i=1;i<=1000000;i++) print "#",i} 1' >very_long.sh

Shell – Shebang line for “run with $SHELL”

#!/bin/sh
my_script(){
    { cat; cat <&3; }>"$0"
} <<SHEBANG 3<<\SCRIPT
#!${SHELL}
SHEBANG
#now all the rest of your script

#goes in here

SCRIPT

my_script

most shells will put all of the contents of here-documents in secure temp files automatically. those that don't use pipes, and those buffers are usually more than enough to accomodate shell-script writes, but they're no sure thing, of course.

and functions are literal strings stored into the shell's memory. doing the above should only be required the one time, and afterwards your script will be interpreted by whatever was in $SHELL at the time you ran it.