Commande ls sous Linux :17 exemples utiles expliqués

Le ls La commande est l'une des premières commandes que nous apprenons lors de la découverte du shell. Et après, quel que soit votre niveau, il restera l'un des plus utilisés.

Malgré cette popularité, nous allons rarement au-delà du -l , -d et -a options. C'est dommage car un ls typique la mise en œuvre a des dizaines d'options disponibles ! Je vous propose donc de me suivre dans ma recherche du ls commander des joyaux cachés.

Exemple de hiérarchie de fichiers que nous utilisons dans ce guide de commande ls

Avant d'entrer dans le vif du sujet, nous avons besoin d'un peu de préparation :il serait difficile d'étudier les ls commande sans répertoire sur lequel travailler. Afin que vous puissiez essayer sur votre ordinateur les commandes données dans cet article, voici comment créer l'exemple de hiérarchie de fichiers que j'utiliserai dans tous mes exemples. Copiez-collez simplement cette liste de commandes sur votre terminal et vous serez prêt :

mkdir ls
cd ls
# Create a hidden file:
echo You can not see me > .hidden
# Create a couple of 2MiB files:
dd if=/dev/zero of=a bs=1M count=2
dd if=/dev/zero of=b bs=1M seek=1 count=1
# Create few sub-directories
mkdir -p dir/subdir dir/subdir2
# Create a bunch of empty files
touch c dir/{d,e,f} dir/subdir/{g,h,i} dir/subdir2/{j,k,l}
# Create few links (hard and symbolic)
ln  dir/e hardlink-to-file
ln -s dir/f symlink-to-file
ln -s dir/subdir symlink-to-subdir

Si vous rencontrez des problèmes avec ces commandes, n'hésitez pas à utiliser la section des commentaires pour demander de l'aide. En supposant que tout soit en ordre, il est temps de plonger dans notre sujet principal.

Les cas d'utilisation bien connus de la commande ls

Comme chaque voyage commence par une première étape, examinons d'abord les cas d'utilisation très basiques pour le ls commande. Bien sûr, si vous vous considérez comme un expert, n'hésitez pas à passer immédiatement aux sections les plus avancées. Mais si vous préférez rester avec moi pour l'instant, tant mieux :vous pourriez apprendre une chose ou deux !

<no option> :le comportement par défaut

Le ls La commande donne des informations sur chaque objet de type fichier pointé par les chemins indiqués sur la ligne de commande. Lorsqu'il est utilisé sans aucune option :

• la seule information affichée est le nom de l'objet de type fichier pointé par le chemin ;
• si ce chemin pointe vers un répertoire (ou un lien symbolique vers un répertoire), le ls la commande répertorie également le contenu de ce répertoire ;
• si plusieurs entrées sont affichées, elles sont triées dans l'ordre alphabétique de leur nom de fichier.

Enfin, lorsqu'aucun chemin n'est donné sur la ligne de commande, le ls les commandes supposent ./ –c'est le répertoire courant.

Voyons maintenant toutes ces règles en action :

# display the content of the current directory
sh:~/ls$ ls ./
a  c    e  hardlink-to-file  symlink-to-file
b  dir    f  link-to-subdir    symlink-to-subdir

# without any option, `ls` is equivalent
# to `ls ./`
sh:~/ls$ ls
a  c    e  hardlink-to-file  symlink-to-file
b  dir    f  link-to-subdir    symlink-to-subdir

# entries are sorted alphabetically
# ("dir/f" starts with a "d" so it is before "e")
sh:~/ls$ ls c b e dir/f a
a  b  c  dir/f    e

# when a command line argument is a directory
# (or a symbolic link to a directory)
# displays its content
sh:~/ls$ ls a b c link-to-subdir dir
a  b  c

dir:
d  e  f  subdir  subdir2

link-to-subdir:
g  h  i

-d :ne liste pas le contenu du répertoire

