Trier les éléments d'un répertoire par taille décroissante à l'aide de Python, PowerShell, C# ou Go

Un programme simple pour trier tous les éléments d'un répertoire, qu'il s'agisse d'un fichier ou d'un dossier, par taille décroissante.

Trier les éléments d'un répertoire par taille décroissante n'est pas aussi simple qu'on pourrait le penser, que vous utilisiez un navigateur de fichiers graphique ou la ligne de commande, car les systèmes d'exploitation ne calculent pas la taille totale du contenu d'un répertoire lors de la navigation dans un répertoire. arbre. Cet article propose des programmes de travail complets pour surmonter ce problème sur la plupart des systèmes d'exploitation.

Problème

Peut-être trouverez-vous le familier suivant :

Que ce soit pour le travail ou pour des projets personnels, j'aime organiser mes actifs numériques en créant un répertoire parent, disons appelé Projets, et en y stockant tout le contenu des projets individuels. Si un projet est petit et n’implique pas beaucoup de contenu, j’utiliserai un seul fichier, généralement un fichier texte. Si un projet implique plus de contenu, par exemple un fichier texte ainsi que quelques captures d'écran, je créerai un dossier pour ce projet et y placerai tous les éléments associés. Ainsi, de mon point de vue, le fichier texte unique et le dossier sont équivalents dans le sens où chacun représente un projet. La seule différence est que le dossier représente un projet plus important, avec plus de choses.

Parfois, je veux voir lequel de mes projets est actuellement le plus grand, lequel contient le plus de choses. Cela arrive généralement parce que je n'ai pas travaillé sur un domaine particulier depuis un certain temps, donc quand j'y reviens, je veux voir quel projet a le plus de contenu. Mon raisonnement est que le projet avec le plus de contenu doit être le plus complet, et donc probablement celui sur lequel je devrais commencer à travailler en premier, car il sera le plus simple à terminer.

Par exemple, considérons un répertoire avec le contenu suivant :

Name	Type	Size
Huge Project.txt	File	2.6KB
Larger Project	Folder	1.07KB
0 - Tiny Project	Folder	0KB
Basic Project.txt	File	0.36KB
Big Project.txt	File	2.11KB

Le tri du répertoire ci-dessus par taille décroissante devrait afficher :

Huge Project.txt        2.6KB
Big Project.txt 2.11KB
Larger Project  1.07KB
Basic Project.txt       0.36KB
0 - Tiny Project        0KB

Cependant, ce n'est pas ce que nous obtenons lorsque nous cliquons sur l'en-tête de colonne Taille dans les navigateurs de fichiers graphiques sous Windows, Mac et Linux.

Fenêtres

Explorateur de fichiers Windows - Les fichiers sont triés par taille décroissante et les dossiers sont affichés en dessous, par ordre alphabétique croissant.

Mac

MacOS Finder - Le contenu du répertoire est trié de la même manière que sous Windows.

Linux

Application Fichiers Linux (Ubuntu) - Les dossiers et fichiers sont triés correctement, mais individuellement ; les dossiers d'abord, puis les fichiers. Ainsi, l'élément qui apparaît en premier sur la liste n'est pas réellement l'élément le plus volumineux du répertoire.

L'utilisation de la ligne de commande fournit un résultat un peu plus proche de celui souhaité, mais toujours pas tout à fait correct :

Fenêtres

dir /b/o:-d

Sortie :

Larger Project
0 - Tiny Project
Huge Project.txt
Big Project.txt
Basic Project.txt

Mac et Linux

Il existe différentes combinaisons de commandes pour le tri du contenu des répertoires sur les systèmes UNIX tels que Mac et Linux. La plupart impliquent l’utilisation de du, sort et ls. D'autres exemples que j'ai trouvés en ligne ont également ajouté find et grep au mix.

Voici ceux que j'ai essayés :

du | trier

du -a -h --max-profondeur=1 | trier -hr

Sortie :

32K     .
8.0K    ./Larger Project
8.0K    ./0 - Tiny Project
4.0K    ./Huge Project.txt
4.0K    ./Big Project.txt
4.0K    ./Basic Project.txt

ls

L'utilisation du commutateur -S sur la commande ls est censée faire exactement ce que je recherche, trier les éléments par taille décroissante.

ls -S

Sortie :

'0 - Tiny Project'  'Larger Project'  'Huge Project.txt'  'A - Big Project.txt'  'Basic Project.txt'

La sortie est toujours désactivée. J'ai essayé d'ajouter le commutateur -l (long).

ls -lS

Sortie :

total 20
drwx---r-x 2 admin admin 4096 Sep 20 21:49 '0 - Tiny Project'
drwx---r-x 2 admin admin 4096 Sep 20 21:49 'Larger Project'
-rw-rw-r-- 1 admin admin 2667 Sep 20 21:49 'Huge Project.txt'
-rw-rw-r-- 1 admin admin 2164 Sep 20 21:49 'Big Project.txt'
-rw-rw-r-- 1 admin admin  368 Sep 20 21:49 'Basic Project.txt'

