La commande 'ls' est obsolète.

Tapez `ls` dans un terminal aujourd'hui et vous voyagez effectivement dans le temps jusqu'aux années 1970. La commande fait toujours ce qu'elle a toujours fait : afficher une liste de répertoire, mais les flux de travail de développement modernes exigent bien plus qu'une colonne monochrome de noms de fichiers. Votre éditeur, navigateur et IDE ont évolué ; votre listeur de fichiers, lui, n'a pas vraiment changé.

Le commande ls traditionnel ne sait rien de Git, même si pratiquement chaque projet sérieux vit dans un dépôt. Vous ne pouvez pas jeter un œil à un répertoire et voir quels fichiers sont modifiés, ignorés ou non suivis sans exécuter des commandes `git status` séparées. Cela signifie un changement constant de contexte mental : `ls` pour voir les fichiers, `git` pour voir l'état, votre cerveau pour relier le tout.

Le retour visuel est tout aussi primitif. GNU ls peut coloriser la sortie, mais cela s'arrête aux types de fichiers et autorisations basiques, sans notion d'icônes, de chemins cliquables ou de dégradés qui mettent en évidence les fichiers volumineux ou récents. Vous n'obtenez pas : - D'indicateurs sensibles à Git - D'icônes par fichier - De liens hypertextes cliquables dans les terminaux modernes

La densité d'information est un autre problème. Un long résultat `ls -l` entasse les permissions, les propriétaires, les tailles et les horodatages dans un mur de texte qui devient difficile à lire une fois qu'un répertoire contient des centaines d'entrées. Vous voyez soit trop peu (`ls`), soit beaucoup trop (`ls -l`), sans aucune option intermédiaire nuancée comme "seulement les répertoires", "cacher les fichiers ignorés par Git" ou "montrer d'abord les répertoires".

Pendant ce temps, votre terminal est devenu votre interface principale alors que des outils comme Git, Docker et Kubernetes intègrent de plus en plus de flux de travail dans la ligne de commande. Vous passez d'un environnement Linux à macOS, jonglez avec des dizaines de dépôts et continuez à compter sur un navigateur de fichiers conçu avant que le contrôle de version ne devienne courant. Pourquoi votre vue de répertoire ne comprend-elle pas votre VCS, vos polices ou votre schéma de couleurs ?

Alors, à quoi ressemblerait un outil de listing de fichiers s'il était conçu pour 2025 au lieu de 1975 ? Et si `ls` pouvait afficher l'état Git en ligne, ajouter automatiquement des icônes et utiliser des drapeaux de tri et de filtrage intelligents qui correspondent à votre façon de travailler ? Cet écart—entre ce que `ls` offre et ce que les développeurs attendent maintenant—est précisément l'endroit où eza intervient.

Les traditionalistes de la ligne de commande peuvent ne pas aimer l'entendre, mais eza est l'outil qui se comporte comme les gens s'attendent à ce que `ls` se comporte en 2025. Il est livré avec des paramètres par défaut raisonnables, de la couleur par défaut, et une mise en page qui fait ressortir ce qui compte vraiment : les types de fichiers, le statut Git, et les métadonnées lisibles par l'homme, au lieu d'un mur de texte monochrome. Écrit en Rust, il s'appuie sur la sécurité mémoire et un parallélisme agressif pour rester rapide même dans des dépôts gigantesques.

Eza n'est pas apparu de nulle part. Cela a commencé comme un fork maintenu par la communauté de exa, le remplaçant de `ls` en Rust adoré, créé par Benjamin Sago (connu sous le nom de « ogham ») qui n'a pas été maintenu pendant des années. Lorsque exa a stagné, les contributeurs ont déplacé la base de code vers le dépôt eza-community/eza, ont résolu des problèmes de longue date et ont commencé à publier des versions fréquentes pour Linux et macOS.

Mis à part son origine, la proposition d'eza est simple : de meilleures options par défaut, des informations plus riches et une expérience centrée sur le développeur. Exécutez `eza -l --git` et vous voyez immédiatement des marqueurs compatibles avec Git comme `M` pour modifié, `N` pour nouveau, et `I` pour les fichiers ignorés dans la même liste que les permissions et les tailles. Ajoutez `--git-repos` et les répertoires se transforment en un tableau de bord de branches et d'état « sale/propre » à travers plusieurs dépôts.

