How to retrieve absolute path given relative

Question

Is there a command to retrieve the absolute path given a relative path?

For example I want $line to contain the absolute path of each file in dir ./etc/

find ./ -type f | while read line; do
   echo $line
done

Helpmeet

possible duplicate of Converting relative path into absolute path or this. – Hypocotyl

possible duplicate of bash/fish command to print absolute path to a file – Interplanetary

A much better solution than any of the ones listed so far is here how-to-convert-relative-path-to-absolute-path-in-unix – Remaremain

You may want to see this for it may be of use to configure paths in your scripts relative to repo path when in a git repo. – Peoples

Answer 1

use:

find "$(pwd)"/ -type f

to get all files or

echo "$(pwd)/$line"

to display full path (if relative path matters to)

Voorhis

Answer 2

Try realpath.

~ $ sudo apt-get install realpath  # may already be installed
~ $ realpath .bashrc
/home/username/.bashrc

To avoid expanding symlinks, use realpath -s.

The answer comes from "bash/fish command to print absolute path to a file".

Brigitta

realpath does not seem to be available on the Mac (OS X 10.11 "El Capitan"). :-( – Rigadoon

realpath does not seem to be available on CentOS 6 either – Gensmer

on osx, brew install coreutils will bring in realpath – Bourg

On my Ubuntu 18.04, realpath is already present. I didn't have to install it separately. – Chromaticness

Surprisingly, realpath is available on Git for Windows (for me, at least). – If

Related: stackoverflow.com/questions/59895/… – Graceless

And it has the advantage of allowing you to pass an already absolute path to it. That is... it is idempotent. – Nauseous

Need a pure bash solution, even if it's 30KLOC. – Manuscript

Preferable solution is within shell and not requiring external software – Pittsburgh

realpath now ships with macOS 13 (Ventura), under /bin. – Nonconformity

Answer 3

If you have the coreutils package installed you can generally use readlink -f relative_file_name in order to retrieve the absolute one (with all symlinks resolved)

Ashraf

The behaviour for this is a little different from what the user asks, it will also follow and resolve recursive symlinks anywhere in the path. You might not want that in some cases. – Badly

@BradPeabody This does work in a Mac if you install coreutils from homebrew brew install coreutils. However the executable is prepended by a g: greadlink -f relative_file_name – Speculum

Notice that the manual page of readlink(1) has as the first sentence of its description: "Note realpath(1) is the preferred command to use for canonicalization functionality." – Drisko

you can use -e instead of -f to check if the file/directory exists or not – Sternum

Completely fails with something as elementary as ".". – Manuscript

Preferable solution is within shell and not requiring external software – Pittsburgh

Answer 4

#! /bin/sh
echo "$(cd "$(dirname "$1")"; pwd)/$(basename "$1")"

UPD Some explanations

1. This script get relative path as argument "$1"
2. Then we get dirname part of that path (you can pass either dir or file to this script): dirname "$1"
3. Then we cd "$(dirname "$1") into this relative dir and get absolute path for it by running pwd shell command
4. After that we append basename to absolute path: $(basename "$1")
5. As final step we echo it

Goggle

readlink is the simple solution for linux, but this solution works on OSX too, so +1 – Lainelainey

This script is not equivalent to what realpath or readlink -f do. For instance, it doesn't work on paths where the last component is a symlink. – Drisko

@josch: The question is not about symlink resolving. But if you want to do that you can provide -P option to pwd command: echo "$(cd "$(dirname "$1")"; pwd -P)/$(basename "$1")" – Goggle

I like the answer, but it only works, if the user is allowed to cd into the directory. This might not always be possible. – Braille

My personal favourite :) Unfortunately, it failed when I fed it "." and ".." as relative paths. Slightly improved version: https://mcmap.net/q/19845/-how-to-retrieve-absolute-path-given-relative – Solenne

