Il modo più veloce per rimuoverli da quella directory è spostarli fuori da lì, dopodiché rimuovili semplicemente in background:
mkdir ../.tmp_to_remove
mv -- * ../.tmp_to_remove
rm -rf ../.tmp_to_remove &
Ciò presuppone che la tua directory corrente non sia il livello più alto di qualche partizione montata (cioè che ../.tmp_to_remove è sullo stesso filesystem).
Il -- dopo mv (come modificato da Stéphane) è necessario se hai nomi di file/directory che iniziano con - .
Quanto sopra rimuove i file dalla tua directory corrente in una frazione di secondo, poiché non deve gestire in modo ricorsivo le sottodirectory. L'effettiva rimozione dell'albero dal filesystem richiede più tempo, ma poiché è fuori mano, la sua effettiva efficienza non dovrebbe avere molta importanza.
rsync è sorprendentemente veloce e semplice. Devi prima creare una directory vuota,
mkdir emptydir rsync -a --delete emptydir/ yourdirectory/
yourdirectory/ è la directory da cui vuoi rimuovere i file.
Un problema con rm -rf * , o il suo equivalente più corretto rm -rf -- * è che la shell deve prima elencare tutti i file (non nascosti) nella directory corrente, ordinarli e passarli a rm , che se l'elenco di file nella directory corrente è grande aggiungerà un sovraccarico extra non necessario e potrebbe anche fallire se l'elenco di file è troppo grande.
Normalmente, faresti rm -rf . invece (che avrebbe anche il vantaggio di eliminare anche i file nascosti). Ma la maggior parte rm le implementazioni, incluse tutte quelle conformi a POSIX, si rifiuteranno di farlo. Il motivo è che alcune shell (comprese tutte quelle POSIX) hanno quella caratteristica errata che l'espansione di .* glob includerebbe . e .. . Il che significherebbe che rm -rf .* eliminerebbe la directory corrente e padre, quindi rm è stato modificato per aggirare la caratteristica errata di quelle shell.
Alcune shell come pdksh (e altri derivati della shell Forsyth), zsh o fish non avere quella caratteristica sbagliata. zsh ha un rm builtin che puoi abilitare con autoload zsh/files che, poiché zsh è .* non include . né .. funziona bene con rm -rf . . Quindi in zsh , puoi eseguire:
autoload zsh/files
rm -rf .
Su Linux, puoi fare:
rm -rf /proc/self/cwd/
per svuotare la directory corrente o:
rm -rf /dev/fd/3/ 3< some/dir
per svuotare una directory arbitraria.
(notare il / finale )
Sui sistemi GNU, puoi fare:
find . -delete
Ora, se la directory corrente ha solo poche voci e la maggior parte dei file si trova nelle sottodirectory, ciò non farà una differenza significativa e rm -rf -- * sarà probabilmente il più veloce che puoi ottenere. È previsto per rm -rf (o qualsiasi cosa che rimuova ogni file) sia costoso in quanto significa leggere il contenuto di tutte le directory e chiamare unlink() su ogni ingresso. unlink() di per sé può essere piuttosto costoso in quanto comporta la modifica dell'inode del file eliminato, la directory contenente il file e alcune mappe del file system o altre aree libere.
rm e find (almeno le implementazioni GNU) ordinano già l'elenco dei file per numero di inode in ogni directory che può fare un'enorme differenza in termini di prestazioni sui file system ext4 poiché riduce il numero di modifiche ai dispositivi a blocchi sottostanti quando consecutive (o vicine tra loro) gli inode vengono modificati in sequenza.
rsync ordina i file per nome, il che potrebbe ridurre drasticamente le prestazioni a meno che l'ordine per nome non corrisponda all'ordine per inum (come quando i file sono stati creati da un elenco ordinato di nomi di file).
Uno dei motivi per cui rsync potrebbe essere più veloce in alcuni casi è che non sembra prendere precauzioni di sicurezza per evitare condizioni di competizione che potrebbero farla scendere nella directory sbagliata se una directory è stata sostituita con un collegamento simbolico mentre funziona come rm o find fare.
Per ottimizzare ulteriormente:
Se conosci la profondità massima del tuo albero di directory, puoi passarlo a find :
find . -maxdepth 3 -delete
Ciò consente di risparmiare find dover cercare di leggere il contenuto delle directory in profondità 3.