La densité du signal visuel est l'endroit où eza se distingue de `ls`. Les couleurs sont toujours actives lors de l'utilisation interactive, et des options comme `--colour=always` les préservent à travers les pipes, tandis que `--colour-scale` utilise des dégradés pour mettre en avant les fichiers volumineux ou récents. Avec une police Nerd installée, `--icons` décore chaque entrée avec des glyphes de type de fichier, et `--hyperlink` transforme les chemins en liens cliquables dans les terminaux qui le supportent.

L'ergonomie des développeurs se manifeste dans le modèle de tri et de filtrage. Au lieu de mémoriser des combinaisons obscures d'options `ls`, vous avez des options explicites telles que : - `--sort=size`, `--sort=time`, ou `--sort=extension` - `--reverse` pour un ordre inversé - `--group-directories-first`, `--only-dirs`, ou `--only-files`

Des alternatives existent, mais eza les cible directement. Le projet affirme explicitement être plus rapide que lsd, un autre clone de `ls` en Rust, tout en offrant une intégration Git plus profonde, un thémage via des fichiers de configuration, des vues arborescentes avec `--tree`, et des couches de compatibilité pour que vous puissiez aliaser `ls` ou même `exa` à eza et oublier que le changement a jamais eu lieu.

Les machines macOS modernes rendent l'installation de eza presque triviale. Avec Homebrew configuré, exécutez : - `brew install eza` Cette seule commande télécharge un binaire Rust précompilé, l'ajoute à votre PATH et vous donne des mises à jour via `brew upgrade eza` chaque fois que le projet publie une nouvelle version.

Les utilisateurs de Linux reçoivent un traitement similaire. Sur Debian/Ubuntu, exécutez `sudo apt install eza` (sur les versions plus anciennes, vous devrez peut-être utiliser le .deb depuis GitHub). Sur Arch et ses dérivés, `sudo pacman -S eza` l'installe depuis les dépôts communautaires. D'autres distributions l'emballent sous `eza` ou fournissent des instructions sur eza – Une alternative moderne à ls (GitHub Officiel).

Pour rendre eza invisible mais omniprésent, aliaser-le à ls. Ajoutez cette ligne à votre configuration de shell : - Bash : ajoutez `alias ls='eza'` à `~/.bashrc` - Zsh : ajoutez `alias ls='eza'` à `~/.zshrc` Après l'édition, rechargez avec `source ~/.bashrc` ou `source ~/.zshrc`, ou ouvrez simplement un nouvel onglet de terminal.

D'abord, exécutez `eza` sans options. Vous obtiendrez immédiatement une sortie colorée, alignée sur les colonnes, qui respecte mieux la largeur du terminal que `ls`. Les fichiers cachés restent cachés par défaut, ce qui rend les racines de projet moins encombrantes et plus lisibles.

Ensuite, essayez `eza -l`. La vue longue ajoute des permissions, des propriétaires, des tailles et des horodatages dans un format plus lisible, avec des couleurs séparant les métadonnées des noms de fichiers. Puis exécutez `eza -a` pour inclure les fichiers cachés ; vous obtenez toujours une liste propre et triée par couleur plutôt qu'une soupe visuelle que `ls -a` produit généralement.

Si votre alias ne fonctionne pas, vous avez probablement modifié le mauvais fichier ou votre shell charge une configuration différente. Vérifiez `$SHELL` pour confirmer Bash contre Zsh, assurez-vous que la ligne de l'alias n'a pas d'espaces ou de guillemets inutiles, et exécutez `type ls` pour vérifier qu'il pointe maintenant vers eza. En cas de doute, redémarrez le terminal pour forcer un environnement propre.

Les listes de fichiers conscientes de Git vous évitent de devoir passer à `git status` toutes les 30 secondes. Avec eza, Git n'est pas une étape séparée ; il est intégré directement dans la vue du répertoire, de sorte que la santé de votre arbre de travail est affichée à côté des noms de fichiers, des tailles et des horodatages.

Exécutez `eza -l --git` dans n'importe quel dépôt et vous obtiendrez une colonne d'état supplémentaire directement issue de Git. Chaque fichier affiche un marqueur concis tiré de `git status --short`, vous permettant de repérer les problèmes sans avoir à analyser un mur de texte.

Ces petites lettres portent beaucoup de signification. En format long, eza utilise :

• 1`M` à gauche : modifié et en préparation
• 2`M` à droite : modifié mais non mis en scène
• 3`N`: nouveau fichier non suivi
• 4`I`: ignoré par `.gitignore` ou `.git/info/exclude`

Parce que ces marqueurs se situent par ligne, vous voyez immédiatement quels fichiers sont sûrs, lesquels sont à moitié engagés et lesquels sont encore en cours. Fini de deviner quel changement dans `src/` vous avez oublié d'ajouter avant votre dernier commit.

Les grands monorepos multiplient cette valeur. Avec `eza --git --tree --level=2`, vous pouvez explorer la hiérarchie d'un projet tout en gardant à l'œil l'état Git à chaque profondeur. Cette combinaison transforme une simple vue en arbre en une carte interactive du travail non validé.

L'étalement des dépôts crée un problème différent : savoir quel projet est propre avant de pousser. Le drapeau `--git-repos` s'attaque exactement à cela. Orientez eza vers un répertoire plein de projets et il résume chaque dépôt Git en une seule ligne.

Pour chaque sous-répertoire contenant un dossier `.git`, `eza --git-repos` affiche la branche actuelle, ainsi qu'un indicateur "sale" ou "propre". Vous pouvez jeter un œil à 10 ou 50 dépôts à la fois et repérer instantanément celui avec des changements non poussés ou non validés.

Le bruit provenant des actifs générés et des journaux peut noyer le signal dans de grandes bases de code. Ajoutez `--git-ignore` et eza masque tout ce que Git ignore déjà, appliquant efficacement vos règles `.gitignore` à la liste des fichiers elle-même. Le dossier `dist/` de Node, le dossier `.venv/` de Python, les rapports `coverage/` et les artefacts de construction disparaissent de la vue.

Combinez ces drapeaux et le terminal devient un tableau de bord Git : `eza -l --git --git-ignore --group-directories-first` pour un editing ciblé, ou `eza --git-repos ~/code` pour un contrôle d'état à l'échelle du portefeuille. L'ancien `ls` affiche les fichiers ; eza montre l'état réel de votre travail.

La couleur est l'endroit où eza cesse de prétendre être un substitut facile et commence à ressembler à une interface utilisateur moderne compressée dans un terminal. Par défaut, il est livré avec une palette intelligente qui encode les types de fichiers, les permissions et les métadonnées d'un coup d'œil : les répertoires dans une teinte, les exécutables dans une autre, les liens symboliques dans une troisième, avec des accents supplémentaires pour des éléments comme les bits collants et les chemins écrits par tout le monde. Vous ne configurez rien ; vous exécutez simplement `eza` et votre système de fichiers a soudainement une légende.

Le traditionnel `ls --color` semble rudimentaire en comparaison. Les paramètres par défaut d'Eza distinguent non seulement ce qu'est un fichier, mais aussi à quel point il est sûr de l'ouvrir. Les combinaisons de permissions suspectes, comme les binaires modifiables par le groupe, se démarquent immédiatement, agissant comme un audit de sécurité à faible friction chaque fois que vous listez un répertoire.

La couleur devient encore plus importante dès que vous commencez à utiliser des pipes. De nombreux outils suppriment les codes ANSI à moins que vous ne leur disiez explicitement de ne pas le faire, donc eza propose `--colour=always` pour forcer une sortie de couleur persistante. Ce simple drapeau maintient vos teintes en vie à travers `grep`, `less -R`, `fzf`, ou même dans les fichiers journaux que vous consultez plus tard.

Utilisés ensemble, le motif ressemble à ceci : - `eza --colour=always | less -R` - `eza --colour=always | grep motif` - `eza -l --git --colour=always | fzf`

Là où eza se démarque vraiment de `ls`, c'est avec `--colour-scale`, une fonctionnalité qui transforme les métadonnées brutes en un dégradé visuel. Avec `--colour-scale=size`, les objets volumineux - pensez aux images de machine virtuelle de plusieurs gigaoctets ou aux dossiers node_modules encombrés - s'illuminent différemment des petits fichiers de configuration. Passez à `--colour-scale=age` et les modifications d'hier brillent sur fond de déchets hérités non touchés.

