Як ви нормалізуєте шлях до файлу в Bash?

Я хочу перетворитися /foo/bar/..на/foo

Чи є команда bash, яка це робить?

Редагувати: в моєму практичному випадку каталог існує.

якщо ви хочете зігнати частину імені файлу з контуру, "dirname" та "basename" - ваші друзі, і "realpath" також корисний.

dirname /foo/bar/baz 
# /foo/bar 
basename /foo/bar/baz
# baz
dirname $( dirname  /foo/bar/baz  ) 
# /foo 
realpath ../foo
# ../foo: No such file or directory
realpath /tmp/../tmp/../tmp
# /tmp

realpath альтернативи

Якщо realpathваша оболонка не підтримується, ви можете спробувати

readlink -f /path/here/.. 

Також

readlink -m /path/there/../../ 

Працює так само, як і

realpath -s /path/here/../../

в тому, що шлях не потрібно існувати для нормалізації.

Я не знаю, чи є пряма команда bash для цього, але я зазвичай це роблю

normalDir="`cd "${dirToNormalize}";pwd`"
echo "${normalDir}"

і це добре працює.

Спробуйте realpath. Нижче наведено джерело в повному обсязі, передане в загальнодоступне надбання.

// realpath.c: display the absolute path to a file or directory.
// Adam Liss, August, 2007
// This program is provided "as-is" to the public domain, without express or
// implied warranty, for any non-profit use, provided this notice is maintained.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <libgen.h>   
#include <limits.h>

static char *s_pMyName;
void usage(void);

int main(int argc, char *argv[])
{
    char
        sPath[PATH_MAX];


    s_pMyName = strdup(basename(argv[0]));

    if (argc < 2)
        usage();

    printf("%s\n", realpath(argv[1], sPath));
    return 0;
}    

void usage(void)
{
    fprintf(stderr, "usage: %s PATH\n", s_pMyName);
    exit(1);
}

Портативне та надійне рішення - використовувати пітон, який попередньо встановлений майже скрізь (включаючи Дарвін). У вас є два варіанти:

1. abspath повертає абсолютний шлях, але не вирішує символьні посилання:

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

2. realpath повертає абсолютний шлях і тим самим вирішує символьні посилання, генеруючи канонічний шлях:

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

У кожному випадку це path/to/fileможе бути відносний або абсолютний шлях.

Використовуйте утиліту readlink з пакета coreutils.

MY_PATH=$(readlink -f "$0")

readlinkє базовим стандартом для отримання абсолютного шляху. Він також має перевагу повертати порожні рядки, якщо шляхи або шлях не існує (з огляду на прапорці).

Щоб отримати абсолютний шлях до каталогу, який може бути або не існує, але батьки якого існують, скористайтеся:

abspath=$(readlink -f $path)

Щоб отримати абсолютний шлях до каталогу, який повинен існувати разом з усіма батьками:

abspath=$(readlink -e $path)

Щоб канонізувати даний шлях і слідувати посиланнями, якщо вони трапляються, але в іншому випадку ігноруйте відсутні каталоги та просто поверніть шлях у будь-якому випадку, це:

abspath=$(readlink -m $path)

Єдиним недоліком є ​​те, що readlink буде переходити за посиланнями. Якщо ви не хочете переходити за посиланнями, ви можете скористатися цією альтернативною умовою:

abspath=$(cd ${path%/*} && echo $PWD/${path##*/})

Це дозволить chdir до частини каталогу $ path і надрукує поточну директорію разом з файловою частиною $ path. Якщо не вдасться chdir, ви отримаєте порожній рядок та помилку на stderr.

Старе питання, але є набагато простіший спосіб, якщо ви маєте справу з повними іменами шляху на рівні оболонки:

   abspath = "$ (cd" $ path "&& pwd)"

Оскільки компакт-диск трапляється в нижній частині, він не впливає на основний сценарій.

Дві варіанти, припускаючи, що ваші вбудовані команди оболонки приймають -L та -P, це:

   abspath = "$ (cd -P" $ path "&& pwd -P)" #фізичний шлях з вирішеними символьними посиланнями
   abspath = "$ (cd -L" $ path "&& pwd -L)" #логічний шлях із збереженням посилань

Особисто мені рідко потрібен такий пізніший підхід, якщо я чомусь не захоплююсь символічними посиланнями.

