Eu tenho dois caminhos:

fred\frog

e

..\frag

Posso juntá-los no PowerShell assim:

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

Isso me dá isso:

fred\frog\..\frag

Mas eu não quero isso. Quero um caminho normalizado sem os pontos duplos, como este:

fred\frag

Como posso conseguir isso?

Você pode usar uma combinação de pwd, Join-Pathe [System.IO.Path]::GetFullPathpara obter um caminho expandido totalmente qualificado.

Como cd( Set-Location) não altera o diretório de trabalho atual do processo, simplesmente passar um nome de arquivo relativo a uma API .NET que não entende o contexto do PowerShell pode ter efeitos colaterais indesejados, como resolver para um caminho baseado no trabalho inicial diretório (não sua localização atual).

O que você faz é primeiro qualificar seu caminho:

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

Isso produz (dada minha localização atual):

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

Com uma base absoluta, é seguro chamar a API .NET GetFullPath:

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

O que fornece o caminho totalmente qualificado e com o ..removido:

C:\WINDOWS\system32\fred\frag

Também não é complicado, pessoalmente, desprezo as soluções que para isso dependem de scripts externos, é um problema simples resolvido de forma bastante adequada por Join-Pathe pwd( GetFullPathserve apenas para torná-lo bonito). Se você quiser manter apenas a parte relativa , basta adicionar .Substring((pwd).Path.Trim('\').Length + 1)e pronto!

fred\frag

ATUALIZAR

Obrigado a @Dangph por apontar o C:\caso extremo.

Você pode expandir .. \ frag para seu caminho completo com resolve-path:

PS > resolve-path ..\frag 

Tente normalizar o caminho usando o método combine ():

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

Você também pode usar Path.GetFullPath , embora (como na resposta de Dan R) isso forneça o caminho completo. O uso seria o seguinte:

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

ou mais interessante

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

ambos produzem o seguinte (assumindo que seu diretório atual seja D: \):

D:\fred\frag

Observe que este método não tenta determinar se fred ou frag realmente existem.

A resposta aceita foi de grande ajuda, mas também não "normaliza" adequadamente um caminho absoluto. Encontre abaixo meu trabalho derivado que normaliza os caminhos absolutos e relativos.

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

Quaisquer funções de manipulação de caminho não PowerShell (como aquelas em System.IO.Path) não serão confiáveis ​​do PowerShell porque o modelo de provedor do PowerShell permite que o caminho atual do PowerShell seja diferente do que o Windows pensa que é o diretório de trabalho do processo.

Além disso, como você já deve ter descoberto, os cmdlets Resolve-Path e Convert-Path do PowerShell são úteis para converter caminhos relativos (aqueles contendo '..' s) em caminhos absolutos qualificados de unidade, mas eles falham se o caminho referenciado não existir.

O seguinte cmdlet muito simples deve funcionar para caminhos não existentes. Ele converterá 'fred \ frog \ .. \ frag' em 'd: \ fred \ frag' mesmo se um arquivo ou pasta 'fred' ou 'frag' não puder ser encontrado (e a unidade PowerShell atual for '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 é boa: NDepend.Helpers.FileDirectoryPath .

EDIT: Isto é o que eu inventei:

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

Chame assim:

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

Observe que este trecho requer o caminho para a DLL. Existe um truque que você pode usar para encontrar a pasta que contém o script em execução no momento, mas no meu caso, eu tinha uma variável de ambiente que poderia usar, então acabei de usá-la.

Isso fornece o caminho completo:

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

Isso fornece o caminho relativo ao diretório atual:

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

Por algum motivo, eles só funcionam se fragfor um arquivo, não um directory.

Crie uma função. Esta função normalizará um caminho que não existe em seu sistema e também não adicionará letras de unidade.

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'

Agradeço a Oliver Schadlich pela ajuda no RegEx.

Se o caminho incluir um qualificador (letra da unidade), a resposta de x0n para o Powershell: resolver caminho que pode não existir? irá normalizar o caminho. Se o caminho não incluir o qualificador, ele ainda será normalizado, mas retornará o caminho totalmente qualificado relativo ao diretório atual, que pode não ser o que você deseja.

$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 você precisar se livrar da parte .., você pode usar um objeto System.IO.DirectoryInfo. Use 'fred \ frog .. \ frag' no construtor. A propriedade FullName fornecerá o nome do diretório normalizado.

A única desvantagem é que ele fornecerá o caminho completo (por exemplo, c: \ test \ fred \ frag).

As partes convenientes dos comentários aqui combinadas de modo que unificam os caminhos relativos e absolutos:

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

Algumas amostras:

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

resultado:

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

Bem, uma maneira seria:

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

Espere, talvez eu tenha entendido mal a pergunta. No seu exemplo, frag é uma subpasta de sapo?