¿Cómo unir cadenas de ruta del sistema de archivos en PHP?

function join_paths() {
    $paths = array();

    foreach (func_get_args() as $arg) {
        if ($arg !== '') { $paths[] = $arg; }
    }

    return preg_replace('#/+#','/',join('/', $paths));
}

Mi solución es más simple y más similar a la forma en que Python os.camino.join works

Considere estos casos de prueba

array               my version    @deceze      @david_miller    @mark

['','']             ''            ''           '/'              '/'
['','/']            '/'           ''           '/'              '/'
['/','a']           '/a'          'a'          '//a'            '/a'
['/','/a']          '/a'          'a'          '//a'            '//a'
['abc','def']       'abc/def'     'abc/def'    'abc/def'        'abc/def'
['abc','/def']      'abc/def'     'abc/def'    'abc/def'        'abc//def'
['/abc','def']      '/abc/def'    'abc/def'    '/abc/def'       '/abc/def'
['','foo.jpg']      'foo.jpg'     'foo.jpg'    '/foo.jpg'       '/foo.jpg'
['dir','0','a.jpg'] 'dir/0/a.jpg' 'dir/a.jpg'  'dir/0/a.jpg'    'dir/0/a.txt'

La función de@deceze no mantiene el principio / cuando intenta unirse a una ruta que comienza con una ruta absoluta de Unix, por ejemplo, joinPaths('/var/www', '/vhosts/site');.

function unix_path() {
  $args = func_get_args();
  $paths = array();

  foreach($args as $arg) {
    $paths = array_merge($paths, (array)$arg);
  }

  foreach($paths as &$path) {
    $path = trim($path, '/');
  }

  if (substr($args[0], 0, 1) == '/') {
    $paths[0] = '/' . $paths[0];
  }

  return join('/', $paths);
}

Mi opinión:

function trimds($s) {
    return rtrim($s,DIRECTORY_SEPARATOR);
}

function joinpaths() {
    return implode(DIRECTORY_SEPARATOR, array_map('trimds', func_get_args()));
}

Habría usado una función anónima para trimds, pero las versiones anteriores de PHP no lo soportan.

Ejemplo:

join_paths('a','\\b','/c','d/','/e/','f.jpg'); // a\b\c\d\e\f.jpg (on Windows)

Actualizado Abril 2013 Marzo 2014 Mayo 2018:

function join_paths(...$paths) {
    return preg_replace('~[/\\\\]+~', DIRECTORY_SEPARATOR, implode(DIRECTORY_SEPARATOR, $paths));
}

Este corregirá las barras para que coincidan con su sistema operativo, no eliminará una barra diagonal y limpiará varias barras en una fila.

Una alternativa es usar implode() y explode().

$a = '/a/bc/def/';
$b = '/q/rs/tuv/path.xml';

$path = implode('/',array_filter(explode('/', $a . $b)));

echo $path;  // -> a/bc/def/q/rs/tuv/path.xml

Si sabe que el archivo/directorio existe , puede agregar barras adicionales (que pueden ser innecesarias), luego llame a realpath, es decir,

realpath(join('/', $parts));

Esto, por supuesto, no es lo mismo que la versión de Python, pero en muchos casos puede ser lo suficientemente bueno.

Para obtener partes de rutas puede usar pathinfo http://nz2.php.net/manual/en/function.pathinfo.php

Para unirse a la respuesta de @deceze se ve bien

Una forma diferente de atacar a este:

function joinPaths() {
  $paths = array_filter(func_get_args());
  return preg_replace('#/{2,}#', '/', implode('/', $paths));
}

