Top commande ls sous Linux : 17 exemples utiles expliqués

La lscommande est l’une des premières commandes que nous apprenons lors de la découverte du shell. Et après cela, quel que soit votre niveau de compétence, il restera l’un des plus utilisés.

Malgré cette popularité, nous allons rarement au-delà des options -l-det . -aC’est dommage car une lsimplémentation typique a des dizaines d’options disponibles ! Je vous propose donc de me suivre dans ma recherche de la lscommande 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 la lscommande sans un 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 de la lscommande. 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, super : vous pourriez apprendre une chose ou deux !

<no option>: le comportement par défaut

La lscommande 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), la lscommande 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, les lscommandes supposent ./que 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 l’ -doption, lsn’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

Lorsque vous utilisez l’ -doption seule, il n’y a pas beaucoup de différence entre lsune commande simpleecho :

# 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 l’ -doption devient plus utile lorsqu’elle est associée à une autre option pour afficher des informations supplémentaires, comme lors de l’utilisation du -ldrapeau que nous allons voir maintenant.

-l: l’option format long

Dans le lsconcours de popularité des options, l’ -loption (lettre ell minuscule) serait probablement la gagnante. C’est tellement utile que de nombreux systèmes offrent un llalias pour ls -l(ou ls -l<something>)

Le -lreprésente le format long. Avec cette option, la lscommande 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

De plus, avec l’ -loption, lsne 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, la lscommande 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 les options -let :-d

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 l’ -aoption, lsinclut les fichiers cachés lors de l’affichage du contenu d’un répertoire. Mais qu’est-ce qu’un fichier caché ?

READ  Comment créer un fichier zip protégé par mot de passe sous Linux

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 :

  • l’ .entrée pointe 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.
  • l’ ..entrée pointe vers le répertoire parent. Étant donné que la hiérarchie des fichiers sur les systèmes de type Unix est strictement organisée sous forme d’ 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 les options , et bien connues -l, tournons notre attention vers quelques options moins connues que je trouve particulièrement utiles.-d-a

-s: affiche la taille allouée

Vous vous souvenez peut-être que l’ -loption affichait le nombre d’octets dans le fichier. L’ -soption 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 sur BSD et de 1024 octets sur 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, les -soptions affichent la taille allouée . Pas la taille logique 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 la commande dd avec l’ seekoption de créer des fichiers fragmentés comme je l’ai fait pour le bfichier 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 fichiers aet mes bfichiers semblent avoir une longueur de deux mégaoctets . Mais le bfichier étant clairsemé, il ne prend que 1028 blocs sur le disque (environ un mébioctet).

-hafficher des tailles lisibles par l’homme

Avec l’ -hoption, lsaffichera les tailles de fichiers en utilisant des suffixes d’unités pour les rendre plus conviviaux. Cette option n’a de sens que lorsqu’elle est utilisée en combinaison avec l’ -loption (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 que l’ lsimplémentation fournie dans le cadre de GNU Coreutils a une --sioption supplémentaire 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

-iafficher 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 numéro qui identifie de manière unique un objet du système de fichiers (un fichier, un répertoire, un tube nommé, …). Avec l’ -ioption, la lscommande affichera son numéro d’ inode à côté de chaque chemin.

Même si cela semble quelque peu exotique, je me retrouve à utiliser l’ -ioption 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 lorsque vous enquêterez sur des liens physiques ou des 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 les entrées hardlink-to-fileet . dir/eLes 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 .

READ  Comment rechercher les commandes Linux disponibles avec apropos

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 l’ -ioption, il est assez facile de vérifier cette affirmation :

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 les manpour me rafraîchir la mémoire.

Cette option modifie le comportement de la lscommande lorsqu’elle est appliquée à des liens symboliques. Avec l’ -Loption, lsaffichera les informations relatives à la cible du lien symbolique au lieu d’afficher celles relatives 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

L’ -Foption 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 nom de chemin 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 mkfifopour plus d’informations à ce sujet)

À mes débuts sous Unix, j’utilisais beaucoup cette option. Mais comme lson 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 l’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 l’ -toption, la lscommande affiche les entrées du répertoire triées par heure 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 l’ -Soption, lsaffichera 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 trouve cela plus utile lorsqu’il est associé à l’ -toption d’afficher en premier le fichier le moins récemment modifié ou à l’ -Soption d’afficher le plus petit fichier en premier. Mais cela fonctionne également avec l’ordre de tri par défaut, par nom de chemin :

# 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: Affichage UID/GID numérique

Cette option est exactement la même que l’option, -lsauf que -nl’identifiant de groupe (GID) et l’identifiant d’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 lsoptions. 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.

READ  7 distributions Linux inspirées par l'apparence de macOS

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

Par défaut, la lscommande n’affiche que le contenu des répertoires explicitement donnés sur la ligne de commande. Avec l’ -Roption, 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 la find .commande plus lisible à cette fin. 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’elles ne soient pas définies dans la norme POSIX, les -Aoptions apparaissent à la fois dans le monde GNU et BSD. Dans les deux cas, cela fonctionne comme -a, mais en excluant les entrées .et . ..A noter sur les systèmes BSD, -Aest sous-entendu 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 l’ -foption, lsaffichera 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. L’ -foption implique également l’ -aoption :

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

Curieusement, avec l’implémentation de GNU Coreutils 8.26 ls, vous pouvez utiliser à la fois les options -let -fsi vous l’épelez, -flmais 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?

Sur les systèmes de fichiers de style Unix, un nom de fichier peut contenir n’importe quel caractère à l’exception des caractères \et des 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, l’ -qoption 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 | catest inutile, mais comme effet secondaire, la lscommande voit maintenant un tube sur sa sortie standard au lieu d’un tty (un “terminal”). Puisque la sortie n’est plus un terminal, l’ -qoption n’est plus implicite et lsaffichera le nom du fichier textuellement. Dans ce cas, si tout fonctionne comme prévu, présenter le nom du fichier avec un effet vidéo funky.

L’utilisation explicite de l’ -qoption résoudrait ce problème. 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 de la lscommande dans les scripts shell. En pratique, lsest conçu pour 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, une simple forboucle suffit même, mais ce serait une autre histoire.

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

conclusion

Voilà qui conclut notre visite des lsoptions 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 lsimplé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 !

5/5 - (1 vote)
SAKHRI Mohamed
SAKHRI Mohamed

Le blog d'un passionné d'informatique qui partage des actualités, des tutoriels, des astuces, des outils en ligne et des logiciels pour Windows, macOS, Linux, Web designer et jeux vidéo.

Publications: 3747

Laisser un commentaire

Your email address will not be published.