İki yolum var:

fred\frog

ve

..\frag

Onları PowerShell'de şu şekilde birleştirebilirim:

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

Bu bana şunu veriyor:

fred\frog\..\frag

Ama bunu istemiyorum. Çift nokta içermeyen normalleştirilmiş bir yol istiyorum, şöyle:

fred\frag

Bunu nasıl elde edebilirim?

Sen bir arada kullanabilir pwd, Join-Pathve [System.IO.Path]::GetFullPathbir tam genişletilmiş yol alır.

Yana cd( Set-Location) basitçe PowerShell bağlamda anlamak olmayan bir .NET API göreceli bir dosya adı geçen süreç Geçerli çalışma dizini değişmez böyle başlangıç çalışma dışı esaslı bir yola çözülmesi gibi istenmeyen yan etkileri olabilir dizin (mevcut konumunuz değil).

Yaptığınız şey, önce yolunuzu nitelemek:

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

Bu, (mevcut konumum göz önüne alındığında):

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

Mutlak bir temel ile, .NET API'yi çağırmak güvenlidir GetFullPath:

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

Bu size tam nitelikli yolu ve ..kaldırılmış yolu verir :

C:\WINDOWS\system32\fred\frag

Kişisel olarak da karmaşık değil, bunun için harici komut dosyalarına bağlı çözümleri küçümsüyorum, basit bir problem tarafından oldukça uygun bir şekilde çözüldü Join-Pathve pwd( GetFullPathsadece güzelleştirmek için). Sadece göreceli kısmı korumak istiyorsanız , sadece ekleyin .Substring((pwd).Path.Trim('\').Length + 1)ve tamamlayın!

fred\frag

GÜNCELLEME

En C:\uç durumu işaret ettiği için @Dangph'a teşekkürler .

.. \ frag'ı çözüm yolu ile tam yoluna genişletebilirsiniz:

PS > resolve-path ..\frag 

Comb () yöntemini kullanarak yolu normalleştirmeyi deneyin:

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

Path.GetFullPath'i de kullanabilirsiniz , ancak (Dan R'nin cevabında olduğu gibi) bu size tüm yolu verecektir. Kullanım aşağıdaki gibi olacaktır:

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

veya daha ilginci

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

her ikisi de aşağıdakileri verir (geçerli dizininizin D: \ olduğunu varsayarsak):

D:\fred\frag

Bu yöntemin fred veya frag'ın gerçekten var olup olmadığını belirlemeye çalışmadığını unutmayın.

Kabul edilen cevap çok yardımcı oldu, ancak mutlak bir yolu da gerektiği gibi 'normalleştirmiyor'. Hem mutlak hem de göreceli yolları normalleştiren türev çalışmamın altında bulun.

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

PowerShell dışındaki yol işleme işlevleri (System.IO.Path gibi), PowerShell'den güvenilir olmayacaktır çünkü PowerShell'in sağlayıcı modeli, PowerShell'in geçerli yolunun Windows'un işlemin çalışma dizini olarak düşündüğünden farklı olmasına izin verir.

Ayrıca, zaten keşfetmiş olabileceğiniz gibi, PowerShell'in Çözüm Yolu ve Yolu Dönüştür cmdlet'leri göreceli yolları (".." içerenler) sürücü nitelikli mutlak yollara dönüştürmek için kullanışlıdır, ancak başvurulan yol yoksa başarısız olurlar.

Aşağıdaki çok basit cmdlet, var olmayan yollar için çalışmalıdır. Bir 'fred' veya 'frag' dosya veya klasör bulunamasa bile (ve mevcut PowerShell sürücüsü 'd:') 'fred \ frog \ .. \ frag'ı' d: \ fred \ frag 'olarak dönüştürecektir. .

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

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

Bu kitaplık iyidir: NDepend.Helpers.FileDirectoryPath .

DÜZENLEME: Bulduğum şey bu:

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

Şöyle diyelim:

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

Bu kod parçacığının DLL yolunu gerektirdiğini unutmayın. Şu anda çalıştırılan betiği içeren klasörü bulmak için kullanabileceğiniz bir numara var, ancak benim durumumda kullanabileceğim bir ortam değişkenine sahiptim, bu yüzden onu kullandım.

Bu tam yolu verir:

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

Bu, geçerli dizine göre yolu verir:

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

Bazı nedenlerden dolayı, yalnızca bir dosyaysa çalışırlar frag, bir directory.

Bir işlev oluşturun. Bu işlev, sisteminizde olmayan bir yolu normalleştirecek ve sürücü harfleri eklemeyecektir.

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

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

Ör:

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

Normal İfadede yardım için Oliver Schadlich'e teşekkürler.

Yol bir niteleyici (sürücü harfi) içeriyorsa, x0n'nin Powershell'e cevabı: var olmayan yolu çöz? yolu normalleştirecek. Yol niteleyiciyi içermiyorsa, yine de normalleştirilecektir, ancak istediğiniz dizine göre tam olarak nitelenmiş yolu döndürecektir, ki bu istediğinizi olmayabilir.

$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

.. kısmından kurtulmanız gerekirse, bir System.IO.DirectoryInfo nesnesi kullanabilirsiniz. Yapıcıda 'fred \ frog .. \ frag' kullanın. FullName özelliği size normalleştirilmiş dizin adını verecektir.

Tek dezavantajı, size tüm yolu vermesidir (örneğin c: \ test \ fred \ frag).

Buradaki yorumların uygun kısımları, göreceli ve mutlak yolları birleştirecek şekilde birleştirildi:

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

Bazı örnekler:

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

çıktı:

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

Bir yol şu olabilir:

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

Bekle, belki soruyu yanlış anladım. Örneğinizde frag, kurbağanın bir alt klasörü mü?