echo "$(cd ${1%/*}; pwd)/${1##*/}" Some similar with string manipulation if rel path in $1. – Nixon

Doesn't work correctly with paths that are already absolute. – Manuscript

Why is this using $1? On my system it largely fails with $1 and gets many of the issues reported in the comments above. If I use $0 it works perfectly for any situation I have tried. This makes sense as $1 is an empty string and $0 contains the path used to start the script – Mairemaise

@MikeKulls: This script expect that you provide parameter. A relative path to somewhere. – Goggle

@EugenKonkov ah, makes sense. I was focused on my particular use case, which was to find the path of my own script – Mairemaise

Answer 5

For what it's worth, I voted for the answer that was picked, but wanted to share a solution. The downside is, it's Linux only - I spent about 5 minutes trying to find the OSX equivalent before coming to Stack overflow. I'm sure it's out there though.

On Linux you can use readlink -e in tandem with dirname.

$(dirname $(readlink -e ../../../../etc/passwd))

yields

/etc/

And then you use dirname's sister, basename to just get the filename

$(basename ../../../../../passwd)

yields

passwd

Put it all together..

F=../../../../../etc/passwd
echo "$(dirname $(readlink -e $F))/$(basename $F)"

yields

/etc/passwd

You're safe if you're targeting a directory, basename will return nothing and you'll just end up with double slashes in the final output.

Anitaanitra

Excellent entry with dirname, readlink, and basename. That helped me to get the absolute path of a symbolic link -- not its target. – Amidst

Doesn't work when you want to return path to symbolic links (which I just happen to need to do...). – Callosity

How could you ever find the absolute path to a path that doesn't exist? – Anitaanitra

@Anitaanitra Quite easily, I would have thought; if I'm in /home/GKFX and I type touch newfile, then before I press enter you could work out that I mean "create /home/GKFX/newfile", which is an absolute path to a file that doesn't exist yet. – Roundworm

Answer 6

I think this is the most portable:

abspath() {                                               
    cd "$(dirname "$1")"
    printf "%s/%s\n" "$(pwd)" "$(basename "$1")"
    cd "$OLDPWD"
}

It will fail if the path does not exist though.

Harmonica

There's no need to cd back again. See https://mcmap.net/q/20152/-how-to-obtain-the-absolute-path-of-a-file-via-shell-bash-zsh-sh. Your's is the best answer on this page, IMHO. For those interested the link gives an explanation as to why this solution works. – Woodworking

This is not very portable, dirname is a GNU core utility, not common to all unixen I believe. – Christiansen

@Christiansen dirname is a POSIX standard utility, see here: pubs.opengroup.org/onlinepubs/9699919799/utilities/dirname.html – Harmonica

Oh my God, thank you. I've been trying to fix the version that uses ${1##*/} for a day now, and now that I replaced that trash with basename "$1" it seems to finally be properly handling paths that end in /. – Flamenco

NB, this doesn't do the right thing with a path ending in ../.. – Kristine

I made a version which deals with that. – Kristine

What if pushd and popd? – Seng

Answer 7

realpath is probably best

But ...

The initial question was very confused to start with, with an example poorly related to the question as stated.

The selected answer actually answers the example given, and not at all the question in the title. The first command is that answer (is it really ? I doubt), and could do as well without the '/'. And I fail to see what the second command is doing.

Several issues are mixed :

• changing a relative pathname into an absolute one, whatever it denotes, possibly nothing. (Typically, if you issue a command such as touch foo/bar, the pathname foo/bar must exist for you, and possibly be used in computation, before the file is actually created.)

• there may be several absolute pathname that denote the same file (or potential file), notably because of symbolic links (symlinks) on the path, but possibly for other reasons (a device may be mounted twice as read-only). One may or may not want to resolve explicity such symlinks.

• getting to the end of a chain of symbolic links to a non-symlink file or name. This may or may not yield an absolute path name, depending on how it is done. And one may, or may not want to resolve it into an absolute pathname.

The command readlink foo without option gives an answer only if its argument foo is a symbolic link, and that answer is the value of that symlink. No other link is followed. The answer may be a relative path: whatever was the value of the symlink argument.

However, readlink has options (-f -e or -m) that will work for all files, and give one absolute pathname (the one with no symlinks) to the file actually denoted by the argument.

This works fine for anything that is not a symlink, though one might desire to use an absolute pathname without resolving the intermediate symlinks on the path. This is done by the command realpath -s foo

In the case of a symlink argument, readlink with its options will again resolve all symlinks on the absolute path to the argument, but that will also include all symlinks that may be encountered by following the argument value. You may not want that if you desired an absolute path to the argument symlink itself, rather than to whatever it may link to. Again, if foo is a symlink, realpath -s foo will get an absolute path without resolving symlinks, including the one given as argument.

Without the -s option, realpath does pretty much the same as readlink, except for simply reading the value of a link, as well as several other things. It is just not clear to me why readlink has its options, creating apparently an undesirable redundancy with realpath.

Exploring the web does not say much more, except that there may be some variations across systems.

Conclusion : realpath is the best command to use, with the most flexibility, at least for the use requested here.

Sheikdom

man page of readlinksays: "Note realpath(1) is the preferred command to use for canonicalization functionality." – Thackeray

@Thackeray Interesting. My man page does say that, but dates from April 2021. Any idea when that line was included? – Sheikdom

The commit was made in 2017. – Thackeray

@Thackeray Thanks. I should learn to search for that kind of info. Well, it is nice to have an answer that gets officially supported after 4 years :-). Too bad there is no badge for that. – Sheikdom

Answer 8

My favourite solution was the one by @EugenKonkov because it didn't imply the presence of other utilities (the coreutils package).

But it failed for the relative paths "." and "..", so here is a slightly improved version handling these special cases.

It still fails if the user doesn't have the permission to cd into the parent directory of the relative path, though.

#! /bin/sh

# Takes a path argument and returns it as an absolute path. 
# No-op if the path is already absolute.
function to-abs-path {
    local target="$1"

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

Solenne

+1 Nice!! But has a bug in this use-case: to-abs-path /tmp/../tmp/../var //var For comparison, the proper expected output would be: realpath /tmp/../tmp/../var /var – Engorge

Answer 9

Eugen's answer didn't quite work for me but this did:

    absolute="$(cd $(dirname \"$file\"); pwd)/$(basename \"$file\")"

Side note, your current working directory is unaffected.

Laocoon

Answer 10

The best solution, imho, is the one posted here: https://mcmap.net/q/13697/-how-do-you-normalize-a-file-path-in-bash.

It does require python to work, but it seems to cover all or most of the edge cases and be very portable solution.

1. With resolving symlinks:

python -c "import os,sys; print(os.path.realpath(sys.argv[1]))" path/to/file

2. or without it:

python -c "import os,sys; print(os.path.abspath(sys.argv[1]))" path/to/file

Comatose

The only sane solution. Unlike readlink- and readpath-based solutions, some variant of Python is basically guaranteed to be available everywhere – even under edge-case environments like vanilla macOS and the *BSDs. It's both fascinating and sad that POSIX-compliant shells fail to support this out-of-the-box. Unix: still imperfect after all these years. – Feaster

Answer 11

An improvement to @ernest-a's rather nice version:

absolute_path() {
    cd "$(dirname "$1")"
    case $(basename $1) in
        ..) echo "$(dirname $(pwd))";;
        .)  echo "$(pwd)";;
        *)  echo "$(pwd)/$(basename $1)";;
    esac
}

This deals correctly with the case where the last element of the path is .., in which case the "$(pwd)/$(basename "$1")" in @ernest-a's answer will come through as accurate_sub_path/spurious_subdirectory/...

Kristine

nice try, but: (1) absolute_path /tmp/../tmp/../var //var (2) target must exist. – Engorge

Answer 12

In case of find, it's probably easiest to just give the absolute path for it to search in, e.g.:

find /etc
find `pwd`/subdir_of_current_dir/ -type f

Flavius

Answer 13

If you are using bash on Mac OS X which neither has realpath existed nor its readlink can print the absolute path, you may have choice but to code your own version to print it. Here is my implementation:

(pure bash)

abspath(){
  local thePath
  if [[ ! "$1" =~ ^/ ]];then
    thePath="$PWD/$1"
  else
    thePath="$1"
  fi
  echo "$thePath"|(
  IFS=/
  read -a parr
  declare -a outp
  for i in "${parr[@]}";do
    case "$i" in
    ''|.) continue ;;
    ..)
      len=${#outp[@]}
      if ((len==0));then
        continue
      else
        unset outp[$((len-1))] 
      fi
      ;;
    *)
      len=${#outp[@]}
      outp[$len]="$i"
      ;;
    esac
  done
  echo /"${outp[*]}"
)
}

(use gawk)

abspath_gawk() {
    if [[ -n "$1" ]];then
        echo $1|gawk '{
            if(substr($0,1,1) != "/"){
                path = ENVIRON["PWD"]"/"$0
            } else path = $0
            split(path, a, "/")
            n = asorti(a, b,"@ind_num_asc")
            for(i in a){
                if(a[i]=="" || a[i]=="."){
                    delete a[i]
                }
            }
            n = asorti(a, b, "@ind_num_asc")
            m = 0
            while(m!=n){
                m = n
                for(i=1;i<=n;i++){
                    if(a[b[i]]==".."){
                        if(b[i-1] in a){
                            delete a[b[i-1]]
                            delete a[b[i]]
                            n = asorti(a, b, "@ind_num_asc")
                            break
                        } else exit 1
                    }
                }
            }
            n = asorti(a, b, "@ind_num_asc")
            if(n==0){
                printf "/"
            } else {
                for(i=1;i<=n;i++){
                    printf "/"a[b[i]]
                }
            }
        }'
    fi
}

(pure bsd awk)

#!/usr/bin/env awk -f
function abspath(path,    i,j,n,a,b,back,out){
  if(substr(path,1,1) != "/"){
    path = ENVIRON["PWD"]"/"path
  }
  split(path, a, "/")
  n = length(a)
  for(i=1;i<=n;i++){
    if(a[i]==""||a[i]=="."){
      continue
    }
    a[++j]=a[i]
  }
  for(i=j+1;i<=n;i++){
    delete a[i]
  }
  j=0
  for(i=length(a);i>=1;i--){
    if(back==0){
      if(a[i]==".."){
        back++
        continue
      } else {
        b[++j]=a[i]
      }
    } else {
      if(a[i]==".."){
        back++
        continue
      } else {
        back--
        continue
      }
    }
  }
  if(length(b)==0){
    return "/"
  } else {
    for(i=length(b);i>=1;i--){
      out=out"/"b[i]
    }
    return out
  }
}

BEGIN{
  if(ARGC>1){
    for(k=1;k<ARGC;k++){
      print abspath(ARGV[k])
    }
    exit
  }
}
{
  print abspath($0)
}

example:

$ abspath I/am/.//..//the/./god/../of///.././war
/Users/leon/I/the/war

Predicative

readlink can handle missing files/folders just file: readlink -m I/am/.//..//the/./god/../of///.././war Yields same (as yours) output: /home/dmitry/I/the/war – Engorge

Answer 14

I found Eugen Konkov's answer to be the best as it doesn't require installing any program. However, it will fail for non-existent directories.

I wrote a function that works for non-existent directories:

function getRealPath()
{
    local -i traversals=0
    currentDir="$1"
    basename=''
    while :; do
        [[ "$currentDir" == '.' ]] && { echo "$1"; return 1; }
        [[ $traversals -eq 0 ]] && pwd=$(cd "$currentDir" 2>&1 && pwd) && { echo "$pwd/$basename"; return 0; }
        currentBasename="$(basename "$currentDir")"
        currentDir="$(dirname "$currentDir")"
        [[ "$currentBasename" == '..' ]] && (( ++traversals )) || { [[ traversals -gt 0 ]] && (( traversals-- )) || basename="$currentBasename/$basename"; }
    done
}

It solves the problem of non-existent directories by traversing up with dirname until cd succeeds, then returning the current directory plus everything that was removed by dirname.

Wireman

Answer 15

Similar to @ernest-a's answer but without affecting $OLDPWD or define a new function you could fire a subshell (cd <path>; pwd)

$ pwd
/etc/apache2
$ cd ../cups 
$ cd -
/etc/apache2
$ (cd ~/..; pwd)
/Users
$ cd -
/etc/cups

Colpotomy

Answer 16

I was unable to find a solution that was neatly portable between Mac OS Catalina, Ubuntu 16 and Centos 7, so I decided to do it with python inline and it worked well for my bash scripts.

to_abs_path() {
  python -c "import os; print os.path.abspath('$1')"
}

to_abs_path "/some_path/../secrets"

Pioneer

Answer 17

BLUF:

cd $relative_path ; pwd

Here is an explanation that is POSIX compliant (I think), so it should work on any platform.

This is scriptable, of course, but I think breaking it down might make it easier for some people to understand / modify to a particular use case.

You can use which, locate, find, full paths, whatever.

x=your_file_name

$ x="nvi" 

file easily indicates symlinks

$ file -h `which $x`
/usr/local/bin/nvi: symbolic link to ../Cellar/nvi/1.81.6_5/bin/nvi

Next, munge the output a bit so we get a "complete" relative path.
We just need to remove the middle part in this example.

Note UPPERCASE Y vs lowercase x. There is probably a cleaner way to do this.

$ Y=$(file -h `which $x` | sed "s/$x: symbolic link to //")


$ echo $Y
/usr/local/bin/../Cellar/nvi/1.81.6_5/bin/nvi

Using dirname we get just the path portion. cd to it and the name should clean itself up.

$ cd `dirname $Y` ; pwd
/usr/local/Cellar/nvi/1.81.6_5/bin

That leads us to the old UNIX trick to "ghost walk" a directory by doing it all in parenthesis / a sub-shell. This effectively returns us to our current directory when done.

We can stick the actual file name back on the end for completeness.

ls even makes sure the absolute path is valid, for bonus points.

$ ( cd `dirname ${Y}` ; ls `pwd`/${x} )
/usr/local/Cellar/nvi/1.81.6_5/bin/nvi

So /usr/local/bin/nvi is really /usr/local/Cellar/nvi/1.81.6_5/bin/nvi

Simplified example to quickly "convert" a path:

$ (cd /usr/local/bin/../Cellar/nvi/1.81.6_5/bin ; pwd)
/usr/local/Cellar/nvi/1.81.6_5/bin

https://pubs.opengroup.org/onlinepubs/9699919799/utilities/file.html https://pubs.opengroup.org/onlinepubs/9699919799/utilities/dirname.html

Acquiescence

Answer 18

What they said, except find $PWD or (in bash) find ~+ is a bit more convenient.

Nowhere

Answer 19

If the relative path is a directory path, then try mine, should be the best:

absPath=$(pushd ../SOME_RELATIVE_PATH_TO_Directory > /dev/null && pwd && popd > /dev/null)

echo $absPath

Edgar

This solution only works for bash, see also https://mcmap.net/q/20154/-bin-sh-pushd-not-found – Quadrumanous

Answer 20

echo "mydir/doc/ mydir/usoe ./mydir/usm" |  awk '{ split($0,array," "); for(i in array){ system("cd "array[i]" && echo $PWD") } }'