Avec le -d option, ls n'affiche plus le contenu du répertoire donné sur la ligne de commande mais traite plutôt les entrées de répertoire comme des entrées de fichier. Comparons :

# Default behavior: display the content of the `dir` directory
sh:~/ls$  ls a dir b
a  b

dir:
d  e  f  subdir  subdir2

# `-d` option: directories are handled like files
sh:~/ls$  ls -d a dir b
a  b  dir

Lors de l'utilisation du -d option seule, il n'y a pas beaucoup de différence entre ls et un simple echo commande :

# In both case, the `*` glob pattern is expanded by
# the shell, which also takes care of
# sorting entries in the alphabetical order
sh:~/ls$  ls -d *
a  b  c  dir  hardlink-to-file    symlink-to-file  symlink-to-subdir

sh:~/ls$  echo *
a b c dir hardlink-to-file symlink-to-file symlink-to-subdir

Mais le -d l'option devient plus utile lorsqu'elle est associée à une autre option pour afficher des informations supplémentaires, comme lors de l'utilisation de -l drapeau nous allons voir maintenant.

-l :l'option format long

Dans le ls concours de popularité des options, le -l (lettre ell minuscule) serait probablement le gagnant. C'est tellement utile que de nombreux systèmes offrent un ll alias pour ls -l (ou ls -l<something> )

Le -l correspond au format long. Avec cette option, le ls La commande affichera chaque entrée sur sa propre ligne contenant les informations suivantes :* mode de fichier * nombre de liens * nom du propriétaire * nom du groupe * nombre d'octets dans le fichier * date et heure * chemin d'accès

Aussi, avec le -l option, ls ne suivra plus les liens symboliques. Ainsi, il affichera les informations (mode de fichier, nombre de liens, etc.) sur le lien lui-même, et non sur sa destination. Pour la même raison, le ls La commande n'affichera pas le contenu des répertoires pointés par des liens symboliques :

# Default behavior: displays only the filename and
# follows symbolic links:
sh:~/ls$  ls *
a  b  c  e  f  hardlink-to-file  symlink-to-file

dir:
d  e  f  subdir  subdir2

link-to-subdir:
g  h  i

symlink-to-subdir:
g  h  i

# `-l` option: displays extended informations and
# no longer follows symbolic links
sh:~/ls$  ls -l *
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 19 22:18 a
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 19 22:18 b
-rw-r--r-- 1 sylvain sylvain       0 Sep 19 22:18 c
-rw-r--r-- 3 sylvain sylvain       0 Sep 19 22:18 e
lrwxrwxrwx 1 sylvain sylvain       5 Sep 19 12:09 f -> dir/f
-rw-r--r-- 3 sylvain sylvain       0 Sep 19 22:18 hardlink-to-file
lrwxrwxrwx 1 sylvain sylvain      10 Sep 19 12:09 link-to-subdir -> dir/subdir
lrwxrwxrwx 1 sylvain sylvain       5 Sep 19 22:18 symlink-to-file -> dir/f
lrwxrwxrwx 1 sylvain sylvain      10 Sep 19 22:18 symlink-to-subdir -> dir/subdir

dir:
total 8
-rw-r--r-- 1 sylvain sylvain    0 Sep 19 22:18 d
-rw-r--r-- 3 sylvain sylvain    0 Sep 19 22:18 e
-rw-r--r-- 1 sylvain sylvain    0 Sep 19 22:18 f
drwxr-xr-x 2 sylvain sylvain 4096 Sep 19 12:09 subdir
drwxr-xr-x 2 sylvain sylvain 4096 Sep 19 12:09 subdir2

Pour conclure cette section, je vous laisse examiner la sortie que nous obtenons en combinant à la fois le -l et -d option :