Ces dégradés se répartissent particulièrement bien dans de grands arbres. Exécutez `eza --tree --colour-scale=size` sur un projet et vous pourrez repérer les 3 à 4 fichiers qui consomment de l'espace disque sans avoir à lire un seul chiffre. Cela ressemble davantage à une carte thermique qu'à une simple liste.

Si vous n'aimez pas les paramètres par défaut, eza ne vous piège pas. Il prend en charge des thèmes de couleurs personnalisés, chargés à partir de fichiers de configuration qui associent des rôles sémantiques (répertoire, lien symbolique, socket, modifié par git) à des styles spécifiques. Vous pouvez récupérer un thème de la communauté sur eza-community/eza, l'ajouter à votre configuration, ou créer le vôtre pour que chaque terminal que vous utilisez se sente indéniablement à vous.

La vue en grille est l'endroit où eza commence. Par défaut, elle regroupe les noms de fichiers dans une grille à plusieurs colonnes, utilisant la largeur de votre terminal pour éviter le désordre en colonne unique que vous obtenez souvent avec ls. Vous bénéficiez toujours de couleurs, d'icônes et de marqueurs Git dans cette vue, donc un simple `eza` est déjà plus informatif que `ls -F`.

Lorsque vous avez besoin de détails, `long view` est la valeur sûre. `eza -l` passe à une liste longue avec les permissions, propriétaires, groupes, tailles, horodatages et un statut Git optionnel dans un tableau clair et aligné. Combinez `-l` avec `-a` pour afficher les fichiers cachés ou avec `--group-directories-first` pour garder les dossiers en haut de la pile.

Parfois, vous souhaitez de la densité, pas de la décoration. `eza --oneline` affiche une entrée par ligne, idéal pour les scripts, les tuyauteries avec `fzf`, ou pour parcourir visuellement des répertoires massifs sans défilement horizontal. Ajoutez `--sort=size` ou `--sort=modified` pour transformer cela en un rapport visuel rapide de vos fichiers les plus gros ou les plus récents.

Les développeurs sont attirés par `eza --tree`. La vue en arbre parcourt récursivement les répertoires et affiche une hiérarchie complète avec des caractères de dessin de boîte, des icônes et des couleurs, rendant les répertoires imbriqués `src`, `tests` et `migrations` instantanément lisibles. Exécutez `eza --tree src` dans un dépôt JavaScript ou Rust et vous obtenez une carte du projet qui surpasse n'importe quel mur de texte produit par `ls -R`.

La sortie d'arbre peut exploser sur des monorepos réels, donc eza propose un frein efficace : `--level`. Utilisez `eza --tree --level=2` pour voir seulement les deux premières couches d'un espace de travail Node, ou `--level=4` pour jeter un œil plus profond dans `packages/` sans se noyer dans `node_modules`. Cette limite de profondeur transforme `--tree` d'une nouveauté en un outil quotidien pour naviguer dans des structures complexes.

Pour plus de contrôle, eza propose quelques commutateurs d'affichage ciblés. `--header` ajoute une ligne d'en-tête aux listes longues, étiquetant des colonnes telles que les permissions, la taille et l'heure de modification, ce qui est parfait lorsque vous capturez une capture d'écran de la sortie pour des documents ou des rapports de bogues. `--inode` affiche les numéros d'inode, inestimables lorsque vous déboguez des liens matériels ou un comportement étrange du système de fichiers.

Les utilisateurs avancés peuvent empiler ces options. Une commande comme `eza -la --header --inode --tree --level=2` vous offre un aperçu de projet richement annoté sur deux niveaux en un seul coup d'œil. Pour des explications plus approfondies sur ces modes et d'autres exemples, eza : Simplifier l'affichage des fichiers avec des fonctionnalités améliorées de 'ls' – Linuxiac décompose des combinaisons supplémentaires et des cas particuliers.

Les utilisateurs avancés de la ligne de commande vivent et meurent par l'ordre de tri. Eza considère le tri comme une fonctionnalité de premier plan avec un seul drapeau `--sort` cohérent, au lieu du mélange d'options de `ls`. Vous pouvez trier par taille (`--sort=size`), temps de modification (`--sort=modified` ou `--sort=mtime`), temps de création (`--sort=created` ou `--sort=ctime`), nom (`--sort=name`), ou extension (`--sort=extension`).

Là où `ls` répartit le comportement à travers des options comme `-t`, `-S` et `-X`, `eza` le regroupe en arguments lisibles et adaptés aux scripts. Vous avez besoin des plus gros artefacts en haut de votre répertoire de build ? `eza --sort=size --reverse target` fait apparaître immédiatement les plus gros coupables.

Inverser un tri expose l'une des différences les plus importantes par rapport à `ls`. Au lieu de variantes inverses séparées comme `-tr` ou `-Sr`, eza utilise toujours le même drapeau `--reverse`. Vous spécifiez par quoi trier, puis vous inversez : `eza --sort=modified --reverse` signifie « le plus ancien d'abord », sans gymnastique mentale requise.

Ce choix de conception porte ses fruits lorsque vous enchaînez les options. Une vue Git longue de votre dépôt, avec les dernières modifications en haut, devient `eza -l --git --sort=modified`. Vous voulez la même liste mais avec les anciens fichiers encombrants que vous devriez probablement supprimer ? Ajoutez `--reverse` et rien d'autre ne change.

Le tri ne vous amène qu'à mi-chemin ; les projets sérieux ont besoin de filtrage. Eza propose `--group-directories-first`, qui place les dossiers en haut de la liste sans astuces de locale étranges ni astuces de shell. Combinez-le avec `--sort=name` pour un agencement clair et prévisible dans n'importe quelle langue.

Lorsque vous devez réduire le bruit, `--only-dirs` et `--only-files` agissent comme des filtres chirurgicaux. Scannez uniquement votre structure de répertoires avec `eza --only-dirs --group-directories-first --tree`, ou inspectez uniquement les binaries compilés et les actifs en utilisant `eza --only-files --sort=size`. Aucune incantation `find` requise.

Ces drapeaux commencent à ressembler à des opérateurs de requête une fois que vous les empilez. Des combinaisons courantes dans le monde réel incluent : - `eza --group-directories-first --sort=extension --only-files src` - `eza -l --sort=created --reverse --only-files dist` - `eza --sort=modified --only-dirs --git`

Cette dernière commande affiche uniquement les répertoires, triés par activité récente, avec l'état Git intégré—une carte thermique en direct de l'endroit où votre travail se déroule réellement.

Les icônes transforment eza, un `ls` plus intelligent, en quelque chose qui semble vraiment moderne. Ajoutez `--icons` à n'importe quelle commande et les listes de fichiers obtiennent soudainement de petites glyphes à fort impact : un logo Python pour `.py`, une icône de document pour `.md`, un engrenage pour les exécutables, des symboles distincts pour les liens symboliques et les fichiers cachés. Les répertoires obtiennent des icônes de dossier, et les dépôts Git se démarquent instantanément lorsqu'ils sont combinés avec `--git` et `--git-repos`.

Ces icônes dépendent de Nerd Fonts, un projet populaire qui améliore les polices adaptées aux développeurs avec des milliers de glyphes supplémentaires. Nerd Fonts regroupe des symboles provenant de projets comme Font Awesome, Devicons et Octicons dans plus de 50 polices de base. Vous n'installez pas un plugin pour eza ; vous installez une police que votre terminal peut rendre.

Sur macOS, une configuration typique se fait en trois étapes. Téléchargez une police Nerd telle que FiraCode Nerd Font ou JetBrainsMono Nerd Font depuis nerdfonts.com, installez-la en double-cliquant puis en cliquant sur « Installer la police », puis configurez votre terminal pour l'utiliser. Les utilisateurs de Linux peuvent souvent l'installer via des gestionnaires de paquets (par exemple, `sudo pacman -S nerd-fonts-jetbrains-mono`) puis la sélectionner dans les préférences de leur émulateur.

Configurer iTerm2 est facile. Ouvrez Préférences → Profils → Texte, cliquez sur le sélecteur de police et choisissez votre Nerd Font installée (les variantes régulières et non-ligaturées fonctionnent toutes les deux). Ensuite, `eza --icons` affiche immédiatement les logos de langages, les icônes d'archives pour `.zip` et `.tar.gz`, les icônes de base de données pour `.sql`, et bien plus encore.

