Come trovo i file con una lunghezza del percorso maggiore di 260 caratteri in Windows?

Sto usando un xcopy in uno script di Windows XP per copiare in modo ricorsivo una directory. Continuo a ricevere un errore "Memoria insufficiente", che capisco perché un file che sto cercando di copiare ha un percorso troppo lungo. Posso facilmente ridurre la lunghezza del percorso, ma sfortunatamente non riesco a capire quali file stanno violando la limitazione della lunghezza del percorso. I file che vengono copiati vengono stampati sullo standard output (che sto reindirizzando a un file di registro), ma il messaggio di errore viene stampato sul terminale, quindi non riesco nemmeno a capire approssimativamente per quale directory viene fornito l'errore .

fare a dir /s /b > out.txte quindi aggiungere una guida alla posizione 260

In PowerShell cmd /c dir /s /b |? {$_.length -gt 260}

Ho creato lo strumento Path Length Checker per questo scopo, che è una bella app GUI gratuita che puoi usare per vedere le lunghezze del percorso di tutti i file e le directory in una determinata directory.

Ho anche scritto e scritto su un semplice script PowerShell per ottenere lunghezze di file e directory. Produrrà la lunghezza e il percorso di un file e, facoltativamente, lo scriverà anche sulla console. Non si limita a visualizzare i file che superano solo una certa lunghezza (una modifica facile da apportare), ma li visualizza in ordine decrescente in base alla lunghezza, quindi è ancora semplicissimo vedere quali percorsi sono oltre la soglia. Ecco qui:

$pathToScan = "C:\Some Folder"  # The path to scan and the the lengths for (sub-directories will be scanned as well).
$outputFilePath = "C:\temp\PathLengths.txt" # This must be a file in a directory that exists and does not require admin rights to write to.
$writeToConsoleAsWell = $true   # Writing to the console will be much slower.

# Open a new file stream (nice and fast) and write all the paths and their lengths to it.
$outputFileDirectory = Split-Path $outputFilePath -Parent
if (!(Test-Path $outputFileDirectory)) { New-Item $outputFileDirectory -ItemType Directory }
$stream = New-Object System.IO.StreamWriter($outputFilePath, $false)
Get-ChildItem -Path $pathToScan -Recurse -Force | Select-Object -Property FullName, @{Name="FullNameLength";Expression={($_.FullName.Length)}} | Sort-Object -Property FullNameLength -Descending | ForEach-Object {
    $filePath = $_.FullName
    $length = $_.FullNameLength
    $string = "$length : $filePath"

    # Write to the Console.
    if ($writeToConsoleAsWell) { Write-Host $string }

    #Write to the file.
    $stream.WriteLine($string)
}
$stream.Close()

Come perfezionamento della soluzione più semplice e se non puoi o non vuoi installare Powershell, esegui:

dir /s /b | sort /r /+261 > out.txt

o (più veloce):

dir /s /b | sort /r /+261 /o out.txt

E le righe più lunghe di 260 arriveranno all'inizio dell'elenco. Tieni presente che devi aggiungere 1 al parametro della colonna SORT (/ + n).

Ho fatto un'alternativa alle altre buone risposte qui che utilizza PowerShell, ma la mia salva anche l'elenco in un file. Lo condividerò qui nel caso in cui qualcun altro abbia bisogno vuole qualcosa del genere.

Avviso: il codice sovrascrive "longfilepath.txt" nella directory di lavoro corrente. So che è improbabile che tu ne abbia già uno, ma per ogni evenienza!

Volutamente voluto in una sola riga:

Out-File longfilepath.txt ; cmd /c "dir /b /s /a" | ForEach-Object { if ($_.length -gt 250) {$_ | Out-File -append longfilepath.txt}}

Istruzioni dettagliate:

1. Esegui PowerShell
2. Vai alla directory di cui vuoi controllare la lunghezza del percorso del file (C: funziona)
3. Copia e incolla il codice [Fare clic con il pulsante destro del mouse per incollare in PowerShell o Alt + Spazio> E> P]
4. Attendi fino al termine e quindi visualizza il file: cat longfilepath.txt | sort

Spiegazione:

Out-File longfilepath.txt ;- Crea (o sovrascrivi) un file vuoto intitolato "longfilepath.txt". Punto e virgola per separare i comandi.

cmd /c "dir /b /s /a" |- Esegui il comando dir su PowerShell, /aper mostrare tutti i file inclusi i file nascosti. |per pipe.

ForEach-Object { if ($_.length -gt 250) {$_ | Out-File -append longfilepath.txt}} - Per ogni riga (indicata come $ _), se la lunghezza è maggiore di 250, aggiungere quella riga al file.

puoi reindirizzare stderr.

ulteriori spiegazioni qui , ma con un comando come:

MyCommand >log.txt 2>errors.txt

dovrebbe prendere i dati che stai cercando.

Inoltre, come trucco, Windows ignora tale limitazione se il percorso ha il prefisso \\?\( msdn )

Un altro trucco se hai una radice o una destinazione che inizia con un lungo percorso, forse SUBSTti aiuterà:

SUBST Q: "C:\Documents and Settings\MyLoginName\My Documents\MyStuffToBeCopied"
Xcopy Q:\ "d:\Where it needs to go" /s /e
SUBST Q: /D

Da http://www.powershellmagazine.com/2012/07/24/jaap-brassers-favorite-powershell-tips-and-tricks/ :

Get-ChildItem –Force –Recurse –ErrorAction SilentlyContinue –ErrorVariable AccessDenied

la prima parte scorre semplicemente attraverso questa e le sottocartelle; using -ErrorVariable AccessDeniedsignifica spingere gli elementi offensivi nella variabile powershell AccessDenied.

È quindi possibile eseguire la scansione della variabile in questo modo

$AccessDenied |
Where-Object { $_.Exception -match "must be less than 260 characters" } |
ForEach-Object { $_.TargetObject }

Se non ti interessano questi file (potrebbero essere applicabili in alcuni casi), rilascia semplicemente la -ErrorVariable AccessDeniedparte.

TLPD ("directory del percorso troppo lungo") è il programma che mi ha salvato. Molto facile da usare:

https://sourceforge.net/projects/tlpd/

Per percorsi maggiori di 260:
puoi usare:

Get-ChildItem | Where-Object {$_.FullName.Length -gt 260}

Esempio su 14 caratteri:
Per visualizzare le lunghezze dei percorsi:

Get-ChildItem | Select-Object -Property FullName, @{Name="FullNameLength";Expression={($_.FullName.Length)}

Ottieni percorsi maggiori di 14:

Get-ChildItem | Where-Object {$_.FullName.Length -gt 14}  

Immagine dello schermo:

Per i nomi di file maggiori di 10:

Get-ChildItem | Where-Object {$_.PSChildName.Length -gt 10}

Immagine dello schermo: