Il potere del terminale Linux è che puoi personalizzare rapidamente il tuo ambiente in modo che funzioni meglio e più duramente in base alle tue esigenze. Esistono molti modi diversi per "hackerare" il tuo terminale, alcuni dei quali sono praticamente interi campi dell'informatica in sé, ma ci sono molti piccoli trucchi per i principianti, specialmente quando si tratta di lavorare con il filesystem Linux. Vedi il mio articolo Gestire i file con il terminale Linux per le basi.
Il modo più semplice per personalizzare l'ambiente del tuo terminale di lavoro è modificare il suo file di configurazione, che contiene le tue impostazioni personali della shell. Bash (il Bourne Again Shell ) è la shell più comune su Linux (inclusi Red Hat Enterprise Linux e Fedora) e il file di configurazione di Bash è ~/.bashrc .
Crea un alias
Un primo passo facile nella personalizzazione è la creazione di alias. Gli alias ti consentono di definire i tuoi semplici comandi o ridefinire quelli esistenti. Per aggiungere alias, modifica il tuo file .bashrc in un editor di testo, oppure crearli direttamente dal terminale usando il echo comando.
Ad esempio, per ridefinire ls comando in modo che utilizzi sempre il --classify (-F ) e --almost-all (-a ), aggiungi una regola alias a .bashrc , quindi source (rileggere e caricare) il file di configurazione modificato.
$ echo "alias ls='ls --classify --almost-all'" >> ~/.bashrc
$ source .bashrc
$ ls
bin/
Desktop/
despacer.sh
documentation.zip*
Documents/
Music/
Pictures/
Public/
Una volta che l'alias è stato creato e ricaricato, ls il comando utilizzerà sempre il --classify opzione in modo da poter distinguere i file dalle cartelle e il --almost-all opzione per escludere la notazione punto e doppio punto. Ci sono molte altre opzioni per ls comando. Vedi le ls manuale per maggiori informazioni digitando:
$ man ls
È possibile creare alias per tutti i tipi di attività semplici e ripetitive. Operazioni complesse possono richiedere qualcosa di più robusto di un alias, come uno script di shell, ma gli alias sono un ottimo modo per far funzionare il tuo ambiente per te.
Personalizza la tua spazzatura
Apri una serie di finestre per trovare il file che desideri eliminare. Sposta il file nel Cestino o Cestino icona sul desktop. Quando hai raccolto abbastanza spazzatura e sei sicuro che tutto possa essere rimosso in sicurezza dal tuo sistema, vai al Cestino menu e seleziona Svuota .
Non c'è cestino nel tuo terminale per impostazione predefinita, ma di nuovo, un "cestino" è solo un altro cartella che accetta tutti i file che intendi eventualmente eliminare. I dati sono ancora lì finché non li svuoti. Farlo è banale. Con le lezioni che hai imparato in questo articolo, puoi creare un sistema di spazzatura sicuro e affidabile per il tuo terminale.
Se il tuo computer ha un desktop, come il desktop GNOME su Red Hat Enterprise Linux e Fedora, allora hai già un cestino di sistema che si trova in ~/.local/share/Trash/files . Puoi fare riferimento direttamente a questa cartella o per ridurre la digitazione puoi creare un collegamento simbolico ad essa:
$ ln --symbolic ~/.local/share/Trash/files ~/.trash
Se il tuo computer non ha un desktop, potresti non avere un Cestino cartella, ma puoi crearne una manualmente. Un cestino è davvero solo un'altra cartella. Usa la mkdir comando con --parents (-p ) opzione per creare una serie di cartelle in un unico comando:
$ mkdir --parents ~/.local/share/Trash/files
$ ln --symbolic ~/.local/share/Trash/files ~/.trash
Quando vuoi spostare un file o una cartella nel cestino, usa il mv comando come al solito:
$ mv oldfile.txt ~/.trash
Crea un comando cestino migliore
Un modo ancora più semplice di utilizzare un Cestino cartella è scrivere il tuo nuovo comando chiamato trash , che sposta un file nel tuo ~/.trash cartella. Questo è un esercizio avanzato e introduce alcuni nuovi comandi, ma potresti essere sorpreso di quanto sia facile creare i tuoi comandi personalizzati. In sole due righe di codice Bash, puoi progettare il tuo personale sistema di gestione dei rifiuti.
Prima di creare il tuo comando, hai bisogno di un posto dove archiviare gli script personalizzati. È comune per gli utenti Linux mantenere un ~/bin directory, dove conservano le utilità personali e gli eseguibili binari. Questo non esiste per impostazione predefinita, ma puoi crearlo e aggiungerlo al tuo percorso:
$ mkdir ~/bin
$ echo "export PATH=$PATH:$HOME/bin" >> ~/.bashrc
$ source ~/.bashrc
Ora puoi creare il tuo comando cestino con echo comando:
$ echo '#!/bin/sh' > ~/trash
$ echo 'mv "${@}" ~/.local/share/Trash/files' >> ~/trash
In alternativa, puoi aprire un editor di testo e copiare e incollare il codice al suo interno:
#!/bin/sh
mv "${@}" ~/.local/share/Trash/files
Salva il file come ~/bin/trash .
La prima riga di questo script dichiara quale applicazione è necessaria per eseguirlo. In questo caso, la prima riga specifica che sh shell, che si trova in /bin è richiesta la directory nella radice del filesystem. Dopotutto, questo è uno script di shell:una serie di comandi della shell Bash nell'ordine di esecuzione desiderato.
La seconda riga usa mv comando in combinazione con una speciale variabile Bash, "${@}" , che significa qualsiasi cosa digitata dopo il comando . Questo è ciò che consente a un singolo comando di agire su più file. Non dovrai eseguire il comando una volta per file in questo modo:
$ trash foo
$ trash bar
$ trash baz
Invece, stai programmando il tuo comando per riconoscere più argomenti contemporaneamente:
$ trash foo bar baz
Per confermare che lo script della tua shell sia corretto, usa il cat comando per concatenare il contenuto del file nell'output della shell:
$ cat trash
#!/bin/sh
mv "${@}" ~/.local/share/Trash/files
Per rendere questo comando utilizzabile per te stesso, usa mv per spostarlo in una directory chiamata ~/bin (questa directory non esiste per impostazione predefinita, quindi creala prima):
$ mkdir ~/bin
$ mv trash ~/bin
La tua shell attualmente vede lo script della tua shell come un file pieno di testo. Non hai ancora autorizzato il computer a trattare il tuo script come un comando eseguibile. Questa differenziazione è importante, perché se la tua shell fosse in grado di eseguire tutto come comando senza il tuo esplicito permesso, qualsiasi file sul tuo sistema avrebbe il potenziale di eseguire codice arbitrario (immagina di eliminare tutte le tabelle in un database importante solo perché tu o uno dei tuoi utenti hanno cliccato sul file sbagliato).
Per concedere a un file l'autorizzazione a essere trattato come eseguibile, imposta il bit eseguibile nei suoi attributi di file usando il chmod comando (cambia modalità):
$ chmod +x ~/bin/trash
Ora puoi eseguire il file come comando. Provalo creando un file e quindi spostandolo nel cestino:
$ echo "This is rubbish." >> rubbish.file
$ cat rubbish.file
This is rubbish.
$ ~/bin/trash rubbish.file
Se stai utilizzando un desktop sul tuo computer, apri il cestino e conferma che rubbish.file è ora nel cestino di sistema. Se non stai utilizzando un desktop, controlla il tuo ~/.trash collegamento simbolico. Come filtro ad hoc, invia l'output di ls comando tramite una pipe (| ), utilizzando grep comando per cercare la stringa spazzatura :
$ ls ~/.trash | grep rubbish
rubbish.file
Nota, tuttavia, che stai utilizzando il tuo trash comando senza fornire il percorso completo non funziona come previsto:
$ echo "This is more rubbish." >> rubbish2.file
$ trash rubbish2.file
bash: trash: command not found...
Questo perché non è ancora nel tuo percorso eseguibile.
Di' alla tua shell dove guardare
Alcuni comandi, come cd , pwd e alias , sono integrati nella tua shell. Altri, come ls , mv e echo , sono installati in posizioni designate dalla shell come posizioni di ricerca valide per i comandi. Quando digiti comandi come ls , mv o trash , la tua shell cerca in un elenco di directory che è stato detto contenere file eseguibili. Puoi visualizzare questo elenco di posizioni di ricerca guardando il PATH variabile. L'echo Il comando ti consente di esaminare le variabili anteponendo un segno di dollaro ($ ) prima del nome della variabile:
$ echo $PATH
/usr/bin:/usr/sbin:/bin:/sbin:/usr/local/bin:/usr/local/sbin
In modo che tu possa usare trash proprio come faresti con qualsiasi altro comando sul tuo sistema, devi aggiungere il tuo ~/bin personale directory nella tua variabile PATH. Le variabili di ambiente della shell vengono caricate all'avvio della shell, quindi sono impostate in ~/.bashrc file di configurazione. Puoi aggiungere questa directory al tuo PERCORSO usando un editor di testo, o semplicemente usare echo comando con un doppio reindirizzamento per aggiungere la regola alla tua configurazione:
$ echo 'export PATH=$PATH:/home/seth/bin' >> ~/.bashrc
Carica la tua nuova configurazione nella tua shell:
$ source ~/.bashrc
E prova il tuo comando ancora una volta:
$ trash rubbish2.file
Rimuovi definitivamente un file
Alla fine, il cestino della spazzatura deve essere svuotato. Il rm comando rimuove un file dal tuo filesystem (permanentemente, quindi usalo con moderazione e attenzione).
Perché il rm comando può essere dannoso se usato in modo improprio, è una buona idea limitare la tua interazione con esso e limitarne l'ambito quando lo usi. In questo caso, vuoi rm per operare solo all'interno del cestino, quindi puoi creare un alias per ridurre il rischio di digitare il comando in modo errato. Meno volte invochi rm , minori sono le possibilità di rimuovere accidentalmente i file.
Crea un alias chiamato empty digitando quanto segue:
$ echo 'empty="rm --recursive --verbose --force ~/.local/share/Trash/files/*"' >> ~/.bashrc
A differenza del tuo trash comando, empty viene trattato come un comando integrato poiché è un alias anziché uno script esterno. Ciò significa che non devi inserire nulla nel tuo ~/bin directory o aggiungi qualcosa al tuo PATH variabile. Devi solo ricaricare la configurazione della shell, quindi testare il tuo nuovo comando integrato:
$ source .bashrc
$ empty
removed '/home/seth/.trash/rubbish.file
removed '/home/seth/.trash/rubbish2.file
La pratica rende fluente
Ora hai programmato il tuo primo script di shell e personalizzato il tuo ambiente di shell. Piccoli esercizi come questo sono importanti, perché più lavori nella shell, meglio diventi. Cerca di massimizzare il tuo tempo di lavoro nel terminale per metterti a tuo agio. All'inizio non devi svolgere compiti importanti. Inizia in piccolo e fatti strada.
Non c'è momento migliore come il presente, quindi esplora il terminale Linux!