In the snippet above awk is used to split the string of directories received from echo (via the pipeline) and creates an array.

Here is a step-by-step list of what is happening:

• Space delimited list of directories is piped to awk
• awk splits piped text into an array by spaces
• awk loops over each item in the array (variable i)
• awk uses the awk system command to run a cli command
• The CLI command changes directory (cd) to the path specified by item "i" in the array and then prints (echo) the working directory using the environment variable $PWD"

Using cd to travel to each directory and then print the value of $PWD is a great way to have the OS do the work of determining an absolute path

Westering

Thank you for this code snippet, which might provide some limited short-term help. A proper explanation would greatly improve its long-term value by showing why this is a good solution to the problem, and would make it more useful to future readers with other, similar questions. Please edit your answer to add some explanation, including the assumptions you've made. – Fikes

Answer 21

You could use bash string substitution for any relative path $line:

line=$(echo ${line/#..\//`cd ..; pwd`\/})
line=$(echo ${line/#.\//`pwd`\/})
echo $line

The basic front-of-string substitution follows the formula
${string/#substring/replacement}
which is discussed well here: https://www.tldp.org/LDP/abs/html/string-manipulation.html

The \ character negates the / when we want it to be part of the string that we find/replace.

Cerveny

Note that you could just use dirname & basename, I think. Something like dir=`dirname $line`; file=`basename $line`; line=`cd $dir; pwd`/$file – Prytaneum

Answer 22

Here's a rather short function that can be used to fully absolutize and canonicalize any given input path using only POSIX shell and readlink semantics:

canonicalize_path() {
    (
        FILEPATH="$1"
        for _ in 1 2 3 4 5 6 7 8;  # Maximum symlink recursion depth
        do
            cd -L "`case "${FILEPATH}" in */*) echo "${FILEPATH%/*}";; *) echo ".";; esac`/"  # cd $(dirname)
            if ! FILEPATH="$(readlink "${FILEPATH##*/}" || ( echo "${FILEPATH##*/}" && false ) )";
            then
                break
            fi
        done
        cd -P "." || return $?
        echo "$(pwd)/${FILEPATH}"
    )
}

If the referenced file does not exist only the directory path leading up to the final filename will be resolved. If the any of the directories leading up to the file path does not exist a cd error will be returned. This happens to be the exact semantics of the GNU/Linux readlink -f command it tries to mimic.

In bash/zsh you can also compact the list of numbers to just {1..8} or similar. The number of 8 was chosen as this was maximum limit in Linux for many years before the changed it a total limit of 40 resolution for the entire path in version 4.2. If the resolution limit is reached the code will not fail, but instead return last considered path instead – an explicit [ -L "${FILEPATH}" ] check could be added to detect this condition however.

This code can also be easily reused for ensuring the current working directory matches the executed script's location in the filesystem (a common requirement for shell scripts), by simply removing the function and subshell wrapper:

FILEPATH="$0"
for _ in 1 2 3 4 5 6 7 8;  # Maximum symlink recursion depth
do
    cd -L "`case "${FILEPATH}" in */*) echo "${FILEPATH%/*}";; *) echo ".";; esac`/"  # cd $(dirname)
    if ! FILEPATH="$(readlink "${FILEPATH##*/}" || ( echo "${FILEPATH##*/}" && false ) )";
    then
        break
    fi
done
cd -P "."
FILEPATH="$(pwd)/${FILEPATH}"

Repine

Answer 23

An update on previous answer using python 3

to_abs_path() {
  python -c "import os; print (os.path.abspath('$1'))"
}

Allowing

to_abs_path "./../some_file.txt"

Gearldinegearshift

Answer 24

If you want to transform a variable containing a relative path into an absolute one, this works :

   dir=`cd "$dir"`

"cd" echoes without changing the working directory, because executed here in a sub-shell.

Anticipate

On bash-4.3-p46, this doesn’t work: the shell prints an empty line when I run dir=`cd ".."` && echo $dir – Quadrumanous

Answer 25

This is a chained solution from all others, for example, when realpath fails, either because it is not installed or because it exits with error code, then, the next solution is attempted until it get the path right.

#!/bin/bash

function getabsolutepath() {
    local target;
    local changedir;
    local basedir;
    local firstattempt;

    target="${1}";
    if [ "$target" == "." ];
    then
        printf "%s" "$(pwd)";

    elif [ "$target" == ".." ];
    then
        printf "%s" "$(dirname "$(pwd)")";

    else
        changedir="$(dirname "${target}")" && basedir="$(basename "${target}")" && firstattempt="$(cd "${changedir}" && pwd)" && printf "%s/%s" "${firstattempt}" "${basedir}" && return 0;
        firstattempt="$(readlink -f "${target}")" && printf "%s" "${firstattempt}" && return 0;
        firstattempt="$(realpath "${target}")" && printf "%s" "${firstattempt}" && return 0;

        # If everything fails... TRHOW PYTHON ON IT!!!
        local fullpath;
        local pythoninterpreter;
        local pythonexecutables;
        local pythonlocations;

        pythoninterpreter="python";
        declare -a pythonlocations=("/usr/bin" "/bin");
        declare -a pythonexecutables=("python" "python2" "python3");

        for path in "${pythonlocations[@]}";
        do
            for executable in "${pythonexecutables[@]}";
            do
                fullpath="${path}/${executable}";

                if [[ -f "${fullpath}" ]];
                then
                    # printf "Found ${fullpath}\\n";
                    pythoninterpreter="${fullpath}";
                    break;
                fi;
            done;

            if [[ "${pythoninterpreter}" != "python" ]];
            then
                # printf "Breaking... ${pythoninterpreter}\\n"
                break;
            fi;
        done;

        firstattempt="$(${pythoninterpreter} -c "import os, sys; print( os.path.abspath( sys.argv[1] ) );" "${target}")" && printf "%s" "${firstattempt}" && return 0;
        # printf "Error: Could not determine the absolute path!\\n";
        return 1;
    fi
}

printf "\\nResults:\\n%s\\nExit: %s\\n" "$(getabsolutepath "./asdfasdf/ asdfasdf")" "${?}"

Telegu

Answer 26

Based on this answer by @EugenKonkov and this answer by @HashChange, my answer combines the brevity of the former with the handling of . and .. of the latter. I believe that all the options below rely upon nothing more than the basic Shell Command Language POSIX standards.

Using dirname and basename, an option is:

absPathDirname()
{
    [ -d "${1}" ] && set -- "${1}" || set -- "`dirname "${1}"`" "/`basename "${1}"`"
    echo "`cd "${1}"; pwd`${2}";
}

Without using dirname or basename, another brief option is:

absPathMinusD()
{
    [ -d "${1}" ] && set -- "${1}" || set -- "${1%${1##*/}}" "/${1##*/}"
    echo "`cd "${1:-.}"; pwd`${2}";
}

I would recommend one of the two options above, the rest are just for fun...

Grep version:

absPathGrep()
{
    echo "`[ "${1##/*}" ] && echo "$1" | grep -Eo '^(.*/)?\.\.($|/)' | { read d && cd "$d"; echo "${PWD}/${1#$d}"; } || echo "$1"`"
}

As an interesting example of "what can be done with the shell's limited RegEx":

absPathShellReplace()
{
    E="${1##*/}"; D="${E#$E${E#.}}"; DD="${D#$D${D#..}}"
    DIR="${1%$E}${E#$DD}"; FILE="${1#$DIR}"; SEP=${FILE:+/}
    echo "`cd "${DIR:-.}"; pwd`${SEP#$DIR}$FILE"
}

Flocculant