sh:~/ls$  ls -ld *
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 19 22:18 a
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 19 22:18 b
-rw-r--r-- 1 sylvain sylvain       0 Sep 19 22:18 c
drwxr-xr-x 4 sylvain sylvain    4096 Sep 19 12:09 dir
-rw-r--r-- 3 sylvain sylvain       0 Sep 19 22:18 e
lrwxrwxrwx 1 sylvain sylvain       5 Sep 19 12:09 f -> dir/f
-rw-r--r-- 3 sylvain sylvain       0 Sep 19 22:18 hardlink-to-file
lrwxrwxrwx 1 sylvain sylvain      10 Sep 19 12:09 link-to-subdir -> dir/subdir
lrwxrwxrwx 1 sylvain sylvain       5 Sep 19 22:18 symlink-to-file -> dir/f
lrwxrwxrwx 1 sylvain sylvain      10 Sep 19 22:18 symlink-to-subdir -> dir/subdir

-a :affiche tous les fichiers

Avec le -a option, ls inclut les fichiers cachés lors de l'affichage du contenu d'un répertoire. Mais qu'est-ce qu'un fichier caché ?

Par convention, sur les systèmes de type Unix, un fichier dont le nom commence par un point est considéré comme caché. De plus, chaque répertoire contient également deux entrées spéciales, normalement masquées :. et ..

Dans chaque répertoire :

• le . points d'entrée vers le répertoire lui-même. Ce genre d'auto-référence peut sembler curieux. Mais c'est parfois utile, un peu comme avoir son propre numéro de téléphone dans le répertoire de son smartphone.
• le .. points d'entrée vers le répertoire parent. Étant donné que la hiérarchie des fichiers sur les systèmes de type Unix est strictement organisée en arborescence, chaque répertoire a un et un seul parent. Sauf le répertoire racine / peut être? Eh bien, pas vraiment :le parent du répertoire racine est… le répertoire racine lui-même.

# Default behavior: do not display hidden entries
# (including . and ..)
sh:~/ls$  ls
a  c    e  hardlink-to-file  symlink-to-file
b  dir    f  link-to-subdir    symlink-to-subdir

# `-a` option: show hidden files and directories
sh:~/ls$  ls -a
.   a  c    e  hardlink-to-file  link-to-subdir   symlink-to-subdir
..  b  dir  f  .hidden         symlink-to-file

Les options utiles de la commande ls

Après avoir passé en revue le bien connu -l , -d et -a options, tournons notre attention vers quelques options moins connues que je trouve particulièrement utiles.

-s :affiche la taille allouée

Vous vous souvenez peut-être du -l option affiche le nombre d'octets dans le fichier. Le -s L'option affiche la taille allouée en blocs. Qu'est-ce qu'un bloc ? Eh bien, un groupe d'octets dont la taille dépend de l'implémentation. Il est généralement de 512 octets sous BSD et de 1 024 octets sous Linux.

Pourquoi devrais-je m'embêter avec la taille en blocs alors que j'ai déjà accès à la taille en octets ? Eh bien, le -s les options affichent les alloués Taille. Pas la logique taille du fichier. Il peut s'agir de deux choses complètement différentes pour les fichiers fragmentés. Les fichiers fragmentés sont des fichiers qui contiennent des "trous". Lors de la lecture, ces trous se comportent comme des blocs de fichiers normaux contenant uniquement des zéros. Mais ils ne prennent pratiquement pas d'espace sur le disque. Nous pouvons utiliser le dd commande avec le seek option pour créer des fichiers clairsemés comme je l'ai fait pour le b fichier dans mon exemple de hiérarchie :

sh:~/ls$ ls -ls a b
2052 -rw-r--r-- 1 sylvain sylvain 2097152 Sep 19 22:18 a
1028 -rw-r--r-- 1 sylvain sylvain 2097152 Sep 19 22:18 b

Comme vous pouvez le voir, mes deux a et b les fichiers semblent avoir une longueur de deux mébioctets. Mais le b fichier étant clairsemé, il ne prend que 1028 blocs sur le disque (environ un mébioctet).

-h afficher des tailles lisibles par l'homme

