ls Command in Linux:17 esempi utili spiegati

Il ls command è uno dei primi comandi che impariamo quando scopriamo la shell. E dopo, qualunque sia il tuo livello di abilità, rimarrà uno dei più utilizzati.

Nonostante questa popolarità, raramente andiamo oltre il -l , -d e -a opzioni. È un peccato poiché un tipico ls l'implementazione ha decine di opzioni disponibili! Vi propongo quindi di seguirmi nella mia ricerca dei ls comanda gemme nascoste.

Gerarchia di file di esempio che utilizziamo in questa guida ai comandi ls

Prima di entrare nel vivo della questione, occorre un po' di preparazione:sarebbe difficile studiare le ls comando senza una directory su cui lavorare. Affinché tu possa provare sul tuo computer i comandi forniti in questo articolo, ecco come creare la gerarchia di file di esempio che userò in tutti i miei esempi. Basta copiare e incollare quell'elenco di comandi sul tuo terminale e sarai pronto:

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

In caso di problemi con questi comandi, non esitare a utilizzare la sezione commenti per chiedere aiuto. Supponendo che ora tutto sia in ordine, è tempo di approfondire il nostro argomento principale.

I casi d'uso noti del comando ls

Poiché ogni viaggio inizia con un primo passaggio, esaminiamo prima i casi d'uso di base per ls comando. Naturalmente, se ti consideri un esperto, sentiti libero di passare subito alle sezioni più avanzate. Ma se preferisci stare con me per ora, fantastico:potresti imparare una o due cose!

<no option> :il comportamento predefinito

Il ls comando fornisce informazioni su ogni oggetto simile a un file indicato dai percorsi forniti sulla riga di comando. Se utilizzato senza alcuna opzione:

• l'unica informazione visualizzata è il nome dell'oggetto simile a un file indicato dal percorso;
• se quel percorso punta a una directory (o un collegamento simbolico a una directory), il ls comando elenca anche il contenuto di quella directory;
• se vengono visualizzate più voci, queste vengono ordinate nell'ordine alfabetico del nome del file.

Infine, quando non viene fornito alcun percorso sulla riga di comando, ls comandi presuppone ./ –questa è la directory corrente.

Vediamo ora tutte quelle regole in azione:

# 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 :non elenca il contenuto della directory

Con il -d opzione, ls non visualizza più il contenuto della directory fornita sulla riga di comando ma tratterà invece le voci di directory proprio come le voci di file. Confrontiamo:

# 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

Quando si utilizza -d opzione da sola, non c'è molta differenza tra ls e un semplice echo comando:

# 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

Ma il -d l'opzione diventa più utile se associata a un'altra opzione per visualizzare informazioni aggiuntive, come quando si utilizza -l bandiera che vedremo ora.

-l :l'opzione di formato lungo

Nel ls opzioni popolarità concorso, il -l L'opzione (lettera minuscola) sarebbe probabilmente la vincitrice. È così utile che molti sistemi offrono un ll alias per ls -l (o ls -l<something> )

Il -l sta per il formato lungo. Con questa opzione, ls il comando visualizzerà ciascuna voce su una propria riga contenente le seguenti informazioni:* modalità file * numero di collegamenti * nome del proprietario * nome del gruppo * numero di byte nel file * data e ora * percorso

Inoltre, con il -l opzione, ls non seguirà più i collegamenti simbolici. Quindi, visualizzerà le informazioni (modalità file, numero di collegamenti e così via) sul collegamento stesso e non sulla sua destinazione. Per lo stesso motivo, il ls comando non visualizzerà il contenuto delle directory indicate da collegamenti simbolici:

# 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

Per concludere questa sezione, ti lascio esaminare l'output che otteniamo combinando entrambi i -l e -d opzioni:

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 :mostra tutti i file

Con il -a opzione, ls include file nascosti durante la visualizzazione del contenuto di una directory. Ma cos'è un file nascosto?

Per convenzione, su sistemi simili a Unix, un file il cui nome inizia con un punto è considerato nascosto. Inoltre, ogni directory contiene anche due voci speciali, normalmente nascoste:. e ..

In ogni directory:

• il . punti di ingresso alla directory stessa. Questo tipo di auto-riferimento può sembrare curioso. Ma a volte è utile, un po' come avere il proprio numero di telefono nel repertorio del proprio smartphone.
• il .. punti di ingresso alla directory principale. Poiché la gerarchia dei file su sistemi simili a Unix è organizzata rigorosamente come un albero, ogni directory ha uno e un solo genitore. Tranne la directory principale / può essere? Beh, non proprio:il genitore della directory radice è... la directory radice stessa.

# 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

Le opzioni utili del comando ls

Dopo aver esaminato il noto -l , -d e -a opzioni, rivolgiamo la nostra attenzione su un paio di opzioni meno conosciute che trovo particolarmente utili.

-s :mostra la dimensione assegnata

Potresti ricordare il -l opzione mostrava il numero di byte nel file. Il -s l'opzione mostra la dimensione allocata in blocchi. Cos'è un blocco? Bene, un gruppo di byte la cui dimensione dipende dall'implementazione. Di solito sono 512 byte su BSD e 1024 byte su Linux.

Perché dovrei preoccuparmi della dimensione in blocchi quando ho già accesso alla dimensione in byte? Bene, il -s le opzioni mostrano l'allocato dimensione. Non il logico dimensione del file. Potrebbero essere due cose completamente diverse per i file sparsi. I file sparsi sono file che contengono "buchi". Quando vengono letti, questi buchi si comportano come normali blocchi di file contenenti solo zeri. Ma non occupano praticamente spazio sul disco. Possiamo usare il dd comando con il seek opzione per creare file sparsi come ho fatto per il b file nella mia gerarchia di esempio:

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

Come puoi vedere, sia il mio a e b i file sembrano essere lunghi due mebibyte. Ma il b essendo il file sparso, richiede solo 1028 blocchi sul disco (circa un mebibyte).

-h visualizzare dimensioni leggibili dall'uomo

Con il -h opzione, ls visualizzerà le dimensioni dei file utilizzando i suffissi delle unità per renderli più facili da usare. Questa opzione ha senso solo se usata in combinazione con -l opzione (Linux, BSD) o -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

Potresti aver notato che le dimensioni vengono visualizzate utilizzando potenze di 1024 unità, dove K sta per 2^10=1024 byte, M per 1024^2=1048576 byte e così via. Vale la pena menzionare qui il ls l'implementazione fornita come parte di GNU Coreutils ha un extra --si opzioni per utilizzare la potenza 1000 anziché la potenza 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 visualizzare il numero dell'inode

Su un filesystem in stile Unix, un numero di inode (o numero di serie del file nella terminologia POSIX) è un numero che identifica in modo univoco un oggetto del filesystem (un file, una directory, una named pipe, …). Con il -i opzione, il ls il comando visualizzerà il suo numero di inode accanto a ciascun percorso.

Anche se sembra un po' esotico, mi ritrovo a usare -i opzione di volta in volta, in particolare per identificare le voci di directory che fanno riferimento allo stesso oggetto del filesystem. Utilizzerai questa opzione principalmente quando indaghi sui collegamenti fisici o sui montaggi vincolati. Dai un'occhiata a quel video per un esempio pratico: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

Nell'esempio sopra, puoi vedere ogni nome di file preceduto dal numero di inode associato a quel percorso. Sul tuo sistema, i numeri saranno sicuramente diversi. Ad ogni modo, dai un'occhiata più da vicino al hardlink-to-file e dir/e inserimenti. Entrambi hanno lo stesso numero di inode (8264 nel mio caso). Ciò significa che sono due voci che fanno riferimento allo stesso oggetto del filesystem sottostante, che è, in effetti, la definizione esatta di cosa sia un collegamento fisico.

Forse ricorderai che prima ho detto che il genitore della directory principale era la directory radice stessa. Usando il -i opzione, è abbastanza facile verificare tale affermazione:

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

Come puoi vedere, sul mio sistema, la directory principale è associata all'inode numero 2, che è anche l'inode del suo genitore. Questo dimostra che la directory principale è il proprio genitore.

Le opzioni usate raramente del comando ls

Uso regolarmente le opzioni descritte nella sezione precedente, ma quelle di cui parlerò ora... beh... so che esistono. Tuttavia devo ammettere che quando ne ho bisogno, devo spesso guardare l'man per rinfrescarmi la memoria.

-L :visualizza le informazioni sulla destinazione dei collegamenti simbolici

Questa opzione modifica il comportamento di ls comando quando applicato ai collegamenti simbolici. Con il -L opzione, ls visualizzerà le informazioni relative al target del collegamento simbolico invece di visualizzare quelli relativi al collegamento simbolico stesso. Esaminando il seguente esempio, la differenza risulterà evidente:

# 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 :aggiunge un carattere di classificazione al nome del file

Il -F l'opzione aggiunge un carattere extra dopo il nome del percorso di alcune categorie di oggetti del file system per identificarli. Aggiungerà:

• un \ dopo ogni percorso che è una directory,
• un @ dopo ogni percorso che è un collegamento simbolico,
• un * dopo ogni file eseguibile,
• e un | dopo ogni FIFO (vedi mkfifo per ulteriori informazioni a riguardo)

Nei miei primi giorni in Unix, usavo molto questa opzione. Ma poiché ls può colorare il suo output (e poiché abbiamo monitor a colori!), raramente ne ho bisogno. Ma lo ricordo. E di tanto in tanto, su un terminale remoto, trovo l'occasione per usarlo:

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

t :ordina le voci per ora di modifica

Con il -t opzione, il ls comando con le voci della directory di visualizzazione ordinate per ora di modifica (prima la più recente) invece di ordinarle per nome:

# 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