FYI: варіація отримання початкового каталогу скрипту, який працює навіть у тому випадку, якщо сценарій згодом змінює поточний каталог.

name0 = "$ (базове ім'я" $ 0 ")"; # base ім'я сценарію
dir0 = "$ (cd" $ (dirname "$ 0") "&& pwd)"; #absolute стартовий реж

Використання CD запевняє, що у вас завжди є абсолютна директорія, навіть якщо сценарій працює за допомогою таких команд, як ./script.sh, який без cd / pwd часто дає просто .. Марно, якщо пізніше сценарій має компакт-диск.

Як зазначав Адам Лісс realpath, не в комплекті з кожним розповсюдженням. Що соромно, бо це найкраще рішення. Наданий вихідний код чудовий, і я, мабуть, почну його використовувати вже зараз. Ось те, що я використовував дотепер, яким я поділяюсь тут лише для повноти:

get_abs_path() {
     local PARENT_DIR=$(dirname "$1")
     cd "$PARENT_DIR"
     local ABS_PATH="$(pwd)"/"$(basename "$1")"
     cd - >/dev/null
     echo "$ABS_PATH"
} 

Якщо ви хочете, щоб воно вирішило посилання, просто замініть pwdна pwd -P.

Моє недавнє рішення:

pushd foo/bar/..
dir=`pwd`
popd

На основі відповіді Тіма Віткомба.

Не зовсім відповідь, але, можливо, наступне запитання (оригінальне запитання не було явним):

readlinkдобре, якщо ви насправді хочете слідувати посиланнями. Але є також варіант використання тільки нормалізують ./і ../та //послідовностей, які можуть бути зроблені чисто синтаксично, без канонізації симлінк. readlinkце не добре для цього, і ні realpath.

for f in $paths; do (cd $f; pwd); done

працює для існуючих шляхів, але перерви для інших.

sedСценарій , здавалося б хорошим вибором, за винятком того, що ви не можете итеративно замінити послідовності ( /foo/bar/baz/../..-> /foo/bar/..-> /foo) , не використовуючи що - щось на зразок Perl, який не є безпечним припустити на всіх системах, або з допомогою якої - то потворний цикл , щоб порівняти вихід sedдо його вхід.

FWIW, однолінійний з використанням Java (JDK 6+):

jrunscript -e 'for (var i = 0; i < arguments.length; i++) {println(new java.io.File(new java.io.File(arguments[i]).toURI().normalize()))}' $paths

Я спізнююсь на вечірку, але це рішення, яке я підробив, прочитавши купу ниток на кшталт цього:

resolve_dir() {
        (builtin cd `dirname "${1/#~/$HOME}"`'/'`basename "${1/#~/$HOME}"` 2>/dev/null; if [ $? -eq 0 ]; then pwd; fi)
}

Це дозволить вирішити абсолютний шлях у $ 1, грати добре з ~, зберігати посилання на шляху, де вони є, і це не буде возитися зі стеком вашого каталогу. Він повертає повний шлях або нічого, якщо його не існує. Він очікує, що $ 1 буде каталогом і, ймовірно, не вдасться, якщо це не так, але це легко перевірити, як зробити це самостійно.

Говорена та трохи пізня відповідь. Мені потрібно написати один, оскільки я застряг на старшому RHEL4 / 5. Я обробляє абсолютні та відносні посилання та спрощує записи //, /./ та somedir /../.

test -x /usr/bin/readlink || readlink () {
        echo $(/bin/ls -l $1 | /bin/cut -d'>' -f 2)
    }


test -x /usr/bin/realpath || realpath () {
    local PATH=/bin:/usr/bin
    local inputpath=$1
    local changemade=1
    while [ $changemade -ne 0 ]
    do
        changemade=0
        local realpath=""
        local token=
        for token in ${inputpath//\// }
        do 
            case $token in
            ""|".") # noop
                ;;
            "..") # up one directory
                changemade=1
                realpath=$(dirname $realpath)
                ;;
            *)
                if [ -h $realpath/$token ] 
                then
                    changemade=1
                    target=`readlink $realpath/$token`
                    if [ "${target:0:1}" = '/' ]
                    then
                        realpath=$target
                    else
                        realpath="$realpath/$target"
                    fi
                else
                    realpath="$realpath/$token"
                fi
                ;;
            esac
        done
        inputpath=$realpath
    done
    echo $realpath
}

mkdir -p /tmp/bar
(cd /tmp ; ln -s /tmp/bar foo; ln -s ../.././usr /tmp/bar/link2usr)
echo `realpath /tmp/foo`

Спробуйте наш новий продукт із бібліотекою Bash realpath-lib, який ми розмістили на GitHub для вільного та необмеженого використання. Це ретельно задокументовано і робить чудовий інструмент навчання.

Він вирішує локальні, відносні та абсолютні шляхи і не має ніяких залежностей, окрім Bash 4+; тому воно має працювати майже де завгодно. Це безкоштовно, чисто, просто та повчально.

Ви можете зробити:

get_realpath <absolute|relative|symlink|local file path>

Ця функція є ядром бібліотеки:

function get_realpath() {

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

# reassemble realpath
echo "$tmppwd"/"${1##*/}"
return 0 # success

}

Він також містить функції get_dirname, get_filename, get_ ім'я стовбура та validate_path. Спробуйте це на різних платформах та допоможете вдосконалити його.

Проблема realpathполягає в тому, що він не доступний на BSD (або OSX для цього питання). Ось простий рецепт, витягнутий із досить старої (2009 р.) Статті з журналу Linux , який є досить портативним:

function normpath() {
  # Remove all /./ sequences.
  local path=${1//\/.\//\/}

  # Remove dir/.. sequences.
  while [[ $path =~ ([^/][^/]*/\.\./) ]]; do
    path=${path/${BASH_REMATCH[0]}/}
  done
  echo $path
}

Зауважте, що цей варіант також не вимагає існування шляху.

Виходячи з відповіді @ Andre, я можу мати трохи кращу версію, якщо хтось знайде рішення, що не має циклу, повністю на основі рядкових маніпуляцій. Це також корисно для тих, хто не хоче скинути з ладу жодні символьні посилання, що є недоліком використання realpathабо readlink -f.

Він працює на bash версії 3.2.25 і новіших.

shopt -s extglob

normalise_path() {
    local path="$1"
    # get rid of /../ example: /one/../two to /two
    path="${path//\/*([!\/])\/\.\./}"
    # get rid of /./ and //* example: /one/.///two to /one/two
    path="${path//@(\/\.\/|\/+(\/))//}"
    # remove the last '/.'
    echo "${path%%/.}"
}

$ normalise_path /home/codemedic/../codemedic////.config
/home/codemedic/.config

Спираючись на чудовий фрагмент python loveborg, я написав це:

#!/bin/sh

# Version of readlink that follows links to the end; good for Mac OS X

for file in "$@"; do
  while [ -h "$file" ]; do
    l=`readlink $file`
    case "$l" in
      /*) file="$l";;
      *) file=`dirname "$file"`/"$l"
    esac
  done
  #echo $file
  python -c "import os,sys; print os.path.abspath(sys.argv[1])" "$file"
done

FILEPATH="file.txt"
echo $(realpath $(dirname $FILEPATH))/$(basename $FILEPATH)

Це працює, навіть якщо файл не існує. Для цього потрібен каталог, що містить файл.

Мені потрібно було рішення, яке би виконало всі три:

• Робота на складі Mac. realpathі readlink -fє аддон
• Розв’яжіть символьні посилання
• Майте обробку помилок

Жодна з відповідей не мала і №1, і №2. Я додав №3, щоб врятувати інших від подальшого гоління як.

#!/bin/bash

P="${1?Specify a file path}"

[ -e "$P" ] || { echo "File does not exist: $P"; exit 1; }

while [ -h "$P" ] ; do
    ls="$(ls -ld "$P")"
    link="$(expr "$ls" : '.*-> \(.*\)$')"
    expr "$link" : '/.*' > /dev/null &&
        P="$link" ||
        P="$(dirname "$P")/$link"
done
echo "$(cd "$(dirname "$P")"; pwd)/$(basename "$P")"

Ось короткий тестовий випадок з деякими закрученими пробілами в шляхах для повного здійснення цитування

mkdir -p "/tmp/test/ first path "
mkdir -p "/tmp/test/ second path "
echo "hello" > "/tmp/test/ first path / red .txt "
ln -s "/tmp/test/ first path / red .txt " "/tmp/test/ second path / green .txt "

cd  "/tmp/test/ second path "
fullpath " green .txt "
cat " green .txt "

Я знаю, що це давнє питання. Я все ще пропоную альтернативу. Нещодавно я зустрічався з тією ж проблемою і не знайшов жодної існуючої та портативної команди для цього. Тому я написав наступний скрипт оболонки, який включає функцію, яка може виконати трюк.

#! /bin/sh                                                                                                                                                

function normalize {
  local rc=0
  local ret

  if [ $# -gt 0 ] ; then
    # invalid
    if [ "x`echo $1 | grep -E '^/\.\.'`" != "x" ] ; then
      echo $1
      return -1
    fi

    # convert to absolute path
    if [ "x`echo $1 | grep -E '^\/'`" == "x" ] ; then
      normalize "`pwd`/$1"
      return $?
    fi

    ret=`echo $1 | sed 's;/\.\($\|/\);/;g' | sed 's;/[^/]*[^/.]\+[^/]*/\.\.\($\|/\);/;g'`
  else
    read line
    normalize "$line"
    return $?
  fi

  if [ "x`echo $ret | grep -E '/\.\.?(/|$)'`" != "x" ] ; then
    ret=`normalize "$ret"`
    rc=$?
  fi

  echo "$ret"
  return $rc
}