Les utilisateurs de Kitty modifient directement `kitty.conf`. Ajoutez une ligne comme `font_family JetBrainsMono Nerd Font` et redémarrez Kitty ou rechargez la configuration. Comme Kitty gère proprement l'Unicode moderne, les icônes s'affichent nettement, sans colonnes mal alignées ni caractères de boîte cassés.

La densité visuelle augmente, mais la charge cognitive diminue. Lorsque vous exécutez une commande comme `eza -l --git --icons`, votre œil peut parcourir rapidement : - Des icônes de dossier pour suivre la structure des répertoires - Des icônes de dépôt pour repérer les racines Git - Des icônes de langage pour trouver des `.ts`, `.rs`, `.go` d'un coup d'œil

Les liens hypertextes poussent eza encore plus loin dans le domaine des interfaces utilisateur graphiques. Avec `--hyperlink`, eza émet des séquences d'échappement OSC 8 que de nombreux terminaux modernes reconnaissent comme des liens cliquables. Les noms de fichiers deviennent des URL pointant vers des chemins `file://`, si bien que les cliquer peut ouvrir Finder sur macOS, votre gestionnaire de fichiers sur Linux, ou un éditeur qui s'inscrit comme gestionnaire.

Le support varie selon l'émulateur, mais iTerm2, Kitty et les versions récentes de GNOME Terminal gèrent ces liens de manière fiable. Combinez `--hyperlink` avec `--icons --long --git` et vous obtenez un tableau de bord dense, cliquable et visuellement codé de votre répertoire de travail - le tout à partir d'une seule commande.

Le ls à l'ancienne est toujours présent sur chaque système de type Unix, mais son ensemble de fonctionnalités a stagné il y a des décennies. Pas de couleurs par défaut, pas de prise en charge de Git, pas d'icônes et pas de liens hypertexte. Vous pouvez ajouter des alias et des LS_COLORS, mais vous devez toujours jongler avec des options qui varient entre GNU coreutils, BSD et macOS.

Les remplacements modernes se répartissent en trois catégories : exa, lsd et eza. Les trois visent de meilleurs paramètres par défaut, des couleurs et de meilleures métadonnées. Cependant, seul l'un d'eux est activement maintenu en 2024.

Aperçu rapide des fonctionnalités :

• 1ls : C, omniprésent, fonctionnalités minimales, pas de Git, pas d'icônes
• 2exa : Rust, archivé sur GitHub, couleur, Git de base, support de certains arbres
• 3lsd : Rust, icônes et couleurs réfléchies, pas de Git approfondi, vélocité des fonctionnalités plus lente.
• 4eza : Rust, communauté active, orienté vers Git, icônes, hyperliens, arbres, personnalisation des thèmes

Différenciateur clé : exa est effectivement gelé. Son dépôt GitHub est archivé, avec des problèmes ouverts et des pull requests non fusionnées s'accumulant. Eza a commencé comme un fork, mais les mainteneurs de la communauté eza l'ont transformé en un projet en pleine évolution avec des versions fréquentes, des indicateurs modernes et des paquets de distribution arrivant rapidement.

Les performances restent excellentes au sein du trio Rust. Les benchmarks réalisés par les utilisateurs montrent qu'eza et lsd effectuent des listings de répertoires en quelques dizaines de millisecondes sur des arbres de taille moyenne, battant généralement GNU ls une fois que vous activez des drapeaux de couleur et de classification comparables. Eza s'appuie sur l'écosystème compatible avec l'asynchrone de Rust et sur des appels système optimisés pour maintenir une faible latence, même lorsque `--git` ou `--tree` parcourent des dépôts entiers.

La profondeur des fonctionnalités est là où eza prend l'avantage. Vous obtenez `--git`, `--git-repos`, `--git-ignore`, `--colour-scale`, `--icons`, `--hyperlink`, `--only-dirs` et `--sort` avec des champs comme `size`, `modified`, `created` et `extension`. Lsd se concentre sur de jolis paramètres par défaut et des icônes mais ignore les métadonnées Git avancées ; exa expose certaines informations Git mais manque de nouveaux flags et des corrections de bugs ajoutées par eza.

L'écosystème et la documentation scellent l'accord. Eza s'installe via Homebrew, dans les principaux dépôts Linux, et propose des pages de manuel détaillées, ainsi que des thèmes communautaires et des extraits de configuration. Pour une analyse approfondie, Transformez votre terminal avec eza : la mise à niveau que ls méritait - DEV Community présente des configurations pratiques et des alias.