Le résultat comprend plus de détails, comme prévu, mais l'ordre de tri est le même qu'auparavant.

Cause première

Bien que le résultat des différentes commandes ne fournisse pas le résultat souhaité, il met en évidence la cause première du problème. Lors de la navigation dans une arborescence de répertoires, les systèmes d'exploitation ne parcourent pas les dossiers pour calculer la taille totale de leur contenu. Au lieu de cela, ils traitent tous les dossiers comme ayant la même taille fixe. Il s'agit généralement de la taille de bloc minimale du système de fichiers, généralement 4 096 octets, 4 Ko.

Solution

Il doit y avoir au moins une douzaine d'outils gratuits qui résolvent ce problème, mais pour être honnête, je n'ai même pas regardé. Écrire un script/programme qui fait la même chose, puis le partager ici me semblait que ce serait plus facile, impliquerait moins de ballonnements, utile pour les autres, et certainement plus amusant.

J'ai tergiversé assez longtemps. Voici le code :

Python

Huge Project.txt        2.6KB
Big Project.txt 2.11KB
Larger Project  1.07KB
Basic Project.txt       0.36KB
0 - Tiny Project        0KB

PowerShell

Larger Project
0 - Tiny Project
Huge Project.txt
Big Project.txt
Basic Project.txt

C Sharp

32K     .
8.0K    ./Larger Project
8.0K    ./0 - Tiny Project
4.0K    ./Huge Project.txt
4.0K    ./Big Project.txt
4.0K    ./Basic Project.txt

Aller

'0 - Tiny Project'  'Larger Project'  'Huge Project.txt'  'A - Big Project.txt'  'Basic Project.txt'

Il existe quelques différences mineures entre les quatre implémentations, mais l'approche générale utilisée pour les quatre est la même :

1. Créez une fonction récursive qui renvoie une collection de paires clé-valeur du nom et de la taille de l'élément (fichier ou dossier).
2. Dans la fonction ou le bloc principal, effectuez une validation d'entrée de base, et si l'utilisateur a fourni un chemin valide, exécutez la fonction récursive sur ce chemin.
3. Trier la sortie de la fonction récursive par valeur (taille), par ordre décroissant.
4. Imprimez la sortie triée sur la console. Chaque ligne imprimée respecte le format : le nom de l'élément, suivi d'un caractère de tabulation, suivi de la taille de l'élément divisé par 1024 et arrondi à deux décimales pour obtenir la taille en kilo-octets, suivi de "KB" pour désigner l'unité de taille.

Usage

Sur la ligne de commande, transmettez le chemin du répertoire que vous souhaitez trier comme premier paramètre. Je ne listerai pas tous les exemples possibles, mais en voici quelques-uns, en supposant que vous avez copié le code et l'avez enregistré sous le nom de fichier dir_desc, abréviation de « répertoire décroissant », plus l'extension de fichier appropriée :

Utiliser Python sur Mac ou Linux :

python3 dir_desc.py

Utiliser PowerShell sous Windows :

powershell -f dir_desc.ps1

Différences entre les langages et les implémentations

• Python et Go ressemblent au C et à d'autres langages de type C dans la mesure où le premier argument de ligne de commande est le deuxième élément du tableau args. Dans les langages .NET, PowerShell et C#, le premier argument est le premier élément du tableau args.
• Dans PowerShell, il n'est pas nécessaire de créer une fonction récursive distincte, car le résultat souhaité peut être obtenu plus facilement en utilisant les applets de commande intégrées Get-ChildItem (gci) et Measure-Object (measure).
• Dans Go, trier une collection de paires clé-valeur (carte) par valeur nécessite quelques lignes de code de plus que dans d'autres langages, car les fonctions de tri intégrées sont conçues pour fonctionner avec des tableaux/tranches, pas des cartes.
• Dans Go, l'arrondi d'un nombre à virgule flottante à X décimales est géré lors de l'impression du résultat, à l'aide de la fonction fmt.Printf(), par opposition à l'arrondi du nombre, ce qui, d'ailleurs, peut être effectué sans utiliser les mathématiques. Fonction .Round(). Si vous avez une formation en C, c'est probablement intuitif. Pour le reste d'entre nous, c'est un peu bizarre, mais ça marche bien.

J'ai porté mon approche originale en Python vers quelques autres langages, afin qu'il existe au moins une version qui devrait fonctionner sur chacun des trois principaux systèmes d'exploitation :

• Mac et Linux : l'interpréteur python3 devrait être installé par défaut. Sinon, vous pouvez utiliser la version Go. Certains systèmes Linux peuvent avoir une version de gcc installée par défaut qui peut compiler Go, mais la plupart des systèmes ne le feront pas, vous devrez donc télécharger le compilateur Go.
• Windows : la version PowerShell devrait fonctionner immédiatement sur les systèmes équipés de Windows 10 ou version ultérieure. Pour les systèmes plus anciens, la version C# est probablement le meilleur choix. Vous pouvez utiliser le compilateur C# intégré de Windows pour compiler le code.

Et c'est tout. Un autre yak, rasé. J'espère que vous avez trouvé cela utile.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!