Получение относительного пути из абсолютного пути в PHP

Question

Я заметил несколько похожих вопросов об этой проблеме, когда набирал заголовок, но, похоже, их нет в PHP. Так каково его решение с помощью функции PHP?

Указать.

$a="/home/apache/a/a.php";
$b="/home/root/b/b.php";
$relpath = getRelativePath($a,$b); //needed function,should return '../../root/b/b.php'

Есть хорошие идеи? Спасибо.

Answer 1

Попробуйте это:

function getRelativePath($from, $to)
{
    // some compatibility fixes for Windows paths
    $from = is_dir($from) ? rtrim($from, '\/') . '/' : $from;
    $to   = is_dir($to)   ? rtrim($to, '\/') . '/'   : $to;
    $from = str_replace('\\', '/', $from);
    $to   = str_replace('\\', '/', $to);

    $from     = explode('/', $from);
    $to       = explode('/', $to);
    $relPath  = $to;

    foreach($from as $depth => $dir) {
        // find first non-matching dir
        if($dir === $to[$depth]) {
            // ignore this directory
            array_shift($relPath);
        } else {
            // get number of remaining dirs to $from
            $remaining = count($from) - $depth;
            if($remaining > 1) {
                // add traversals up to first matching dir
                $padLength = (count($relPath) + $remaining - 1) * -1;
                $relPath = array_pad($relPath, $padLength, '..');
                break;
            } else {
                $relPath[0] = './' . $relPath[0];
            }
        }
    }
    return implode('/', $relPath);
}

Это даст

$a="/home/a.php";
$b="/home/root/b/b.php";
echo getRelativePath($a,$b), PHP_EOL;  // ./root/b/b.php

и

$a="/home/apache/a/a.php";
$b="/home/root/b/b.php";
echo getRelativePath($a,$b), PHP_EOL; // ../../root/b/b.php

и

$a="/home/root/a/a.php";
$b="/home/apache/htdocs/b/en/b.php";
echo getRelativePath($a,$b), PHP_EOL; // ../../apache/htdocs/b/en/b.php

и

$a="/home/apache/htdocs/b/en/b.php";
$b="/home/root/a/a.php";
echo getRelativePath($a,$b), PHP_EOL; // ../../../../root/a/a.php

Answer 2

Поскольку у нас было несколько ответов, я решил проверить их все и сравнить их. Я использовал эти пути для проверки:

$from = "/var/www/sites/web/mainroot/webapp/folder/sub/subf/subfo/subfol/subfold/lastfolder/"; ПРИМЕЧАНИЕ: если это папка, вы должны поставить косую черту, чтобы функции работали правильно! Итак, __DIR__ не будет работать. Используйте __FILE__ вместо или __DIR__ . '/'

$to = "/var/www/sites/web/mainroot/webapp/folder/aaa/bbb/ccc/ddd";

РЕЗУЛЬТАТЫ: (десятичный разделитель - запятая, разделитель тысяч - точка)

• Функция Гордона: результат ПРАВИЛЬНО , время для 100.000 execs 1,222 секунд
• Функция по Юнгу: результат ПРАВИЛЬНО , время для 100 000 execs 1540 секунд
• Функция Ceagle: результат НЕПРАВИЛЬНО (он работает с некоторыми путями, но не работает с некоторыми другими, такими как те, которые использовались в тестах и ​​написаны выше)
• Функция от Loranger: результат НЕПРАВИЛЬНО (он работает с некоторыми путями, но не работает с некоторыми другими, такими как те, которые использовались в тестах и ​​написаны выше)

Итак, я предлагаю вам использовать реализацию Гордона! (помеченный как ответ)

Модель Юнга тоже хороша и работает лучше с простыми структурами каталогов (например, "a / b / c.php"), в то время как модель Гордона работает лучше со сложными структурами, с большим количеством подкаталогов (как те, которые используются в этом тесте) .

---

ПРИМЕЧАНИЕ: ниже я пишу результаты, возвращаемые с $from и $to в качестве входных данных, чтобы вы могли проверить, что 2 из них в порядке, а 2 других не верны:

• Гордон: ../../../../../../aaa/bbb/ccc/ddd -> ПРАВИЛЬНО
• Молодые: ../../../../../../aaa/bbb/ccc/ddd -> ПРАВИЛЬНО
• Ceagle: ../../../../../../bbb/ccc/ddd -> НЕПРАВИЛЬНО
• Loranger: ../../../../../aaa/bbb/ccc/ddd -> НЕПРАВИЛЬНО

Answer 3

Относительный путь? Это больше похоже на путь путешествия. Похоже, вы хотите знать путь, по которому вы идете от пути A к пути B. Если это так, вы можете взорвать $ a и $ b на '/', затем выполнить обратный цикл по $ aParts сравнивая их с $ bParts того же индекса, пока не будет найден каталог «общий знаменатель» (записывая количество циклов по пути). Затем создайте пустую строку и добавьте к ней '../' $ numLoops-1 раз, затем добавьте к этому $ b минус каталог общего знаменателя.

Answer 4

const DS = DIRECTORY_SEPARATOR; // for convenience

function getRelativePath($from, $to) {
    $dir = explode(DS, is_file($from) ? dirname($from) : rtrim($from, DS));
    $file = explode(DS, $to);

    while ($dir && $file && ($dir[0] == $file[0])) {
        array_shift($dir);
        array_shift($file);
    }
    return str_repeat('..'.DS, count($dir)) . implode(DS, $file);
}

Моя попытка намеренно проще, хотя, вероятно, не отличается по производительности. Я оставлю бенчмаркинг в качестве упражнения для любознательного читателя. Однако это достаточно надежно и должно быть независимым от платформы.

Остерегайтесь решений, использующих функции array_intersect, поскольку они сломаются, если параллельные каталоги имеют одинаковые имена. Например, getRelativePath('start/A/end/', 'start/B/end/') вернет "../end", потому что array_intersect находит все одинаковые имена, в данном случае 2, когда должно быть только 1.

Answer 5

Этот код взят из генератора URL Symfony https://github.com/symfony/Routing/blob/master/Generator/UrlGenerator.php

    /**
     * Returns the target path as relative reference from the base path.
     *
     * Only the URIs path component (no schema, host etc.) is relevant and must be given, starting with a slash.
     * Both paths must be absolute and not contain relative parts.
     * Relative URLs from one resource to another are useful when generating self-contained downloadable document archives.
     * Furthermore, they can be used to reduce the link size in documents.
     *
     * Example target paths, given a base path of "/a/b/c/d":
     * - "/a/b/c/d"     -> ""
     * - "/a/b/c/"      -> "./"
     * - "/a/b/"        -> "../"
     * - "/a/b/c/other" -> "other"
     * - "/a/x/y"       -> "../../x/y"
     *
     * @param string $basePath   The base path
     * @param string $targetPath The target path
     *
     * @return string The relative target path
     */
    function getRelativePath($basePath, $targetPath)
    {
        if ($basePath === $targetPath) {
            return '';
        }

        $sourceDirs = explode('/', isset($basePath[0]) && '/' === $basePath[0] ? substr($basePath, 1) : $basePath);
        $targetDirs = explode('/', isset($targetPath[0]) && '/' === $targetPath[0] ? substr($targetPath, 1) : $targetPath);
        array_pop($sourceDirs);
        $targetFile = array_pop($targetDirs);

        foreach ($sourceDirs as $i => $dir) {
            if (isset($targetDirs[$i]) && $dir === $targetDirs[$i]) {
                unset($sourceDirs[$i], $targetDirs[$i]);
            } else {
                break;
            }
        }

        $targetDirs[] = $targetFile;
        $path = str_repeat('../', count($sourceDirs)).implode('/', $targetDirs);

        // A reference to the same base directory or an empty subdirectory must be prefixed with "./".
        // This also applies to a segment with a colon character (e.g., "file:colon") that cannot be used
        // as the first segment of a relative-path reference, as it would be mistaken for a scheme name
        // (see http://tools.ietf.org/html/rfc3986#section-4.2).
        return '' === $path || '/' === $path[0]
            || false !== ($colonPos = strpos($path, ':')) && ($colonPos < ($slashPos = strpos($path, '/')) || false === $slashPos)
            ? "./$path" : $path;
    }