Pris ensemble, le développement actif, les performances de Rust et un ensemble de fonctionnalités axé sur Git font d'eza le remplaçant `ls` le plus performant que vous puissiez installer en 2024.

Commencez par des alias. La plupart des gens intègrent `eza` dans leur mémoire musculaire avec quelques raccourcis très utiles dans `~/.zshrc` ou `~/.bashrc` :

• 1`alias ll="eza -l --group-directories-first --git --icons"`
• 2`alias la="eza -la --group-directories-first --git --icons"`
• 3`alias lt="eza --arbre --niveau=2 --long --git --icônes"`
• 4`alias l1="eza --oneline --sort=name"`
• 5`alias lg='eza -l --git --git-ignore --group-directories-first'`

Ces cinq éléments couvrent 90 % des listes quotidiennes : vue détaillée, vue tous fichiers, vue arborescente, vue en colonne unique et vue compatible avec Git.

Ensuite, créez un paramètre personnel par défaut et liez-le à `ls` lui-même. Beaucoup de développeurs le font :

- `alias ls="eza --groupes-dossiers-en-premier --icônes --git --en-tête"`

À partir de là, ajoutez des drapeaux qui correspondent à votre flux de travail : `--all` si vous vivez dans les dotfiles, `--binary` si vous tenez à des tailles lisibles par un humain, ou `--colour-scale=size` si vous chassez constamment de gros artefacts dans `dist/` ou `node_modules/`.

Les utilisateurs avancés empilent plusieurs comportements dans des vues spécialisées. Exemples :

• 1`alias lcode='eza -l --git --git-ignore --sort=modifié --groupes-dossiers-en-premier src tests'`
• 2`alias lbig="eza -l --sort=taille --reverse --colour-scale=taille"`
• 3`alias lrecent='eza -l --sort=modifié --inverse --échelle-couleur=âge'`
• 4`alias ldirs="eza --only-dirs --group-directories-first --tree --level=3"`

Ces compressent des intentions complexes—« montre-moi les changements de code récents » ou « fais ressortir les plus gros fichiers »—en 5 à 6 caractères.

La personnalisation ne s'arrête pas aux drapeaux. Eza prend en charge les thèmes, vous pouvez donc déposer un thème communautaire dans le répertoire de configuration (voir GitHub) et basculer instantanément, ou ajuster manuellement les couleurs pour les permissions, les liens symboliques et les états Git à l'aide du guide de personnalisation. Combinez cela avec Nerd Fonts, `--hyperlink` et `--icons` pour transformer votre terminal en un tableau de bord dense et navigable.

À vous de jouer : partagez vos alias `eza` les plus percutants, vos configurations de thèmes et vos répliques décalées dans les commentaires. Le truc à trois drapeaux de quelqu'un d'autre pourrait devenir votre nouvelle référence.

Qu'est-ce que l'eza ?

Eza est une utilité moderne riche en fonctionnalités en ligne de commande qui remplace la commande traditionnelle 'ls'. Écrite en Rust, elle offre de meilleures performances, une sortie codée par couleur, une intégration Git, des icônes de fichiers, une vue en arborescence, et bien plus encore.

Eza est-il un remplacement direct et transparent pour 'ls' ?

Principalement, mais pas entièrement. Bien que vous puissiez aliaser 'ls' en 'eza' pour un usage quotidien, certaines options et comportements de tri diffèrent. Par exemple, inverser une liste par temps nécessite une combinaison d'options différente dans eza par rapport à ls.

Comment installer eza ?

Vous pouvez installer eza en utilisant des gestionnaires de paquets comme Homebrew pour macOS (`brew install eza`) ou le gestionnaire de paquets de votre distribution pour Linux (par exemple, `sudo apt install eza`).

Pourquoi ai-je besoin d'une Nerd Font pour utiliser des icônes avec eza ?

Les Nerd Fonts sont des polices spéciales patchées avec un grand nombre de glyphes et d'icônes. Eza utilise ces icônes pour représenter différents types de fichiers et dossiers, donc une Nerd Font doit être installée et configurée dans votre terminal pour les afficher correctement.