Ho due percorsi:

fred\frog

e

..\frag

Posso unirli insieme in PowerShell in questo modo:

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

Questo mi dà questo:

fred\frog\..\frag

Ma non lo voglio. Voglio un percorso normalizzato senza i doppi punti, come questo:

fred\frag

Come posso ottenerlo?

È possibile utilizzare una combinazione di pwd, Join-Pathe [System.IO.Path]::GetFullPathper ottenere un percorso espanso completo.

Poiché cd( Set-Location) non modifica la directory di lavoro corrente del processo, il semplice passaggio di un nome file relativo a un'API .NET che non comprende il contesto di PowerShell, può avere effetti collaterali indesiderati, come la risoluzione di un percorso basato sul lavoro iniziale directory (non la posizione corrente).

Quello che fai è prima qualificare il tuo percorso:

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

Questo produce (data la mia posizione attuale):

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

Con una base assoluta, è sicuro chiamare l'API .NET GetFullPath:

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

Che ti dà il percorso completo e con il ..rimosso:

C:\WINDOWS\system32\fred\frag

Non è nemmeno complicato, personalmente, disdegno le soluzioni che dipendono da script esterni per questo, è un problema semplice risolto piuttosto opportunamente da Join-Pathe pwd( GetFullPathè solo per renderlo carino). Se vuoi solo mantenere solo la parte relativa , aggiungi .Substring((pwd).Path.Trim('\').Length + 1)e voilà!

fred\frag

AGGIORNARE

Grazie a @Dangph per aver sottolineato il C:\caso limite.

Puoi espandere .. \ frag al suo percorso completo con il percorso di risoluzione:

PS > resolve-path ..\frag 

Prova a normalizzare il percorso usando il metodo combination ():

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

Puoi anche usare Path.GetFullPath , sebbene (come con la risposta di Dan R) questo ti darà l'intero percorso. L'utilizzo sarebbe il seguente:

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

o più interessante

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

entrambi producono quanto segue (assumendo che la directory corrente sia D: \):

D:\fred\frag

Nota che questo metodo non tenta di determinare se fred o frag esistono effettivamente.

La risposta accettata è stata di grande aiuto, tuttavia non "normalizza" correttamente anche un percorso assoluto. Trova di seguito il mio lavoro derivato che normalizza i percorsi sia assoluti che relativi.

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;
}

Qualsiasi funzione di manipolazione del percorso non PowerShell (come quelle in System.IO.Path) non sarà affidabile da PowerShell perché il modello di provider di PowerShell consente al percorso corrente di PowerShell di differire da ciò che Windows pensa che sia la directory di lavoro del processo.

Inoltre, come potresti aver già scoperto, i cmdlet Resolve-Path e Convert-Path di PowerShell sono utili per convertire i percorsi relativi (quelli contenenti "..") in percorsi assoluti qualificati per l'unità, ma falliscono se il percorso a cui si fa riferimento non esiste.

Il seguente cmdlet molto semplice dovrebbe funzionare per percorsi inesistenti. Convertirà "fred \ frog \ .. \ frag" in "d: \ fred \ frag" anche se non è possibile trovare un file o una cartella "fred" o "frag" (e l'unità PowerShell corrente è "d:") .

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

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

Questa libreria è buona: NDepend.Helpers.FileDirectoryPath .

EDIT: Questo è quello che mi è venuto in mente:

[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
}

Chiamalo così:

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

Tieni presente che questo frammento richiede il percorso della DLL. C'è un trucco che puoi usare per trovare la cartella contenente lo script attualmente in esecuzione, ma nel mio caso avevo una variabile d'ambiente che potevo usare, quindi l'ho usata.

Questo dà il percorso completo:

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

Questo fornisce il percorso relativo alla directory corrente:

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

Per qualche motivo funzionano solo se fragè un file, non un file directory.

Crea una funzione. Questa funzione normalizzerà un percorso che non esiste sul tuo sistema e non aggiungerà lettere di unità.

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'

Grazie a Oliver Schadlich per l'aiuto nelle RegEx.

Se il percorso include un qualificatore (lettera di unità), la risposta di x0n a Powershell: risolvere il percorso che potrebbe non esistere? normalizzerà il percorso. Se il percorso non include il qualificatore, verrà comunque normalizzato ma restituirà il percorso completo relativo alla directory corrente, che potrebbe non essere quello desiderato.

$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

Se è necessario eliminare la parte .., è possibile utilizzare un oggetto System.IO.DirectoryInfo. Usa "fred \ frog .. \ frag" nel costruttore. La proprietà FullName ti darà il nome della directory normalizzato.

L'unico inconveniente è che ti darà l'intero percorso (ad esempio c: \ test \ fred \ frag).

Le parti utili dei commenti qui combinate in modo tale da unificare i percorsi relativi e assoluti:

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

Alcuni esempi:

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

produzione:

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

Bene, un modo sarebbe:

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

Aspetta, forse ho frainteso la domanda. Nel tuo esempio, frag è una sottocartella di frog?