Esta es una versión corregida de la función publicada por deceze. Sin este cambio, joinPaths ( " , ' foo.jpg') se convierte en ' / foo.jpg "

function joinPaths() {
    $args = func_get_args();
    $paths = array();
    foreach ($args as $arg)
        $paths = array_merge($paths, (array)$arg);

    $paths2 = array();
    foreach ($paths as $i=>$path)
    {   $path = trim($path, '/');
        if (strlen($path))
            $paths2[]= $path;
    }
    $result = join('/', $paths2); // If first element of old path was absolute, make this one absolute also
    if (strlen($paths[0]) && substr($paths[0], 0, 1) == '/')
        return '/'.$result;
    return $result;
}

Esto parece ser un trabajo bastante bien, y me parece razonablemente limpio.

private function JoinPaths() {
  $slash = DIRECTORY_SEPARATOR;
  $sections = preg_split(
          "@[/\\\\]@",
          implode('/', func_get_args()),
          null,
          PREG_SPLIT_NO_EMPTY);
  return implode($slash, $sections);
}

Mejor solución encontrada:

function joinPaths($leftHandSide, $rightHandSide) { 
    return rtrim($leftHandSide, '/') .'/'. ltrim($rightHandSide, '/'); 
}

NOTA: Copiado del comentario por user89021

La solución a continuación utiliza la lógica propuesta por @RiccardoGalli, pero se mejora para aprovechar la constante DIRECTORY_SEPARATOR, como sugirieron @Qix y @FélixSaparelli, y, más importante, para recortar cada elemento dado para evitar que aparezcan nombres de carpetas solo de espacio en la ruta final (era un requisito en mi caso).

Con respecto al escape del separador de directorios dentro del patrón preg_replace(), como puede ver, usé la función preg_quote() que hace el trabajo bien.
Además, yo reemplazaría solo separadores múltiples (cuantificador de expresiones regulares {2,}).

// PHP 7.+
function paths_join(string ...$parts): string {
    $parts = array_map('trim', $parts);
    $path = [];

    foreach ($parts as $part) {
        if ($part !== '') {
            $path[] = $part;
        }
    }

    $path = implode(DIRECTORY_SEPARATOR, $path);

    return preg_replace(
        '#' . preg_quote(DIRECTORY_SEPARATOR) . '{2,}#',
        DIRECTORY_SEPARATOR,
        $path
    );
}

Aquí hay una función que se comporta como el nodo path.resolve:

function resolve_path() {
    $working_dir = getcwd();
    foreach(func_get_args() as $p) {
        if($p === null || $p === '') continue;
        elseif($p[0] === '/') $working_dir = $p;
        else $working_dir .= "/$p";
    }
    $working_dir = preg_replace('~/{2,}~','/', $working_dir);
    if($working_dir === '/') return '/';
    $out = [];
    foreach(explode('/',rtrim($working_dir,'/')) as $p) {
        if($p === '.') continue;
        if($p === '..') array_pop($out);
        else $out[] = $p;
    }
    return implode('/',$out);
}

Casos de prueba:

resolve_path('/foo/bar','./baz')         # /foo/bar/baz
resolve_path('/foo/bar','/tmp/file/')    # /tmp/file
resolve_path('/foo/bar','/tmp','file')   # /tmp/file
resolve_path('/foo//bar/../baz')         # /foo/baz
resolve_path('/','foo')                  # /foo
resolve_path('/','foo','/')              # /
resolve_path('wwwroot', 'static_files/png/', '../gif/image.gif') 
                                  # __DIR__.'/wwwroot/static_files/gif/image.gif'

De la gran respuesta de Ricardo Galli, un poco de mejora para evitar matar el prefijo del protocolo.

La idea es probar la presencia de un protocolo en un argumento, y mantenerlo en el resultado. ADVERTENCIA: ¡esta es una implementación ingenua!

Por ejemplo:

array("http://domain.de","/a","/b/")

Resultados para (mantener el protocolo)

"http://domain.de/a/b/"

En lugar de (matar protocolo)

"http:/domain.de/a/b/"

Pero http://codepad.org/hzpWmpzk necesita una mejor habilidad para escribir código.

Me gustaron varias soluciones presentadas. Pero aquellos que reemplazan todo '/ + ' en ' / ' (expresiones regulares) están olvidando ese sistema operativo.camino.join() de python puede manejar este tipo de join:

os.path.join('http://example.com/parent/path', 'subdir/file.html')

Resultado: 'http://example.com/parent/path/subdir/file.html'