https://gist.github.com/bestofsong/8830bdf3e5eb9461d27313c3c282868c

Я створив лише вбудовану функцію для вирішення цього питання з акцентом на максимально високу продуктивність (для розваги). Він не вирішує символьні посилання, тому він в основному такий же, як realpath -sm.

## A bash-only mimic of `realpath -sm`. 
## Give it path[s] as argument[s] and it will convert them to clean absolute paths
abspath () { 
  ${*+false} && { >&2 echo $FUNCNAME: missing operand; return 1; };
  local c s p IFS='/';  ## path chunk, absolute path, input path, IFS for splitting paths into chunks
  local -i r=0;         ## return value

  for p in "$@"; do
    case "$p" in        ## Check for leading backslashes, identify relative/absolute path
    '') ((r|=1)); continue;;
    //[!/]*)  >&2 echo "paths =~ ^//[^/]* are impl-defined; not my problem"; ((r|=2)); continue;;
    /*) ;;
    *)  p="$PWD/$p";;   ## Prepend the current directory to form an absolute path
    esac

    s='';
    for c in $p; do     ## Let IFS split the path at '/'s
      case $c in        ### NOTE: IFS is '/'; so no quotes needed here
      ''|.) ;;          ## Skip duplicate '/'s and '/./'s
      ..) s="${s%/*}";; ## Trim the previous addition to the absolute path string
      *)  s+=/$c;;      ### NOTE: No quotes here intentionally. They make no difference, it seems
      esac;
    done;

    echo "${s:-/}";     ## If xpg_echo is set, use `echo -E` or `printf $'%s\n'` instead
  done
  return $r;
}

Примітка. Ця функція не обробляє контури, починаючи з того //, що саме два подвійних косої риски на початку шляху є поведінкою. Однак він справляється /,/// і так далі просто відмінно.

Ця функція, здається, справляється з усіма крайовими справами належним чином, але там все ще можуть бути деякі, з якими я не займався.

Примітка про ефективність: коли викликається з тисячами аргументів, abspathпрацює приблизно в 10 разів повільніше realpath -sm; коли викликається одним аргументом, abspathпрацює> 110x швидше, ніж realpath -smна моїй машині, в основному через те, що не потрібно кожного разу виконувати нову програму.

Сьогодні я виявив, що ви можете використовувати stat команду для вирішення шляхів.

Отже, для каталогу типу "~ / Documents":

Ви можете запустити це:

stat -f %N ~/Documents

Щоб отримати повний шлях:

/Users/me/Documents

Для посилань ви можете скористатися параметром формату% Y:

stat -f %Y example_symlink

Що може повернути такий результат, як:

/usr/local/sbin/example_symlink

Параметри форматування можуть бути різними в інших версіях * NIX, але вони працювали для мене на OSX.

Просте рішення з використанням node.js:

#!/usr/bin/env node
process.stdout.write(require('path').resolve(process.argv[2]));