Answer 6

Основываясь на функции Гордона, мое решение выглядит следующим образом:

function getRelativePath($from, $to)
{
   $from = explode('/', $from);
   $to = explode('/', $to);
   foreach($from as $depth => $dir)
   {

        if(isset($to[$depth]))
        {
            if($dir === $to[$depth])
            {
               unset($to[$depth]);
               unset($from[$depth]);
            }
            else
            {
               break;
            }
        }
    }
    //$rawresult = implode('/', $to);
    for($i=0;$i<count($from)-1;$i++)
    {
        array_unshift($to,'..');
    }
    $result = implode('/', $to);
    return $result;
}

Answer 7

Я пришел к тому же результату, используя эти манипуляции с массивами:

function getRelativePath($path, $from = __FILE__ )
{
    $path = explode(DIRECTORY_SEPARATOR, $path);
    $from = explode(DIRECTORY_SEPARATOR, dirname($from.'.'));
    $common = array_intersect_assoc($path, $from);

    $base = array('.');
    if ( $pre_fill = count( array_diff_assoc($from, $common) ) ) {
        $base = array_fill(0, $pre_fill, '..');
    }
    $path = array_merge( $base, array_diff_assoc($path, $common) );
    return implode(DIRECTORY_SEPARATOR, $path);
}

Второй аргумент - это файл, к которому относится путь. Это необязательно, поэтому вы можете получить относительный путь независимо от того, какая веб-страница у вас есть. Чтобы использовать его с примером @Young или @Gordon, поскольку вы хотите узнать относительный путь к $ b из $ a, вам нужно будет использовать

getRelativePath($b, $a);

Answer 8

По какой-то причине Гордон не работает для меня ... Вот мое решение

function getRelativePath($from, $to) {
    $patha = explode('/', $from);
    $pathb = explode('/', $to);
    $start_point = count(array_intersect($patha,$pathb));
    while($start_point--) {
        array_shift($patha);
        array_shift($pathb);
    }
    $output = "";
    if(($back_count = count($patha))) {
        while($back_count--) {
            $output .= "../";
        }
    } else {
        $output .= './';
    }
    return $output . implode('/', $pathb);
}

Answer 9

Вот что у меня работает. По какой-то неизвестной причине ответ на этот вопрос с наибольшим количеством голосов не сработал, как ожидалось

public function getRelativePath($absolutePathFrom, $absolutePathDestination)
{
    $absolutePathFrom = is_dir($absolutePathFrom) ? rtrim($absolutePathFrom, "\/")."/" : $absolutePathFrom;
    $absolutePathDestination = is_dir($absolutePathDestination) ? rtrim($absolutePathDestination, "\/")."/" : $absolutePathDestination;
    $absolutePathFrom = explode("/", str_replace("\\", "/", $absolutePathFrom));
    $absolutePathDestination = explode("/", str_replace("\\", "/", $absolutePathDestination));
    $relativePath = "";
    $path = array();
    $_key = 0;
    foreach($absolutePathFrom as $key => $value)
    {
        if (strtolower($value) != strtolower($absolutePathDestination[$key]))
        {
            $_key = $key + 1;
            for ($i = $key; $i < count($absolutePathDestination); $i++)
            {
                $path[] = $absolutePathDestination[$i];
            }
            break;
        }
    }
    for ($i = 0; $i <= (count($absolutePathFrom) - $_key - 1); $i++)
    {
        $relativePath .= "../";
    }

    return $relativePath.implode("/", $path);
}

если $a = "C:\xampp\htdocs\projects\SMS\App\www\App\index.php" и
$b = "C:\xampp\htdocs\projects\SMS\App/www/App/bin/bootstrap/css/bootstrap.min.css"

Тогда $c, который является относительным путем $b от $a, будет

$c = getRelativePath($a, $b) = "bin/bootstrap/css/bootstrap.min.css"

Answer 10

Простой однострочник для распространенных сценариев:

str_replace(getcwd() . DIRECTORY_SEPARATOR, '', $filepath)

или

substr($filepath, strlen(getcwd())+1)

Чтобы проверить, является ли путь абсолютным, попробуйте:

$filepath[0] == DIRECTORY_SEPARATOR