Mais uma solução, pura bash+ GNU, readlinkpara fácil utilização no seguinte contexto:
ln -s "$(relpath "$A" "$B")" "$B"
Editar: verifique se "$ B" não existe ou não possui softlink nesse caso; caso contrário, relpathsiga este link que não é o que você deseja!
Isso funciona em quase todo o Linux atual. Se readlink -mnão funcionar ao seu lado, tente readlink -f. Consulte também https://gist.github.com/hilbix/1ec361d00a8178ae8ea0 para obter possíveis atualizações:
: relpath A B
# Calculate relative path from A to B, returns true on success
# Example: ln -s "$(relpath "$A" "$B")" "$B"
relpath()
{
local X Y A
# We can create dangling softlinks
X="$(readlink -m -- "$1")" || return
Y="$(readlink -m -- "$2")" || return
X="${X%/}/"
A=""
while Y="${Y%/*}"
[ ".${X#"$Y"/}" = ".$X" ]
do
A="../$A"
done
X="$A${X#"$Y"/}"
X="${X%/}"
echo "${X:-.}"
}
Notas:
- Foi tomado cuidado para que ele seja seguro contra a expansão indesejada de metacaracteres do shell, caso os nomes de arquivos contenham
*ou ?.
- A saída deve ser usada como o primeiro argumento para
ln -s:
relpath / /dá .e não a string vaziarelpath a adá a, mesmo que aseja um diretório
- Os casos mais comuns foram testados para fornecer resultados razoáveis também.
- Esta solução usa correspondência de prefixo de string, portanto,
readlinké necessária para canonizar caminhos.
- Graças a
readlink -mele, também funciona para caminhos ainda não existentes.
Nos sistemas antigos, onde readlink -mnão está disponível, readlink -ffalhará se o arquivo não existir. Portanto, você provavelmente precisará de uma solução alternativa como esta (não testada!):
readlink_missing()
{
readlink -m -- "$1" && return
readlink -f -- "$1" && return
[ -e . ] && echo "$(readlink_missing "$(dirname "$1")")/$(basename "$1")"
}
Isso não é realmente muito correto no caso de $1incluir .ou ..para caminhos inexistentes (como em /doesnotexist/./a), mas deve cobrir a maioria dos casos.
(Substitua readlink -m --acima por readlink_missing.)
Editar por causa do voto negativo a seguir
Aqui está um teste, de que essa função, de fato, está correta:
check()
{
res="$(relpath "$2" "$1")"
[ ".$res" = ".$3" ] && return
printf ':WRONG: %-10q %-10q gives %q\nCORRECT %-10q %-10q gives %q\n' "$1" "$2" "$res" "$@"
}
# TARGET SOURCE RESULT
check "/A/B/C" "/A" ".."
check "/A/B/C" "/A.x" "../../A.x"
check "/A/B/C" "/A/B" "."
check "/A/B/C" "/A/B/C" "C"
check "/A/B/C" "/A/B/C/D" "C/D"
check "/A/B/C" "/A/B/C/D/E" "C/D/E"
check "/A/B/C" "/A/B/D" "D"
check "/A/B/C" "/A/B/D/E" "D/E"
check "/A/B/C" "/A/D" "../D"
check "/A/B/C" "/A/D/E" "../D/E"
check "/A/B/C" "/D/E/F" "../../D/E/F"
check "/foo/baz/moo" "/foo/bar" "../bar"
Intrigado? Bem, estes são os resultados corretos ! Mesmo se você acha que isso não se encaixa na pergunta, aqui está a prova de que isso está correto:
check "http://example.com/foo/baz/moo" "http://example.com/foo/bar" "../bar"
Sem dúvida, ../baré o caminho relativo exato e único correto da página barvisto a partir da página moo. Tudo o resto estaria completamente errado.
É trivial adotar a saída para a pergunta que aparentemente assume, que currenté um diretório:
absolute="/foo/bar"
current="/foo/baz/foo"
relative="../$(relpath "$absolute" "$current")"
Isso retorna exatamente o que foi solicitado.
E antes que você levante uma sobrancelha, aqui está uma variante um pouco mais complexa de relpath(identifique a pequena diferença), que também deve funcionar para a sintaxe de URL (para que uma trilha /sobreviva, graças a alguns bash-magic):
# Calculate relative PATH to the given DEST from the given BASE
# In the URL case, both URLs must be absolute and have the same Scheme.
# The `SCHEME:` must not be present in the FS either.
# This way this routine works for file paths an
: relpathurl DEST BASE
relpathurl()
{
local X Y A
# We can create dangling softlinks
X="$(readlink -m -- "$1")" || return
Y="$(readlink -m -- "$2")" || return
X="${X%/}/${1#"${1%/}"}"
Y="${Y%/}${2#"${2%/}"}"
A=""
while Y="${Y%/*}"
[ ".${X#"$Y"/}" = ".$X" ]
do
A="../$A"
done
X="$A${X#"$Y"/}"
X="${X%/}"
echo "${X:-.}"
}
E aqui estão as verificações apenas para deixar claro: ele realmente funciona como dito.
check()
{
res="$(relpathurl "$2" "$1")"
[ ".$res" = ".$3" ] && return
printf ':WRONG: %-10q %-10q gives %q\nCORRECT %-10q %-10q gives %q\n' "$1" "$2" "$res" "$@"
}
# TARGET SOURCE RESULT
check "/A/B/C" "/A" ".."
check "/A/B/C" "/A.x" "../../A.x"
check "/A/B/C" "/A/B" "."
check "/A/B/C" "/A/B/C" "C"
check "/A/B/C" "/A/B/C/D" "C/D"
check "/A/B/C" "/A/B/C/D/E" "C/D/E"
check "/A/B/C" "/A/B/D" "D"
check "/A/B/C" "/A/B/D/E" "D/E"
check "/A/B/C" "/A/D" "../D"
check "/A/B/C" "/A/D/E" "../D/E"
check "/A/B/C" "/D/E/F" "../../D/E/F"
check "/foo/baz/moo" "/foo/bar" "../bar"
check "http://example.com/foo/baz/moo" "http://example.com/foo/bar" "../bar"
check "http://example.com/foo/baz/moo/" "http://example.com/foo/bar" "../../bar"
check "http://example.com/foo/baz/moo" "http://example.com/foo/bar/" "../bar/"
check "http://example.com/foo/baz/moo/" "http://example.com/foo/bar/" "../../bar/"
E aqui está como isso pode ser usado para fornecer o resultado desejado da pergunta:
absolute="/foo/bar"
current="/foo/baz/foo"
relative="$(relpathurl "$absolute" "$current/")"
echo "$relative"
Se você encontrar algo que não funciona, entre em contato nos comentários abaixo. Obrigado.
PS:
Por que os argumentos de relpath"invertido" contrastam com todas as outras respostas aqui?
Se você mudar
Y="$(readlink -m -- "$2")" || return
para
Y="$(readlink -m -- "${2:-"$PWD"}")" || return
então você pode deixar o segundo parâmetro ausente, de modo que o BASE seja o diretório / URL atual / o que for. Esse é apenas o princípio Unix, como de costume.
Se você não gostar disso, volte ao Windows. Obrigado.