Comment puis-je trouver des fichiers avec une longueur de trajet de plus de 260 caractères dans Windows?

Question

Je suis à l'aide d'un xcopy dans une XP windows script pour copier un répertoire de façon récursive.Je reçois un 'Mémoire Insuffisante' erreur, je crois comprendre que c'est à cause d'un fichier que je suis en train de copier est trop long d'un chemin.Je peux facilement réduire la longueur du chemin, mais malheureusement je ne peux pas savoir quels sont les fichiers violation de la longueur du chemin de restriction.Les fichiers qui sont copiés sont imprimés sur la sortie standard (dont je suis rediriger vers un fichier de log), mais le message d'erreur est imprimé sur le terminal, donc je ne peux même pas travailler environ le répertoire de l'erreur est donnée pour.

Answer 1

faire un dir /s /b > out.txt puis ajouter un guide à la position 260

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

Answer 2

j'ai créé L'outil de vérification de la longueur du chemin à cet effet, qui est une bonne application GIV gratuite queVous pouvez utiliser pour voir les longueurs de chemin de tous les fichiers et répertoires dans un répertoire donné.

J'ai aussi écrit et blogué sur un simple script PowerShell pour obtenir des longueurs de fichier et de répertoire.Il va émettre la longueur et le chemin d'accès à un fichier et l'écrira éventuellement à la console.Il ne limite pas d'affichage des fichiers qui ne sont que sur une certaine longueur (une modification facile à faire), mais les affichent de manière descendante de longueur, il est donc encore super facile de voir quels chemins sont sur votre seuil.Ici c'est:

$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

comme un raffinement de la solution la plus simple, et si vous ne pouvez pas ou non pas installer PowerShell, il suffit de courir:

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

ou (plus rapide):

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

et des lignes plus longues que 260 vont se rendre au sommet de la liste.Notez que vous devez ajouter 1 pour trier le paramètre de colonne (/ + N).

Answer 4

J'ai fait une alternative à l'autre de bonnes réponses sur ici qui utilise PowerShell, mais aussi la mienne enregistre la liste dans un fichier.Partagez ici au cas où quelqu'un d'autre a besoin veut quelque chose comme ça.

Avertissement: Code remplace "longfilepath.txt" dans le répertoire de travail courant.Je sais que c'est peu probable que vous auriez déjà un, mais juste au cas où!

Délibérément voulue en une seule ligne:

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

Des instructions détaillées:

1. Exécuter PowerShell
2. Parcourir le répertoire que vous souhaitez vérifier filepath longueurs (C:fonctionne)
3. Copiez et collez le code [clic Droit coller dans PowerShell, ou Alt + Espace > E > P]
4. Attendre jusqu'à ce qu'elle fait et puis voir le fichier: cat longfilepath.txt | sort

Explication:

Out-File longfilepath.txt ; – Créer (ou remplacer) un fichier vide, intitulée "longfilepath.txt'.Point-virgule pour séparer les commandes.

cmd /c "dir /b /s /a" | – Exécuter la commande dir sur PowerShell, /a pour afficher tous les fichiers y compris les fichiers cachés. | à la pipe.

ForEach-Object { if ($_.length -gt 250) {$_ | Out-File -append longfilepath.txt}} – Pour chaque ligne (notée $_), si la longueur est supérieure à 250, ajouter cette ligne dans le fichier.

Answer 5

vous pouvez rediriger stderr.

plus d'explication ici, mais d'avoir une commande comme:

MyCommand >log.txt 2>errors.txt

doit saisir les données que vous recherchez.

Aussi, comme une astuce, Windows contourne cette limitation si le chemin est préfixé avec \\?\ (msdn)

Une autre astuce si vous avez une racine ou une destination qui commence par un long chemin, peut-être SUBST pour vous aider:

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

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

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

la première partie juste parcourt ce et sous-dossiers;à l'aide de -ErrorVariable AccessDenied les moyens de pousser les éléments en cause dans la variable powershell AccessDenied.

Vous pouvez ensuite analyser la variable comme

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

Si vous ne vous inquiétez pas à propos de ces fichiers (peut être applicable dans certains cas), il suffit de déposer le -ErrorVariable AccessDenied partie.

Answer 7

TLPD ("Trop long chemin de chemin") est le programme qui m'a sauvé. Très facile à utiliser:

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

Answer 8

Pour les chemins supérieurs à 260:
Vous pouvez utiliser:

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

Exemple sur 14 caractères:
Pour afficher les longueurs des chemins:

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

Obtenez des chemins supérieurs à 14:

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

Capture d'écran:

Pour les noms de fichiers supérieurs à 10:

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

Capture d'écran: