Elencherà sempre i file che rm rimuoverà?

Qualcosa che sento di dover sapere con certezza: se lo farò ls <something>, rm <something>rimuoverò esattamente gli stessi file lsvisualizzati? Vi sono circostanze in cui è rmpossibile rimuovere i file che lsnon sono stati visualizzati? (Questo è nel 18.04 bash)

Modifica: grazie a tutti quelli che hanno risposto. Penso che la risposta completa sia una combinazione di tutte le risposte, quindi ho accettato la risposta più votata come "la risposta".

Cose inaspettate che ho imparato lungo la strada:

• ls non è così semplice come si potrebbe pensare nella gestione dei suoi argomenti
• In una semplice installazione non complicata di Ubuntu, alias .bashrc ls
• Non dare un nome ai tuoi file che iniziano con un trattino perché possono sembrare argomenti di comando, e nominarne uno -r lo sta chiedendo!

Bene, entrambi lse rmoperare sugli argomenti che sono passati a loro.

Questi argomenti possono essere un semplice file, in modo ls file.exte rm file.extoperano sullo stesso file e il risultato è chiaro (lista il file / eliminare il file).

Se invece l'argomento è una directory, ls directoryelenca il contenuto della directory mentre rm directorynon funzionerà così com'è (ovvero rmsenza flag non è possibile rimuovere le directory, mentre se lo fa rm -r directory, elimina ricorsivamente tutti i file in directory e la directory stessa ).

Ma tieni presente che gli argomenti della riga di comando possono essere soggetti all'espansione della shell , quindi non è sempre garantito che gli stessi argomenti vengano passati a entrambi i comandi se contengono caratteri jolly, variabili, output da altri comandi, ecc.

Come esempio estremo pensare ls $(rand).txte rm $(rand).txt, gli argomenti sono "gli stessi" ma i risultati sono abbastanza diversi!

Se stai pensando a qualcosa come ls foo*.txtvs. rm foo*.txt, allora sì, mostreranno e rimuoveranno gli stessi file. La shell espande il glob e lo passa al comando in questione, e i comandi funzionano sui file elencati. Uno li elenca, uno li rimuove.

L'ovvia differenza è che se uno di quei file fosse una directory, lsne elencherebbe il contenuto, ma rmnon riuscirà a rimuoverlo. Questo di solito non è un problema, poiché rmrimuoverebbe meno di quello che è stato mostrato ls.

Il grosso problema qui viene dall'esecuzione ls *o rm *in una directory contenente nomi di file che iniziano con un trattino . Avrebbero espandersi per le linee di comando dei due programmi, come se li hai scritto voi stessi, e lsavrebbero preso -ril significato di "ordinamento inverso", mentre rmavrebbe preso -ra significare una rimozione ricorsiva. La differenza è importante se si dispone di sottodirectory con almeno due livelli di profondità. ( ls *mostrerà i contenuti delle directory di primo livello, ma rm -r *tutto supererà anche il primo livello secondario).

Per evitarlo, scrivi globs permissivi con un iniziale ./per indicare la directory corrente e / o metti a --per segnalare la fine dell'elaborazione delle opzioni prima del glob (cioè rm ./*o rm -- *).

Con un glob come *.txt, in realtà non è un problema poiché il punto è un carattere di opzione non valido e causerà un errore (fino a quando qualcuno non espande le utility per inventarne un significato), ma è comunque più sicuro metterlo ./lì.

Ovviamente potresti anche ottenere risultati diversi per i due comandi se hai cambiato le opzioni di globbing della shell, o hai creato / spostato / rimosso file tra i comandi, ma dubito che tu abbia inteso uno di questi casi. (Avere a che fare con file nuovi / spostati sarebbe estremamente complicato da eseguire in sicurezza.)

Lasciando da parte il comportamento della shell, concentriamoci solo su ciò rmche lspossiamo affrontare. Almeno un caso in cui lsverrà mostrato ciò che rmnon è possibile rimuovere riguarda i permessi di directory e l'altro - directory speciali .e ...

Autorizzazioni per le cartelle

rmè un'operazione su una directory, perché rimuovendo un file, stai cambiando il contenuto della directory (o in altre parole l'elenco delle voci della directory, poiché d irectory non è altro che un elenco di nomi di file e inode ). Ciò significa che è necessario disporre delle autorizzazioni di scrittura su una directory. Anche se sei il proprietario del file , senza le autorizzazioni della directory non puoi rimuovere i file. È vero anche il contrario : rmpuoi rimuovere file che potrebbero essere di proprietà di altri, se sei il proprietario della directory.

Quindi potresti benissimo aver letto ed eseguire le autorizzazioni su una directory, il che ti permetterà di attraversare la directory e visualizzare i contenuti in modo corretto, ad esempio ls /bin/echo, ma non puoi rm /bin/echose non sei il proprietario /bin o eleva i tuoi privilegi sudo.

E vedrai casi come questo ovunque. Ecco uno di questi casi: https://superuser.com/a/331124/418028

Elenchi speciali "." e '..'

Un altro caso speciale è .e ..directory. Se lo fai ls .o ls .., ti mostrerà felicemente i contenuti, ma rmnon è consentito ingerirli:

$ rm -rf .
rm: refusing to remove '.' or '..' directory: skipping '.'

Se digiti ls *e quindi rm *, è possibile rimuovere più file di quelli lsmostrati: potrebbero essere stati creati nel breve intervallo di tempo tra la fine di lse l'inizio di rm.

ls *e rm *non sono responsabili dell'espansione del glob - ciò viene fatto dalla shell prima di passarlo al comando.

Ciò significa che è possibile utilizzare qualsiasi comando con l'elenco di file espanso, quindi utilizzerei qualcosa che fa il meno possibile.

Quindi un modo migliore per farlo (o almeno, un altro modo) è saltare l'uomo di mezzo.

echo *ti mostrerà esattamente cosa verrebbe passato al tuo rmcomando.

Che ne dite di:

$ mkdir what
$ cd what
$ mkdir -p huh/uhm ./-r
$ ls *
uhm
$ rm *
$ ls
-r
$ ls -R
.:
-r

./-r:

Fondamentalmente i caratteri jolly che si espandono in elementi che iniziano con -(o elementi inseriti manualmente che iniziano con -ma che assomigliano un po 'più a barare) possono essere interpretati in modo diverso da lse rm.

Ci sono casi limite in cui ciò che lsmostra non è ciò che rmrimuove. Uno piuttosto estremo, ma fortunatamente benigno è se l'argomento che passi è un collegamento simbolico a una directory: lsti mostrerà tutti i file nella directory symlinked, mentre rmrimuoverà il symlink, lasciando intatta la directory originale e il suo contenuto:

% ln -s $HOME some_link
% ls some_link    # Will display directory contents  
bin    lib    Desktop ...
% rm some_link
% ls $HOME
bin    lib    Desktop ...

Se lo fai solo al lsposto di ls -a, yes rmpuò rimuovere i file nascosti che non hai visto lssenza -a.

Esempio :

Secondo :

dir_test
├── .test
└── test2

ls dir_test : visualizzerà solo test2

ls -A dir_test : visualizzerà test2 + .test

rm -r dir_test : rimuoverà tutto (.test + test2)

Spero che ti possa aiutare.

Ci sono già molte buone risposte, ma voglio aggiungere alcune intuizioni più profonde.

Ponetevi la domanda: a quanti parametri vengono passati ls, se si scrive

ls *

...? Si noti che il lscomando non ottiene il *parametro as se ci sono file che *possono essere espansi. Invece, la shell esegue prima il globbing prima di invocare il comando, quindi il lscomando ottiene effettivamente tutti i parametri quanti sono i file corrispondenti al globbing. Per eliminare il globbing, citare il parametro.

Questo è vero per qualsiasi comando: echo *vs echo '*'.

C'è uno script, chiamalo countparams.shper testare l'effetto. Ti dice quanti parametri ha superato e li elenca.

#!/bin/bash
echo "This script was given $# parameters."
arr=( "$@" )
for ((i=0;i<$#;i++)); do
        echo "Parameter $((i+1)): ${arr[$i]}"
done

Renderlo eseguibile ed eseguirlo ./countparams.sh *. Impara dal suo output!

Il glob si espanderà allo stesso modo entrambe le volte, se il contenuto della directory è lo stesso in quei due tempi diversi.

Se vuoi davvero controllare cosa verrà rimosso, usa rm -i *.txt. Ti verrà richiesto separatamente per ogni file prima di (tentando di) rimuoverlo.

Questo è garantito per essere sicuro contro le condizioni di gara:
        ls *.txt/ viene creato un nuovo file / rm *.txt
perché ti viene richiesto ogni file dallo stesso programma che sta eseguendo la rimozione.

Questo è troppo ingombrante per l'uso normale, e se si alias rmper rm -i, vi ritroverete con \rmo rm -fabbastanza spesso. Ma vale la pena ricordare almeno che esiste una soluzione alle condizioni di gara. (È persino portabile su sistemi non GNU: POSIX rm(1)specifica l' -iopzione .)

Un'altra opzione sarebbe una matrice bash:, to_remove=(*.txt)quindi chiedere all'utente di confermare (forse dopo averlo fatto ls -ld -- "${to_remove[@]}"), quindi rm -- "${to_remove[@]}". Quindi l'espansione glob viene eseguita una sola volta e l'elenco viene passato testualmente rm.

Un'altra opzione praticamente utilizzabile è GNU rm -I( pagina man ), che richiede di rimuovere più di 4 elementi. (Ma non ti mostra la lista, solo il totale.) Uso alias rm='rm -I'sul mio desktop.

È una buona protezione contro il ritorno di una diteggiatura grassa con un modello mezzo tipizzato che corrisponde troppo. Ma usare lsprima è generalmente buono in una directory che possiedi, o su un sistema a utente singolo, e quando non ci sono processi in background che potrebbero creare in modo asincrono nuovi file lì. Per evitare la diteggiatura del grasso, non digitare rm -rf /foo/bar/bazda sinistra a destra. rm -rf /è speciale, ma rm -rf /usrnon lo è! Lasciare la -rfparte o iniziare con lse aggiungere la rm -rfparte solo dopo aver digitato il percorso.