Is there any `Bash` shebang objectively better than the others for most uses?


* `#!/usr/bin/env bash`
* `#!/bin/bash`
* `#!/bin/sh`
* `#!/bin/sh -`
* etc

I vaguely recall a long time ago hearing that adding a dash to the end prevents someone passing a command to your script, but can’t find any details on that.


What is the preferred Bash shebang?

I see this at the top of Python files:

1. For Python 2 files
    ```python
    #!/usr/bin/env python
    ```
1. For Python 3 files
    ```python
    #!/usr/bin/env python3
    ```

It seems to me like the files run the same without that line.

Why do people write #!/usr/bin/env python on the first line of a Python script?

Should I put the shebang in my Python scripts? In what form?

&lt;!-- language: lang-none --&gt;

    #!/usr/bin/env python 

or

&lt;!-- language: lang-none --&gt;

    #!/usr/local/bin/python

Are these equally portable? Which form is used most?

***Note:*** the [tornado](https://github.com/facebook/tornado) project uses the shebang. On the other hand the [Django](https://www.djangoproject.com/) project doesn&#39;t.

Should I put #! (shebang) in Python scripts, and what form should it take?

I have made [Bash][1] scripts before and they all ran fine without `#!/bin/bash` at the beginning.

What&#39;s the point of putting it in? Would things be any different?

Also, how do you pronounce `#`? I know that `!` is pronounced as &quot;bang.&quot;

How is `#!` pronounced?

  [1]: http://en.wikipedia.org/wiki/Bash_%28Unix_shell%29


Why do you need to put #!/bin/bash at the beginning of a script file?

In the header of a Bash script, what&#39;s the difference between those two statements:

 1.  `#!/usr/bin/env bash`

 2.  `#!/usr/bin/bash`

When I consulted the `env` [man page](https://linux.die.net/man/1/env), I get this definition:

&lt;!-- language: none --&gt;

     env - run a program in a modified environment

What does it mean?


What is the difference between &quot;#!/usr/bin/env bash&quot; and &quot;#!/usr/bin/bash&quot;?

I&#39;ve seen in a number of places, including recommendations on this site (https://stackoverflow.com/questions/10376206/preferred-bash-shebang), to use `#!/usr/bin/env bash` in preference to `#!/bin/bash`. I&#39;ve even seen one enterprising individual [suggest using `#!/bin/bash` was *wrong*](http://mywiki.wooledge.org/BashGuide/Practices#Choose_Your_Shell) and bash functionality would be lost by doing so.

All that said, I use bash in a tightly controlled test environment where every drive in circulation is essentially a clone of a single master drive. I understand the portability argument, though it is not necessarily applicable in my case. Is there any other reason to prefer `#!/usr/bin/env bash`over the alternatives and, assuming portability was a concern, is there any reason using it could break functionality?

Why is #!/usr/bin/env bash superior to #!/bin/bash?

I was going through some shell script tutorials and found the following sample program:

    #!/bin/sh
    clear
    echo &quot;HELLO WORLD&quot;

Can anyone please tell me what the significance of the comment `#!/bin/sh` at the start is?


What does the line &quot;#!/bin/sh&quot; mean in a UNIX shell script?

I had seen this line `#!/usr/bin/env node` at the beginning of some examples in `nodejs` and I had googled without finding any topic that could answer the reason for that line.

The nature of the words makes search it not that easy.

I&#39;d read some `javascript` and `nodejs` books recently and I didn&#39;t remember seeing it in any of them. 

If you want an example, you could see the `RabbitMQ` official [tutorial][1], they have it in almost all of their examples, here is one of them:

    #!/usr/bin/env node
    
    var amqp = require(&#39;amqplib/callback_api&#39;);
    
    amqp.connect(&#39;amqp://localhost&#39;, function(err, conn) {
      conn.createChannel(function(err, ch) {
        var ex = &#39;logs&#39;;
        var msg = process.argv.slice(2).join(&#39; &#39;) || &#39;Hello World!&#39;;
    
        ch.assertExchange(ex, &#39;fanout&#39;, {durable: false});
        ch.publish(ex, &#39;&#39;, new Buffer(msg));
        console.log(&quot; [x] Sent %s&quot;, msg);
      });
    
      setTimeout(function() { conn.close(); process.exit(0) }, 500);
    });

Could someone explain me what is the meaning of this line?

What is the difference if I put or remove this line? In what cases do I need it?

  [1]: https://www.rabbitmq.com/tutorials/tutorial-three-javascript.html

What exactly does &quot;/usr/bin/env node&quot; do at the beginning of node files?

I&#39;d like to execute an [gawk][1] script with `--re-interval` using a shebang. The &quot;naive&quot; approach of 

    #!/usr/bin/gawk --re-interval -f
    ... awk script goes here

does not work, since gawk is called with the first argument `&quot;--re-interval -f&quot;` (not splitted around the whitespace), which it does not understand. Is there a workaround for that?

Of course you can either not call gawk directly but wrap it into a shell script that splits the first argument, or make a shell script that then calls gawk and put the script into another file, but I was wondering if there was some way to do this within one file.

The behaviour of shebang lines differs from system to system - at least in [Cygwin][2] it does not split the arguments by whitespaces. I just care about how to do it on a system that behaves like that; the script is not meant to be portable.

  [1]: http://en.wikipedia.org/wiki/AWK#Versions_and_implementations
  [2]: http://en.wikipedia.org/wiki/Cygwin


How to use multiple arguments for awk with a shebang (i.e. #!)?

I&#39;m trying to create a script for node.js that will work in multiple environments.  Particularly for me, I&#39;m switching back and forth between OS X and Ubuntu.  In the former, Node is installed as `node`, but in the latter it is `nodejs`.  At the top of my script, I can have:

    #!/usr/bin/env node

or

    #!/usr/bin/env nodejs

I&#39;d rather have the script run as an executable for either environment as long as node is installed rather than have one or the other have to specify the command (`./script-name.js` vs. `node script-name.js`).

Is there any way to specify a backup hashbang or one that is compatible in either case for node.js?

Appropriate hashbang for Node.js scripts

I needed to have a directly executable python script, so i started the file with `#!/usr/bin/env python`. However, I also need unbuffered output, so i tried `#!/usr/bin/env python -u`, but that fails with `python -u: no such file or directory`.

I found out that `#/usr/bin/python -u` works, but I need it to get the `python` in `PATH` to support virtual `env` environments.

What are my options?

Cannot pass an argument to python with &quot;#!/usr/bin/env python&quot;

I have some small utility scripts written in Python that I want to be usable on both Windows and Linux.  I want to avoid having to explicitly invoke the Python interpreter.  Is there an easy way to point shebang notation to the correct locations on both Windows and Linux?  If not, is there another way to allow implicit invocation of the Python interpreter on both Windows and Linux without having to modify the script when transferring between operating systems?

Edit:  The shebang support on Windows is provided Cygwin, but I want to use the native Windows Python interpreter on Windows, not the Cygwin one. 

Edit # 2:  It appears that shebang notation overrides file associations in Cygwin terminals.  I guess I could just uninstall Cygwin Python and symlink /usr/bin/python to Windows-native Python.

Shebang Notation: Python Scripts on Windows and Linux?

My node installation is at:

`/usr/local/bin/node`

and I&#39;ve added the shebang:

`#!/usr/local/bin/node`

to the top of the file and given my node app file the permissions 755, but when I try to run:

`&gt; ./my-app`

I get the old:

`-bash: ./my-app: No such file or directory`

What am I doing wrong?

node and shebang : help executing via command line

I used to use the shebang 

    #!/usr/bin/env python

When is it better to use

    #!/usr/bin/python

What is the exact difference between them?

What&#39;s the difference between python shebangs with /usr/bin/env rather than hard-path?

I&#39;m usually using the following shebang declaration in my Python scripts:

    #!/usr/bin/python

Recently, I&#39;ve came across this shebang declaration:

    #!/usr/bin/env python

In the script documentation, it was noted that using this form is &quot;more portable&quot;.

What does this declaration mean? How come there&#39;s a space in the middle of the path? Does it actually contribute to protability?

Proper shebang for Python script

In a script you must include a `#!` on the first line followed by the path to the program that will execute the script (e.g.: sh, perl).

As far as I know, the `#` character denotes the start of a comment and that line is supposed to be ignored by the program executing the script. It would seem, that this first line is at some point read by something in order for the script to be executed by the proper program. 

Could somebody please shed more light on the workings of the `#!`?

I&#39;m really curious about this, so the more in-depth the answer the better.

How does the #! shebang work?

My Python script `beak` contains the following shebang:

    #!/usr/bin/env python

When I run the script `$ ./beak`, I get

    env: python\r: No such file or directory

I previously pulled this script from a repository. What could be the reason for this?

env: python\r: No such file or directory

Which of these is better or faster to use as the shebang line for a Perl script?

    #! perl

    #! perl.exe

    #! fullpath/perl(/perl.exe)

    #! partialpath/perl(/perl.exe)


And, when using `#!perl`, when it works on a particular system, how do I find out in the script which perl interpreter I&#39;m using so I can put that one into the shebang line?

---

And, if using a `/path/path/perl`, are `*` or `...` allowed to be used for the folders?

What should I use for a Perl script&#39;s shebang line?

I know shebang line like this: 

    #!/bin/sh
but I found out I can also use shebang line like this: 

    #!/usr/bin/env python3
This confuses me, can someone explain to me how Linux will process this one? 


How does /usr/bin/env work in a Linux shebang line?

I have the following program:

    #!/usr/local/bin/python3

    print(&quot;Hello&quot;)

Via terminal I do `test.py` and I get:

    Traceback (most recent call last):
      File &quot;/usr/lib/python3.3/site.py&quot;, line 629, in &lt;module&gt;
        main()
      File &quot;/usr/lib/python3.3/site.py&quot;, line 614, in main
        known_paths = addusersitepackages(known_paths)
      File &quot;/usr/lib/python3.3/site.py&quot;, line 284, in addusersitepackages
        user_site = getusersitepackages()
      File &quot;/usr/lib/python3.3/site.py&quot;, line 260, in getusersitepackages
        user_base = getuserbase() # this will also set USER_BASE
      File &quot;/usr/lib/python3.3/site.py&quot;, line 250, in getuserbase
        USER_BASE = get_config_var(&#39;userbase&#39;)
      File &quot;/usr/lib/python3.3/sysconfig.py&quot;, line 610, in get_config_var
        return get_config_vars().get(name)
      File &quot;/usr/lib/python3.3/sysconfig.py&quot;, line 560, in get_config_vars
        _init_posix(_CONFIG_VARS)
      File &quot;/usr/lib/python3.3/sysconfig.py&quot;, line 432, in _init_posix
        from _sysconfigdata import build_time_vars
      File &quot;/usr/lib/python3.3/_sysconfigdata.py&quot;, line 6, in &lt;module&gt;
        from _sysconfigdata_m import *
    ImportError: No module named &#39;_sysconfigdata_m&#39;

Instead if I type `python3 test.py` it works, I get:

`Hello`

P.S. `which python3` ----&gt; `/usr/local/bin/python3`

All Shebang Solutions on Gang of Coders

Total of 20 Shebang Solutions

What is the preferred Bash shebang?

Why do people write #!/usr/bin/env python on the first line of a Python script?

Should I put #! (shebang) in Python scripts, and what form should it take?

Why do you need to put #!/bin/bash at the beginning of a script file?

What is the difference between "#!/usr/bin/env bash" and "#!/usr/bin/bash"?

Why is #!/usr/bin/env bash superior to #!/bin/bash?

What does the line "#!/bin/sh" mean in a UNIX shell script?

What exactly does "/usr/bin/env node" do at the beginning of node files?

How to use multiple arguments for awk with a shebang (i.e. #!)?

Appropriate hashbang for Node.js scripts

Cannot pass an argument to python with "#!/usr/bin/env python"

Shebang Notation: Python Scripts on Windows and Linux?

node and shebang : help executing via command line

What's the difference between python shebangs with /usr/bin/env rather than hard-path?

Proper shebang for Python script

How does the #! shebang work?

env: python\r: No such file or directory

What should I use for a Perl script's shebang line?

How does /usr/bin/env work in a Linux shebang line?

Shebang doesn't work with python3