Avec le -h option, ls affichera les tailles de fichier en utilisant des suffixes d'unité pour les rendre plus conviviaux. Cette option n'a de sens que lorsqu'elle est utilisée en combinaison avec le -l (Linux, BSD) ou -s (Linux):

sh:~/ls$ ls -lsh a b
2.1M -rw-r--r-- 1 sylvain sylvain 2.0M Sep 19 22:18 a
1.1M -rw-r--r-- 1 sylvain sylvain 2.0M Sep 19 22:18 b

openbsd-6.3$ ls -lsh a b
4128 -rw-r--r--  1 sylvain  sylvain   2.0M Sep 19 23:49 a
2112 -rw-r--r--  1 sylvain  sylvain   2.0M Sep 19 23:49 b

Vous avez peut-être remarqué que les tailles sont affichées en utilisant des puissances de 1024 unités, où K représente 2^10=1024 octets, M pour 1024^2=1048576 octets et ainsi de suite. Il convient de mentionner ici le ls l'implémentation fournie dans le cadre de GNU Coreutils a un --si supplémentaire options pour utiliser la puissance 1000 au lieu des puissances de 1024 :

sh:~/ls$ ls -lsh --si a b
2.2M -rw-r--r-- 1 sylvain sylvain 2.1M Sep 19 22:18 a
1.1M -rw-r--r-- 1 sylvain sylvain 2.1M Sep 19 22:18 b

-i afficher le numéro d'inode

Sur un système de fichiers de style Unix, un numéro d'inode (ou numéro de série de fichier dans la terminologie POSIX) est un nombre qui identifie de manière unique un objet du système de fichiers (un fichier, un répertoire, un tube nommé, …). Avec le -i option, le ls La commande affichera son numéro d'inode à côté de chaque chemin.

Même si cela semble quelque peu exotique, je me retrouve à utiliser le -i option de temps en temps, en particulier pour identifier les entrées de répertoire qui font référence au même objet de système de fichiers. Vous utiliserez cette option principalement lors de la recherche de liens physiques ou de montages liés. Regardez cette vidéo pour un exemple pratique :https://youtu.be/Jp58Osb1uFo?t=140

sh:~/ls$  ls -i *
8222 a    8243 b    8262 c    8264 hardlink-to-file  8272 symlink-to-file

dir:
8263 d    8264 e    8265 f    8245 subdir  8261 subdir2

symlink-to-subdir:
8266 g    8267 h    8268 i

Dans l'exemple ci-dessus, vous pouvez voir chaque nom de fichier préfixé par le numéro d'inode associé à ce chemin. Sur votre système, les chiffres seront sûrement différents. Quoi qu'il en soit, regardez de plus près le hardlink-to-file et dir/e entrées. Les deux ont le même numéro d'inode (8264 dans mon cas). Cela signifie qu'il s'agit de deux entrées faisant référence au même objet de système de fichiers sous-jacent, ce qui est, en fait, la définition exacte de ce qu'est un lien physique.

Vous vous souvenez peut-être que j'ai dit plus tôt que le parent du répertoire racine était le répertoire racine lui-même. En utilisant le -i option, il est assez facile de vérifier cette assertion :

openbsd-6$  ls -id /
2 /
openbsd-6$ ls -ia /
    2 .             25985 bin               5 dev           77954 sbin
    2 ..             1235 boot          51969 etc              10 sys
    8 .cshrc         1240 bsd               2 home              7 tmp
    9 .profile       1241 bsd.booted    77953 mnt               2 usr
51968 altroot           4 bsd.rd        26016 root          78016 var

Comme vous pouvez le voir, sur mon système, le répertoire racine est associé à l'inode numéro 2, qui est également l'inode de son parent. Cela prouve donc que le répertoire racine est son propre parent.

Les options rarement utilisées de la commande ls

J'utilise régulièrement les options décrites dans la section précédente, mais celles dont je vais parler maintenant… eh bien… je sais qu'elles existent. Cependant, je dois admettre que lorsque j'en ai besoin, je dois souvent regarder le man pour me rafraîchir la mémoire.

-L :affiche des informations sur la cible des liens symboliques

Cette option modifie le comportement du ls commande lorsqu'elle est appliquée à des liens symboliques. Avec le -L option, ls affichera les informations sur la cible du lien symbolique au lieu d'afficher ceux liés au lien symbolique lui-même. En examinant l'exemple suivant, la différence sera évidente :

# Pay special attention to the permission
# and file size for symbolic links with and without
# the `-L` option:
sh:~/ls$  ls -ld *
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 20 00:09 a
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 20 00:09 b
-rw-r--r-- 1 sylvain sylvain       0 Sep 20 00:09 c
drwxr-xr-x 4 sylvain sylvain    4096 Sep 20 00:09 dir
-rw-r--r-- 2 sylvain sylvain       0 Sep 20 00:09 hardlink-to-file
lrwxrwxrwx 1 sylvain sylvain       5 Sep 20 00:09 symlink-to-file -> dir/f
lrwxrwxrwx 1 sylvain sylvain      10 Sep 20 00:09 symlink-to-subdir -> dir/subdir
[email protected]:/tmp/ls/ls/ls$ ls -lLd *
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 20 00:09 a
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 20 00:09 b
-rw-r--r-- 1 sylvain sylvain       0 Sep 20 00:09 c
drwxr-xr-x 4 sylvain sylvain    4096 Sep 20 00:09 dir
-rw-r--r-- 2 sylvain sylvain       0 Sep 20 00:09 hardlink-to-file
-rw-r--r-- 1 sylvain sylvain       0 Sep 20 00:09 symlink-to-file
drwxr-xr-x 2 sylvain sylvain    4096 Sep 20 00:09 symlink-to-subdir

-F :ajoute un caractère de classification au nom du fichier

Le -F L'option ajoute un caractère supplémentaire après le chemin d'accès de certaines catégories d'objets du système de fichiers pour les identifier. Il ajoutera :

