Tengo dos caminos:

fred\frog

y

..\frag

Puedo unirlos en PowerShell de esta manera:

join-path 'fred\frog' '..\frag'

Eso me da esto:

fred\frog\..\frag

Pero yo no quiero eso. Quiero una ruta normalizada sin los puntos dobles, como este:

fred\frag

¿Cómo puedo conseguirlo?

Se puede utilizar una combinación de pwd, Join-Pathy [System.IO.Path]::GetFullPathpara obtener una ruta ampliada completo.

Dado que cd( Set-Location) no cambia el directorio de trabajo actual del proceso, simplemente pasar un nombre de archivo relativo a una API .NET que no comprende el contexto de PowerShell puede tener efectos secundarios no deseados, como resolver una ruta basada en el trabajo inicial. directorio (no su ubicación actual).

Lo que haces es primero calificar tu camino:

Join-Path (Join-Path (pwd) fred\frog) '..\frag'

Esto produce (dada mi ubicación actual):

C:\WINDOWS\system32\fred\frog\..\frag

Con una base absoluta, es seguro llamar a la API .NET GetFullPath:

[System.IO.Path]::GetFullPath((Join-Path (Join-Path (pwd) fred\frog) '..\frag'))

Lo que le brinda la ruta completamente calificada y con lo ..eliminado:

C:\WINDOWS\system32\fred\frag

Tampoco es complicado, personalmente, desdeño las soluciones que dependen de scripts externos para esto, es un problema simple resuelto con bastante acierto por Join-Pathy pwd( GetFullPathes solo para hacerlo bonito). Si solo desea conservar solo la parte relativa , simplemente agregue .Substring((pwd).Path.Trim('\').Length + 1)y ¡listo!

fred\frag

ACTUALIZAR

Gracias a @Dangph por señalar el C:\caso de borde.

Puede expandir .. \ frag a su ruta completa con resolve-path:

PS > resolve-path ..\frag 

Intente normalizar la ruta usando el método combine ():

[io.path]::Combine("fred\frog",(resolve-path ..\frag).path)

También puede usar Path.GetFullPath , aunque (como con la respuesta de Dan R) esto le dará la ruta completa. El uso sería el siguiente:

[IO.Path]::GetFullPath( "fred\frog\..\frag" )

o más interesante

[IO.Path]::GetFullPath( (join-path "fred\frog" "..\frag") )

ambos producen lo siguiente (asumiendo que su directorio actual es D: \):

D:\fred\frag

Tenga en cuenta que este método no intenta determinar si fred o frag realmente existen.

La respuesta aceptada fue de gran ayuda, sin embargo, tampoco 'normaliza' adecuadamente una ruta absoluta. Encuentre a continuación mi trabajo derivado que normaliza rutas absolutas y relativas.

function Get-AbsolutePath ($Path)
{
    # System.IO.Path.Combine has two properties making it necesarry here:
    #   1) correctly deals with situations where $Path (the second term) is an absolute path
    #   2) correctly deals with situations where $Path (the second term) is relative
    # (join-path) commandlet does not have this first property
    $Path = [System.IO.Path]::Combine( ((pwd).Path), ($Path) );

    # this piece strips out any relative path modifiers like '..' and '.'
    $Path = [System.IO.Path]::GetFullPath($Path);

    return $Path;
}

Cualquier función de manipulación de ruta que no sea de PowerShell (como las de System.IO.Path) no será confiable desde PowerShell porque el modelo de proveedor de PowerShell permite que la ruta actual de PowerShell difiera de lo que Windows cree que es el directorio de trabajo del proceso.

Además, como ya habrá descubierto, los cmdlets Resolve-Path y Convert-Path de PowerShell son útiles para convertir rutas relativas (las que contienen '..' s) en rutas absolutas calificadas por la unidad, pero fallan si la ruta a la que se hace referencia no existe.

El siguiente cmdlet muy simple debería funcionar para rutas inexistentes. Convertirá 'fred \ frog \ .. \ frag' a 'd: \ fred \ frag' incluso si no se puede encontrar un archivo o carpeta 'fred' o 'frag' (y la unidad PowerShell actual es 'd:') .

function Get-AbsolutePath {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, ValueFromPipeline = $true, ValueFromPipelineByPropertyName = $true)]
        [string[]]
        $Path
    )

    process {
        $Path | ForEach-Object {
            $PSCmdlet.SessionState.Path.GetUnresolvedProviderPathFromPSPath($_)
        }
    }
}

