Ich habe zwei Wege:

fred\frog

und

..\frag

Ich kann sie in PowerShell folgendermaßen zusammenfügen:

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

Das gibt mir folgendes:

fred\frog\..\frag

Aber das will ich nicht. Ich möchte einen normalisierten Pfad ohne die doppelten Punkte, wie folgt:

fred\frag

Wie kann ich das bekommen?

Sie können eine Kombination von verwenden pwd, Join-Pathund [System.IO.Path]::GetFullPatheinen vollständig qualifizierten gespreizten Weg zu bekommen.

Da cd( Set-Location) das aktuelle Arbeitsverzeichnis des Prozesses nicht ändert, kann die einfache Übergabe eines relativen Dateinamens an eine .NET-API, die den PowerShell-Kontext nicht versteht, unbeabsichtigte Nebenwirkungen haben, z. B. das Auflösen in einen Pfad, der auf der anfänglichen Arbeit basiert Verzeichnis (nicht Ihr aktueller Standort).

Was Sie tun, ist, dass Sie zuerst Ihren Weg qualifizieren:

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

Dies ergibt (angesichts meines aktuellen Standorts):

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

Mit einer absoluten Basis ist es sicher, die .NET-API aufzurufen GetFullPath:

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

Welches gibt Ihnen den voll qualifizierten Weg und mit dem ..entfernten:

C:\WINDOWS\system32\fred\frag

Es ist auch nicht kompliziert, persönlich, ich verachte die Lösungen, die von externen Skripten abhängen, es ist ein einfaches Problem, das ziemlich treffend durch Join-Pathund gelöst wird pwd( GetFullPathnur um es hübsch zu machen). Wenn Sie nur den relativen Teil behalten möchten, fügen Sie einfach hinzu .Substring((pwd).Path.Trim('\').Length + 1)und voila!

fred\frag

AKTUALISIEREN

Vielen Dank an @Dangph für den Hinweis auf den Randfall C:\.

Sie können .. \ frag mit dem Auflösungspfad auf den vollständigen Pfad erweitern:

PS > resolve-path ..\frag 

Versuchen Sie, den Pfad mit der Methode comb () zu normalisieren:

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

Sie können auch Path.GetFullPath verwenden , obwohl dies (wie bei der Antwort von Dan R) den gesamten Pfad angibt . Die Verwendung wäre wie folgt:

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

oder interessanter

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

Beide ergeben Folgendes (vorausgesetzt, Ihr aktuelles Verzeichnis ist D: \):

D:\fred\frag

Beachten Sie, dass diese Methode nicht versucht festzustellen, ob Fred oder Frag tatsächlich vorhanden sind.

Die akzeptierte Antwort war eine große Hilfe, aber sie "normalisiert" auch einen absoluten Pfad nicht richtig. Finden Sie unten meine abgeleitete Arbeit, die sowohl absolute als auch relative Pfade normalisiert.

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

Alle Funktionen zur Manipulation von Nicht-PowerShell-Pfaden (z. B. in System.IO.Path) sind in PowerShell nicht zuverlässig, da das PowerShell-Anbietermodell es ermöglicht, dass der aktuelle Pfad von PowerShell von dem abweicht, was Windows für das Arbeitsverzeichnis des Prozesses hält.

Wie Sie vielleicht bereits festgestellt haben, sind die Cmdlets Resolve-Path und Convert-Path von PowerShell nützlich, um relative Pfade (solche mit '..') in Laufwerk-qualifizierte absolute Pfade zu konvertieren. Sie schlagen jedoch fehl, wenn der angegebene Pfad nicht vorhanden ist.

Das folgende sehr einfache Cmdlet sollte für nicht vorhandene Pfade funktionieren. Es konvertiert 'fred \ frog \ .. \ frag' in 'd: \ fred \ frag', auch wenn eine 'fred'- oder' frag'-Datei oder ein Ordner nicht gefunden werden kann (und das aktuelle PowerShell-Laufwerk 'd:' ist). .

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

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

Diese Bibliothek ist gut: NDepend.Helpers.FileDirectoryPath .

EDIT: Das habe ich mir ausgedacht :

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

Nennen Sie es so:

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

Beachten Sie, dass für dieses Snippet der Pfad zur DLL erforderlich ist. Es gibt einen Trick, mit dem Sie den Ordner finden können, der das aktuell ausgeführte Skript enthält, aber in meinem Fall hatte ich eine Umgebungsvariable, die ich verwenden konnte, also habe ich diese einfach verwendet.

Dies gibt den vollständigen Weg:

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

Dies gibt den Pfad relativ zum aktuellen Verzeichnis an:

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

Aus irgendeinem Grund funktionieren sie nur, wenn frages sich um eine Datei handelt, nicht um eine directory.

Erstellen Sie eine Funktion. Diese Funktion normalisiert einen Pfad, der auf Ihrem System nicht vorhanden ist, und fügt keine Laufwerksbuchstaben hinzu.

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'

Vielen Dank an Oliver Schadlich für die Hilfe bei der RegEx.

Wenn der Pfad ein Qualifikationsmerkmal (Laufwerksbuchstabe) enthält, lautet die Antwort von x0n auf Powershell: Pfad auflösen, der möglicherweise nicht vorhanden ist? normalisiert den Pfad. Wenn der Pfad das Qualifikationsmerkmal nicht enthält, wird er weiterhin normalisiert, gibt jedoch den vollständig qualifizierten Pfad relativ zum aktuellen Verzeichnis zurück, was möglicherweise nicht Ihren Wünschen entspricht.

$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

Wenn Sie den Teil .. entfernen müssen, können Sie ein System.IO.DirectoryInfo-Objekt verwenden. Verwenden Sie im Konstruktor 'fred \ frog .. \ frag'. Die FullName-Eigenschaft gibt Ihnen den normalisierten Verzeichnisnamen.

Der einzige Nachteil ist, dass Sie den gesamten Pfad erhalten (z. B. c: \ test \ fred \ frag).

Die zweckmäßigen Teile der Kommentare hier wurden so kombiniert, dass sie relative und absolute Pfade vereinen:

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

Einige Beispiele:

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

Ausgabe:

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

Ein Weg wäre:

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

Warten Sie, vielleicht verstehe ich die Frage falsch. Ist frag in Ihrem Beispiel ein Unterordner von Frosch?