Se cambio un file, ora apparirà come la prima voce (cioè l'ultima modificata) nell'elenco:

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

-S :ordina le voci per dimensione

Con il -S opzione, ls visualizzerà le voci ordinate per dimensione, prima il file più grande. In caso di parità, le voci vengono ordinate in base al loro percorso:

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 :ordine inverso

Questa opzione inverte l'ordinamento. Lo trovo molto utile se associato a -t opzione per visualizzare per primo il file modificato meno di recente o con -S opzione per visualizzare prima il file più piccolo. Ma funziona anche con l'impostazione predefinita, per percorso, ordinamento:

# 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 :Visualizza UID/GID numerico

Questa opzione è esattamente la stessa di -l opzione— tranne con -n l'ID gruppo (GID) e l'ID utente (UID) del proprietario vengono visualizzati come numeri anziché utilizzare il nome associato:

 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'uso davvero esotico del comando ls

Nessuno può pretendere di sapere tutto. E mentre scrivevo questo articolo, ho (ri)scoperto un paio di ls opzioni. Non ricordo di averli usati io stesso, ma forse l'hai fatto tu? Se è il caso, sarei curioso di leggere nella sezione commenti in quali circostanze li trovi utili. Ad ogni modo, ecco una selezione che potresti trovare interessante.

-R :elenca ricorsivamente le sottodirectory

Per impostazione predefinita, ls comando visualizza solo il contenuto delle directory fornite esplicitamente sulla riga di comando. Con il -R opzione, visualizzerà anche ricorsivamente il contenuto delle directory incontrate:

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

Sebbene sia interessante in teoria, trovo (gioco di parole) l'output prodotto da find . comando più leggibile a tale scopo. Ma il tuo chilometraggio può variare, ovviamente:

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 :mostra quasi tutti i file

Sebbene non sia definito nello standard POSIX, il -A le opzioni appaiono sia nel mondo GNU che BSD. In entrambi i casi, funziona come -a , ma escluso il . e .. inserimenti. Degno di nota sui sistemi BSD, -A è implicito per il superutente:

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 :non ordinare

Con il -f opzione, ls visualizzerà le voci nell'ordine in cui appaiono nella directory. Quell'ordine dipende dal filesystem sottostante e i file dell'ordine sono stati creati, quindi è difficilmente prevedibile. Il -f l'opzione implica anche il -a opzione:

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

Abbastanza divertente, con GNU Coreutils 8.26 ls implementazione, puoi usare sia -l e -f opzioni se lo scrivi -fl –ma non se scrivi -lf . Su OpenBSD entrambi funzionano come previsto:

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 :Visualizza i caratteri del nome file non stampabili come ?

Sui filesystem in stile Unix, un nome file può contenere qualsiasi carattere tranne il \ e i caratteri NUL. Ciò significa che un nome file può contenere caratteri non stampabili o persino sequenze di controllo che potrebbero interferire con il tuo terminale. Proviamo qualcosa di divertente:

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

Ovviamente, quel nome file contiene caratteri non stampabili. Sulle moderne implementazioni di ls , il -q opzione è implicita quando l'uscita è un terminale, per evitare potenziali effetti nefasti. Quindi i caratteri non stampabili verranno sostituiti da un punto interrogativo:

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

Tuttavia, le cose andranno diversamente se scrivi che invece:

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

Il | cat è inutile, ma come effetto collaterale, il ls Il comando ora vede una pipe sul suo output standard invece di un tty (un "terminale"). Poiché l'output non è più un terminale, il -q opzione non è più implicita e ls visualizzerà il nome del file testualmente. In tal caso, se tutto funziona come previsto, per presentare il nome del file con un effetto video funky.

Usando esplicitamente il -q l'opzione lo risolverebbe. Ti farò provare da solo (e alla fine giocando con altre sequenze di escape ANSI). Ma colgo l'occasione per metterti in guardia dall'usare ls comando negli script di shell. In pratica, ls è progettato per il “consumo umano”. Esistono molti casi secondari relativi a nomi di file appositamente realizzati che sono molto difficili da gestire correttamente. Se hai bisogno di scorrere un elenco di file, ti consiglio vivamente di usare invece il comando trova. Nei casi più semplici, un semplice for loop è anche sufficiente, ma questa sarebbe un'altra storia.

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

La fine?

Questo conclude il nostro tour dei ls opzioni di comando. Non c'è bisogno di menzionare che era tutt'altro che esaustivo e ho cercato di concentrarmi qui sulle opzioni più utili e più portatili. Ma ogni ls l'implementazione ha la sua parte di interessanti funzionalità, quindi se conosci qualche bella opzione che mi sono persa in questo articolo, non esitare a condividerla con noi usando la sezione commenti. Se abbiamo abbastanza feedback, potremmo persino compilarli e pubblicarli in un articolo di follow-up!

Parlando del comando ls, conosci il comando lsof? Non è correlato a ls ma ti dice quale utente sta accedendo a un determinato file.