Esta biblioteca es buena: NDepend.Helpers.FileDirectoryPath .

EDITAR: Esto es lo que se me ocurrió:

[Reflection.Assembly]::LoadFrom("path\to\NDepend.Helpers.FileDirectoryPath.dll") | out-null

Function NormalizePath ($path)
{
    if (-not $path.StartsWith('.\'))  # FilePathRelative requires relative paths to begin with '.'
    {
        $path = ".\$path"
    }

    if ($path -eq '.\.')  # FilePathRelative can't deal with this case
    {
        $result = '.'
    }
    else
    {
        $relPath = New-Object NDepend.Helpers.FileDirectoryPath.FilePathRelative($path)
        $result = $relPath.Path
    }

    if ($result.StartsWith('.\')) # remove '.\'. 
    {
        $result = $result.SubString(2)
    }

    $result
}

Llámalo así:

> NormalizePath "fred\frog\..\frag"
fred\frag

Tenga en cuenta que este fragmento requiere la ruta a la DLL. Hay un truco que puede usar para encontrar la carpeta que contiene el script que se está ejecutando actualmente, pero en mi caso tenía una variable de entorno que podía usar, así que simplemente la usé.

Esto da la ruta completa:

(gci 'fred\frog\..\frag').FullName

Esto da la ruta relativa al directorio actual:

(gci 'fred\frog\..\frag').FullName.Replace((gl).Path + '\', '')

Por alguna razón, solo funcionan si frages un archivo, no un directory.

Crea una función. Esta función normalizará una ruta que no existe en su sistema y no agregará letras de unidades.

function RemoveDotsInPath {
  [cmdletbinding()]
  Param( [Parameter(Position=0,  Mandatory=$true)] [string] $PathString = '' )

  $newPath = $PathString -creplace '(?<grp>[^\n\\]+\\)+(?<-grp>\.\.\\)+(?(grp)(?!))', ''
  return $newPath
}

Ex:

$a = 'fooA\obj\BusinessLayer\..\..\bin\BusinessLayer\foo.txt'
RemoveDotsInPath $a
'fooA\bin\BusinessLayer\foo.txt'

Gracias a Oliver Schadlich por su ayuda en la RegEx.

Si la ruta incluye un calificador (letra de unidad), entonces la respuesta de x0n a Powershell: ¿resolver la ruta que podría no existir? normalizará el camino. Si la ruta no incluye el calificador, aún se normalizará, pero devolverá la ruta completamente calificada en relación con el directorio actual, que puede no ser lo que desea.

$p = 'X:\fred\frog\..\frag'
$ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($p)
X:\fred\frag

$p = '\fred\frog\..\frag'
$ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($p)
C:\fred\frag

$p = 'fred\frog\..\frag'
$ExecutionContext.SessionState.Path.GetUnresolvedProviderPathFromPSPath($p)
C:\Users\WileCau\fred\frag

Si necesita deshacerse de la parte .., puede usar un objeto System.IO.DirectoryInfo. Use 'fred \ frog .. \ frag' en el constructor. La propiedad FullName le dará el nombre del directorio normalizado.

El único inconveniente es que le dará la ruta completa (por ejemplo, c: \ test \ fred \ frag).

Las partes convenientes de los comentarios aquí se combinan de manera que unifican caminos relativos y absolutos:

[System.IO.Directory]::SetCurrentDirectory($pwd)
[IO.Path]::GetFullPath($dapath)

Algunas muestras:

$fps = '.', 'file.txt', '.\file.txt', '..\file.txt', 'c:\somewhere\file.txt'
$fps | % { [IO.Path]::GetFullPath($_) }

salida:

C:\Users\thelonius\tests
C:\Users\thelonius\tests\file.txt
C:\Users\thelonius\tests\file.txt
C:\Users\thelonius\file.txt
c:\somewhere\file.txt

Bueno, una forma sería:

Join-Path 'fred\frog' '..\frag'.Replace('..', '')

Espera, quizás no entiendo bien la pregunta. En su ejemplo, ¿frag es una subcarpeta de frog?