• un \ après chaque chemin d'accès qui est un répertoire,
• un @ après chaque nom de chemin qui est un lien symbolique,
• un * après chaque fichier exécutable,
• et un | après chaque FIFO (voir mkfifo pour plus d'informations à ce sujet)

À mes débuts sous Unix, j'utilisais beaucoup cette option. Mais depuis ls peut coloriser sa sortie (et puisque nous avons des moniteurs couleur !), j'en ai rarement besoin. Mais je m'en souviens. Et de temps en temps, sur un terminal distant, je trouve une occasion de l'utiliser :

sh:~/ls$ ls -F
a  b  c  dir/  hardlink-to-file  [email protected]  [email protected]

t :trier les entrées par heure de modification

Avec le -t option, le ls commande avec les entrées du répertoire d'affichage triées par date de modification (la plus récente en premier) au lieu de les trier par leur nom :

# Default sort order (by filename)
sh:~/ls$  ls
a  b  c  dir  hardlink-to-file    symlink-to-file  symlink-to-subdir

# Sort by modification date
sh:~/ls$ ls -t
symlink-to-subdir  symlink-to-file  c  dir  hardlink-to-file  b  a

Si je modifie un fichier, il apparaîtra désormais comme la première entrée (c'est-à-dire la plus récemment modifiée) de la liste :

sh:~/ls$ echo >> a
sh:~/ls$ ls -t
a  symlink-to-subdir  symlink-to-file  c  dir  hardlink-to-file  b

-S :trier les entrées par taille

Avec le -S option, ls affichera les entrées triées par taille, le plus grand fichier en premier. En cas d'égalité, les entrées sont triées selon leur chemin :

sh:~/ls$ ls -lS
total 6244
-rw-r--r--  1 sylvain  sylvain  2097152 Sep 19 23:49 a
-rw-r--r--  1 sylvain  sylvain  2097152 Sep 19 23:49 b
drwxr-xr-x  4 sylvain  sylvain      512 Sep 19 23:49 dir
lrwxr-xr-x  1 sylvain  sylvain       10 Sep 19 23:49 symlink-to-subdir -> dir/subdir
lrwxr-xr-x  1 sylvain  sylvain        5 Sep 19 23:49 symlink-to-file -> dir/f
-rw-r--r--  1 sylvain  sylvain        0 Sep 19 23:49 c
-rw-r--r--  2 sylvain  sylvain        0 Sep 19 23:49 hardlink-to-file

-r :ordre de tri inversé

Cette option inverse l'ordre de tri. Je le trouve plus utile lorsqu'il est associé au -t option pour afficher le fichier le moins récemment modifié en premier ou avec le -S option pour afficher le plus petit fichier en premier. Mais cela fonctionne également avec l'ordre de tri par défaut, par chemin d'accès :

# Display the least recently modified file first
sh:~/ls$ ls -rt
b  hardlink-to-file  dir  c  symlink-to-file  symlink-to-subdir  a

# Display the smallest file first
sh:~/ls$ ls -rS
hardlink-to-file  c  symlink-to-file  symlink-to-subdir  dir  b  a

# Display path names in reversed alphabetical order
sh:~/ls$ ls -r
symlink-to-subdir  symlink-to-file  hardlink-to-file  dir  c  b  a

-n :Afficher l'UID/GID numérique

Cette option est exactement la même que le -l option— sauf avec -n l'identifiant de groupe (GID) et l'identifiant utilisateur (UID) du propriétaire sont affichés sous forme de nombres plutôt que d'utiliser leur nom associé :

 sh:~/ls$ ls -ld a b c /
drwxr-xr-x 28 root    root       4096 May  6 00:28 /
-rw-r--r--  1 sylvain sylvain 2097153 Sep 20 00:45 a
-rw-r--r--  1 sylvain sylvain 2097152 Sep 20 00:09 b
-rw-r--r--  1 sylvain sylvain       0 Sep 20 00:09 c
sh:~/ls$ ls -nd a b c /
drwxr-xr-x 28    0    0    4096 May  6 00:28 /
-rw-r--r--  1 1000 1000 2097153 Sep 20 00:45 a
-rw-r--r--  1 1000 1000 2097152 Sep 20 00:09 b
-rw-r--r--  1 1000 1000       0 Sep 20 00:09 c

L'utilisation vraiment exotique de la commande ls

Personne ne peut prétendre tout savoir. Et en écrivant cet article, j'ai (re-)découvert quelques ls options. Je ne me souviens pas les avoir utilisés moi-même, mais peut-être l'avez-vous fait ? Si tel est le cas, je serais curieux de lire dans la section commentaire dans quelles circonstances vous les trouvez utiles. Quoi qu'il en soit, voici une sélection qui pourrait vous intéresser.

-R :liste récursivement les sous-répertoires

Par défaut, le ls La commande affiche uniquement le contenu des répertoires explicitement donnés sur la ligne de commande. Avec le -R option, il affichera aussi récursivement le contenu des répertoires rencontrés :

sh:~/ls$ ls -R
.:
a  b  c  dir  hardlink-to-file    symlink-to-file  symlink-to-subdir

./dir:
d  e  f  subdir  subdir2

./dir/subdir:
g  h  i

./dir/subdir2:
j  k  l

Bien qu'intéressant en théorie, je trouve (jeu de mots) la sortie produite par le find . commande plus lisible à cet effet. Mais votre kilométrage peut varier, bien sûr :

sh:~/ls$  find .
.
./c
./.hidden
./hardlink-to-file
./b
./symlink-to-subdir
./dir
./dir/d
./dir/e
./dir/subdir2
./dir/subdir2/l
./dir/subdir2/j
./dir/subdir2/k
./dir/subdir
./dir/subdir/g
./dir/subdir/i
./dir/subdir/h
./dir/f
./symlink-to-file
./a

-A :affiche presque tous les fichiers

Bien qu'il ne soit pas défini dans la norme POSIX, le -A les options apparaissent à la fois dans le monde GNU et BSD. Dans les deux cas, cela fonctionne comme -a , mais en excluant le . et .. entrées. À mentionner sur les systèmes BSD, -A est implicite pour le superutilisateur :

sh:~/ls$  ls -a
.   a  c    hardlink-to-file  symlink-to-file
..  b  dir  .hidden          symlink-to-subdir
sh:~/ls$  ls -A
a  b  c  dir  hardlink-to-file    .hidden  symlink-to-file  symlink-to-subdir

openbsd-6.3$ su root
openbsd-6.3# ls
.hidden a  b  c  dir  hardlink-to-file  symlink-to-file  symlink-to-subdir

-f :ne pas trier

Avec le -f option, ls affichera les entrées dans l'ordre dans lequel elles apparaissent dans le répertoire. Cet ordre dépend du système de fichiers sous-jacent et les fichiers de commande ont été créés, il est donc difficilement prévisible. Le -f l'option implique également le -a choix :

sh:~/ls$  ls -f
..  .hidden          b             dir          a
c   hardlink-to-file  symlink-to-subdir  symlink-to-file  .

openbsd-6$ ls -f
.                   a                   c                   symlink-to-subdir
..                  b                   hardlink-to-file
.hidden             dir                 symlink-to-file

Assez amusant, avec le GNU Coreutils 8.26 ls implémentation, vous pouvez utiliser à la fois le -l et -f options si vous l'épelez -fl –mais pas si vous écrivez -lf . Sur OpenBSD, les deux fonctionnent comme prévu :

sh:~/ls$ ls -lf
..  .hidden          b             dir          a
c   hardlink-to-file  symlink-to-subdir  symlink-to-file  .
sh:~/ls$ ls -fl
total 3100
drwxr-xr-x 3 sylvain sylvain    4096 Sep 19 12:09 ..
-rw-r--r-- 1 sylvain sylvain       0 Sep 20 00:09 c
-rw-r--r-- 1 sylvain sylvain      19 Sep 20 00:09 .hidden
-rw-r--r-- 2 sylvain sylvain       0 Sep 20 00:09 hardlink-to-file
-rw-r--r-- 1 sylvain sylvain 2097152 Sep 20 00:09 b
lrwxrwxrwx 1 sylvain sylvain      10 Sep 20 00:09 symlink-to-subdir -> dir/subdir
drwxr-xr-x 4 sylvain sylvain    4096 Sep 20 00:09 dir
lrwxrwxrwx 1 sylvain sylvain       5 Sep 20 00:09 symlink-to-file -> dir/f
-rw-r--r-- 1 sylvain sylvain 2097153 Sep 20 00:45 a
drwxr-xr-x 3 sylvain sylvain    4096 Sep 20 00:09 .

openbsd-6$ ls -lf
total 6256
drwxr-xr-x  3 sylvain  sylvain      512 Sep 19 23:49 .
drwxr-xr-x  5 sylvain  sylvain      512 Sep 19 23:49 ..
-rw-r--r--  1 sylvain  sylvain       19 Sep 19 23:49 .hidden
-rw-r--r--  1 sylvain  sylvain  2097152 Sep 19 23:49 a
-rw-r--r--  1 sylvain  sylvain  2097152 Sep 19 23:49 b
drwxr-xr-x  4 sylvain  sylvain      512 Sep 19 23:49 dir
-rw-r--r--  1 sylvain  sylvain        0 Sep 19 23:49 c
-rw-r--r--  2 sylvain  sylvain        0 Sep 19 23:49 hardlink-to-file
lrwxr-xr-x  1 sylvain  sylvain        5 Sep 19 23:49 symlink-to-file -> dir/f
lrwxr-xr-x  1 sylvain  sylvain       10 Sep 19 23:49 symlink-to-subdir -> dir/subdir
openbsd-6$ ls -fl
total 6256
drwxr-xr-x  3 sylvain  sylvain      512 Sep 19 23:49 .
drwxr-xr-x  5 sylvain  sylvain      512 Sep 19 23:49 ..
-rw-r--r--  1 sylvain  sylvain       19 Sep 19 23:49 .hidden
-rw-r--r--  1 sylvain  sylvain  2097152 Sep 19 23:49 a
-rw-r--r--  1 sylvain  sylvain  2097152 Sep 19 23:49 b
drwxr-xr-x  4 sylvain  sylvain      512 Sep 19 23:49 dir
-rw-r--r--  1 sylvain  sylvain        0 Sep 19 23:49 c
-rw-r--r--  2 sylvain  sylvain        0 Sep 19 23:49 hardlink-to-file
lrwxr-xr-x  1 sylvain  sylvain        5 Sep 19 23:49 symlink-to-file -> dir/f
lrwxr-xr-x  1 sylvain  sylvain       10 Sep 19 23:49 symlink-to-subdir -> dir/subdir

-q :affiche les caractères de nom de fichier non imprimables sous la forme ?

Sur les systèmes de fichiers de style Unix, un nom de fichier peut contenir n'importe quel caractère sauf le \ et les caractères NUL. Cela signifie qu'un nom de fichier peut contenir des caractères non imprimables ou même des séquences de contrôle qui peuvent interférer avec votre terminal. Essayons quelque chose d'amusant :

touch "$(echo -e '\x1B[7mBOO\x1B[0m')"

De toute évidence, ce nom de fichier contient des caractères non imprimables. Sur les implémentations modernes de ls , le -q L'option est implicite lorsque la sortie est un terminal, pour éviter les effets néfastes potentiels. Ainsi les caractères non imprimables seront remplacés par un point d'interrogation :

sh:~/ls$ ls *BOO*
?[7mBOO?[0m

Cependant, les choses seront différentes si vous écrivez plutôt :

# I let you try that by yourself
# to not spoil the fun;)
sh:~/ls$ ls *BOO* | cat

Le | cat est inutile, mais comme effet secondaire, le ls La commande voit maintenant un tube sur sa sortie standard au lieu d'un tty (un "terminal"). Puisque la sortie n'est plus un terminal, le -q l'option n'est plus implicite, et ls affichera le nom du fichier tel quel. Dans ce cas, si tout fonctionne comme prévu, pour présenter le nom du fichier avec un effet vidéo funky.

Utiliser explicitement le -q l'option résoudrait cela. Je vous laisse essayer par vous-même (et éventuellement jouer avec d'autres séquences d'échappement ANSI). Mais je profite de cette occasion pour vous mettre en garde contre l'utilisation du ls commande dans les scripts shell. En pratique, ls est destiné à la « consommation humaine ». Il existe de nombreux cas secondaires concernant des noms de fichiers spécialement conçus qui sont très difficiles à gérer correctement. Si vous avez besoin de parcourir une liste de fichiers, je vous encourage fortement à utiliser la commande find à la place. Dans les cas les plus simples, un simple for boucle est même suffisante, mais ce serait une autre histoire.

for f in *; do echo "$f"; done

La fin ?

Voilà qui conclut notre visite du ls options de commande. Inutile de le préciser c'était loin d'être exhaustif et j'ai essayé de me concentrer ici sur les options les plus utiles et les plus portables. Mais chaque ls l'implémentation a sa part de fonctionnalités intéressantes, donc si vous connaissez une option intéressante que j'ai manquée dans cet article, n'hésitez pas à la partager avec nous en utilisant la section des commentaires. Si nous avons suffisamment de commentaires, nous pouvons même les compiler et les publier dans un article de suivi !

En parlant de la commande ls, connaissez-vous la commande lsof ? Il n'est pas lié à ls mais il vous indique quel utilisateur accède à un certain fichier.