How can I get the source directory of a Bash script from within the script itself?

Question

How do I get the path of the directory in which a Bash script is located, inside that script?

I want to use a Bash script as a launcher for another application. I want to change the working directory to the one where the Bash script is located, so I can operate on the files in that directory, like so:

$ ./application

None of the current solutions work if there are any *newlines at the end of the directory name* - They will be stripped by the command substitution. To work around this you can append a non-newline character inside the command substitution - `DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd && echo x)"` - and remove it without a command substitution - `DIR="${DIR%x}"`. — l0b0, Sep 24 '12 at 12:15
@jpmc26 There are two very common situations: Accidents and sabotage. A script shouldn't fail in unpredictable ways just because someone, somewhere, did a `mkdir $'\n'`. — l0b0, Mar 28 '13 at 08:14
Tyipcally, the caller of the script can easily provide the input to that script it needs, such as "/home/userx/bin/my_script /home/userx/bin" since the caller knows the path it's using to access the script. Because Linux uses the inode model from Unix (awesome feature), it's often tricky to find the answer automatically. And, even using the techniques mentioned below, it can be tricky. For example, a script can reside at more than one path (ln without -s). If the fragility those considerations add is not a concern, the answers using BASH_SOURCE and the like do the job. — ash, Aug 22 '13 at 19:11
ash: With hardlinks, you'll get one of the correct answers - the path which was used for invocation. If hardlinks are a problem, don't use them (they're probably a bad idea for scripts anyway, in *most* cases). — Blaisorblade, Sep 26 '13 at 23:57
@l0b0 I used your solution on RHEL 6.5x64, but my $DIR variable ends up with a newline after it anyway. Any idea why that might be? — Ryan, Jul 01 '14 at 16:17
@l0b0 I've posted a question: http://stackoverflow.com/questions/24537068/how-does-bash-script-command-substitution-work — Ryan, Jul 02 '14 at 17:08
See also: [Bash script: set current working directory to the directory of the script](http://stackoverflow.com/questions/3349105/bash-script-set-current-working-directory-to-the-directory-of-the-script). — kenorb, Sep 20 '14 at 14:25
http://stackoverflow.com/questions/19313056/what-platform-independent-way-to-find-directory-of-shell-executable-in-shell-scr — gavenkoa, Jan 07 '15 at 18:09
anyone who lets people sabotage their system in that way shouldn't leave it up to bash to detect such problems... much less hire people capable of making that kind of mistake. I have never had, in the 25 years of using bash, seen this kind of thing happen anywhere.... this is why we have things like perl and practices such as taint checking (i will probably be flamed for saying that :) — osirisgothra, Feb 05 '15 at 00:12
@l0b0 Consider that you'd need the same protection on `dirname`, and that the directory could start with a `-` (e.g. `--help`). `DIR=$(reldir=$(dirname -- "$0"; echo x); reldir=${reldir%?x}; cd -- "$reldir" && pwd && echo x); DIR=${DIR%?x}`. Perhaps this is overkill? — Score_Under, Apr 28 '15 at 17:46
Guys, you should check out my simple script here: https://github.com/lingtalfi/printScriptDir/blob/master/printScriptDir.sh, it handles symlinks, relative paths, absolute paths, tested on linux and macOsX. — ling, Oct 02 '15 at 22:07
I stronly suggest to read this [Bash FAQ](http://mywiki.wooledge.org/BashFAQ/028) about the subject. — Rany Albeg Wein, Jan 30 '16 at 02:22
@Blaisorblade writes "If hardlinks are a problem, don't use them". That is not possible. Every entry in a directory is a hard link. Every path to a file is a hard link. Without hard links, you cannot access a file. The problem with this question is in the wording: files are not stored in directories. Directories are nothing but a list of hard links. — William Pursell, Aug 27 '16 at 20:37
@WilliamPursell Then read that as "avoid adding a second hardlink to the file", which I think was clear in context and is a standard abuse of language. The Bash FAQ lists other and more relevant concerns, though it seems more bent on discouraging this than describing when this is safe. — Blaisorblade, Aug 28 '16 at 12:13
For the filename, see: [How do I know the script file name in a Bash script?](https://stackoverflow.com/q/192319/55075) — kenorb, Jul 19 '17 at 18:40
@Score_Under Just don't use `dirname` at all: just use `reldir=${0%/*}` directly — mtraceur, Oct 18 '18 at 21:14
@Rainb I had no idea my comments were popular :) I've posted it as an answer. Editors, if you see this, should I delete the original comments? — l0b0, Apr 15 '21 at 08:48
A robust and Mac/Linux-friendly solution is HERE=$(cd "$(dirname "$BASH_SOURCE")"; cd -P "$(dirname "$(readlink "$BASH_SOURCE" || echo .)")"; pwd) - explanation (with simpler variations) here: https://www.binaryphile.com/bash/2020/01/12/determining-the-location-of-your-script-in-bash.html — Binary Phile, Apr 18 '21 at 13:22

score 7131 · Accepted Answer · edited Apr 28 '21 at 10:18

7131

#!/bin/bash

SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

is a useful one-liner which will give you the full directory name of the script no matter where it is being called from.

It will work as long as the last component of the path used to find the script is not a symlink (directory links are OK). If you also want to resolve any links to the script itself, you need a multi-line solution:

#!/bin/bash

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
  SOURCE="$(readlink "$SOURCE")"
  [[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
done
DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"

This last one will work with any combination of aliases, source, bash -c, symlinks, etc.

Beware: if you cd to a different directory before running this snippet, the result may be incorrect!

Also, watch out for $CDPATH gotchas, and stderr output side effects if the user has smartly overridden cd to redirect output to stderr instead (including escape sequences, such as when calling update_terminal_cwd >&2 on Mac). Adding >/dev/null 2>&1 at the end of your cd command will take care of both possibilities.

To understand how it works, try running this more verbose form:

#!/bin/bash

SOURCE="${BASH_SOURCE[0]}"
while [ -h "$SOURCE" ]; do # resolve $SOURCE until the file is no longer a symlink
  TARGET="$(readlink "$SOURCE")"
  if [[ $TARGET == /* ]]; then
    echo "SOURCE '$SOURCE' is an absolute symlink to '$TARGET'"
    SOURCE="$TARGET"
  else
    DIR="$( dirname "$SOURCE" )"
    echo "SOURCE '$SOURCE' is a relative symlink to '$TARGET' (relative to '$DIR')"
    SOURCE="$DIR/$TARGET" # if $SOURCE was a relative symlink, we need to resolve it relative to the path where the symlink file was located
  fi
done
echo "SOURCE is '$SOURCE'"
RDIR="$( dirname "$SOURCE" )"
DIR="$( cd -P "$( dirname "$SOURCE" )" >/dev/null 2>&1 && pwd )"
if [ "$DIR" != "$RDIR" ]; then
  echo "DIR '$RDIR' resolves to '$DIR'"
fi
echo "DIR is '$DIR'"

And it will print something like:

SOURCE './scriptdir.sh' is a relative symlink to 'sym2/scriptdir.sh' (relative to '.')
SOURCE is './sym2/scriptdir.sh'
DIR './sym2' resolves to '/home/ubuntu/dotfiles/fo fo/real/real1/real2'
DIR is '/home/ubuntu/dotfiles/fo fo/real/real1/real2'

edited Apr 28 '21 at 10:18

laurent

79,308
64
256
389

answered Oct 29 '08 at 08:36

dogbane

242,394
72
372
395

This also does not work if the shell is invoked with an explicit `bash` command, as you would need to do if you wanted to invoke with a shell option, as in `sh -x myscript.sh` – Jim Garrison Aug 09 '11 at 16:07
3

For one last upgrade, try this: DIR="$( cd -P "$( dirname "$0" )" && pwd )" --- that will give you the absolute dereferenced path, ie, resolves all symlinks. – Dave Dopson Aug 16 '11 at 18:03
It also does not work if you call the scripts via symbolic link; it returns the directory where the symlink is. But this may even be desirable. – eold Aug 18 '11 at 22:00
32

You can fuse this approach with the answer by user25866 to arrive at a solution that works with `source – Dan Moulding Oct 19 '11 at 15:54
let me try that again... The while loop breaks if any symlink in the chain is a relative symlink. Consider the following setup: /bin/bar -> /etc/alternatives/bar -> /usr/lib/bar-bsd -> bsdbar You'll need to change the while loop to while [ -h "$SOURCE" ] ; do LAST_SOURCE="$SOURCE"; SOURCE="$(readlink "$SOURCE")"; if [ "${SOURCE:0:1}" != / ] ; then SOURCE="$(dirname "$LAST_SOURCE")/$SOURCE"; fi; done – beltorak Dec 15 '11 at 09:47
4

*When doing variable assignment to the output of command substitution or to the output of a variable reference, there is no reason whatsoever to use quotes*. Proof: run `x="my name is ryran"` and then `a=$x` or `a=${x/ryran/bob jones}` or `a=$(echo $x)` – rsaw Mar 08 '12 at 18:54
This is great, however I ran into a really weird problem. I have a funky command prompt defined, and when using this exact method I was getting unprintable characters in my DIR. I fixed it by using the following: DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )" – fileoffset Mar 26 '12 at 03:50
5

To deal with a relative symlink, I found I needed `DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && cd -P "$( dirname "$SOURCE" )" && pwd )"` – Joseph Wright Apr 15 '12 at 19:35
@ryran: yes, but beware that you cannot portably expect `local a=$x` or `export a=$x` to work the same way. I'm not sure about `a=$x foo`, where foo is some command or builtin, but I suspect that you can't portably rely on the assignment behavior you describe there either. – dubiousjim May 31 '12 at 17:21
@dubiousjim: Hmm. What do you mean "*portably* expect"? I don't see how you'd have any trouble with any of it -- local/export, whatever. It all works in every version of BASH (and we're only talking about BASH here). As far as "`a=$x foo` where foo is some command or builtin" ... I'm not sure what you're trying to say there. – rsaw May 31 '12 at 23:48
@ryran: By "portably" I did mean in other shells. Granted this discussion is bash-specific, but it's worth being aware of what idioms one is using that may unexpectedly break in dash, ash, etc. It's easy to remember that `[[ ]]` is non-portable; more suprising that `local a=$x` with no quotes around the `$x` is too. I just checked FreeBSD sh (a species of ash): here `local a=$x` only assigns the first word of `$x`'s expansion to a; similarly with `export`. But `a=$x ./foo` will (temporarily) assign the whole contents of `$x`'s expansion to a. – dubiousjim Jun 01 '12 at 00:15
1

@dubiousjim: I hear you and you're right that it's good to be aware. I don't care though, because I don't ever code shell scripts in anything other than bash since virtually every linux distro comes with gnu bash installed. (I don't mean as the default shell; I just mean installed and available for bash scripts.) – rsaw Jun 01 '12 at 23:36
Short version does not work in cygwin when the path is like "C:\...". Output of cd is `: No such file or directoryabc` where `abc` is the end of the directory name that contains the script. Second version works though. – Qwertie Jun 20 '12 at 21:59
1

Do not `cd` to other directory before this code, otherwise it will be wrong. – weynhamz Dec 25 '12 at 12:13
7

Note that BASH_SOURCE was added for debugging purposes in version bash-3.0-alpha. So if you are working with a legacy system this won't work. – JeffCharter Jan 11 '13 at 23:12
22

Sometimes `cd` prints something to STDOUT! E.g., if your `$CDPATH` has `.`. To cover this case, use `DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" > /dev/null && pwd )"` – user716468 Feb 03 '13 at 02:33
Note that `dirname $0` appriach won't work on just started bash shell session. (Of course this is not the case of OP) Try it on just launched terminal. In contrast, `BASH_SOURCE` approach works well. – eonil Apr 03 '13 at 09:41
@fileoffset: You probably have CDPATH set to something. If that variable is set in your environment, the cd command will echo the new directory to stdout. Any portable ksh or bash script that uses cd should either redirect its output, or should prefix the cd command with CDPATH=. – Chris Quenelle Apr 17 '13 at 16:58
1

Is BASH_SOURCE[0] always the same as $0? If that is true, then why not use $0? It's simpler, more portable and more idiomatic. BASH_SOURCE is useful for processing as a list to find the call stack. In this case, $0 is good enough. – Chris Quenelle Apr 17 '13 at 16:59
5

@ChrisQuenelle: [`${BASH_SOURCE[0]}` differs from `$0` when using `source`](http://www.cyberciti.biz/faq/unix-linux-script-sourced-by-bash-can-it-determine-its-own-location/). – Matt Kantor Apr 28 '13 at 20:14
@DaveDopson: I suggest to add `>/dev/null` after the `cd` because the above breaks in odd ways when `cd` prints something to stdout. – Aaron Digulla Nov 04 '13 at 13:40
1

In my experience, it is not necessary to add quotes around `$()` expressions. Thus: `FILES=$(ls -1)` and `FILES="$(ls -1)"` are exactly the same. – kevinarpe Nov 24 '13 at 07:19
1

A stupid mistake, but at first I didn't get why ${BASH_SOURCE[0]} didn't work until I realized I had used #!/bin/sh instead of #!/bin/bash. – Zitrax Feb 17 '14 at 14:40
5

Why not use the following command? `DIR=$(dirname -- "$(readlink -f -- "${BASH_SOURCE[0]}")")` – x-yuri Apr 29 '14 at 15:18
2

According to [ss64's docs](http://ss64.com/bash/pwd.html), `pwd` takes a `-P` argument. The description states that the `-P` argument ensures the path contains no symbolic links. Could this argument be used to follow symbolic links instead of the loop? – jpmc26 Aug 14 '14 at 15:13
3

@x-yuri - FYI, `readlink` is not available in the current form on OSX, hence this method would be best, if you're trying to write a semi-crossplatform script on Linux & OSX using Bash. – slm Sep 02 '14 at 19:52
Sadly, this will not work from ~/.bashrc because the $DIR variable is only evaluated once at login time, not dynamically all the time. :-( – lpapp Oct 20 '14 at 17:09
@lpapp If you're trying to reference the directory of `~/.bashrc`, you already know it! It's `~`. ;) Normally, I don't like to assume, but in this case, it's a pretty safe assumption since it's happening at log in and `bash` is only looking in that specific place. – jpmc26 Dec 03 '14 at 04:00
This solution doesn't work for autoenv `.env` scripts (or similar scripts that execute when you `cd` because it will call itself recursively) why not just DIR=$( dirname "${BASH_SOURCE[0]}" ) – Pete May 06 '15 at 12:02
207

This accepted answer is not ok, it doesn't work with symlinks and is overly complex. ````dirname $(readlink -f $0)```` is the right command. See https://gist.github.com/tvlooy/cbfbdb111a4ebad8b93e for a testcase – tvlooy Jun 09 '15 at 19:32
182

@tvlooy IMO your answer isn't exactly OK as-is either, because it fails when there is a space in the path. In contrast to a newline character, this isn't unlikely or even uncommon. `dirname "$(readlink -f "$0")"` doesn't add complexity and is fair measure more robust for the minimal amount of trouble. – Adrian Günter Oct 28 '15 at 23:38
This solution doesn't work in a script called when running an application by clicking on an icon under Ubuntu, the script is mentioned in the Exec attribute. The same script works flawlessly in the terminal. I'm currently investigating. I don't want to set the Path attribute in the desktop file as it wouldn't be distro-agnostic. – gouessej Oct 29 '15 at 10:39
2

As a side note: By convention, environment variables (PATH, EDITOR, SHELL, ...) and internal shell variables (BASH_VERSION, RANDOM, ...) are fully capitalized. All other variable names should be lowercase. Since variable names are case-sensitive, this convention avoids accidentally overriding environmental and internal variables. – Rany Albeg Wein Jan 16 '16 at 14:02
3

By convention, environment variables (`PATH`, `EDITOR`, `SHELL`, ...) and internal shell variables (`BASH_VERSION`, `RANDOM`, ...) are fully capitalized. All other variable names should be lowercase. Since variable names are case-sensitive, this convention avoids accidentally overriding environmental and internal variables. – Rany Albeg Wein Jan 30 '16 at 02:16
1

To deal with symlinks, use `pwd -P` – Jesin Sep 06 '16 at 00:29
1

@switch87 your solution doesn't work in all cases. Please do not edit the answer if you are not 100% sure. – smancill Mar 20 '17 at 03:23
The oneliner assumes 'cd' is silent. If not you will end up with garbage. Better: DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >>/dev/null && pwd )" – Andreas Apr 27 '17 at 14:27
19

@tvlooy your comment is not macOS (or probably BSD in general) compatible, while the accepted answer is. `readlink -f $0` gives `readlink: illegal option -- f`. – Alexander Ljungberg May 09 '17 at 16:14
1

All BSD's have it. OSX doesn't. Install coreutils and use greadline – tvlooy May 09 '17 at 20:31
Cute format: `DIR=$(cd $(dirname ${BASH_SOURCE[0]}) && pwd)` – zored Jul 17 '17 at 11:00
2

Seems like no one has the problem with changing working directory without putting it back where it was. :( EDIT: My bad `$()` creates a new shell, doesn't it? – tishma Sep 09 '17 at 08:47
While both `-h` and `-L` opts for `test` find wide dual support, there is a preference to favor `-L`. See these stackoverflow questions: [ref 1](https://stackoverflow.com/questions/5767062/how-to-check-if-a-symlink-exists) and [ref 2](https://stackoverflow.com/questions/1997666/difference-between-test-h-and-test-l). However, your milage may vary depending on who is refusing to follow standards. – Novice C Sep 27 '17 at 12:26
3

So, @tvlooy, if I'm running on macOS, your solution is to install a software package so I can use your answer? That's far worse than the little bit of complexity of the accepted answer (assuming no symlinks). – Ethan Reesor Nov 08 '17 at 05:13
1

Why not use `realpath` (as in the other answers) instead of the `while` loop? – Vladimir Panteleev Dec 12 '17 at 21:31
Probably it's not robust, for the link and no link aproach I do the following: LINK=`readlink "${BASH_SOURCE[0]}"` if [ $? -eq 0 ]; then echo "Link detected" export SCRIPT_DIR="$( cd "$( dirname "$LINK" )" && pwd )" else echo "No link" export SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )" fi – Anton Krug Aug 21 '18 at 14:16
1

Note: don't forget the `#!/bin/bash` at the top. `#!/bin/sh` won't work. You'll get a `Bad substitution` error. – Gabriel Staples Dec 02 '18 at 05:41
1

The one-liner fails on OSX El Capitan, because of Bash Sessions, which pollute the output with `Saving session... ...copying shared history... ...saving history...truncating history files... ...completed.` This works: `read DIR < /dev/null 2>&1 && pwd)` – Rich Kuzsma May 09 '19 at 15:13
I always change the formatting of this line into: `DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" >/dev/null 2>&1 && pwd)"` – wieczorek1990 Jun 28 '19 at 09:20
1

Is it possible to wrap this in a function, or does it have to be copy/pasted all over the place? – Alexander Jul 12 '19 at 21:27
I just found out that the above does not work when the script is straight out executed rather than sourced: https://stackoverflow.com/questions/27880087/weird-behaviour-of-bash-source – Andrei LED Aug 27 '19 at 11:49
@Andrei LED, this seems to work for the bash bug case: $(cd $(dirname ${BASH_SOURCE[@]}) &>/dev/null && pwd) – Neil McGill Sep 24 '19 at 13:04
why ${BASH_SOURCE[0]} instead of simpler $BASH_SOURCE – Nam G VU Nov 22 '19 at 15:57
For many cases, `realpath` will work in place of all this; ex: `PATH_TO_SCRIPT=$(realpath $0)`. I found about `realpath` from here: https://stackoverflow.com/a/14892459/4561887. I also just posted this as a new answer here: https://stackoverflow.com/questions/59895/how-to-get-the-source-directory-of-a-bash-script-from-within-the-script-itself/60157372#60157372. – Gabriel Staples Feb 10 '20 at 19:49
dirname executes an extra process. consider ${BASH_SOURCE[0]%/*} instead. – Serg Apr 06 '20 at 12:14
1

tvlooy's compact solution worked for all the torture test cases that I tried. Dave Dopson's more complex solution also works for all the torture test cases that I tried. – MAXdB Jul 03 '20 at 02:29
Torture cases included running as a service and using multiple variations of differently named relative symlinks calling differently named relative symlinks finally calling the script relatively.I also need the actual name of the script, not the name of the first symlink. `TRUESCRIPT="$(dirname $(readlink -f $0))/$(basename $(readlink -f $0))"` – MAXdB Jul 03 '20 at 02:40
@MAXdB, did you test on osx? The concern was osx. – fuzzyTew May 05 '21 at 15:02
Just came here to say that this is my most used stack overflow answer right here. – Mark Pauley May 19 '21 at 06:08

score 983 · Answer 2 · edited Jan 20 '21 at 02:08

983

Use dirname "$0":

#!/bin/bash
echo "The script you are running has basename `basename "$0"`, dirname `dirname "$0"`"
echo "The present working directory is `pwd`"

Using pwd alone will not work if you are not running the script from the directory it is contained in.

[matt@server1 ~]$ pwd
/home/matt
[matt@server1 ~]$ ./test2.sh
The script you are running has basename test2.sh, dirname .
The present working directory is /home/matt
[matt@server1 ~]$ cd /tmp
[matt@server1 tmp]$ ~/test2.sh
The script you are running has basename test2.sh, dirname /home/matt
The present working directory is /tmp

edited Jan 20 '21 at 02:08

Peter Mortensen

28,342
21
95
123

answered Sep 12 '08 at 20:49

matt b

132,562
64
267
334

29

For portability beyond bash, $0 may not always be enough. You may need to substitute "type -p $0" to make this work if the command was found on the path. – Darron Oct 23 '08 at 20:15
11

@Darron: you can only use `type -p` if the script is executable. This can also open a subtle hole if the script is executed using `bash test2.sh` and there is another script with the same name executable somewhere else. – D.Shawley Feb 05 '10 at 12:18
100

@Darron: but since the question is tagged `bash` and the hash-bang line explicitly mentions `/bin/bash` I'd say it's pretty safe to depend on bashisms. – Joachim Sauer Jun 11 '10 at 12:56
36

+1, but the problem with using `dirname $0` is that if the directory is the current directory, you'll get `.`. That's fine unless you're going to change directories in the script and expect to use the path you got from `dirname $0` as though it were absolute. To get the absolute path: `pushd \`dirname $0\` > /dev/null`, `SCRIPTPATH=\`pwd\``, `popd > /dev/null`: http://pastie.org/1489386 (But *surely* there's a better way to expand that path?) – T.J. Crowder Jan 23 '11 at 10:30
10

@T.J. Crowder I'm not sure sure `dirname $0` is a problem if you assign it to a variable and then use it to launch a script like `$dir/script.sh`; I would imagine this is the use case for this type of thing 90% of the time. `./script.sh` would work fine. – matt b Jan 24 '11 at 12:55
1

@matt b: As I said, it's fine as long as your script using it doesn't change the current directory. If your script does, then you try to launch `./script.sh` and `script.sh` is meant to be in the same directory as the original, it's going to fail because you're no longer there. See also: http://stackoverflow.com/questions/4774054/reliable-way-to-get-the-full-path-to-a-bash-script – T.J. Crowder Jan 24 '11 at 13:00
6

`$0` gives wrong result in sourced scripts (including `bashrc`) – ivan_pozdeev Jan 11 '12 at 09:02
1

Cool, this doesn't resolve symlinks, which is exactly what I was looking for. – Ehtesh Choudhury Mar 14 '13 at 16:45
7

@T.J. Crowder > But surely there's a better way to expand that path? Yes, you can use $(readlink -f "$0") to get full path in canonical form with all symlinks resolved. Solves tons of problems. – Volodymyr M. Lisivka Jul 09 '13 at 15:33
1

NOTE ${BASH_SOURCE[0]} is different from $0 when you include one bash file into another using . or source. – Du Song Jul 21 '13 at 05:55
DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"; [ -h "$DIR/$0" ] && DIR=`readlink -n "$DIR/$0" ` – Heavy Gray Nov 18 '13 at 20:16
2

Even with `bash`, `$0` is not always enough. A script may source another script! – reinierpost Mar 28 '14 at 13:08
4

@T.J.Crowder @VolodymyrM.Lisivka you could also use `$(realpath "$0")` but note that neither readlink nor readpath will work on Mac OSX. http://stackoverflow.com/questions/3572030/bash-script-absolute-path-with-osx – joeytwiddle Jan 27 '15 at 07:04
1

@mattb This version failed with directory names that contain special chars and double quote char. e.g. **mkdir "$(printf "\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\40\41\42\43\44\45\46\47testdir" "")"** – Jay jargot Mar 31 '16 at 08:32
1

To get this working on Mac OS, probably because of spaces in the path, I had to enclose the argument with quotes, like so: `\`dirname "$0"\``. – Demis Jun 01 '16 at 03:06
@NecipAllef that works only if the script is in the same directory as you/the caller, if you call /directory/test.sh in / it'll output "I'm at //test.sh" – Muskovets Jul 10 '20 at 18:17
Have to say it is annoying how full of pitfalls this is... the problem is `$0` -- in Windows it's always the script name, so this is very simple: `%~dp0` – Paul Aug 26 '20 at 19:44

score 556 · Answer 3 · edited Jan 20 '21 at 03:36

556

The dirname command is the most basic, simply parsing the path up to the filename off of the $0 (script name) variable:

dirname "$0"

But, as matt b pointed out, the path returned is different depending on how the script is called. pwd doesn't do the job because that only tells you what the current directory is, not what directory the script resides in. Additionally, if a symbolic link to a script is executed, you're going to get a (probably relative) path to where the link resides, not the actual script.

Some others have mentioned the readlink command, but at its simplest, you can use:

dirname "$(readlink -f "$0")"

readlink will resolve the script path to an absolute path from the root of the filesystem. So, any paths containing single or double dots, tildes and/or symbolic links will be resolved to a full path.

Here's a script demonstrating each of these, whatdir.sh:

#!/bin/bash
echo "pwd: `pwd`"
echo "\$0: $0"
echo "basename: `basename $0`"
echo "dirname: `dirname $0`"
echo "dirname/readlink: $(dirname $(readlink -f $0))"

Running this script in my home dir, using a relative path:

>>>$ ./whatdir.sh
pwd: /Users/phatblat
$0: ./whatdir.sh
basename: whatdir.sh
dirname: .
dirname/readlink: /Users/phatblat

Again, but using the full path to the script:

>>>$ /Users/phatblat/whatdir.sh
pwd: /Users/phatblat
$0: /Users/phatblat/whatdir.sh
basename: whatdir.sh
dirname: /Users/phatblat
dirname/readlink: /Users/phatblat

Now changing directories:

>>>$ cd /tmp
>>>$ ~/whatdir.sh
pwd: /tmp
$0: /Users/phatblat/whatdir.sh
basename: whatdir.sh
dirname: /Users/phatblat
dirname/readlink: /Users/phatblat

And finally using a symbolic link to execute the script:

>>>$ ln -s ~/whatdir.sh whatdirlink.sh
>>>$ ./whatdirlink.sh
pwd: /tmp
$0: ./whatdirlink.sh
basename: whatdirlink.sh
dirname: .
dirname/readlink: /Users/phatblat

edited Jan 20 '21 at 03:36

Peter Mortensen

28,342
21
95
123

answered Sep 26 '09 at 20:38

phatblat

3,307
2
30
29

15

`readlink` will not availabe in some platform in default installation. Try to avoid using it if you can – T.L Jan 11 '12 at 09:14
46

be careful to quote everything to avoid whitespace issues: `export SCRIPT_DIR="$(dirname "$(readlink -f "$0")")"` – Catskul Sep 17 '13 at 19:40
13

In OSX Yosemite 10.10.1 `-f` is not recognised as an option to `readlink`. Using `stat -f` instead does the job. Thanks – cucu8 Nov 26 '14 at 09:29
11

In OSX, there is `greadlink`, which is basically the `readlink` we are all familiar. Here is a platform independent version: `dir=\`greadlink -f ${BASH_SOURCE[0]} || readlink -f ${BASH_SOURCE[0]}\`` – robert Jan 14 '16 at 20:16
6

Good call, @robert. FYI, `greadlink` can easily be installed through homebrew: `brew install coreutils` – phatblat Jan 15 '16 at 21:27
3

Note that `$0` doesn't work if the file is sourced. You get `-bash` instead of the script name. – svvac Jun 30 '16 at 16:52
In OSX, you can use `realpath` or `grealpath`, which will give you the resolved path from the root of the file system. Example: `cd /usr/bin; realpath ls` `/usr/bin/ls` – Dave Stern Jan 25 '17 at 17:41
@T.L `readlink` is part of the coreutils package which contains the base GNU utilities. No idea why it wouldn't be available on a GNU-based system. I think we can safely assume OP is using GNU, since the question is about GNU Bash? – Adam Burley Jan 24 '18 at 12:09
IMHO, this is the most accurate answer. If you don't have `readlink`, one can use `realpath` too. Be aware only to use canonical output if needed => `readlink -f` – LeoRado Apr 26 '21 at 11:46

score 186 · Answer 4 · edited Jan 20 '21 at 02:27

186

pushd . > /dev/null
SCRIPT_PATH="${BASH_SOURCE[0]}"
if ([ -h "${SCRIPT_PATH}" ]); then
  while([ -h "${SCRIPT_PATH}" ]); do cd `dirname "$SCRIPT_PATH"`;
  SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`; done
fi
cd `dirname ${SCRIPT_PATH}` > /dev/null
SCRIPT_PATH=`pwd`;
popd  > /dev/null

It works for all versions, including

when called via multiple depth soft link,
when the file it
when script called by command "source" aka . (dot) operator.
when arg $0 is modified from caller.
"./script"
"/full/path/to/script"
"/some/path/../../another/path/script"
"./some/folder/script"

Alternatively, if the Bash script itself is a relative symlink you want to follow it and return the full path of the linked-to script:

pushd . > /dev/null
SCRIPT_PATH="${BASH_SOURCE[0]}";
if ([ -h "${SCRIPT_PATH}" ]) then
  while([ -h "${SCRIPT_PATH}" ]) do cd `dirname "$SCRIPT_PATH"`; SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`; done
fi
cd `dirname ${SCRIPT_PATH}` > /dev/null
SCRIPT_PATH=`pwd`;
popd  > /dev/null

SCRIPT_PATH is given in full path, no matter how it is called.

Just make sure you locate this at start of the script.

edited Jan 20 '21 at 02:27

Peter Mortensen

28,342
21
95
123

answered Oct 07 '08 at 16:12

user25866

301
1
2
3

4

Nice! Could be made shorter replacing "pushd[...] popd /dev/null" by SCRIPT_PATH=`readlink -f $(dirname "${VIRTUAL_ENV}")`; – e-satis Nov 29 '09 at 11:34
1

This is by far the most "stable" version I've seen. Thank you! – Tomer Gabel Jan 26 '10 at 08:19
1

Should not the colon in the line 1 be moved in line two between the if- and then-statements? – ovanes Aug 18 '10 at 10:08
5

And instead of using pushd ...; would not it be better to use $(cd `dirname "${SCRIPT_PATH}"` && pwd)? But anyway great script! – ovanes Aug 18 '10 at 10:16
Just to note my use case: I saved the script as `~/getpath`; and then made a bash alias: `echo "alias getpath='"'GP="getpath" ; cp ~/$GP ./$GP ; source ./$GP ; rm ./$GP'"'" >> ~/.bashrc` ... and now I can do, in either shell or script: `getpath ; echo $SCRIPT_PATH` . Thanks for the script - cheers! – sdaau Aug 06 '11 at 13:43
Ups, shame I missed my edit time window - actually, my alias comment above doesn't work in a script, not even with `shopt -s expand_aliases` (see [Aliases](http://tldp.org/LDP/abs/html/aliases.html)) – sdaau Aug 06 '11 at 13:50
1

You can fuse this approach with the answer by ddopson to arrive at a solution that is a simple one-liner: `DIR="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"`. – Dan Moulding Oct 19 '11 at 15:55
6

It's dangerous for a script to `cd` out of its current directory in the hope of `cd`ing back again later: The script may not have permission to change directory back to the directory that was current when it was invoked. (Same goes for pushd/popd) – Adrian Pronk Nov 06 '12 at 01:15
7

`readlink -f` is GNU-specific. BSD `readlink` does not have that option. – Kara Brightwell Jun 03 '14 at 16:48
4

What's with all the unnecessary subshells? `([ ... ])` is less efficient than `[ ... ]`, and there's no advantage taken of the isolation offered in return for that performance hit here. – Charles Duffy Jun 09 '14 at 03:37
3

The list of cases handled (`Works for all versions`) above has one item == `when the file it`. Can anyone appropriately complete that sentence fragment? – TomRoche Oct 31 '17 at 21:22
by far, the best – Vivick Nov 09 '17 at 20:49
1

What's with the long hash at the bottom? Is it a signature of some kind? What does it tell us? – mwfearnley Mar 29 '19 at 08:57
1

In fact, why is this Copyleft in the first place? Does the author ("user25866") want attribution, despite the answer being a community wiki? I don't think SO is a good place to dump a little snippet and then attach a license to it. To guard ownership and authenticate changes, a Github Gist would be much better. – mwfearnley Mar 29 '19 at 09:13
Is the `if` block necessary? The `while` condition is the same, and `while` will skip if the condition is false the first time. – Jacktose Jan 26 '21 at 00:44

score 116 · Answer 5 · edited Jan 18 '20 at 18:33

116

You can use $BASH_SOURCE:

#!/bin/bash

scriptdir=`dirname "$BASH_SOURCE"`

Note that you need to use #!/bin/bash and not #!/bin/sh since it's a Bash extension.

edited Jan 18 '20 at 18:33

the Tin Man

150,910
39
198
279

answered Sep 12 '08 at 20:50

Mr Shark

24,254
5
29
36

14

When I do `./foo/script`, then `$(dirname $BASH_SOURCE)` is `./foo`. – Till Oct 25 '10 at 17:06
2

@Till, In this case we can use `realpath` command to get full path of ./foo/script. So `dirname $(realpath ./foo/script) ` will give the path of script. – purushothaman poovai Dec 17 '19 at 05:17

score 114 · Answer 6 · edited Apr 19 '17 at 06:59

114

Short answer:

`dirname $0`

or (preferably):

$(dirname "$0")

edited Apr 19 '17 at 06:59

Melebius

4,692
3
32
43

answered Dec 03 '08 at 12:57

Fabien

5,810
7
31
34

17

It won't work if you source the script. "source my/script.sh" – Arunprasad Rajkumar Feb 05 '14 at 07:34
I use this all the time in my bash scripts that automate stuff and often invoke other scripts in the same dir. I'd never use `source` on these and `cd $(dirname $0)` is easy to remember. – kqw Jan 03 '17 at 16:28
18

@vidstige: `${BASH_SOURCE[0]}` instead of `$0` will work with `source my/script.sh` – Timothy Jones Sep 27 '17 at 06:48
@TimothyJones that will fail 100% of the time if sourced from any other shell than bash. `${BASH_SOURCE[0]}` is not satisfactory at all. `${BASH_SOURCE:-0}` is much better. – Mathieu CAROFF Nov 13 '18 at 18:43

Simon Rigét · Answer 7 · 2020-03-19T20:15:18.880

83

This should do it:

DIR="$(dirname "$(readlink -f "$0")")"

This works with symlinks and spaces in path.

See the man pages for dirname and readlink.

From the comment track it seems not to work with Mac OS. I have no idea why that is. Any suggestions?

edited Mar 19 '20 at 20:15

answered Feb 12 '16 at 23:40

Simon Rigét

2,211
3
26
28

6

with your solution, invoking the script like `./script.sh` shows `.` instead of the full directory path – Bruno Negrão Zica Jun 14 '16 at 18:27
5

There's no -f option for readlink on MacOS. Use `stat` instead. But still, it shows `.` if you are in 'this' dir. – Denis The Menace Nov 21 '16 at 09:55
2

You need to install `coreutils` from Homebrew and use `greadlink` to get the `-f` option on MacOS because it is *BSD under the covers and not Linux. – dragon788 Apr 22 '19 at 15:59
You should add double quotes surrounding all the right hand side: `DIR="$(dirname "$(readlink -f "$0")")"` – hagello Mar 17 '20 at 11:22

score 81 · Answer 8 · edited Jan 20 '21 at 04:54

81

Here is an easy-to-remember script:

DIR="$(dirname "${BASH_SOURCE[0]}")"  # Get the directory name
DIR="$(realpath "${DIR}")"    # Resolve its full path if need be

edited Jan 20 '21 at 04:54

Peter Mortensen

28,342
21
95
123

answered Nov 07 '18 at 04:30

Thamme Gowda

9,459
1
41
50

6

Or, more obscurely, on one line: `DIR=$(realpath "$(dirname "${BASH_SOURCE[0]}")")` – agc Apr 04 '19 at 11:55
3

Why isn't this the accepted answer? Is there any difference using `realpath` from resolving "manually" with a loop of `readlink`? Even the `readlink` man page says `Note realpath(1) is the preferred command to use for canonicalization functionality.` – User9123 Mar 25 '20 at 01:14
1

And by the way shouldn't we apply `realpath` before `dirname`, not after? If the script file itself is a symlink... It would give something like `DIR="$(dirname "$(realpath "${BASH_SOURCE[0]}")")"`. Actually very close to the answer proposed by Simon. – User9123 Mar 25 '20 at 01:32
@User9123 I think the accept one is try to be compatible with all popular shell/distro. More over, depending on what you are trying to do, in most cases people want to obtain the directory where the symlink located instead of the directory of the actual source. – Wang May 24 '20 at 12:23
The only reason is missing coreutils on mac. I am using `SCRIPT=$(realpath "${BASH_SOURCE[0]}")` + `DIR=$(dirname "$SCRIPT")`. – puchu Aug 29 '20 at 10:15

score 67 · Answer 9 · edited Jan 20 '21 at 02:15

pwd can be used to find the current working directory, and dirname to find the directory of a particular file (command that was run, is $0, so dirname $0 should give you the directory of the current script).

However, dirname gives precisely the directory portion of the filename, which more likely than not is going to be relative to the current working directory. If your script needs to change directory for some reason, then the output from dirname becomes meaningless.

I suggest the following:

#!/bin/bash

reldir=`dirname $0`
cd $reldir
directory=`pwd`

echo "Directory is $directory"

This way, you get an absolute, rather than a relative directory.

Since the script will be run in a separate Bash instance, there isn't any need to restore the working directory afterwards, but if you do want to change back in your script for some reason, you can easily assign the value of pwd to a variable before you change directory, for future use.

Although just

cd `dirname $0`

solves the specific scenario in the question, I find having the absolute path to more more useful generally.

You can do it all in one line like this: DIRECTORY=$(cd `dirname $0` && pwd) — dogbane, Oct 29 '08 at 08:38
This doesn't work if the script sources another script and you want to know the name of the latter. — reinierpost, Mar 28 '14 at 13:10

score 39 · Answer 10 · edited Jan 18 '20 at 18:36

I don't think this is as easy as others have made it out to be. pwd doesn't work, as the current directory is not necessarily the directory with the script. $0 doesn't always have the information either. Consider the following three ways to invoke a script:

./script

/usr/bin/script

script

In the first and third ways $0 doesn't have the full path information. In the second and third, pwd does not work. The only way to get the directory in the third way would be to run through the path and find the file with the correct match. Basically the code would have to redo what the OS does.

One way to do what you are asking would be to just hardcode the data in the /usr/share directory, and reference it by its full path. Data shoudn't be in the /usr/bin directory anyway, so this is probably the thing to do.

If you intend to disprove his comment, PROVE that a script CAN access where it's stored with a code example. — Richard Duerr, Nov 18 '15 at 18:54

score 35 · Answer 11 · edited May 30 '13 at 11:28

35

SCRIPT_DIR=$( cd ${0%/*} && pwd -P )

edited May 30 '13 at 11:28

choroba

200,498
20
180
248

answered Oct 07 '10 at 17:34

P M

817
1
10
17

This is way shorter than the chosen answer. And appears to work just as well. This deserves 1000 votes just so people do not overlook it. – Patrick Sep 19 '13 at 03:07
4

As many of the previous answers explain in detail, neither `$0` nor `pwd` are guaranteed to have the right information, depending on how the script is invoked. – IMSoP Sep 23 '13 at 16:51

score 34 · Answer 12 · edited Jan 20 '21 at 03:43

34

This gets the current working directory on Mac OS X v10.6.6 (Snow Leopard):

DIR=$(cd "$(dirname "$0")"; pwd)

edited Jan 20 '21 at 03:43

Peter Mortensen

28,342
21
95
123

answered Dec 30 '10 at 07:20

Pubguy

1
2
2

score 34 · Answer 13 · edited May 13 '18 at 04:36

34

$(dirname "$(readlink -f "$BASH_SOURCE")")

edited May 13 '18 at 04:36

user1338062

9,351
3
54
56

answered Jul 27 '11 at 07:40

test11

1
2
2

I prefer, `$BASH_SOURCE` over `$0` , because it's explicit even for readers not well-versed in bash. `$(dirname -- "$(readlink -f -- "$BASH_SOURCE")")` – blobmaster Jan 08 '20 at 13:04

score 27 · Answer 14 · edited Dec 22 '13 at 00:07

27

This is Linux specific, but you could use:

SELF=$(readlink /proc/$$/fd/255)

edited Dec 22 '13 at 00:07

Peter Mortensen

28,342
21
95
123

answered Sep 16 '08 at 19:55

Steve Baker

4,169
1
18
14

1

It's also bash specific, but perhaps bash's behavior has changed? `/proc/fd/$$/255` seems to point to the tty, not to a directory. For example, in my current login shell, file descriptors 0, 1, 2, and 255 all refer to `/dev/pts/4`. In any case, the bash manual doesn't mention fd 255, so it's probably unwise to depend on this behavior.\ – Keith Thompson Mar 29 '15 at 00:17
2

Interactive shell != script. Anyway `realpath ${BASH_SOURCE[0]};` would seem to be the best way to go. – Steve Baker Apr 06 '15 at 12:52

score 23 · Answer 15 · edited Apr 15 '13 at 07:28

23

Here is a POSIX compliant one-liner:

SCRIPT_PATH=`dirname "$0"`; SCRIPT_PATH=`eval "cd \"$SCRIPT_PATH\" && pwd"`

# test
echo $SCRIPT_PATH

edited Apr 15 '13 at 07:28

toolbear

6,478
4
31
31

answered Mar 06 '13 at 19:07

lamawithonel

21
1
5

4

I had success with this when running a script by itself or by using sudo, but not when calling source ./script.sh – Michael R Apr 17 '13 at 21:57
And it fails when `cd` is configured to print the new path name. – Aaron Digulla Nov 04 '13 at 13:45

score 19 · Answer 16 · edited Jan 18 '20 at 18:41

19

The shortest and most elegant way to do this is:

#!/bin/bash
DIRECTORY=$(cd `dirname $0` && pwd)
echo $DIRECTORY

This would work on all platforms and is super clean.

More details can be found in "Which directory is that bash script in?".

edited Jan 18 '20 at 18:41

the Tin Man

150,910
39
198
279

answered Jun 20 '19 at 22:08

Atul

1,669
17
22

great clean solution, but this will not work if the file is symlinked. – ruuter Sep 26 '19 at 08:43

score 18 · Answer 17 · edited Jan 20 '21 at 03:39

18

I tried all of these and none worked. One was very close, but it had a tiny bug that broke it badly; they forgot to wrap the path in quotation marks.

Also a lot of people assume you're running the script from a shell, so they forget when you open a new script it defaults to your home.

Try this directory on for size:

/var/No one/Thought/About Spaces Being/In a Directory/Name/And Here's your file.text

This gets it right regardless how or where you run it:

#!/bin/bash
echo "pwd: `pwd`"
echo "\$0: $0"
echo "basename: `basename "$0"`"
echo "dirname: `dirname "$0"`"

So to make it actually useful, here's how to change to the directory of the running script:

cd "`dirname "$0"`"

edited Jan 20 '21 at 03:39

Peter Mortensen

28,342
21
95
123

answered Sep 09 '10 at 07:19

4

Doesn't work if the script is being sourced from another script. – reinierpost Mar 28 '14 at 13:12
This does not work if the last part of $0 is a symbolic link pointing to an entry of another directory (`ln -s ../bin64/foo /usr/bin/foo`). – hagello Mar 17 '20 at 11:20

James Ko · Answer 18 · 2016-02-20T07:53:23.177

Here is the simple, correct way:

actual_path=$(readlink -f "${BASH_SOURCE[0]}")
script_dir=$(dirname "$actual_path")

Explanation:

${BASH_SOURCE[0]} - the full path to the script. The value of this will be correct even when the script is being sourced, e.g. source <(echo 'echo $0') prints bash, while replacing it with ${BASH_SOURCE[0]} will print the full path of the script. (Of course, this assumes you're OK taking a dependency on Bash.)
readlink -f - Recursively resolves any symlinks in the specified path. This is a GNU extension, and not available on (for example) BSD systems. If you're running a Mac, you can use Homebrew to install GNU coreutils and supplant this with greadlink -f.
And of course dirname gets the parent directory of the path.

`greadlink -f` unfortunately doesn't work effectively when `source`ing the script on Mac :( — Gabe Kopley, Apr 30 '19 at 23:50

score 16 · Answer 19 · edited Jan 20 '21 at 04:10

16

I would use something like this:

# Retrieve the full pathname of the called script
scriptPath=$(which $0)

# Check whether the path is a link or not
if [ -L $scriptPath ]; then

    # It is a link then retrieve the target path and get the directory name
    sourceDir=$(dirname $(readlink -f $scriptPath))

else

    # Otherwise just get the directory name of the script path
    sourceDir=$(dirname $scriptPath)

fi

edited Jan 20 '21 at 04:10

Peter Mortensen

28,342
21
95
123

answered Nov 21 '12 at 03:57

Nicolas

133
2
9

This is the real one! Works with simple `sh` too! Problem with simple `dirname "$0"` based solutions: If the script is in the `$PATH` and is invoked without path, they will give wrong result. – Notinlist Nov 18 '14 at 10:25
@Notinlist Not so. If the script is found via the `PATH`, `$0` will contain the absolute filename. If the script is invoked with a relative or absolute filename containing a `/`, `$0` will contain that. – Neil Mayhew Feb 03 '16 at 22:08

score 16 · Answer 20 · edited Jan 20 '21 at 04:39

16

For systems having GNU coreutils readlink (for example, Linux):

$(readlink -f "$(dirname "$0")")

There's no need to use BASH_SOURCE when $0 contains the script filename.

edited Jan 20 '21 at 04:39

Peter Mortensen

28,342
21
95
123

answered May 28 '14 at 07:16

user1338062

9,351
3
54
56

4

unless the script was sourced with . or 'source' in which case it will still be whatever script sourced it, or, if from the command line, '-bash' (tty login) or 'bash' (invoked via 'bash -l') or '/bin/bash' (invoked as an interactive non-login shell) – osirisgothra Feb 05 '15 at 00:07
I added second pair of quotes around `dirname` call. Needed if the directory path contains spaces. – user1338062 May 13 '18 at 04:35

score 16 · Answer 21 · edited Jan 20 '21 at 03:38

16

This is a slight revision to the solution e-satis and 3bcdnlklvc04a pointed out in their answer:

SCRIPT_DIR=''
pushd "$(dirname "$(readlink -f "$BASH_SOURCE")")" > /dev/null && {
    SCRIPT_DIR="$PWD"
    popd > /dev/null
}

This should still work in all the cases they listed.

This will prevent popd after a failed pushd. Thanks to konsolebox.

edited Jan 20 '21 at 03:38

Peter Mortensen

28,342
21
95
123

answered Apr 13 '10 at 22:12

Fuwjax

2,087
19
17

This works perfectly to get the "real" dirname, rather than just the name of a symlink. Thank you! – Jay Taylor Jun 23 '10 at 20:32
1

Better `SCRIPT_DIR=''; pushd "$(dirname "$(readlink -f "$BASH_SOURCE")")" > /dev/null && { SCRIPT_DIR=$PWD; popd > /dev/null; }` – konsolebox Jul 03 '14 at 04:15
@konsolebox, what are you trying to defend against? I'm generally a fan of inlining logical conditionals, but what was the specific error that you were seeing in the pushd? I'd match rather find a way to handle it directly instead of returning an empty SCRIPT_DIR. – Fuwjax Jan 19 '15 at 20:03
@Fuwjax Natural practice to avoid doing `popd` in cases (even when rare) where `pushd` fails. And in case `pushd` fails, what do you think should be the value of `SCRIPT_DIR`? The action may vary depending on what may seem logical or what one user could prefer but certainly, doing `popd` is wrong. – konsolebox Jan 20 '15 at 19:21
All those `pushd` `popd` dangers could be avoided simply by dropping them and using `cd` + `pwd` enclosed in a command substitution instead. `SCRIPT_DIR=$(...)` – Amit Naidu May 27 '20 at 03:16

score 16 · Answer 22 · answered Sep 13 '08 at 01:28

16

#!/bin/sh
PRG="$0"

# need this for relative symlinks
while [ -h "$PRG" ] ; do
   PRG=`readlink "$PRG"`
done

scriptdir=`dirname "$PRG"`

answered Sep 13 '08 at 01:28

1

I haven't tested it across different systems. But this solution is the one that works right away at least on Ubuntu, for me! – Natus Drew May 26 '20 at 00:30

score 13 · Answer 23 · edited Jan 18 '20 at 18:45

13

$_ is worth mentioning as an alternative to $0. If you're running a script from Bash, the accepted answer can be shortened to:

DIR="$( dirname "$_" )"

Note that this has to be the first statement in your script.

edited Jan 18 '20 at 18:45

the Tin Man

150,910
39
198
279

answered Sep 16 '11 at 19:05

hurrymaplelad

23,777
9
50
72

4

It breaks if you `source` or `.` the script. In those situations, `$_` would contain the last parameter of the last command you ran before the `.`. `$BASH_SOURCE` works every time. – clacke Jan 31 '14 at 14:55
This is [Perl](https://en.wikipedia.org/wiki/Perl)-like! A coincidence? – Peter Mortensen Jan 20 '21 at 03:44

score 11 · Answer 24 · edited Jan 20 '21 at 04:13

I've compared many of the answers given, and came up with some more compact solutions. These seem to handle all of the crazy edge cases that arise from your favorite combination of:

Absolute paths or relative paths
File and directory soft links
Invocation as script, bash script, bash -c script, source script, or . script
Spaces, tabs, newlines, Unicode, etc. in directories and/or filename
Filenames beginning with a hyphen

If you're running from Linux, it seems that using the proc handle is the best solution to locate the fully resolved source of the currently running script (in an interactive session, the link points to the respective /dev/pts/X):

resolved="$(readlink /proc/$$/fd/255 && echo X)" && resolved="${resolved%$'\nX'}"

This has a small bit of ugliness to it, but the fix is compact and easy to understand. We aren't using bash primitives only, but I'm okay with that because readlink simplifies the task considerably. The echo X adds an X to the end of the variable string so that any trailing whitespace in the filename doesn't get eaten, and the parameter substitution ${VAR%X} at the end of the line gets rid of the X. Because readlink adds a newline of its own (which would normally be eaten in the command substitution if not for our previous trickery), we have to get rid of that, too. This is most easily accomplished using the $'' quoting scheme, which lets us use escape sequences such as \n to represent newlines (this is also how you can easily make deviously named directories and files).

The above should cover your needs for locating the currently running script on Linux, but if you don't have the proc filesystem at your disposal, or if you're trying to locate the fully resolved path of some other file, then maybe you'll find the below code helpful. It's only a slight modification from the above one-liner. If you're playing around with strange directory/filenames, checking the output with both ls and readlink is informative, as ls will output "simplified" paths, substituting ? for things like newlines.

absolute_path=$(readlink -e -- "${BASH_SOURCE[0]}" && echo x) && absolute_path=${absolute_path%?x}
dir=$(dirname -- "$absolute_path" && echo x) && dir=${dir%?x}
file=$(basename -- "$absolute_path" && echo x) && file=${file%?x}

ls -l -- "$dir/$file"
printf '$absolute_path: "%s"\n' "$absolute_path"

@DanDascalescu Using the one-liner? Or the full code snippet at the bottom? And were you feeding it any tricky pathnames? — billyjmc, Aug 19 '15 at 06:34
The one line plus another line to `echo $resolved`, I saved it as `d`, `chmod +x d`, `./d`. — Dan Dascalescu, Aug 20 '15 at 05:55
@DanDascalescu The first line in your script needs to be `#!/bin/bash` — billyjmc, Aug 23 '15 at 05:07

score 11 · Answer 25 · edited Jan 20 '21 at 02:43

11

This works in Bash 3.2:

path="$( dirname "$( which "$0" )" )"

If you have a ~/bin directory in your $PATH, you have A inside this directory. It sources the script ~/bin/lib/B. You know where the included script is relative to the original one, in the lib subdirectory, but not where it is relative to the user's current directory.

This is solved by the following (inside A):

source "$( dirname "$( which "$0" )" )/lib/B"

It doesn't matter where the user is or how he/she calls the script. This will always work.

edited Jan 20 '21 at 02:43

Peter Mortensen

28,342
21
95
123

answered Oct 14 '08 at 16:39

Matt Tardiff

7,601
1
14
9

4

The point on `which` is very debatable. `type`, `hash`, and other builtins do the same thing better in bash. `which` is kindof more portable, though it really isn't the same `which` used in other shells like tcsh, that has it as a builtin. – Reinstate Monica Please Jan 13 '14 at 22:30
1

"Always"? Not at all. `which` being an external tool, you have no reason to believe it behaves identically to the parent shell. – Charles Duffy Jun 09 '14 at 03:42

score 11 · Answer 26 · edited May 15 '20 at 00:32

11

These are short ways to get script information:

Folders and files:

    Script: "/tmp/src dir/test.sh"
    Calling folder: "/tmp/src dir/other"

Using these commands:

    echo Script-Dir : `dirname "$(realpath $0)"`
    echo Script-Dir : $( cd ${0%/*} && pwd -P )
    echo Script-Dir : $(dirname "$(readlink -f "$0")")
    echo
    echo Script-Name : `basename "$(realpath $0)"`
    echo Script-Name : `basename $0`
    echo
    echo Script-Dir-Relative : `dirname "$BASH_SOURCE"`
    echo Script-Dir-Relative : `dirname $0`
    echo
    echo Calling-Dir : `pwd`

And I got this output:

     Script-Dir : /tmp/src dir
     Script-Dir : /tmp/src dir
     Script-Dir : /tmp/src dir

     Script-Name : test.sh
     Script-Name : test.sh

     Script-Dir-Relative : ..
     Script-Dir-Relative : ..

     Calling-Dir : /tmp/src dir/other

Also see: https://pastebin.com/J8KjxrPF

edited May 15 '20 at 00:32

the Tin Man

150,910
39
198
279

answered Mar 09 '18 at 12:56

User8461

326
2
10

"[Are answers which merely summarize other answers acceptable?](https://meta.stackoverflow.com/q/300586/128421)" – the Tin Man Jan 18 '20 at 18:48
I think my answer is ok because it is hard to find a simple working edition. Here you can take the code you like e.g. cd + pwd, dirname + realpath or dirname + readlink. I am not sure that all parts exist before and most answers are complex and overloaded. Here you can pike out the code you like to use. At least please do not remove it as I need in the future :D – User8461 May 12 '20 at 19:30

score 10 · Answer 27 · edited Feb 06 '12 at 11:20

10

Try using:

real=$(realpath $(dirname $0))

edited Feb 06 '12 at 11:20

eeerahul

1,589
4
27
35

answered Feb 06 '12 at 10:43

DarkPark

1
1
2

1

All I want to know is, why this way is not good? It seemed no bad and correct for me. Could anyone explain why it's downvoted? – Shou Ya Aug 28 '12 at 15:16
7

realpath is not a standard utility. – Steve Bennett May 13 '13 at 12:06
3

On Linux, realpath is a standard utility (part of the GNU coreutils package), but it is not a bash built-in (i.e., a function provided by bash itself). If you're running Linux, this method will probably work, although I'd substitute the `$0` for `${BASH_SOURCE[0]}` so that this method will work anywhere, including in a function. – Doug Richardson Jul 18 '14 at 15:53
4

The order of the operations in this answer is wrong. You need to _first_ resolve the symlink, _then_ do `dirname` because the last part of `$0` may be a symlink that points to a file that is not in the same directory as the symlink itself. The solution described in this answer just gets the path of the directory where the symlink it stored, not the directory of the target. Furthermore, this solution is missing quoting. It will not work if the path contains special characters. – hagello Apr 13 '15 at 21:43
This solution "just gets the path of the directory where the symlink it stored", and that's what I actually want. PS: quoting still should be added. – Kostiantyn Ponomarenko Mar 11 '19 at 10:19
3

`dir="$(realpath "$(dirname "${BASH_SOURCE[0]}")")"` – Kostiantyn Ponomarenko Mar 11 '19 at 12:52
`SCRIPT=\`realpath $0\`` – Pedro Lobito Jun 05 '20 at 13:19

score 9 · Answer 28 · edited Jan 20 '21 at 04:34

9

Try the following cross-compatible solution:

CWD="$(cd -P -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd -P)"

As the commands such as realpath or readlink could be not available (depending on the operating system).

Note: In Bash, it's recommended to use ${BASH_SOURCE[0]} instead of $0, otherwise path can break when sourcing the file (source/.).

Alternatively you can try the following function in Bash:

realpath () {
  [[ $1 = /* ]] && echo "$1" || echo "$PWD/${1#./}"
}

This function takes one argument. If argument has already absolute path, print it as it is, otherwise print $PWD variable + filename argument (without ./ prefix).

Peter Mortensen

28,342
21
95
123

answered Nov 28 '13 at 12:05

kenorb

118,428
63
588
624

Please explain more about the realpath function. – Chris Mar 27 '15 at 16:54
1

@Chris `realpath` function takes 1 argument. If argument has already absolute path, print it as it is, otherwise print `$PWD` + filename (without `./` prefix). – kenorb Mar 27 '15 at 17:35
Your cross-compatible solution doesn’t work when the script is symlinked. – Jakub Jirutka Sep 08 '15 at 20:59

score 9 · Answer 29 · edited Jan 18 '20 at 18:47

I believe I've got this one. I'm late to the party, but I think some will appreciate it being here if they come across this thread. The comments should explain:

#!/bin/sh # dash bash ksh # !zsh (issues). G. Nixon, 12/2013. Public domain.

## 'linkread' or 'fullpath' or (you choose) is a little tool to recursively
## dereference symbolic links (ala 'readlink') until the originating file
## is found. This is effectively the same function provided in stdlib.h as
## 'realpath' and on the command line in GNU 'readlink -f'.

## Neither of these tools, however, are particularly accessible on the many
## systems that do not have the GNU implementation of readlink, nor ship
## with a system compiler (not to mention the requisite knowledge of C).

## This script is written with portability and (to the extent possible, speed)
## in mind, hence the use of printf for echo and case statements where they
## can be substituded for test, though I've had to scale back a bit on that.

## It is (to the best of my knowledge) written in standard POSIX shell, and
## has been tested with bash-as-bin-sh, dash, and ksh93. zsh seems to have
## issues with it, though I'm not sure why; so probably best to avoid for now.

## Particularly useful (in fact, the reason I wrote this) is the fact that
## it can be used within a shell script to find the path of the script itself.
## (I am sure the shell knows this already; but most likely for the sake of
## security it is not made readily available. The implementation of "$0"
## specificies that the $0 must be the location of **last** symbolic link in
## a chain, or wherever it resides in the path.) This can be used for some
## ...interesting things, like self-duplicating and self-modifiying scripts.

## Currently supported are three errors: whether the file specified exists
## (ala ENOENT), whether its target exists/is accessible; and the special
## case of when a sybolic link references itself "foo -> foo": a common error
## for beginners, since 'ln' does not produce an error if the order of link
## and target are reversed on the command line. (See POSIX signal ELOOP.)

## It would probably be rather simple to write to use this as a basis for
## a pure shell implementation of the 'symlinks' util included with Linux.

## As an aside, the amount of code below **completely** belies the amount
## effort it took to get this right -- but I guess that's coding for you.

##===-------------------------------------------------------------------===##

for argv; do :; done # Last parameter on command line, for options parsing.

## Error messages. Use functions so that we can sub in when the error occurs.

recurses(){ printf "Self-referential:\n\t$argv ->\n\t$argv\n" ;}
dangling(){ printf "Broken symlink:\n\t$argv ->\n\t"$(readlink "$argv")"\n" ;}
errnoent(){ printf "No such file: "$@"\n" ;} # Borrow a horrible signal name.

# Probably best not to install as 'pathfull', if you can avoid it.

pathfull(){ cd "$(dirname "$@")"; link="$(readlink "$(basename "$@")")"

## 'test and 'ls' report different status for bad symlinks, so we use this.

 if [ ! -e "$@" ]; then if $(ls -d "$@" 2>/dev/null) 2>/dev/null;  then
    errnoent 1>&2; exit 1; elif [ ! -e "$@" -a "$link" = "$@" ];   then
    recurses 1>&2; exit 1; elif [ ! -e "$@" ] && [ ! -z "$link" ]; then
    dangling 1>&2; exit 1; fi
 fi

## Not a link, but there might be one in the path, so 'cd' and 'pwd'.

 if [ -z "$link" ]; then if [ "$(dirname "$@" | cut -c1)" = '/' ]; then
   printf "$@\n"; exit 0; else printf "$(pwd)/$(basename "$@")\n"; fi; exit 0
 fi

## Walk the symlinks back to the origin. Calls itself recursivly as needed.

 while [ "$link" ]; do
   cd "$(dirname "$link")"; newlink="$(readlink "$(basename "$link")")"
   case "$newlink" in
    "$link") dangling 1>&2 && exit 1                                       ;;
         '') printf "$(pwd)/$(basename "$link")\n"; exit 0                 ;;
          *) link="$newlink" && pathfull "$link"                           ;;
   esac
 done
 printf "$(pwd)/$(basename "$newlink")\n"
}

## Demo. Install somewhere deep in the filesystem, then symlink somewhere 
## else, symlink again (maybe with a different name) elsewhere, and link
## back into the directory you started in (or something.) The absolute path
## of the script will always be reported in the usage, along with "$0".

if [ -z "$argv" ]; then scriptname="$(pathfull "$0")"

# Yay ANSI l33t codes! Fancy.
 printf "\n\033[3mfrom/as: \033[4m$0\033[0m\n\n\033[1mUSAGE:\033[0m   "
 printf "\033[4m$scriptname\033[24m [ link | file | dir ]\n\n         "
 printf "Recursive readlink for the authoritative file, symlink after "
 printf "symlink.\n\n\n         \033[4m$scriptname\033[24m\n\n        "
 printf " From within an invocation of a script, locate the script's "
 printf "own file\n         (no matter where it has been linked or "
 printf "from where it is being called).\n\n"

else pathfull "$@"
fi

Gabriel Staples · Answer 30 · 2020-12-28T05:32:14.613

How to obtain the full file path, full directory, and base filename of any script being run itself

For many cases, all you need to acquire is the full path to the script you just called. This can be easily accomplished using realpath. Note that realpath is part of GNU coreutils. If you don't have it already installed (it comes default on Ubuntu), you can install it with sudo apt update && sudo apt install coreutils.

get_script_path.sh:

#!/bin/bash

FULL_PATH_TO_SCRIPT="$(realpath "$0")"

# You can then also get the full path to the directory, and the base
# filename, like this:
SCRIPT_DIRECTORY="$(dirname "$FULL_PATH_TO_SCRIPT")"
SCRIPT_FILENAME="$(basename "$FULL_PATH_TO_SCRIPT")"

# Now print it all out
echo "FULL_PATH_TO_SCRIPT = \"$FULL_PATH_TO_SCRIPT\""
echo "SCRIPT_DIRECTORY    = \"$SCRIPT_DIRECTORY\""
echo "SCRIPT_FILENAME     = \"$SCRIPT_FILENAME\""

Example output:

~/GS/dev/eRCaGuy_hello_world/bash$ ./get_script_path.sh 
FULL_PATH_TO_SCRIPT = "/home/gabriel/GS/dev/eRCaGuy_hello_world/bash/get_script_path.sh"
SCRIPT_DIRECTORY    = "/home/gabriel/GS/dev/eRCaGuy_hello_world/bash"
SCRIPT_FILENAME     = "get_script_path.sh"

Note that realpath also successfully walks down symbolic links to determine and point to their targets rather than pointing to the symbolic link.

The code above is now part of my eRCaGuy_hello_world repo in this file here: bash/get_script_path.sh.

References:

How to retrieve absolute path given relative

score 8 · Answer 31 · edited Jan 20 '21 at 04:22

8

Hmm, if in the path, basename and dirname are just not going to cut it and walking the path is hard (what if the parent didn't export PATH?!).

However, the shell has to have an open handle to its script, and in Bash the handle is #255.

SELF=`readlink /proc/$$/fd/255`

works for me.

edited Jan 20 '21 at 04:22

Peter Mortensen

28,342
21
95
123

answered Jan 24 '09 at 17:01

Joshua

34,237
6
59
120

I get `/dev/pts/30` with bash on Ubuntu 14.10 Desktop, instead of the actual directory I run the script from. – Dan Dascalescu Aug 15 '15 at 11:30

score 7 · Answer 32 · edited Jan 20 '21 at 04:27

7

The best compact solution in my view would be:

"$( cd "$( echo "${BASH_SOURCE[0]%/*}" )"; pwd )"

There is no reliance on anything other than Bash. The use of dirname, readlink and basename will eventually lead to compatibility issues, so they are best avoided if at all possible.

edited Jan 20 '21 at 04:27

Peter Mortensen

28,342
21
95
123

answered Oct 08 '13 at 14:24

AsymLabs

763
7
13

2

You probably should add slash to that: `"$( cd "$( echo "${BASH_SOURCE[0]%/*}/" )"; pwd )"`. You'd have problems with root directory if you don't. Also why do you even have to use echo? – konsolebox Jul 02 '14 at 17:21
`dirname` and `basename` are POSIX standardized, so why avoid using them? Links: [`dirname`](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/dirname.html), [`basename`](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/basename.html) – myrdd Oct 29 '18 at 09:18
Preventing two extra process forks and sticking to shell built-ins may be one reason why. – Amit Naidu May 27 '20 at 03:37
You can call me purist - I have a somewhat similar version that doesn't involve subshells or forking anything: `BIN=${0/#[!\/]/"$PWD/${0:0:1}"}; DIR=${BIN%/*}`. First replace anything not starting by `/` (i.e. a relative path) with `$PWD/` (we also have to append the first character we matched in the substitution). Then get the directory. You can finally `cd $DIR` if you wish, or use it in relative paths. – Thomas Guyot-Sionnest Dec 23 '20 at 20:38

score 7 · Answer 33 · edited Jan 20 '21 at 05:24

You can do that just combining the script name ($0) with realpath and/or dirname. It works for Bash and Shell.

#!/usr/bin/env bash

RELATIVE_PATH="${0}"
RELATIVE_DIR_PATH="$(dirname "${0}")"
FULL_DIR_PATH="$(realpath "${0}" | xargs dirname)"
FULL_PATH="$(realpath "${0}")"

echo "RELATIVE_PATH->${RELATIVE_PATH}<-"
echo "RELATIVE_DIR_PATH->${RELATIVE_DIR_PATH}<-"
echo "FULL_DIR_PATH->${FULL_DIR_PATH}<-"
echo "FULL_PATH->${FULL_PATH}<-"

The output will be something like this:

# RELATIVE_PATH->./bin/startup.sh<-
# RELATIVE_DIR_PATH->./bin<-
# FULL_DIR_PATH->/opt/my_app/bin<-
# FULL_PATH->/opt/my_app/bin/startup.sh<-

$0 is the name of the script itself

4.4. Special Variable Types

An example: LozanoMatheus/get_script_paths.sh

score 5 · Answer 34 · edited Jan 20 '21 at 03:40

5

None of these other answers worked for a Bash script launched by Finder in OS X. I ended up using:

SCRIPT_LOC="`ps -p $$ | sed /PID/d | sed s:.*/Network/:/Network/: |
sed s:.*/Volumes/:/Volumes/:`"

It is not pretty, but it gets the job done.

edited Jan 20 '21 at 03:40

Peter Mortensen

28,342
21
95
123

answered Sep 22 '10 at 23:22

tigfox

1
1
1

score 5 · Answer 35 · edited Jan 20 '21 at 03:43

5

Use a combination of readlink to canonicalize the name (with a bonus of following it back to its source if it is a symlink) and dirname to extract the directory name:

script="`readlink -f "${BASH_SOURCE[0]}"`"
dir="`dirname "$script"`"

edited Jan 20 '21 at 03:43

Peter Mortensen

28,342
21
95
123

answered Oct 13 '10 at 07:42

alanwj

483
5
5

score 5 · Answer 36 · answered Apr 10 '17 at 21:49

5

This worked for me when the other answers here did not:

thisScriptPath=`realpath $0`
thisDirPath=`dirname $thisScriptPath`
echo $thisDirPath

answered Apr 10 '17 at 21:49

BuvinJ

7,867
3
61
78

2

Note that there's no ned to resort to echo. Simply invoking `dirname` will print the directory name. And, in this case, invoking echo without properly quoting the variable will potentially produce different output, since it will squash whitespace. Overall, cleaner to simply write `dirname "$(realpath "$0")"` – William Pursell Aug 08 '17 at 17:46
You are correct that this can be compressed into a single line. The breakdown into separate variables is for illustrative / self documenting purposes. The echo line is just there as p.o.c. – BuvinJ Aug 08 '17 at 19:05
I'm pretty sure it does (if I remember correctly). Note that different nix distros and contexts like you bring up (and say Linux, vs Mac, vs Cygwin...bash vs dash...) handle all of this somewhat differently. Hence the reason there are SOO many answers on this thread! You'll need to test your use case to confirm. I wish there were a solid, cross platform/context answer to this simple question! – BuvinJ Apr 19 '19 at 13:40

score 4 · Answer 37 · answered Apr 15 '21 at 08:48

None of the current solutions work if there are any newlines at the end of the directory name - They will be stripped by the command substitution. To work around this you can append a non-newline character inside the command substitution and then strip just that character off:

dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd && echo x)"
dir="${dir%x}"

This protects against two very common situations: Accidents and sabotage. A script shouldn't fail in unpredictable ways just because someone, somewhere, did a mkdir $'\n'.

score 4 · Answer 38 · edited Jan 13 '15 at 12:54

4

This is the only way I've found to tell reliably:

SCRIPT_DIR=$(dirname $(cd "$(dirname "$BASH_SOURCE")"; pwd))

edited Jan 13 '15 at 12:54

tripleee

139,311
24
207
268

answered Apr 14 '09 at 16:00

BillTorpey

841
11
8

5

this is giving me the directory with the last entry stripped off, i.e., the path to the container of the container of the script. – tim Mar 28 '15 at 15:17

score 3 · Answer 39 · edited Jan 20 '21 at 04:49

3

$0 is not a reliable way to get the current script path. For example, this is my .xprofile:

#!/bin/bash
echo "$0 $1 $2"
echo "${BASH_SOURCE[0]}"
# $dir/my_script.sh &

cd /tmp && ~/.xprofile && source ~/.xprofile

/home/puchuu/.xprofile
/home/puchuu/.xprofile
-bash
/home/puchuu/.xprofile

So please use BASH_SOURCE instead.

edited Jan 20 '21 at 04:49

Peter Mortensen

28,342
21
95
123

answered Feb 04 '17 at 08:56

puchu

2,801
6
30
55

score 3 · Answer 40 · edited Jan 20 '21 at 05:18

3

I usually use:

dirname $(which $BASH_SOURCE)

edited Jan 20 '21 at 05:18

Peter Mortensen

28,342
21
95
123

answered May 17 '19 at 12:09

cdonat

2,670
13
24

score 3 · Answer 41 · edited Jan 20 '21 at 05:31

The top response does not work in all cases...

As I had problems with the BASH_SOURCE with the included 'cd' approach on some very fresh and also on less fresh installed Ubuntu 16.04 (Xenial Xerus) systems when invoking the shell script by means of "sh my_script.sh", I tried out something different that as of now seems to run quite smoothly for my purposes. The approach is a bit more compact in the script and is further much lesser cryptic feeling.

This alternate approach uses the external applications 'realpath' and 'dirname' from the coreutils package. (Okay, not anyone likes the overhead of invoking secondary processes - but when seeing the multi-line scripting for resolving the true object it won't be that bad either having it solve in a single binary usage.)

So let’s see one example of those alternate solution for the described task of querying the true absolute path to a certain file:

SCRIPT=`realpath -s $0`
SCRIPTPATH=`dirname $SCRIPT`

Or when having the chance of using paths with spaces (or maybe other special characters):

SCRIPT=`realpath -s "$0"`
SCRIPTPATH=`dirname "$SCRIPT"`

Indeed, if you don’t need the value of the SCRIPT variable then you might be able to merge this two-liner into even a single line. But why really shall you spend the effort for this?

This question is `bash` specific. If you invoke a script with `sh`, the shell might be something else, such as `zsh` or `dash`. — neu242, Dec 04 '19 at 13:08

score 2 · Answer 42 · edited Jan 20 '21 at 04:51

If your Bash script is a symlink, then this is the way to do it:

#!/usr/bin/env bash

dirn="$(dirname "$0")"
rl="$(readlink "$0")";
exec_dir="$(dirname $(dirname "$rl"))";
my_path="$dirn/$exec_dir";
X="$(cd $(dirname ${my_path}) && pwd)/$(basename ${my_path})"

X is the directory that contains your Bash script (the original file, not the symlink). I swear to God this works, and it is the only way I know of doing this properly.

score 2 · Answer 43 · edited Jan 20 '21 at 05:21

Here's a command that works under either Bash or zsh, and whether executed stand-alone or sourced:

[ -n "$ZSH_VERSION" ] && this_dir=$(dirname "${(%):-%x}") \
    || this_dir=$(dirname "${BASH_SOURCE[0]:-$0}")

How it works

The zsh current file expansion: `${(%):-%x}`

${(%):-%x} in zsh expands to the path of the currently-executing file.

The fallback substitution operator `:-`

You know already that ${...} substitutes variables inside of strings. You might not know that certain operations are possible (in both Bash and zsh) on the variables during substitution, like the fallback expansion operator :-:

% x=ok
% echo "${x}"
ok

% echo "${x:-fallback}"
ok

% x=
% echo "${x:-fallback}"
fallback

% y=yvalue
% echo "${x:-$y}"
yvalue

The `%x` prompt escape code

Next, we'll introduce prompt escape codes, a zsh-only feature. In zsh, %x will expand to the path of the file, but normally this is only when doing expansion for prompt strings. To enable those codes in our substitution, we can add a (%) flag before the variable name:

% cat apath/test.sh
fpath=%x
echo "${(%)fpath}"

% source apath/test.sh
apath/test.sh

% cd apath
% source test.sh
test.sh

An unlikely match: the percent escape and the fallback

What we have so far works, but it would be tidier to avoid creating the extra fpath variable. Instead of putting %x in fpath, we can use :- and put %x in the fallback string:

% cat test.sh
echo "${(%):-%x}"

% source test.sh
test.sh

Note that we normally would put a variable name between (%) and :-, but we left it blank. The variable with a blank name can't be declared or set, so the fallback is always triggered.

Finishing up: what about `print -P %x`?

Now we almost have the directory of our script. We could have used print -P %x to get the same file path with fewer hacks, but in our case, where we need to pass it as an argument to dirname, that would have required the overhead of a starting a new subshell:

% cat apath/test.sh
dirname "$(print -P %x)"  # $(...) runs a command in a new process
dirname "${(%):-%x}"

% source apath/test.sh
apath
apath

It turns out that the hacky way is both more performant and succinct.

score 2 · Answer 44 · answered Oct 08 '19 at 12:37

The following will return the current directory of the script

works if it's sourced, or not sourced
works if run in the current directory, or some other directory.
works if relative directories are used.
works with bash, not sure of other shells.

/tmp/a/b/c $ . ./test.sh
/tmp/a/b/c

/tmp/a/b/c $ . /tmp/a/b/c/test.sh
/tmp/a/b/c

/tmp/a/b/c $ ./test.sh
/tmp/a/b/c

/tmp/a/b/c $ /tmp/a/b/c/test.sh
/tmp/a/b/c

/tmp/a/b/c $ cd

~ $ . /tmp/a/b/c/test.sh
/tmp/a/b/c

~ $ . ../../tmp/a/b/c/test.sh
/tmp/a/b/c

~ $ /tmp/a/b/c/test.sh
/tmp/a/b/c

~ $ ../../tmp/a/b/c/test.sh
/tmp/a/b/c

test.sh

#!/usr/bin/env bash

# snagged from: https://stackoverflow.com/a/51264222/26510
function toAbsPath {
    local target
    target="$1"

    if [ "$target" == "." ]; then
        echo "$(pwd)"
    elif [ "$target" == ".." ]; then
        echo "$(dirname "$(pwd)")"
    else
        echo "$(cd "$(dirname "$1")"; pwd)/$(basename "$1")"
    fi
}

function getScriptDir(){
  local SOURCED
  local RESULT
  (return 0 2>/dev/null) && SOURCED=1 || SOURCED=0

  if [ "$SOURCED" == "1" ]
  then
    RESULT=$(dirname "$1")
  else
    RESULT="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
  fi
  toAbsPath "$RESULT"
}

SCRIPT_DIR=$(getScriptDir "$0")
echo "$SCRIPT_DIR"

score 2 · Answer 45 · edited Jan 20 '21 at 05:32

2

Python was mentioned a few times. Here is the JavaScript (i.e., Node.js) alternative:

baseDirRelative=$(dirname "$0")
baseDir=$(node -e "console.log(require('path').resolve('$baseDirRelative'))") # Get absolute path using Node.js

echo $baseDir

edited Jan 20 '21 at 05:32

Peter Mortensen

28,342
21
95
123

answered Dec 26 '19 at 08:34

Domi

15,464
9
69
94

ghchoi · Answer 46 · 2021-01-20T06:30:21.837

I tried the followings with 3 different executions.

`echo $(realpath $_)`

. application         # /correct/path/to/dir or /path/to/temporary_dir
bash application      # /path/to/bash
/PATH/TO/application  # /correct/path/to/dir

`echo $(realpath $(dirname $0))`

. application         # failed with `realpath: missing operand`
bash application      # /correct/path/to/dir
/PATH/TO/application  # /correct/path/to/dir

`echo $(realpath $BASH_SOURCE)`

$BASH_SOURCE is basically the same with ${BASH_SOURCE[0]}.

. application         # /correct/path/to/dir
bash application      # /correct/path/to/dir
/PATH/TO/application  # /correct/path/to/dir

Only $(realpath $BASH_SOURCE) seems to be reliable.

score 1 · Answer 47 · edited Jan 20 '21 at 04:40

This solution applies only to Bash. Note that the commonly supplied answer ${BASH_SOURCE[0]} won't work if you try to find the path from within a function.

I've found this line to always work, regardless of whether the file is being sourced or run as a script.

dirname ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

If you want to follow symlinks use readlink on the path you get above, recursively or non-recursively.

Here's a script to try it out and compare it to other proposed solutions. Invoke it as source test1/test2/test_script.sh or bash test1/test2/test_script.sh.

#
# Location: test1/test2/test_script.sh
#
echo $0
echo $_
echo ${BASH_SOURCE}
echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}

cur_file="${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}"
cur_dir="$(dirname "${cur_file}")"
source "${cur_dir}/func_def.sh"

function test_within_func_inside {
    echo ${BASH_SOURCE}
    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}
}

echo "Testing within function inside"
test_within_func_inside

echo "Testing within function outside"
test_within_func_outside

#
# Location: test1/test2/func_def.sh
#
function test_within_func_outside {
    echo ${BASH_SOURCE}
    echo ${BASH_SOURCE[${#BASH_SOURCE[@]} - 1]}
}

The reason the one-liner works is explained by the use of the BASH_SOURCE environment variable and its associated FUNCNAME.

BASH_SOURCE

An array variable whose members are the source filenames where the corresponding shell function names in the FUNCNAME array variable are defined. The shell function ${FUNCNAME[$i]} is defined in the file ${BASH_SOURCE[$i]} and called from ${BASH_SOURCE[$i+1]}.

FUNCNAME

An array variable containing the names of all shell functions currently in the execution call stack. The element with index 0 is the name of any currently-executing shell function. The bottom-most element (the one with the highest index) is "main". This variable exists only when a shell function is executing. Assignments to FUNCNAME doesn't have any effect and return an error status. If FUNCNAME is unset, it loses its special properties, even if it is subsequently reset.

This variable can be used with BASH_LINENO and BASH_SOURCE. Each element of FUNCNAME has corresponding elements in BASH_LINENO and BASH_SOURCE to describe the call stack. For instance, ${FUNCNAME[$i]} was called from the file ${BASH_SOURCE[$i+1]} at line number ${BASH_LINENO[$i]}. The caller builtin displays the current call stack using this information.

[Source: Bash manual]

score 1 · Answer 48 · answered Apr 17 '18 at 00:03

1

This is how I work it on my scripts: pathvar="$( cd "$( dirname $0 )" && pwd )" This will tell you which directory the Launcher (current script) is being executed from.

answered Apr 17 '18 at 00:03

Rawstring

57
2
10

score 1 · Answer 49 · edited Jan 20 '21 at 05:34

One advantage of this method is that it doesn't involve anything outside Bash itself and does not fork any subshell neither.

First, use pattern substitution to replace anything not starting with / (i.e., a relative path) with $PWD/. Since we use a substitution to match the first character of $0, we also have to append it back (${0:0:1} in the substitution).

Now we have a full path to the script; we can get the directory by removing the last / and anything the follows (i.e., the script name). That directory can then be used in cd or as a prefix to other paths relative to your script.

#!/bin/bash

BIN=${0/#[!\/]/"$PWD/${0:0:1}"}
DIR=${BIN%/*}

cd "$DIR"

If your script may be sourced rather than executed, you can of course replace $0 with ${BASH_SOURCE[0]}, such as:

BIN=${BASH_SOURCE[0]/#[!\/]/"$PWD/${BASH_SOURCE[0]:0:1}"}

This will work for executable scripts too. It's longer, but more polyvalent.

score 0 · Answer 50 · answered Feb 14 '13 at 18:14

0

Here is a pure Bash solution

$ cat a.sh
BASENAME=${BASH_SOURCE/*\/}
DIRNAME=${BASH_SOURCE%$BASENAME}.
echo $DIRNAME

$ a.sh
/usr/local/bin/.

$ ./a.sh
./.

$ . a.sh
/usr/local/bin/.

$ /usr/local/bin/a.sh
/usr/local/bin/.

answered Feb 14 '13 at 18:14

Steven Penny

82,115
47
308
348

score 0 · Answer 51 · edited Jan 20 '21 at 04:32

Here's an excerpt from my answer to shell script: check directory name and convert to lowercase in which I demonstrate not only how to solve this problem with very basic POSIX-specified utilities, I also address how to very simply store the function's results in a returned variable...

...Well, as you can see, with some help, I hit upon a pretty simple and very powerful solution:

I can pass the function a sort of messenger variable and dereference any explicit use of the resulting function's argument's $1 name with eval as necessary, and, upon the function routine's completion, I use eval and a backslashed quoting trick to assign my messenger variable the value I desire without ever having to know its name.

In full disclosure, ... (I found the messenger variable portion of this) and at Rich's sh tricks and I have also excerpted the relevant portion of his page below my own answer's excerpt.

... EXCERPT: ...

Though not strictly POSIX yet, realpath is a GNU core application since 2012. Full disclosure: never heard of it before I noticed it in the info coreutils TOC and immediately thought of [the linked] question, but using the following function as demonstrated should reliably, (soon POSIXLY?), and, I hope, efficiently provide its caller with an absolutely sourced $0:

% _abs_0() {
> o1="${1%%/*}"; ${o1:="${1}"}; ${o1:=`realpath -s "${1}"`}; eval "$1=\${o1}";
> }
% _abs_0 ${abs0:="${0}"} ; printf %s\\n "${abs0}"
/no/more/dots/in/your/path2.sh

It may be worth highlighting that this solution uses POSIX parameter expansion to first check if the path actually needs expanding and resolving at all before attempting to do so. This should return an absolutely sourced $0via a messenger variable (with the notable exception that it will preserve symlinks) as efficiently as I could imagine it could be done whether or not the path is already absolute. ...

(minor edit: before finding realpath in the docs, I had at least pared down my version of (the version below) not to depend on the time field (as it does in the first ps command), but, fair warning, after testing some I'm less convinced ps is fully reliable in its command path expansion capacity)

On the other hand, you could do this:

ps ww -fp $$ | grep -Eo '/[^:]*'"${0#*/}"

eval "abs0=${`ps ww -fp $$ | grep -Eo ' /'`#?}"

... And from Rich's sh tricks: ...

Returning strings from a shell function

As can be seen from the above pitfall of command substitution, standard output is not a good avenue for shell functions to return strings to their caller, unless the output is in a format where trailing newlines are insignificant. Certainly such practice is not acceptable for functions meant to deal with arbitrary strings. So, what can be done?

Try this:

func () {
body here
eval "$1=\${foo}"
}

Of course, ${foo} could be replaced by any sort of substitution. The key trick here is the eval line and the use of escaping. The “$1” is expanded when the argument to eval is constructed by the main command parser. But the “${foo}” is not expanded at this stage, because the “$” has been quoted. Instead, it’s expanded when eval evaluates its argument. If it’s not clear why this is important, consider how the following would be bad:

foo='hello ; rm -rf /'
dest=bar
eval "$dest=$foo"

But of course the following version is perfectly safe:

foo='hello ; rm -rf /'
dest=bar
eval "$dest=\$foo"

Note that in the original example, “$1” was used to allow the caller to pass the destination variable name as an argument the function. If your function needs to use the shift command, for instance to handle the remaining arguments as “$@”, then it may be useful to save the value of “$1” in a temporary variable at the beginning of the function.

score 0 · Answer 52 · 2009-02-02T08:50:25.593

0

I usually do:

LIBDIR=$(dirname "$(readlink -f "$(type -P $0 || echo $0)")")
source $LIBDIR/lib.sh

edited Feb 02 '09 at 08:50

answered Jan 24 '09 at 16:32

Top-Master · Answer 53 · 2021-01-21T10:41:41.190

0

The below stores the script's directory path in the dir variable.

(It also tries to support being executed under Cygwin in Windows.)

And at last it runs the my-sample-app executable with all arguments passed to this script using "$@":

#!/usr/bin/env sh

dir=$(cd "${0%[/\\]*}" > /dev/null && pwd)

if [ -d /proc/cygdrive ]; then
    case "$(uname -s)" in
        CYGWIN*|MINGW32*|MSYS*|MINGW*)
            # We are under Windows, so translate path to Windows format.
            dir=$(cygpath -m "$dir");
            ;;
    esac
fi

# Runs the executable which is beside this script
"${dir}/my-sample-app" "$@"

edited Jan 21 '21 at 10:41

answered Mar 26 '19 at 07:50

Top-Master

2,934
1
17
34

What is "Windows PHP"? "[PHP For Windows](https://windows.php.net/)"? Or [WAMP](https://en.wikipedia.org/wiki/LAMP_(software_bundle)#Variants)? Or something else? – Peter Mortensen Jan 20 '21 at 05:00
With help of [another post](https://stackoverflow.com/a/27776822/8740349) removed the need for PHP (and now checks if is running under Windows). – Top-Master Jan 21 '21 at 10:13

score 0 · Answer 54 · edited Jan 20 '21 at 05:33

I think the simplest answer is a parameter expansion of the original variable:

#!/usr/bin/env bash

DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
echo "opt1; original answer: $DIR"
echo ''

echo "opt2; simple answer  : ${BASH_SOURCE[0]%/*}"

It should produce output like:

$ /var/tmp/test.sh
opt1; original answer: /var/tmp

opt2; simple answer  : /var/tmp

The variable/parameter expansion ${BASH_SOURCE[0]%/*}" seems much easier to maintain.

Binary Phile · Answer 55 · 2021-04-18T13:40:03.167

Most answers either don't handle files which are symlinked via a relative path, aren't one-liners or don't handle BSD (Mac). A solution which does all three is:

HERE=$(cd "$(dirname "$BASH_SOURCE")"; cd -P "$(dirname "$(readlink "$BASH_SOURCE" || echo .)")"; pwd)

First, cd to bash's conception of the script's directory. Then readlink the file to see if it is a symlink (relative or otherwise), and if so, cd to that directory. If not, cd to the current directory (necessary to keep things a one-liner). Then echo the current directory via pwd.

You could add -- to the arguments of cd and readlink to avoid issues of directories named like options, but I don't bother for most purposes.

You can see the full explanation with illustrations here:

https://www.binaryphile.com/bash/2020/01/12/determining-the-location-of-your-script-in-bash.html

score -1 · Answer 56 · edited Jan 20 '21 at 04:15

I usually include the following at the top of my scripts which works in the majority of cases:

[ "$(dirname $0)" = '.' ] && SOURCE_DIR=$(pwd) || SOURCE_DIR=$(dirname $0);
ls -l $0 | grep -q ^l && SOURCE_DIR=$(ls -l $0 | awk '{print $NF}');

The first line assigns source based on the value of pwd if run from the current path or dirname if called from elsewhere.

The second line examines the path to see if it is a symlink and if so, updates SOURCE_DIR to the location of the link itself.

There are probably better solutions out there, but this is the cleanest I've managed to come up with myself.

score -1 · Answer 57 · answered Nov 29 '09 at 11:44

-1

function getScriptAbsoluteDir { # fold>>
    # @description used to get the script path
    # @param $1 the script $0 parameter
    local script_invoke_path="$1"
    local cwd=`pwd`

    # absolute path ? if so, the first character is a /
    if test "x${script_invoke_path:0:1}" = 'x/'
    then
        RESULT=`dirname "$script_invoke_path"`
    else
        RESULT=`dirname "$cwd/$script_invoke_path"`
    fi
} # <<fold

answered Nov 29 '09 at 11:44

Stefano Borini

125,999
87
277
404

sorry I'm a bit of a bash scrip noob, do I call this function by just typing `getScriptAbsoluteDir` or `local currdir='getScriptAbsoluteDir'`? – Jiaaro Nov 30 '09 at 16:04
4

-1: The `function` keyword isn't available on POSIX shells, and is a needlessly incompatible bash/ksh/&c. extension. Also, if you're on a shell new enough to have that extension, you don't need the test "x[...]" hack. – Charles Duffy Jun 09 '14 at 03:41
This almost looks like Python...I can't seem to remember that I've ever used the "local" keyword in a shell script...And to what Charles said, use `if [[ "${script_invoke_path:0:1}" == "/" ]]; then` and so on. Note the logical double `==` "equals" operator. – syntaxerror Sep 09 '14 at 23:31
An explanation would be in order. – Peter Mortensen Jan 20 '21 at 03:37
@PeterMortensen why should I? I pasted a solution that worked for me for years and I got spat upon on things that are completely irrelevant. They don't like the function they can take it away. They don't like the hack they can remove it. – Stefano Borini Jan 21 '21 at 10:14

score -1 · Answer 58 · edited Jan 20 '21 at 04:17

Try something like this:

function get_realpath() {

if [[ -f "$1" ]]
then
    # The file *must* exist
    if cd "$(echo "${1%/*}")" &>/dev/null
    then
        # The file *may* not be local.
        # The exception is ./file.ext
        # tTry 'cd .; cd -;' *works!*
        local tmppwd="$PWD"
        cd - &>/dev/null
    else
        # file *must* be local
        local tmppwd="$PWD"
    fi
else
    # The file *cannot* exist
    return 1 # Failure
fi

# Reassemble realpath
echo "$tmppwd"/"${1##*/}"
return 0 # Success

}

function get_dirname(){

local realpath="$(get_realpath "$1")"
if (( $? )) # True when non-zero.
then
    return $? # Failure
fi
echo "${realpath%/*}"
return 0 # Success

}

# Then from the top level:
get_dirname './script.sh'

# Or within a script:
get_dirname "$0"

# Can even test the outcome!
if (( $? )) # True when non-zero.
then
    exit 1 # Failure
fi

These functions and related tools are part of our product that has been made available to the community for free and can be found at GitHub as realpath-lib. It's simple, clean and well documented (great for learning), pure Bash and has no dependencies. Good for cross-platform use too. So for the above example, within a script you could simply:

source '/path/to/realpath-lib'

get_dirname "$0"

if (( $? )) # True when non-zero.
then
    exit 1 # Failure
fi

score -1 · Answer 59 · answered May 24 '14 at 15:47

-1

cur_dir=`old=\`pwd\`; cd \`dirname $0\`; echo \`pwd\`; cd $old;`

answered May 24 '14 at 15:47

ideawu

2,081
1
21
27

konsolebox · Answer 60 · 2014-07-03T05:42:17.010

-1

No forks (besides subshell) and can handle "alien" pathname forms like those with newlines as some would claim:

IFS= read -rd '' DIR < <([[ $BASH_SOURCE != */* ]] || cd "${BASH_SOURCE%/*}/" >&- && echo -n "$PWD")

edited Jul 03 '14 at 05:42

answered Jul 03 '14 at 04:58

konsolebox

60,986
9
83
94

score -1 · Answer 61 · edited Jan 20 '21 at 04:44

The key part is that I am reducing the scope of the problem: I forbid indirect execution of the script via the path (as in /bin/sh [script path relative to path component]).

This can be detected because $0 will be a relative path which does not resolve to any file relative to the current folder. I believe that direct execution using the #! mechanism always results in an absolute $0, including when the script is found on the path.

I also require that the pathname and any pathnames along a chain of symbolic links only contain a reasonable subset of characters, notably not \n, >, * or ?. This is required for the parsing logic.

There are a few more implicit expectations which I will not go into (look at this answer), and I do not attempt to handle deliberate sabotage of $0 (so consider any security implications). I expect this to work on almost any Unix-like system with a Bourne-like /bin/sh.

#!/bin/sh
(
    path="${0}"
    while test -n "${path}"; do
        # Make sure we have at least one slash and no leading dash.
        expr "${path}" : / > /dev/null || path="./${path}"
        # Filter out bad characters in the path name.
        expr "${path}" : ".*[*?<>\\]" > /dev/null && exit 1
        # Catch embedded new-lines and non-existing (or path-relative) files.
        # $0 should always be absolute when scripts are invoked through "#!".
        test "`ls -l -d "${path}" 2> /dev/null | wc -l`" -eq 1 || exit 1
        # Change to the folder containing the file to resolve relative links.
        folder=`expr "${path}" : "\(.*/\)[^/][^/]*/*$"` || exit 1
        path=`expr "x\`ls -l -d "${path}"\`" : "[^>]* -> \(.*\)"`
        cd "${folder}"
        # If the last path was not a link then we are in the target folder.
        test -n "${path}" || pwd
    done
)

Jay jargot · Answer 62 · 2016-03-31T08:13:10.443

Look at the test at bottom with weird directory names.

To change the working directory to the one where the Bash script is located, you should try this simple, tested and verified with shellcheck solution:

#!/bin/bash --
cd "$(dirname "${0}")"/. || exit 2

The test:

$ ls 
application
$ mkdir "$(printf "\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\40\41\42\43\44\45\46\47testdir" "")"
$ mv application *testdir
$ ln -s *testdir "$(printf "\1\2\3\4\5\6\7\10\11\12\13\14\15\16\17\20\21\22\23\24\25\26\27\30\31\32\33\34\35\36\37\40\41\42\43\44\45\46\47symlink" "")"
$ ls -lb
total 4
lrwxrwxrwx 1 jay stacko   46 Mar 30 20:44 \001\002\003\004\005\006\a\b\t\n\v\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\ !"#$%&'symlink -> \001\002\003\004\005\006\a\b\t\n\v\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\ !"#$%&'testdir
drwxr-xr-x 2 jay stacko 4096 Mar 30 20:44 \001\002\003\004\005\006\a\b\t\n\v\f\r\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037\ !"#$%&'testdir
$ *testdir/application && printf "SUCCESS\n" ""
SUCCESS
$ *symlink/application && printf "SUCCESS\n" ""
SUCCESS

Andry · Answer 63 · 2021-01-20T14:04:02.377

There is no 100% portable and reliable way to request a path to a current script directory. Especially between different backends like Cygwin, MinGW, MSYS, Linux, etc. This issue was not properly and completely resolved in Bash for ages.

For example, this could not be resolved if you want to request the path after the source command to make nested inclusion of another Bash script which is in turn use the same source command to include another Bash script and so on.

In case of the source command, I suggest to replace the source command with something like this:

function include()
{
  if [[ -n "$CURRENT_SCRIPT_DIR" ]]; then
    local dir_path=... get directory from `CURRENT_SCRIPT_DIR/$1`, depends if $1 is absolute path or relative ...
    local include_file_path=...
  else
    local dir_path=... request the directory from the "$1" argument using one of answered here methods...
    local include_file_path=...
  fi
  ... push $CURRENT_SCRIPT_DIR in to stack ...
  export CURRENT_SCRIPT_DIR=... export current script directory using $dir_path ...
  source "$include_file_path"
  ... pop $CURRENT_SCRIPT_DIR from stack ...
}

From now on, the use of include(...) is based on previous CURRENT_SCRIPT_DIR in your script.

This only works when you can replace all source commands by include command. If you can't, then you have no choice. At least until developers of the Bash interpreter make an explicit command to request the current running script directory path.

My own closest implementation to this: https://sourceforge.net/p/tacklelib/tacklelib/HEAD/tree/trunk/bash/tacklelib/bash_entry

(search for the tkl_include function)

score -2 · Answer 64 · edited Jan 20 '21 at 04:46

-2

Based on this answer, I suggest the clarified version that gets SCRIPT_HOME as the containing folder of any currently-running Bash script:

s=${BASH_SOURCE[0]} ; s=`dirname $s` ; SCRIPT_HOME=`cd $s ; pwd`
echo $SCRIPT_HOME

edited Jan 20 '21 at 04:46

Peter Mortensen

28,342
21
95
123

answered Oct 24 '16 at 11:45

Nam G VU

28,311
62
206
338

score -2 · Answer 65 · edited Jan 20 '21 at 05:23

I want to comment on the previous answer up there (How can I get the source directory of a Bash script from within the script itself?), but don't have enough reputation to do that.

I found a solution for this two years ago on Apple's documentation site: https://developer.apple.com/library/archive/documentation/OpenSource/Conceptual/ShellScripting/AdvancedTechniques/AdvancedTechniques.html. And I stuck to this method afterwards. It cannot handle soft link, but otherwise works pretty well for me. I'm posting it here for any who needs it and as a request for comment.

#!/bin/sh

# Get an absolute path for the poem.txt file.
POEM="$PWD/../poem.txt"

# Get an absolute path for the script file.
SCRIPT="$(which $0)"
if [ "x$(echo $SCRIPT | grep '^\/')" = "x" ] ; then
    SCRIPT="$PWD/$SCRIPT"
fi

As shown by the code, after you get the absolute path of the script, then you can use the dirname command to get the path of the directory.

score -2 · Answer 66 · edited Jan 20 '21 at 05:27

This is what I crafted throughout the years to use as a header on my Bash scripts:

## BASE BRAIN - Get where you're from and who you are.
MYPID=$$
ORIGINAL_DIR="$(pwd)" # This is not a hot air balloon ride..
fa="$0" # First Assumption
ta= # Temporary Assumption
wa= # Weighed Assumption
while true; do
    [ "${fa:0:1}" = "/" ] && wa=$0 && break
    [ "${fa:0:2}" = "./" ] && ta="${ORIGINAL_DIR}/${fa:2}" && [ -e "$ta" ] && wa="$ta" && break
    ta="${ORIGINAL_DIR}/${fa}" && [ -e "$ta" ] && wa="$ta" && break
done
SW="$wa"
SWDIR="$(dirname "$wa")"
SWBIN="$(basename "$wa")"
unset ta fa wa
( [ ! -e "$SWDIR/$SWBIN" ] || [ -z "$SW" ] ) && echo "I could not find my way around :( possible bug in the TOP script" && exit 1

At this point, your variables SW, SWDIR, and SWBIN contain what you need.

score -3 · Answer 67 · edited Jan 20 '21 at 04:48

-3

This one-liner works on Cygwin even if the script has been called from Windows with bash -c <script>:

set mydir="$(cygpath "$(dirname "$0")")"

edited Jan 20 '21 at 04:48

Peter Mortensen

28,342
21
95
123

answered Feb 03 '17 at 13:57

ankostis

6,471
2
37
54

score -3 · Answer 68 · edited Jan 13 '15 at 12:56

-3

I want to make sure that the script is running in its directory. So

cd $(dirname $(which $0) )

After this, if you really want to know where the you are running then run the command below.

DIR=$(/usr/bin/pwd)

edited Jan 13 '15 at 12:56

tripleee

139,311
24
207
268

answered Feb 12 '09 at 15:06

6

How does this differ from other answers? – mmmmmm Jan 20 '15 at 12:18

score -5 · Answer 69 · edited Jan 20 '21 at 04:56

The chosen answer works very well. I'm posting my solution for anyone looking for shorter alternatives that still addresses sourcing, executing, full paths, relative paths, and symlinks. Finally, this will work on macOS, given that it cannot be assumed that GNU's coreutils' version of readlink is available.

The gotcha is that it's not using Bash, but it is easy to use in a Bash script. While the OP did not place any constraints on the language of the solution, it's probably best that most have stayed within the Bash world. This is just an alternative, and possibly an unpopular one.

PHP is available on macOS by default, and installed on a number of other platforms, though not necessarily by default. I realize this is a shortcoming, but I'll leave this here for any people coming from search engines, anyway.

export SOURCE_DIRECTORY="$(php -r 'echo dirname(realpath($argv[1]));' -- "${BASH_SOURCE[0]}")"

There was nothing about MacOS in the question. I think this answer should start with "Another approach is to use PHP instead of relying on BASH". Because this reveals only at the end of the answer. — DmitryBorodin, Feb 24 '19 at 22:14

score -6 · Answer 70 · answered Feb 24 '20 at 17:58

-6

Keep it simple.

#!/usr/bin/env bash
sourceDir=`pwd`
echo $sourceDir

answered Feb 24 '20 at 17:58

Muhammad Adeel

2,759
1
19
18

score -7 · Answer 71 · edited Jan 20 '21 at 04:43

-7

FOLDERNAME=${PWD##*/}

That is the quickest way I know.

edited Jan 20 '21 at 04:43

Peter Mortensen

28,342
21
95
123

answered Nov 14 '14 at 16:35

Paul Savage

21
2

5

This simply starts from the pwd, and will not return the path where the current script under execution is located. – parvus Jan 02 '15 at 07:59

How can I get the source directory of a Bash script from within the script itself?

71 Answers71

How to obtain the full file path, full directory, and base filename of any script being run itself

References:

How it works

The zsh current file expansion: `${(%):-%x}`

The fallback substitution operator `:-`

The `%x` prompt escape code

An unlikely match: the percent escape and the fallback

Finishing up: what about `print -P %x`?

The following will return the current directory of the script

test.sh

`echo $(realpath $_)`

`echo $(realpath $(dirname $0))`

`echo $(realpath $BASH_SOURCE)`

Linked

Related

How can I get the source directory of a Bash script from within the script itself?

71 Answers71

How to obtain the full file path, full directory, and base filename of any script being run itself

References:

How it works

The zsh current file expansion: ${(%):-%x}

The fallback substitution operator :-

The %x prompt escape code

An unlikely match: the percent escape and the fallback

Finishing up: what about print -P %x?

The following will return the current directory of the script

test.sh

echo $(realpath $_)

echo $(realpath $(dirname $0))

echo $(realpath $BASH_SOURCE)

Linked

Related

The zsh current file expansion: `${(%):-%x}`

The fallback substitution operator `:-`

The `%x` prompt escape code

Finishing up: what about `print -P %x`?

`echo $(realpath $_)`

`echo $(realpath $(dirname $0))`

`echo $(realpath $BASH_SOURCE)`