Come trovo i file con una lunghezza del percorso superiore a 260 caratteri in Windows?

Question

Sto usando una XCopy in uno script di Windows XP per copiare 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 risolvere quali file violano la restrizione della lunghezza del percorso.I file che vengono copiati vengono stampati nell'output standard (che sto reindirizzando un file di registro), ma il messaggio di errore viene stampato sul terminale, quindi non riesco nemmeno a funzionare approssimativamente a quale directory viene fornito l'errore.

Answer 1

Fai un dir /s /b > out.txt e quindi aggiungere una guida in posizione 260

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

Answer 2

Ho creato lo strumento di controllo della lunghezza del percorso per questo scopo, che è una bella app GUI gratuita cheÈ possibile utilizzare per vedere le lunghezze del percorso di tutti i file e le directory in una determinata directory.

Ho anche scritto e bloggato su un semplice script PowerShell per ottenere lunghezze di file e directory.Emetterà la lunghezza e il percorso verso un file, e opzionalmente lo scriveranno anche alla console.Non limita a visualizzare file che sono solo su una certa lunghezza (una modifica facile da fare), ma mostrarli discendenti per lunghezza, quindi è ancora super facile vedere quali percorsi sono sopra la soglia.Ecco:

$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()

.

Answer 3

Come raffinatezza della soluzione più semplice, e se non puoi o non si desidera installare PowerShell, basta eseguire:

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

.

o (più veloce):

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

.

e le linee più lunghe di 260 arriveranno nella parte superiore della quotazione.Si noti che è necessario aggiungere 1 al parametro di colonna di ordinamento (/ + N).

Answer 4

Ho fatto un'alternativa alle altre buone risposte qui che utilizza PowerShell, ma la miniera salva anche la lista in un file. Lo condividerà qui nel caso qualcun altro ha bisogno di qualcosa del genere.

Avvertenza: Codice sovrascrive "Longfilepath.txt" nella directory di lavoro corrente. So che è improbabile che ne avessi già uno, ma solo nel caso!

Volevamente volerlo in una singola 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. Traverse alla directory che desideri controllare per le lunghezze di filepath (c: opere)
3. Copia e incolla il codice [Fare clic con il tasto destro per incollare in PowerShell o Alt + Space> E> P]
4. Attendi fino a quando non viene eseguito e quindi visualizza il file: cat longfilepath.txt | sort

Spiegazione:

Out-File longfilepath.txt ; - Crea (o sovrascrittura) Un file vuoto intitolato 'Longfilepath.txt'. Semi-colon per separare i comandi.

cmd /c "dir /b /s /a" |: eseguire il comando DIR su PowerShell, /a per mostrare tutti i file inclusi i file nascosti. | to Pipe.

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

Answer 5

Puoi reindirizzare STDERR.

Più spiegazione qui , ma avere un comando come:

MyCommand >log.txt 2>errors.txt

.

dovrebbe afferrare i dati che stai cercando.

Anche, come trucco, Windows ignora tale limitazione se il percorso è prefissato con \\?\ ( msdn )

Un altro trucco Se hai una radice o una destinazione che inizia con un percorso lungo, forse SUBST Aiuterà:

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

.

Answer 6

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 è solo itera attraverso questa e sottocartelle;L'utilizzo di -ErrorVariable AccessDenied significa spingere gli elementi offensivi nella variabile variabile di PowerShell.

È quindi possibile eseguire la scansione della variabile come

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

.

Se non ti interessa questi file (potrebbe essere applicabile in alcuni casi), basta rilasciare la parte AccessDenied.

Answer 7

TLPD ("Troppo long Path Directory") è il programma che mi ha salvato. Molto facile da usare:

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

Answer 8

per i percorsi superiori a 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 sentieri superiori a 14:

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

.

Screenshot:

per i nomi dei file superiori a 10:

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

.

Screenshot: