Unix / Linux - Guida rapida
Cos'è Unix?
Il sistema operativo Unix è un insieme di programmi che fungono da collegamento tra il computer e l'utente.
I programmi per computer che allocano le risorse di sistema e coordinano tutti i dettagli degli interni del computer sono chiamati operating system o il kernel.
Gli utenti comunicano con il kernel tramite un programma noto come shell. La shell è un interprete della riga di comando; traduce i comandi inseriti dall'utente e li converte in un linguaggio comprensibile dal kernel.
Unix è stato originariamente sviluppato nel 1969 da un gruppo di dipendenti AT&T Ken Thompson, Dennis Ritchie, Douglas McIlroy e Joe Ossanna dei Bell Labs.
Ci sono varie varianti Unix disponibili sul mercato. Solaris Unix, AIX, HP Unix e BSD sono alcuni esempi. Linux è anche una versione di Unix che è disponibile gratuitamente.
Diverse persone possono utilizzare un computer Unix contemporaneamente; quindi Unix è chiamato un sistema multiutente.
Un utente può anche eseguire più programmi contemporaneamente; quindi Unix è un ambiente multitasking.
Architettura Unix
Ecco uno schema a blocchi di base di un sistema Unix:
Il concetto principale che unisce tutte le versioni di Unix sono le seguenti quattro basi:
Kernel- Il kernel è il cuore del sistema operativo. Interagisce con l'hardware e la maggior parte delle attività come la gestione della memoria, la pianificazione delle attività e la gestione dei file.
Shell- La shell è l'utilità che elabora le tue richieste. Quando digiti un comando sul tuo terminale, la shell interpreta il comando e chiama il programma che desideri. La shell utilizza la sintassi standard per tutti i comandi. C Shell, Bourne Shell e Korn Shell sono le shell più famose che sono disponibili con la maggior parte delle varianti Unix.
Commands and Utilities - Ci sono vari comandi e utilità che puoi utilizzare nelle tue attività quotidiane. cp, mv, cat e grep, ecc. sono alcuni esempi di comandi e utilità. Ci sono più di 250 comandi standard oltre a numerosi altri forniti attraverso 3 ° software di terze parti. Tutti i comandi sono accompagnati da varie opzioni.
Files and Directories- Tutti i dati di Unix sono organizzati in file. Tutti i file vengono quindi organizzati in directory. Queste directory sono ulteriormente organizzate in una struttura ad albero chiamatafilesystem.
Avvio del sistema
Se hai un computer su cui è installato il sistema operativo Unix, devi semplicemente accendere il sistema per farlo funzionare.
Non appena accendi il sistema, inizia ad avviarsi e alla fine ti chiede di accedere al sistema, che è un'attività per accedere al sistema e usarlo per le tue attività quotidiane.
Accedi a Unix
Quando ti connetti per la prima volta a un sistema Unix, di solito vedi un prompt come il seguente:
login:
Per accedere
Tieni a portata di mano l'ID utente (identificazione utente) e la password. Contatta l'amministratore di sistema se non li hai ancora.
Digita il tuo ID utente al prompt di accesso, quindi premi ENTER. Il tuo ID utente ècase-sensitive, quindi assicurati di digitarlo esattamente come indicato dall'amministratore di sistema.
Digita la tua password al prompt della password, quindi premi ENTER. La tua password fa anche distinzione tra maiuscole e minuscole.
Se fornisci l'ID utente e la password corretti, potrai accedere al sistema. Leggi le informazioni e i messaggi che appaiono sullo schermo, che sono i seguenti.
login : amrood
amrood's password:
Last login: Sun Jun 14 09:32:32 2009 from 62.61.164.73
$
Ti verrà fornito un prompt dei comandi (a volte chiamato $prompt) dove digiti tutti i tuoi comandi. Ad esempio, per controllare il calendario, è necessario digitarecal comando come segue -
$ cal June 2009 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 $
Cambia la password
Tutti i sistemi Unix richiedono password per garantire che i tuoi file e dati rimangano tuoi e che il sistema stesso sia protetto da hacker e cracker. Di seguito sono riportati i passaggi per modificare la password:
Step 1 - Per iniziare, digita la password al prompt dei comandi come mostrato di seguito.
Step 2 - Inserisci la tua vecchia password, quella che stai attualmente utilizzando.
Step 3- Digita la tua nuova password. Mantieni sempre la tua password abbastanza complessa in modo che nessuno possa indovinarla. Ma assicurati di ricordarlo.
Step 4 - È necessario verificare la password digitandola di nuovo.
$ passwd Changing password for amrood (current) Unix password:****** New UNIX password:******* Retype new UNIX password:******* passwd: all authentication tokens updated successfully $
Note- Abbiamo aggiunto un asterisco (*) qui solo per mostrare la posizione in cui è necessario inserire la password corrente e quella nuova, altrimenti nel sistema. Non mostra alcun carattere durante la digitazione.
Elenco di directory e file
Tutti i dati in Unix sono organizzati in file. Tutti i file sono organizzati in directory. Queste directory sono organizzate in una struttura ad albero chiamata filesystem.
Puoi usare il file lscomando per elencare tutti i file o le directory disponibili in una directory. Di seguito è riportato l'esempio di utilizzo dils comando con -l opzione.
$ ls -l total 19621 drwxrwxr-x 2 amrood amrood 4096 Dec 25 09:59 uml -rw-rw-r-- 1 amrood amrood 5341 Dec 25 08:38 uml.jpg drwxr-xr-x 2 amrood amrood 4096 Feb 15 2006 univ drwxr-xr-x 2 root root 4096 Dec 9 2007 urlspedia -rw-r--r-- 1 root root 276480 Dec 9 2007 urlspedia.tar drwxr-xr-x 8 root root 4096 Nov 25 2007 usr -rwxr-xr-x 1 root root 3192 Nov 25 2007 webthumb.php -rw-rw-r-- 1 amrood amrood 20480 Nov 25 2007 webthumb.tar -rw-rw-r-- 1 amrood amrood 5654 Aug 9 2007 yourfile.mid -rw-rw-r-- 1 amrood amrood 166255 Aug 9 2007 yourfile.swf $
Qui le voci che iniziano con d.....rappresentano le directory. Ad esempio, uml, univ e urlspedia sono directory e il resto delle voci sono file.
Tu chi sei?
Mentre sei connesso al sistema, potresti essere disposto a sapere: Who am I?
Il modo più semplice per scoprire "chi sei" è entrare nel file whoami comando -
$ whoami amrood $
Provalo sul tuo sistema. Questo comando elenca il nome dell'account associato all'accesso corrente. Puoi provarewho am i comando anche per ottenere informazioni su di te.
Chi è connesso?
A volte potresti essere interessato a sapere chi è connesso al computer allo stesso tempo.
Sono disponibili tre comandi per ottenere queste informazioni, in base a quanto desideri sapere sugli altri utenti: users, who, e w.
$ users amrood bablu qadir $ who
amrood ttyp0 Oct 8 14:10 (limbo)
bablu ttyp2 Oct 4 09:08 (calliope)
qadir ttyp4 Oct 8 12:09 (dent)
$
Prova il wcomando sul sistema per controllare l'output. Questo elenca le informazioni associate agli utenti registrati nel sistema.
Disconnessione
Al termine della sessione, è necessario disconnettersi dal sistema. Questo per garantire che nessun altro acceda ai tuoi file.
To log out
Basta digitare il logout comando al prompt dei comandi e il sistema ripulirà tutto e interromperà la connessione.
Arresto del sistema
Il modo più coerente per arrestare correttamente un sistema Unix tramite la riga di comando è utilizzare uno dei seguenti comandi:
Sr.No. | Comando e descrizione |
---|---|
1 | halt Disattiva immediatamente il sistema |
2 | init 0 Spegne il sistema utilizzando script predefiniti per sincronizzare e ripulire il sistema prima dello spegnimento |
3 | init 6 Riavvia il sistema spegnendolo completamente e riavviandolo |
4 | poweroff Arresta il sistema spegnendolo |
5 | reboot Riavvia il sistema |
6 | shutdown Arresta il sistema |
In genere è necessario essere il super utente o root (l'account più privilegiato su un sistema Unix) per arrestare il sistema. Tuttavia, su alcune macchine Unix autonome o di proprietà personale, un utente amministrativo e talvolta gli utenti regolari possono farlo.
In questo capitolo, discuteremo in dettaglio sulla gestione dei file in Unix. Tutti i dati in Unix sono organizzati in file. Tutti i file sono organizzati in directory. Queste directory sono organizzate in una struttura ad albero chiamata filesystem.
Quando lavori con Unix, in un modo o nell'altro, trascorri la maggior parte del tuo tempo a lavorare con i file. Questo tutorial ti aiuterà a capire come creare e rimuovere file, copiarli e rinominarli, creare collegamenti ad essi, ecc.
In Unix, ci sono tre tipi fondamentali di file:
Ordinary Files- Un file normale è un file sul sistema che contiene dati, testo o istruzioni di programma. In questo tutorial, vedrai come lavorare con file normali.
Directories- Le directory memorizzano sia file speciali che normali. Per gli utenti che hanno familiarità con Windows o Mac OS, le directory Unix sono equivalenti alle cartelle.
Special Files- Alcuni file speciali forniscono l'accesso a hardware come dischi rigidi, unità CD-ROM, modem e adattatori Ethernet. Altri file speciali sono simili agli alias o ai collegamenti e consentono di accedere a un singolo file utilizzando nomi diversi.
File di elenco
Per elencare i file e le directory archiviati nella directory corrente, utilizzare il seguente comando:
$ls
Ecco l'output di esempio del comando precedente:
$ls
bin hosts lib res.03
ch07 hw1 pub test_results
ch07.bak hw2 res.01 users
docs hw3 res.02 work
Il comando ls supporta il -l opzione che ti aiuterebbe a ottenere maggiori informazioni sui file elencati -
$ls -l
total 1962188
drwxrwxr-x 2 amrood amrood 4096 Dec 25 09:59 uml
-rw-rw-r-- 1 amrood amrood 5341 Dec 25 08:38 uml.jpg
drwxr-xr-x 2 amrood amrood 4096 Feb 15 2006 univ
drwxr-xr-x 2 root root 4096 Dec 9 2007 urlspedia
-rw-r--r-- 1 root root 276480 Dec 9 2007 urlspedia.tar
drwxr-xr-x 8 root root 4096 Nov 25 2007 usr
drwxr-xr-x 2 200 300 4096 Nov 25 2007 webthumb-1.01
-rwxr-xr-x 1 root root 3192 Nov 25 2007 webthumb.php
-rw-rw-r-- 1 amrood amrood 20480 Nov 25 2007 webthumb.tar
-rw-rw-r-- 1 amrood amrood 5654 Aug 9 2007 yourfile.mid
-rw-rw-r-- 1 amrood amrood 166255 Aug 9 2007 yourfile.swf
drwxr-xr-x 11 amrood amrood 4096 May 29 2007 zlib-1.2.3
$
Ecco le informazioni su tutte le colonne elencate:
First Column- Rappresenta il tipo di file e l'autorizzazione fornita sul file. Di seguito è la descrizione di tutti i tipi di file.
Second Column - Rappresenta il numero di blocchi di memoria presi dal file o dalla directory.
Third Column- Rappresenta il proprietario del file. Questo è l'utente Unix che ha creato questo file.
Fourth Column- Rappresenta il gruppo del proprietario. Ogni utente Unix avrà un gruppo associato.
Fifth Column - Rappresenta la dimensione del file in byte.
Sixth Column - Rappresenta la data e l'ora in cui questo file è stato creato o modificato per l'ultima volta.
Seventh Column - Rappresenta il nome del file o della directory.
Nel ls -l elenco di esempio, ogni riga di file inizia con un d, -, o l. Questi caratteri indicano il tipo di file elencato.
Sr.No. | Prefisso e descrizione |
---|---|
1 | - File normale, come un file di testo ASCII, un eseguibile binario o un collegamento fisico. |
2 | b Blocca file speciale. Blocca il file del dispositivo di input / output come un disco rigido fisico. |
3 | c File speciale di caratteri. File di dispositivo di input / output non elaborato come un disco rigido fisico. |
4 | d File di directory che contiene un elenco di altri file e directory. |
5 | l File di collegamento simbolico. Collegamenti su qualsiasi file normale. |
6 | p Pipa chiamata. Un meccanismo per le comunicazioni tra processi. |
7 | s Socket utilizzato per la comunicazione tra processi. |
Metacaratteri
I metacaratteri hanno un significato speciale in Unix. Per esempio,* e ?sono metacaratteri. Noi usiamo* per trovare 0 o più caratteri, un punto interrogativo (?) corrisponde a un singolo carattere.
Ad esempio -
$ls ch*.doc
Visualizza tutti i file, i cui nomi iniziano con ch e termina con .doc -
ch01-1.doc ch010.doc ch02.doc ch03-2.doc
ch04-1.doc ch040.doc ch05.doc ch06-2.doc
ch01-2.doc ch02-1.doc c
Qui, *funziona come meta carattere che corrisponde a qualsiasi carattere. Se vuoi visualizzare tutti i file che terminano con solo.doc, quindi puoi usare il seguente comando:
$ls *.doc
File nascosti
Un file invisibile è uno, il cui primo carattere è il punto o il punto (.). I programmi Unix (inclusa la shell) utilizzano la maggior parte di questi file per memorizzare le informazioni di configurazione.
Alcuni esempi comuni di file nascosti includono i file:
.profile - Lo script di inizializzazione della Bourne shell (sh)
.kshrc - Lo script di inizializzazione della shell Korn (ksh)
.cshrc - Lo script di inizializzazione della shell C (csh)
.rhosts - Il file di configurazione della shell remota
Per elencare i file invisibili, specificare il file -a opzione per ls -
$ ls -a
. .profile docs lib test_results
.. .rhosts hosts pub users
.emacs bin hw1 res.01 work
.exrc ch07 hw2 res.02
.kshrc ch07.bak hw3 res.03
$
Single dot (.) - Questo rappresenta la directory corrente.
Double dot (..) - Questo rappresenta la directory principale.
Creazione di file
Puoi usare il file vieditor per creare file ordinari su qualsiasi sistema Unix. Devi semplicemente dare il seguente comando:
$ vi filename
Il comando precedente aprirà un file con il nome file specificato. Ora premi il tastoiper entrare in modalità di modifica. Una volta che sei in modalità di modifica, puoi iniziare a scrivere il tuo contenuto nel file come nel seguente programma:
This is unix file....I created it for the first time.....
I'm going to save this content in this file.
Una volta che hai finito con il programma, segui questi passaggi:
Premi il tasto esc per uscire dalla modalità di modifica.
Premi due tasti Shift + ZZ insieme per uscire completamente dal file.
Ora avrai un file creato con filename nella directory corrente.
$ vi filename $
Modifica dei file
È possibile modificare un file esistente utilizzando l'estensione vieditore. Discuteremo in breve come aprire un file esistente -
$ vi filename
Una volta aperto il file, puoi entrare in modalità di modifica premendo il tasto ie poi puoi procedere modificando il file. Se vuoi muoverti qua e là all'interno di un file, prima devi uscire dalla modalità di modifica premendo il tastoEsc. Successivamente, puoi utilizzare i seguenti tasti per spostarti all'interno di un file:
l tasto per spostarsi a destra.
h tasto per spostarsi a sinistra.
k chiave per spostarsi al rialzo nel file.
j tasto per spostare il lato negativo nel file.
Quindi, usando i tasti sopra, puoi posizionare il cursore dove vuoi modificare. Una volta posizionato, puoi usare ilichiave per entrare in modalità di modifica. Una volta terminata la modifica del file, premereEsc e infine due chiavi Shift + ZZ insieme per uscire completamente dal file.
Visualizza il contenuto di un file
Puoi usare il file catcomando per vedere il contenuto di un file. Di seguito è riportato un semplice esempio per vedere il contenuto del file creato sopra:
$ cat filename
This is unix file....I created it for the first time.....
I'm going to save this content in this file.
$
È possibile visualizzare i numeri di riga utilizzando il -b opzione insieme a cat comando come segue -
$ cat -b filename
1 This is unix file....I created it for the first time.....
2 I'm going to save this content in this file.
$
Contare le parole in un file
Puoi usare il file wccomando per ottenere un conteggio del numero totale di righe, parole e caratteri contenuti in un file. Di seguito è riportato un semplice esempio per visualizzare le informazioni sul file creato sopra:
$ wc filename
2 19 103 filename
$
Ecco il dettaglio di tutte e quattro le colonne:
First Column - Rappresenta il numero totale di righe nel file.
Second Column - Rappresenta il numero totale di parole nel file.
Third Column- Rappresenta il numero totale di byte nel file. Questa è la dimensione effettiva del file.
Fourth Column - Rappresenta il nome del file.
È possibile fornire più file e ottenere informazioni su tali file contemporaneamente. La seguente è una sintassi semplice:
$ wc filename1 filename2 filename3
Copia di file
Per fare una copia di un file usa il cpcomando. La sintassi di base del comando è:
$ cp source_file destination_file
Di seguito è riportato l'esempio per creare una copia del file esistente filename.
$ cp filename copyfile
$
Ora troverai un altro file copyfilenella directory corrente. Questo file sarà esattamente lo stesso del file originalefilename.
Rinominare i file
Per modificare il nome di un file, utilizzare il mvcomando. Di seguito è riportata la sintassi di base:
$ mv old_file new_file
Il seguente programma rinominerà il file esistente filename per newfile.
$ mv filename newfile $
Il mvIl comando sposterà completamente il file esistente nel nuovo file. In questo caso, troverai solonewfile nella directory corrente.
Eliminazione di file
Per eliminare un file esistente, utilizzare il rmcomando. Di seguito è riportata la sintassi di base:
$ rm filename
Caution- Un file può contenere informazioni utili. Si consiglia sempre di fare attenzione durante l'utilizzo di questoDeletecomando. È meglio usare il file-i opzione insieme a rm comando.
Di seguito è riportato l'esempio che mostra come rimuovere completamente il file esistente filename.
$ rm filename
$
È possibile rimuovere più file alla volta con il comando fornito di seguito:
$ rm filename1 filename2 filename3
$
Stream Unix standard
In circostanze normali, ogni programma Unix ha tre flussi (file) aperti all'avvio -
stdin- Questo è indicato come input standard e il descrittore di file associato è 0. Questo è anche rappresentato come STDIN. Il programma Unix leggerà l'input predefinito da STDIN.
stdout- Questo è indicato come output standard e il descrittore di file associato è 1. Questo è anche rappresentato come STDOUT. Il programma Unix scriverà l'output predefinito in STDOUT
stderr- Questo è indicato come errore standard e il descrittore di file associato è 2. Questo è anche rappresentato come STDERR. Il programma Unix scriverà tutti i messaggi di errore in STDERR.
In questo capitolo, discuteremo in dettaglio sulla gestione delle directory in Unix.
Una directory è un file il cui lavoro da solista consiste nel memorizzare i nomi dei file e le relative informazioni. Tutti i file, ordinari, speciali o directory, sono contenuti in directory.
Unix utilizza una struttura gerarchica per organizzare file e directory. Questa struttura viene spesso definita albero di directory. L'albero ha un singolo nodo radice, il carattere barra (/) e tutte le altre directory sono contenute sotto di essa.
Home directory
La directory in cui ti trovi al primo accesso è chiamata directory home.
Farai gran parte del tuo lavoro nella tua home directory e nelle sottodirectory che creerai per organizzare i tuoi file.
Puoi andare nella tua home directory in qualsiasi momento utilizzando il seguente comando:
$cd ~
$
Qui ~indica la directory home. Supponiamo di dover andare nella directory home di qualsiasi altro utente, utilizzare il seguente comando:
$cd ~username
$
Per andare nella tua ultima directory, puoi usare il seguente comando:
$cd -
$
Nomi di percorso assoluti / relativi
Le directory sono disposte in una gerarchia con radice (/) in alto. La posizione di qualsiasi file all'interno della gerarchia è descritta dal suo percorso.
Gli elementi di un percorso sono separati da un /. Un percorso è assoluto, se è descritto in relazione a root, quindi i percorsi assoluti iniziano sempre con /.
Di seguito sono riportati alcuni esempi di nomi di file assoluti.
/etc/passwd
/users/sjones/chem/notes
/dev/rdsk/Os3
Un percorso può anche essere relativo alla directory di lavoro corrente. I nomi di percorso relativi non iniziano mai con /. Relativamente alla home directory dell'utente amrood, alcuni nomi di percorso potrebbero assomigliare a questo:
chem/notes
personal/res
Per determinare in qualsiasi momento dove ti trovi all'interno della gerarchia del filesystem, inserisci il comando pwd per stampare la directory di lavoro corrente -
$pwd
/user0/home/amrood
$
Directory di elenco
Per elencare i file in una directory, puoi usare la seguente sintassi:
$ls dirname
Di seguito è riportato l'esempio per elencare tutti i file contenuti in /usr/local directory -
$ls /usr/local
X11 bin gimp jikes sbin
ace doc include lib share
atalk etc info man ami
Creazione di directory
Ora capiremo come creare directory. Le directory vengono create dal seguente comando:
$mkdir dirname
Qui, directory è il percorso assoluto o relativo della directory che si desidera creare. Ad esempio, il comando -
$mkdir mydir $
Crea la directory mydirnella directory corrente. Ecco un altro esempio:
$mkdir /tmp/test-dir $
Questo comando crea la directory test-dir nel /tmpdirectory. Ilmkdir comando non produce alcun output se crea con successo la directory richiesta.
Se fornisci più di una directory sulla riga di comando, mkdircrea ciascuna delle directory. Ad esempio, -
$mkdir docs pub $
Crea le directory docs e pub nella directory corrente.
Creazione di directory padre
Ora capiremo come creare directory padre. A volte, quando si desidera creare una directory, la directory o le directory principali potrebbero non esistere. In questo caso,mkdir emette un messaggio di errore come segue -
$mkdir /tmp/amrood/test mkdir: Failed to make directory "/tmp/amrood/test"; No such file or directory $
In questi casi, è possibile specificare il file -p opzione per il mkdircomando. Crea per te tutte le directory necessarie. Ad esempio:
$mkdir -p /tmp/amrood/test $
Il comando precedente crea tutte le directory padre richieste.
Rimozione di directory
Le directory possono essere eliminate utilizzando il file rmdir comando come segue -
$rmdir dirname $
Note - Per rimuovere una directory, assicurati che sia vuota, il che significa che non dovrebbe esserci alcun file o sottodirectory all'interno di questa directory.
È possibile rimuovere più directory contemporaneamente come segue:
$rmdir dirname1 dirname2 dirname3 $
Il comando precedente rimuove le directory dirname1, dirname2 e dirname3, se sono vuote. Ilrmdir comando non produce alcun output se ha successo.
Modifica delle directory
Puoi usare il file cdcomando per fare di più che passare a una directory home. È possibile utilizzarlo per passare a qualsiasi directory specificando un percorso assoluto o relativo valido. La sintassi è la seguente:
$cd dirname $
Qui, dirnameè il nome della directory in cui desideri passare. Ad esempio, il comando -
$cd /usr/local/bin $
Modifiche alla directory /usr/local/bin. Da questa directory puoicd nella directory /usr/home/amrood utilizzando il seguente percorso relativo -
$cd ../../home/amrood $
Ridenominazione delle directory
Il mv (move)può essere utilizzato anche per rinominare una directory. La sintassi è la seguente:
$mv olddir newdir $
Puoi rinominare una directory mydir per yourdir come segue -
$mv mydir yourdir $
Le directory. (punto) e .. (punto punto)
Il filename .(punto) rappresenta la directory di lavoro corrente; e ilfilename .. (punto punto) rappresenta la directory un livello sopra la directory di lavoro corrente, spesso indicata come directory padre.
Se inseriamo il comando per mostrare un elenco delle directory / file di lavoro correnti e utilizziamo l'estensione -a option per elencare tutti i file e il file -l option per fornire l'elenco lungo, riceveremo il seguente risultato.
$ls -la drwxrwxr-x 4 teacher class 2048 Jul 16 17.56 . drwxr-xr-x 60 root 1536 Jul 13 14:18 .. ---------- 1 teacher class 4210 May 1 08:27 .profile -rwxr-xr-x 1 teacher class 1948 May 12 13:42 memo $
In questo capitolo, discuteremo in dettaglio sui permessi dei file e le modalità di accesso in Unix. La proprietà dei file è un componente importante di Unix che fornisce un metodo sicuro per l'archiviazione dei file. Ogni file in Unix ha i seguenti attributi:
Owner permissions - Le autorizzazioni del proprietario determinano le azioni che il proprietario del file può eseguire sul file.
Group permissions - Le autorizzazioni del gruppo determinano le azioni che un utente, che è un membro del gruppo a cui appartiene un file, può eseguire sul file.
Other (world) permissions - Le autorizzazioni per gli altri indicano quale azione tutti gli altri utenti possono eseguire sul file.
Gli indicatori di autorizzazione
Durante l'utilizzo ls -l comando, visualizza varie informazioni relative all'autorizzazione del file come segue:
$ls -l /home/amrood
-rwxr-xr-- 1 amrood users 1024 Nov 2 00:10 myfile
drwxr-xr--- 1 amrood users 1024 Nov 2 00:10 mydir
Qui, la prima colonna rappresenta le diverse modalità di accesso, cioè l'autorizzazione associata a un file o una directory.
I permessi sono suddivisi in gruppi di tre e ogni posizione nel gruppo denota un permesso specifico, in questo ordine: read (r), write (w), execute (x) -
I primi tre caratteri (2-4) rappresentano le autorizzazioni per il proprietario del file. Per esempio,-rwxr-xr-- rappresenta che il proprietario ha il permesso di lettura (r), scrittura (w) ed esecuzione (x).
Il secondo gruppo di tre caratteri (5-7) è costituito dalle autorizzazioni per il gruppo a cui appartiene il file. Per esempio,-rwxr-xr-- rappresenta che il gruppo ha il permesso di lettura (r) ed esecuzione (x), ma nessun permesso di scrittura.
L'ultimo gruppo di tre caratteri (8-10) rappresenta le autorizzazioni per tutti gli altri. Per esempio,-rwxr-xr-- rappresenta che c'è read (r) solo permesso.
Modalità di accesso ai file
I permessi di un file sono la prima linea di difesa nella sicurezza di un sistema Unix. Gli elementi costitutivi di base dei permessi Unix sono iread, write, e execute autorizzazioni, che sono state descritte di seguito -
Leggere
Concede la capacità di leggere, cioè visualizzare il contenuto del file.
Scrivi
Concede la capacità di modificare o rimuovere il contenuto del file.
Eseguire
L'utente con autorizzazioni di esecuzione può eseguire un file come programma.
Modalità di accesso alla directory
Le modalità di accesso alla directory sono elencate e organizzate allo stesso modo di qualsiasi altro file. Ci sono alcune differenze che devono essere menzionate:
Leggere
L'accesso a una directory significa che l'utente può leggere i contenuti. L'utente può guardare il filefilenames all'interno della directory.
Scrivi
Accesso significa che l'utente può aggiungere o eliminare file dalla directory.
Eseguire
L'esecuzione di una directory non ha davvero senso, quindi considerala come un'autorizzazione traversa.
Un utente deve avere execute accesso a bin directory per eseguire il file ls o il cd comando.
Modifica delle autorizzazioni
Per modificare le autorizzazioni del file o della directory, utilizzare il chmod(cambia modalità) comando. Ci sono due modi per usare chmod: la modalità simbolica e la modalità assoluta.
Usare chmod in modalità simbolica
Il modo più semplice per un principiante per modificare i permessi di file o directory è utilizzare la modalità simbolica. Con le autorizzazioni simboliche è possibile aggiungere, eliminare o specificare il set di autorizzazioni desiderato utilizzando gli operatori nella tabella seguente.
Sr.No. | Operatore Chmod e descrizione |
---|---|
1 | + Aggiunge le autorizzazioni designate a un file o una directory. |
2 | - Rimuove le autorizzazioni designate da un file o una directory. |
3 | = Imposta le autorizzazioni designate. |
Ecco un esempio di utilizzo di testfile. In esecuzionels -1 sul file di prova mostra che i permessi del file sono i seguenti:
$ls -l testfile
-rwxrwxr-- 1 amrood users 1024 Nov 2 00:10 testfile
Poi ogni esempio chmod il comando della tabella precedente viene eseguito sul file di prova, seguito da ls –l, così puoi vedere le modifiche alle autorizzazioni -
$chmod o+wx testfile $ls -l testfile
-rwxrwxrwx 1 amrood users 1024 Nov 2 00:10 testfile
$chmod u-x testfile $ls -l testfile
-rw-rwxrwx 1 amrood users 1024 Nov 2 00:10 testfile
$chmod g = rx testfile $ls -l testfile
-rw-r-xrwx 1 amrood users 1024 Nov 2 00:10 testfile
Ecco come puoi combinare questi comandi su una singola riga:
$chmod o+wx,u-x,g = rx testfile $ls -l testfile
-rw-r-xrwx 1 amrood users 1024 Nov 2 00:10 testfile
Utilizzo di chmod con autorizzazioni assolute
Il secondo modo per modificare i permessi con il comando chmod consiste nell'usare un numero per specificare ogni set di permessi per il file.
A ogni autorizzazione viene assegnato un valore, come mostra la tabella seguente, e il totale di ogni serie di autorizzazioni fornisce un numero per quella serie.
Numero | Rappresentazione dell'autorizzazione ottale | Rif |
---|---|---|
0 | Nessun permesso | --- |
1 | Esegui autorizzazione | --X |
2 | Scrivere il permesso | -w- |
3 | Esecuzione e autorizzazione di scrittura: 1 (esecuzione) + 2 (scrittura) = 3 | -wx |
4 | Leggi il permesso | r-- |
5 | Permesso di lettura ed esecuzione: 4 (lettura) + 1 (esecuzione) = 5 | rx |
6 | Permesso di lettura e scrittura: 4 (lettura) + 2 (scrittura) = 6 | rw- |
7 | Tutti i permessi: 4 (lettura) + 2 (scrittura) + 1 (esecuzione) = 7 | rwx |
Ecco un esempio utilizzando il file di prova. In esecuzionels -1 sul file di prova mostra che i permessi del file sono i seguenti:
$ls -l testfile
-rwxrwxr-- 1 amrood users 1024 Nov 2 00:10 testfile
Poi ogni esempio chmod il comando della tabella precedente viene eseguito sul file di prova, seguito da ls –l, così puoi vedere le modifiche alle autorizzazioni -
$ chmod 755 testfile
$ls -l testfile -rwxr-xr-x 1 amrood users 1024 Nov 2 00:10 testfile $chmod 743 testfile
$ls -l testfile -rwxr---wx 1 amrood users 1024 Nov 2 00:10 testfile $chmod 043 testfile
$ls -l testfile
----r---wx 1 amrood users 1024 Nov 2 00:10 testfile
Modifica di proprietari e gruppi
Durante la creazione di un account su Unix, assegna un file owner ID e a group IDa ogni utente. Tutti i permessi sopra menzionati vengono assegnati anche in base al Proprietario e ai Gruppi.
Sono disponibili due comandi per modificare il proprietario e il gruppo di file:
chown - Il chown comando sta per "change owner" e viene utilizzato per modificare il proprietario di un file.
chgrp - Il chgrp comando sta per "change group" e viene utilizzato per modificare il gruppo di un file.
Modifica della proprietà
Il chowncomando cambia la proprietà di un file. La sintassi di base è la seguente:
$ chown user filelist
Il valore dell'utente può essere il name of a user sul sistema o il file user id (uid) di un utente sul sistema.
Il seguente esempio ti aiuterà a capire il concetto:
$ chown amrood testfile $
Cambia il proprietario del file specificato per l'utente amrood.
NOTE - Il super utente, root, ha la capacità illimitata di cambiare la proprietà di qualsiasi file, ma gli utenti normali possono cambiare la proprietà solo dei file che possiedono.
Modifica della proprietà del gruppo
Il chgrpIl comando modifica la proprietà del gruppo di un file. La sintassi di base è la seguente:
$ chgrp group filelist
Il valore del gruppo può essere il name of a group sul sistema o the group ID (GID) di un gruppo sul sistema.
L'esempio seguente aiuta a comprendere il concetto:
$ chgrp special testfile
$
Cambia il gruppo del file specificato in special gruppo.
Autorizzazione file SUID e SGID
Spesso quando un comando viene eseguito, dovrà essere eseguito con privilegi speciali per svolgere il suo compito.
Ad esempio, quando modifichi la password con l'estensione passwd comando, la nuova password viene memorizzata nel file /etc/shadow.
Come utente normale, non hai read o writeaccedere a questo file per motivi di sicurezza, ma quando si modifica la password, è necessario disporre dell'autorizzazione di scrittura per questo file. Ciò significa che il filepasswd il programma deve darti autorizzazioni aggiuntive in modo che tu possa scrivere sul file /etc/shadow.
Autorizzazioni aggiuntive vengono fornite ai programmi tramite un meccanismo noto come Set User ID (SUID) e Set Group ID (SGID) bit.
Quando esegui un programma con il bit SUID abilitato, erediti i permessi del proprietario di quel programma. I programmi che non hanno impostato il bit SUID vengono eseguiti con le autorizzazioni dell'utente che ha avviato il programma.
Questo è anche il caso di SGID. Normalmente, i programmi vengono eseguiti con le autorizzazioni del tuo gruppo, ma invece il tuo gruppo verrà modificato solo per questo programma nel proprietario del gruppo del programma.
I bit SUID e SGID appariranno come la lettera "s"se l'autorizzazione è disponibile. Il SUID"s" bit si troverà nei bit di autorizzazione in cui i proprietari execute il permesso risiede normalmente.
Ad esempio, il comando -
$ ls -l /usr/bin/passwd
-r-sr-xr-x 1 root bin 19031 Feb 7 13:47 /usr/bin/passwd*
$
Mostra che il bit SUID è impostato e che il comando è di proprietà della root. Una lettera maiuscolaS nella posizione di esecuzione invece che in minuscolo s indica che il bit di esecuzione non è impostato.
Se lo sticky bit è abilitato nella directory, i file possono essere rimossi solo se sei uno dei seguenti utenti:
- Il proprietario della directory sticky
- Il proprietario del file rimosso
- Il super utente, root
Per impostare i bit SUID e SGID per qualsiasi directory, prova il seguente comando:
$ chmod ug+s dirname
$ ls -l drwsr-sr-x 2 root root 4096 Jun 19 06:45 dirname $
In questo capitolo, discuteremo in dettaglio dell'ambiente Unix. Un importante concetto di Unix è ilenvironment, che è definito dalle variabili di ambiente. Alcuni sono impostati dal sistema, altri da te, altri ancora dalla shell o da qualsiasi programma che carica un altro programma.
Una variabile è una stringa di caratteri a cui assegniamo un valore. Il valore assegnato potrebbe essere un numero, testo, nome file, dispositivo o qualsiasi altro tipo di dati.
Ad esempio, prima impostiamo una variabile TEST e poi accediamo al suo valore utilizzando il echo comando -
$TEST="Unix Programming" $echo $TEST
Produce il seguente risultato.
Unix Programming
Si noti che le variabili di ambiente vengono impostate senza utilizzare il $sign ma durante l'accesso usiamo il segno $ come prefisso. Queste variabili mantengono i loro valori fino a quando non usciamo dalla shell.
Quando si accede al sistema, la shell subisce una fase chiamata initializationper creare l'ambiente. Questo di solito è un processo in due fasi che coinvolge la shell che legge i seguenti file:
- /etc/profile
- profile
Il processo è il seguente:
La shell verifica se il file /etc/profile esiste.
Se esiste, la shell lo legge. In caso contrario, questo file viene ignorato. Non viene visualizzato alcun messaggio di errore.
La shell verifica se il file .profileesiste nella tua directory home. La tua home directory è la directory in cui inizi dopo aver effettuato l'accesso.
Se esiste, la shell lo legge; in caso contrario, la shell lo salta. Non viene visualizzato alcun messaggio di errore.
Non appena entrambi questi file sono stati letti, la shell visualizza un prompt:
$
Questo è il prompt in cui è possibile immettere i comandi per eseguirli.
Note - Il processo di inizializzazione della shell descritto qui si applica a tutti Bourne tipo shell, ma alcuni file aggiuntivi vengono utilizzati da bash e ksh.
Il file .profile
Il file /etc/profile viene mantenuto dall'amministratore di sistema della macchina Unix e contiene le informazioni di inizializzazione della shell richieste da tutti gli utenti di un sistema.
Il file .profileè sotto il tuo controllo. Puoi aggiungere a questo file tutte le informazioni di personalizzazione della shell che desideri. Il set minimo di informazioni che è necessario configurare include:
- Il tipo di terminale che stai utilizzando.
- Un elenco di directory in cui individuare i comandi.
- Un elenco di variabili che influenzano l'aspetto del tuo terminale.
Puoi controllare il tuo .profiledisponibile nella tua home directory. Aprilo usando l'editor vi e controlla tutte le variabili impostate per il tuo ambiente.
Impostazione del tipo di terminale
Di solito, il tipo di terminale che stai utilizzando viene configurato automaticamente dal login o gettyprogrammi. A volte, il processo di configurazione automatica indovina il tuo terminale in modo errato.
Se il tuo terminale è impostato in modo errato, l'output dei comandi potrebbe apparire strano o potresti non essere in grado di interagire correttamente con la shell.
Per assicurarsi che non sia così, la maggior parte degli utenti imposta il proprio terminale sul minimo comune denominatore nel modo seguente:
$TERM=vt100 $
Impostazione del PERCORSO
Quando digiti un comando sul prompt dei comandi, la shell deve individuare il comando prima che possa essere eseguito.
La variabile PATH specifica le posizioni in cui la shell dovrebbe cercare i comandi. Di solito la variabile Path è impostata come segue:
$PATH=/bin:/usr/bin $
Qui, ciascuna delle singole voci separate dal carattere dei due punti (:)sono directory. Se richiedi alla shell di eseguire un comando e non riesce a trovarlo in nessuna delle directory fornite nella variabile PATH, appare un messaggio simile al seguente:
$hello hello: not found $
Ci sono variabili come PS1 e PS2 che vengono discusse nella sezione successiva.
Variabili PS1 e PS2
I caratteri visualizzati dalla shell come prompt dei comandi sono memorizzati nella variabile PS1. Puoi modificare questa variabile in modo che sia tutto ciò che desideri. Non appena lo modifichi, verrà utilizzato dalla shell da quel punto in poi.
Ad esempio, se hai emesso il comando -
$PS1='=>'
=>
=>
=>
Il tuo prompt diventerà =>. Per impostare il valore diPS1 in modo che mostri la directory di lavoro, emetti il comando -
=>PS1="[\u@\h \w]\$"
[root@ip-72-167-112-17 /var/www/tutorialspoint/unix]$ [root@ip-72-167-112-17 /var/www/tutorialspoint/unix]$
Il risultato di questo comando è che il prompt visualizza il nome utente dell'utente, il nome della macchina (nome host) e la directory di lavoro.
ce ne sono un bel pò escape sequencesche può essere utilizzato come argomenti di valore per PS1; cerca di limitarti al più critico in modo che il prompt non ti sommerga di informazioni.
Sr.No. | Sequenza di escape e descrizione |
---|---|
1 | \t Ora corrente, espressa come HH: MM: SS |
2 | \d Data corrente, espressa come data del mese del giorno della settimana |
3 | \n Nuova linea |
4 | \s Ambiente shell corrente |
5 | \W Directory di lavoro |
6 | \w Percorso completo della directory di lavoro |
7 | \u Nome utente dell'utente corrente |
8 | \h Nome host della macchina corrente |
9 | \# Numero di comando del comando corrente. Aumenta quando viene immesso un nuovo comando |
10 | \$ Se l'UID effettivo è 0 (ovvero, se si è connessi come root), terminare il prompt con il carattere #; altrimenti, usa il segno $ |
Puoi apportare tu stesso la modifica ogni volta che accedi, oppure puoi fare in modo che la modifica venga eseguita automaticamente in PS1 aggiungendola al tuo .profile file.
Quando si immette un comando incompleto, la shell mostrerà un prompt secondario e aspetterà che tu completi il comando e premi Enter ancora.
Il prompt secondario predefinito è > (il segno di maggiore di), ma può essere modificato ridefinendo il PS2 variabile di shell -
Di seguito è riportato l'esempio che utilizza il prompt secondario predefinito:
$ echo "this is a > test" this is a test $
L'esempio fornito di seguito ridefinisce la PS2 con un prompt personalizzato:
$ PS2="secondary prompt->" $ echo "this is a
secondary prompt->test"
this is a
test
$
variabili ambientali
Di seguito è riportato l'elenco parziale delle variabili di ambiente importanti. Queste variabili vengono impostate e accessibili come indicato di seguito:
Sr.No. | Variabile e descrizione |
---|---|
1 | DISPLAY Contiene l'identificatore per il display che X11 i programmi dovrebbero essere usati per impostazione predefinita. |
2 | HOME Indica la directory home dell'utente corrente: l'argomento predefinito per il cd built-in comando. |
3 | IFS Indica il Internal Field Separator che viene utilizzato dal parser per la suddivisione delle parole dopo l'espansione. |
4 | LANG LANG si espande nella locale di sistema predefinita; LC_ALL può essere utilizzato per sovrascriverlo. Ad esempio, se il suo valore èpt_BR, quindi la lingua è impostata sul portoghese (brasiliano) e la lingua sul Brasile. |
5 | LD_LIBRARY_PATH Un sistema Unix con un linker dinamico, contiene un elenco di directory separate da due punti che il linker dinamico deve cercare per oggetti condivisi quando crea un'immagine di processo dopo exec, prima di cercare in qualsiasi altra directory. |
6 | PATH Indica il percorso di ricerca dei comandi. È un elenco di directory separato da due punti in cui la shell cerca i comandi. |
7 | PWD Indica la directory di lavoro corrente come impostata dal comando cd. |
8 | RANDOM Genera un numero intero casuale compreso tra 0 e 32.767 ogni volta che viene fatto riferimento. |
9 | SHLVL Aumenta di uno ogni volta che viene avviata un'istanza di bash. Questa variabile è utile per determinare se il comando di uscita integrato termina la sessione corrente. |
10 | TERM Si riferisce al tipo di visualizzazione. |
11 | TZ Si riferisce al fuso orario. Può assumere valori come GMT, AST, ecc. |
12 | UID Si espande nell'ID utente numerico dell'utente corrente, inizializzato all'avvio della shell. |
Di seguito è riportato l'esempio di esempio che mostra poche variabili di ambiente:
$ echo $HOME /root ]$ echo $DISPLAY $ echo $TERM xterm $ echo $PATH /usr/local/bin:/bin:/usr/bin:/home/amrood/bin:/usr/local/bin $
In questo capitolo, discuteremo in dettaglio della stampa e della posta elettronica come utilità di base di Unix. Finora abbiamo cercato di comprendere il sistema operativo Unix e la natura dei suoi comandi di base. In questo capitolo apprenderemo alcune importanti utilità Unix che possono essere utilizzate nella nostra vita quotidiana.
Stampa di file
Prima di stampare un file su un sistema Unix, potresti volerlo riformattare per regolare i margini, evidenziare alcune parole e così via. La maggior parte dei file può anche essere stampata senza riformattarla, ma la stampa non elaborata potrebbe non essere così attraente.
Molte versioni di Unix includono due potenti formattatori di testo, nroff e troff.
Il comando pr
Il prcomando esegue una formattazione minore dei file sullo schermo del terminale o per una stampante. Ad esempio, se hai un lungo elenco di nomi in un file, puoi formattarlo sullo schermo in due o più colonne.
Di seguito è riportata la sintassi per pr comando -
pr option(s) filename(s)
Il prcambia il formato del file solo sullo schermo o sulla copia stampata; non modifica il file originale. La tabella seguente ne elenca alcunipr opzioni -
Sr.No. | Opzione e descrizione |
---|---|
1 | -k Produce k colonne di output |
2 | -d Spazia doppia l'output (non su tutti pr versioni) |
3 | -h "header" Prende l'elemento successivo come intestazione del report |
4 | -t Elimina la stampa dell'intestazione e dei margini superiore / inferiore |
5 | -l PAGE_LENGTH Imposta la lunghezza della pagina su PAGE_LENGTH (66) righe. Il numero predefinito di righe di testo è 56 |
6 | -o MARGIN Compensa ogni riga con spazi MARGIN (zero) |
7 | -w PAGE_WIDTH Imposta la larghezza della pagina su PAGE_WIDTH (72) caratteri solo per l'output di più colonne di testo |
Prima di usare pr, ecco il contenuto di un file di esempio denominato food.
$cat food Sweet Tooth Bangkok Wok Mandalay Afghani Cuisine Isle of Java Big Apple Deli Sushi and Sashimi Tio Pepe's Peppers ........ $
Usiamo il file prcomando per creare un report di due colonne con l'intestazione Ristoranti -
$pr -2 -h "Restaurants" food Nov 7 9:58 1997 Restaurants Page 1 Sweet Tooth Isle of Java Bangkok Wok Big Apple Deli Mandalay Sushi and Sashimi Afghani Cuisine Tio Pepe's Peppers ........ $
I comandi lp e lpr
Il comando lp o lprstampa un file su carta invece che sullo schermo. Una volta che sei pronto con la formattazione usando ilpr comando, è possibile utilizzare uno qualsiasi di questi comandi per stampare il file sulla stampante collegata al computer.
Il tuo amministratore di sistema ha probabilmente impostato una stampante predefinita sul tuo sito. Per stampare un file denominatofood sulla stampante predefinita, utilizzare l'estensione lp o lpr comando, come nell'esempio seguente:
$lp food request id is laserp-525 (1 file) $
Il lp mostra un ID che è possibile utilizzare per annullare il lavoro di stampa o verificarne lo stato.
Se stai usando il file lp puoi usare il comando -nNumopzione per stampare Num numero di copie. Insieme al comandolpr, Puoi usare -Num per lo stesso.
Se sono presenti più stampanti connesse alla rete condivisa, è possibile scegliere una stampante utilizzando -dprinter opzione insieme al comando lp e per lo stesso scopo puoi usare -Pprinteropzione insieme al comando lpr. Qui stampante è il nome della stampante.
I comandi lpstat e lpq
Il lpstat Il comando mostra cosa c'è nella coda della stampante: ID delle richieste, proprietari, dimensioni dei file, quando i lavori sono stati inviati per la stampa e lo stato delle richieste.
Uso lpstat -ose vuoi vedere tutte le richieste di output oltre alle tue. Le richieste vengono visualizzate nell'ordine in cui verranno stampate:
$lpstat -o laserp-573 john 128865 Nov 7 11:27 on laserp laserp-574 grace 82744 Nov 7 11:28 laserp-575 john 23347 Nov 7 11:35 $
Il lpq fornisce informazioni leggermente diverse rispetto a lpstat -o -
$lpq laserp is ready and printing Rank Owner Job Files Total Size active john 573 report.ps 128865 bytes 1st grace 574 ch03.ps ch04.ps 82744 bytes 2nd john 575 standard input 23347 bytes $
Qui la prima riga mostra lo stato della stampante. Se la stampante è disattivata o sta esaurendo la carta, potrebbero essere visualizzati messaggi diversi su questa prima riga.
I comandi cancel e lprm
Il cancel il comando termina una richiesta di stampa dal file lp command. Illprm comando termina tutto lpr requests. È possibile specificare l'ID della richiesta (visualizzato da lp o lpq) o il nome della stampante.
$cancel laserp-575 request "laserp-575" cancelled $
Per annullare qualsiasi richiesta in fase di stampa, indipendentemente dal suo ID, è sufficiente immettere annulla e il nome della stampante -
$cancel laserp request "laserp-573" cancelled $
Il lprmIl comando annullerà il lavoro attivo se appartiene a te. Altrimenti, puoi fornire i numeri del lavoro come argomenti o utilizzare un filedash (-) per rimuovere tutti i tuoi lavori -
$lprm 575 dfA575diamond dequeued cfA575diamond dequeued $
Il lprm comando indica i nomi file effettivi rimossi dalla coda della stampante.
Invio di e-mail
Si utilizza il comando di posta Unix per inviare e ricevere posta. Ecco la sintassi per inviare un'e-mail:
$mail [-s subject] [-c cc-addr] [-b bcc-addr] to-addr
Qui ci sono importanti opzioni relative ai comandi di posta
Sr.No. | Opzione e descrizione |
---|---|
1 | -s Specifica l'oggetto sulla riga di comando. |
2 | -c Invia copie per conoscenza all'elenco degli utenti. L'elenco dovrebbe essere un elenco di nomi separati da virgole. |
3 | -b Invia copie per conoscenza nascoste alla lista. L'elenco dovrebbe essere un elenco di nomi separati da virgole. |
Di seguito è riportato un esempio per inviare un messaggio di prova a [email protected].
$mail -s "Test Message" [email protected]
Dovrai quindi digitare il tuo messaggio, seguito da "control-D"all'inizio di una riga. Per interrompere, digita semplicemente punto(.) come segue -
Hi,
This is a test
.
Cc:
È possibile inviare un file completo utilizzando un file redirect < operator come segue -
$mail -s "Report 05/06/07" [email protected] < demo.txt
Per controllare la posta in arrivo sul tuo sistema Unix, digita semplicemente email come segue:
$mail
no email
In questo capitolo, discuteremo in dettaglio di pipe e filtri in Unix. È possibile collegare due comandi insieme in modo che l'output di un programma diventi l'input del programma successivo. Due o più comandi collegati in questo modo formano una pipe.
Per fare una pipa, metti una barra verticale (|) sulla riga di comando tra due comandi.
Quando un programma prende l'input da un altro programma, esegue alcune operazioni su quell'input e scrive il risultato sullo standard output. È indicato come afilter.
Il comando grep
Il comando grep cerca uno o più file per le righe che hanno un certo modello. La sintassi è:
$grep pattern file(s)
Il nome "grep" proviene dal comando ed (un editor di riga Unix) g/re/p che significa "cercare globalmente un'espressione regolare e stampare tutte le righe che la contengono".
Un'espressione regolare è un testo semplice (una parola, ad esempio) e / o caratteri speciali utilizzati per la corrispondenza dei modelli.
L'uso più semplice di grep è cercare un pattern composto da una singola parola. Può essere utilizzato in una pipe in modo che solo quelle righe dei file di input contenenti una data stringa vengano inviate allo standard output. Se non date a grep un nome di file da leggere, legge il suo standard input; è così che funzionano tutti i programmi di filtraggio -
$ls -l | grep "Aug"
-rw-rw-rw- 1 john doc 11008 Aug 6 14:10 ch02
-rw-rw-rw- 1 john doc 8515 Aug 6 15:30 ch07
-rw-rw-r-- 1 john doc 2488 Aug 15 10:51 intro
-rw-rw-r-- 1 carol doc 1605 Aug 23 07:35 macros
$
Ci sono varie opzioni che puoi usare insieme a grep comando -
Sr.No. | Opzione e descrizione |
---|---|
1 | -v Stampa tutte le righe che non corrispondono al modello. |
2 | -n Stampa la riga corrispondente e il relativo numero di riga. |
3 | -l Stampa solo i nomi dei file con righe corrispondenti (lettera "l") |
4 | -c Stampa solo il conteggio delle righe corrispondenti. |
5 | -i Corrisponde a lettere maiuscole o minuscole. |
Usiamo ora un'espressione regolare che dice a grep di trovare le linee con "carol", seguito da zero o da altri caratteri abbreviati in un'espressione regolare come ". *"), quindi seguito da "Ago". -
Qui stiamo usando il -i opzione per avere la ricerca senza distinzione tra maiuscole e minuscole -
$ls -l | grep -i "carol.*aug"
-rw-rw-r-- 1 carol doc 1605 Aug 23 07:35 macros
$
Il comando di ordinamento
Il sortIl comando dispone le righe di testo in ordine alfabetico o numerico. L'esempio seguente ordina le righe nel file di cibo:
$sort food
Afghani Cuisine
Bangkok Wok
Big Apple Deli
Isle of Java
Mandalay
Sushi and Sashimi
Sweet Tooth
Tio Pepe's Peppers
$
Il sortIl comando dispone le righe di testo in ordine alfabetico per impostazione predefinita. Ci sono molte opzioni che controllano l'ordinamento:
Sr.No. | Descrizione |
---|---|
1 | -n Ordina numericamente (esempio: 10 ordinerà dopo 2), ignora gli spazi e le tabulazioni. |
2 | -r Inverte l'ordine di ordinamento. |
3 | -f Ordina insieme maiuscole e minuscole. |
4 | +x Ignora prima x campi durante l'ordinamento. |
Più di due comandi possono essere collegati in una pipe. Prendendo un esempio di pipe precedente usandogrep, possiamo ulteriormente ordinare i file modificati in agosto in base all'ordine di dimensione.
La seguente pipe è composta dai comandi ls, grep, e sort -
$ls -l | grep "Aug" | sort +4n
-rw-rw-r-- 1 carol doc 1605 Aug 23 07:35 macros
-rw-rw-r-- 1 john doc 2488 Aug 15 10:51 intro
-rw-rw-rw- 1 john doc 8515 Aug 6 15:30 ch07
-rw-rw-rw- 1 john doc 11008 Aug 6 14:10 ch02
$
Questa pipe ordina tutti i file nella directory modificata ad agosto in base alla dimensione e li stampa sullo schermo del terminale. L'opzione di ordinamento + 4n salta quattro campi (i campi sono separati da spazi) quindi ordina le righe in ordine numerico.
I comandi pg e altri
Un output lungo può normalmente essere compresso da te sullo schermo, ma se fai scorrere più testo o usi il file pgcomando come filtro; il display si ferma quando lo schermo è pieno di testo.
Supponiamo che tu abbia un lungo elenco di directory. Per semplificare la lettura dell'elenco ordinato, convogliare l'outputmore come segue -
$ls -l | grep "Aug" | sort +4n | more
-rw-rw-r-- 1 carol doc 1605 Aug 23 07:35 macros
-rw-rw-r-- 1 john doc 2488 Aug 15 10:51 intro
-rw-rw-rw- 1 john doc 8515 Aug 6 15:30 ch07
-rw-rw-r-- 1 john doc 14827 Aug 9 12:40 ch03
.
.
.
-rw-rw-rw- 1 john doc 16867 Aug 6 15:56 ch05
--More--(74%)
Lo schermo si riempirà quando lo schermo sarà pieno di testo composto da righe ordinate in base alla dimensione del file. Nella parte inferiore dello schermo c'è il filemore prompt, in cui è possibile digitare un comando per spostarsi nel testo ordinato.
Una volta che hai finito con questa schermata, puoi usare uno qualsiasi dei comandi elencati nella discussione del programma more.
In questo capitolo, discuteremo in dettaglio sulla gestione dei processi in Unix. Quando esegui un programma sul tuo sistema Unix, il sistema crea un ambiente speciale per quel programma. Questo ambiente contiene tutto ciò che è necessario al sistema per eseguire il programma come se nessun altro programma fosse in esecuzione sul sistema.
Ogni volta che si immette un comando in Unix, viene creato o avviato un nuovo processo. Quando hai provato il filelscomando per elencare il contenuto della directory, hai avviato un processo. Un processo, in termini semplici, è un'istanza di un programma in esecuzione.
Il sistema operativo tiene traccia dei processi tramite un numero ID a cinque cifre noto come pid o il process ID. Ogni processo nel sistema ha un unicopid.
I pid alla fine si ripetono perché tutti i numeri possibili sono esauriti e il pid successivo rotola o ricomincia. In qualsiasi momento, nel sistema non esistono due processi con lo stesso pid perché è il pid che Unix utilizza per tenere traccia di ciascun processo.
Avvio di un processo
Quando avvii un processo (esegui un comando), ci sono due modi per eseguirlo:
- Processi in primo piano
- Processi in background
Processi in primo piano
Per impostazione predefinita, ogni processo avviato viene eseguito in primo piano. Riceve il suo input dalla tastiera e invia il suo output allo schermo.
Puoi vedere che questo accade con il lscomando. Se desideri elencare tutti i file nella directory corrente, puoi utilizzare il seguente comando:
$ls ch*.doc
In questo modo verranno visualizzati tutti i file, i cui nomi iniziano con ch e termina con .doc -
ch01-1.doc ch010.doc ch02.doc ch03-2.doc
ch04-1.doc ch040.doc ch05.doc ch06-2.doc
ch01-2.doc ch02-1.doc
Il processo viene eseguito in primo piano, l'output viene diretto al mio schermo e se il file ls comando vuole qualsiasi input (cosa che non fa), lo attende dalla tastiera.
Mentre un programma è in esecuzione in primo piano e richiede molto tempo, non è possibile eseguire altri comandi (avviare altri processi) perché il prompt non sarebbe disponibile finché il programma non termina l'elaborazione e viene visualizzato.
Processi in background
Un processo in background viene eseguito senza essere connesso alla tastiera. Se il processo in background richiede un input da tastiera, attende.
Il vantaggio di eseguire un processo in background è che puoi eseguire altri comandi; non devi aspettare fino al termine per avviarne un altro!
Il modo più semplice per avviare un processo in background è aggiungere una e commerciale (&) alla fine del comando.
$ls ch*.doc &
Questo mostra tutti quei file i cui nomi iniziano con ch e termina con .doc -
ch01-1.doc ch010.doc ch02.doc ch03-2.doc
ch04-1.doc ch040.doc ch05.doc ch06-2.doc
ch01-2.doc ch02-1.doc
Qui, se il file ls Il comando vuole qualsiasi input (cosa che non fa), va in uno stato di stop fino a quando non lo spostiamo in primo piano e gli forniamo i dati dalla tastiera.
La prima riga contiene informazioni sul processo in background: il numero del lavoro e l'ID del processo. È necessario conoscere il numero del lavoro per manipolarlo tra lo sfondo e il primo piano.
Premi il tasto Invio e vedrai quanto segue:
[1] + Done ls ch*.doc &
$
La prima riga ti dice che il file lsil processo in background del comando viene completato correttamente. Il secondo è un prompt per un altro comando.
Elenco dei processi in esecuzione
È facile vedere i propri processi eseguendo il file ps (stato del processo) come segue:
$ps
PID TTY TIME CMD
18358 ttyp3 00:00:00 sh
18361 ttyp3 00:01:31 abiword
18789 ttyp3 00:00:00 ps
Uno dei flag più comunemente usati per ps è il -f (f per intero), che fornisce ulteriori informazioni come mostrato nell'esempio seguente:
$ps -f
UID PID PPID C STIME TTY TIME CMD
amrood 6738 3662 0 10:23:03 pts/6 0:00 first_one
amrood 6739 3662 0 10:22:54 pts/6 0:00 second_one
amrood 3662 3657 0 08:10:53 pts/6 0:00 -ksh
amrood 6892 3662 4 10:51:50 pts/6 0:00 ps -f
Ecco la descrizione di tutti i campi visualizzati da ps -f comando -
Sr.No. | Colonna e descrizione |
---|---|
1 | UID ID utente a cui appartiene questo processo (la persona che lo esegue) |
2 | PID ID processo |
3 | PPID ID processo padre (l'ID del processo che lo ha avviato) |
4 | C Utilizzo della CPU del processo |
5 | STIME Ora di inizio del processo |
6 | TTY Tipo di terminale associato al processo |
7 | TIME Tempo di CPU impiegato dal processo |
8 | CMD Il comando che ha avviato questo processo |
Ci sono altre opzioni che possono essere utilizzate insieme a ps comando -
Sr.No. | Opzione e descrizione |
---|---|
1 | -a Mostra le informazioni su tutti gli utenti |
2 | -x Mostra le informazioni sui processi senza terminali |
3 | -u Mostra informazioni aggiuntive come l'opzione -f |
4 | -e Visualizza informazioni estese |
Arresto dei processi
La conclusione di un processo può essere eseguita in diversi modi. Spesso, da un comando basato su console, l'invio di una sequenza di tasti CTRL + C (il carattere di interruzione predefinito) farà terminare il comando. Funziona quando il processo è in esecuzione in modalità primo piano.
Se un processo è in esecuzione in background, dovresti ottenere il suo ID lavoro utilizzando il file pscomando. Successivamente, puoi utilizzare il filekill comando per terminare il processo come segue:
$ps -f
UID PID PPID C STIME TTY TIME CMD
amrood 6738 3662 0 10:23:03 pts/6 0:00 first_one
amrood 6739 3662 0 10:22:54 pts/6 0:00 second_one
amrood 3662 3657 0 08:10:53 pts/6 0:00 -ksh
amrood 6892 3662 4 10:51:50 pts/6 0:00 ps -f
$kill 6738
Terminated
Qui, il kill il comando termina il first_oneprocessi. Se un processo ignora un normale comando kill, puoi usarekill -9 seguito dall'ID processo come segue:
$kill -9 6738
Terminated
Processi padre e figlio
A ogni processo unix sono assegnati due numeri ID: l'ID processo (pid) e l'ID processo padre (ppid). Ogni processo utente nel sistema ha un processo padre.
La maggior parte dei comandi che esegui hanno la shell come genitore. Controlla ilps -f esempio in cui questo comando elencava sia l'ID processo che l'ID processo padre.
Processi zombi e orfani
Normalmente, quando un processo figlio viene terminato, il processo genitore viene aggiornato tramite un file SIGCHLDsegnale. Quindi il genitore può svolgere qualche altra attività o riavviare un nuovo bambino, se necessario. Tuttavia, a volte il processo genitore viene interrotto prima che il suo figlio venga ucciso. In questo caso, il "genitore di tutti i processi", il fileinitprocesso, diventa il nuovo PPID (ID processo padre). In alcuni casi, questi processi sono chiamati processi orfani.
Quando un processo viene interrotto, a ps l'elenco potrebbe ancora mostrare il processo con l'estensione Zstato. Questo è un processo zombie o defunto. Il processo è morto e non viene utilizzato. Questi processi sono diversi dai processi orfani. Hanno completato l'esecuzione ma trovano ancora una voce nella tabella dei processi.
Processi daemon
I daemon sono processi in background relativi al sistema che spesso vengono eseguiti con le autorizzazioni di root e le richieste di servizi da altri processi.
Un demone non ha un terminale di controllo. Non può aprirsi/dev/tty. Se fai un file"ps -ef" e guarda il file tty campo, tutti i daemon avranno l'estensione ? per il tty.
Per essere precisi, un demone è un processo che viene eseguito in background, solitamente in attesa che accada qualcosa con cui è in grado di lavorare. Ad esempio, un demone della stampante in attesa di comandi di stampa.
Se hai un programma che richiede una lunga elaborazione, allora vale la pena renderlo un demone ed eseguirlo in background.
Il comando superiore
Il top Il comando è uno strumento molto utile per mostrare rapidamente i processi ordinati in base a vari criteri.
È uno strumento diagnostico interattivo che si aggiorna frequentemente e mostra informazioni su memoria fisica e virtuale, utilizzo della CPU, medie di carico e processi occupati.
Ecco la semplice sintassi per eseguire il comando top e per vedere le statistiche di utilizzo della CPU da parte di diversi processi:
$top
ID lavoro e ID processo
I processi in background e sospesi vengono solitamente manipolati tramite job number (job ID). Questo numero è diverso dall'ID del processo e viene utilizzato perché è più breve.
Inoltre, un lavoro può essere costituito da più processi in esecuzione in serie o contemporaneamente, in parallelo. Utilizzare l'ID lavoro è più semplice che tenere traccia dei singoli processi.
In questo capitolo, discuteremo in dettaglio sulle utilità di comunicazione di rete in Unix. Quando lavori in un ambiente distribuito, devi comunicare con utenti remoti e devi anche accedere a macchine Unix remote.
Ci sono diverse utilità Unix che aiutano gli utenti a calcolare in un ambiente distribuito in rete. Questo capitolo ne elenca alcuni.
L'utilità ping
Il pingil comando invia una richiesta di eco a un host disponibile sulla rete. Usando questo comando, puoi verificare se il tuo host remoto sta rispondendo bene o no.
Il comando ping è utile per quanto segue:
- Monitoraggio e isolamento dei problemi hardware e software.
- Determinazione dello stato della rete e di vari host esterni.
- Testare, misurare e gestire le reti.
Sintassi
Di seguito è riportata la semplice sintassi per utilizzare il comando ftp:
$ping hostname or ip-address
Il comando precedente avvia la stampa di una risposta ogni secondo. Per uscire dal comando, è possibile terminarlo premendoCNTRL + C chiavi.
Esempio
Di seguito è riportato un esempio per verificare la disponibilità di un host disponibile sulla rete:
$ping google.com PING google.com (74.125.67.100) 56(84) bytes of data. 64 bytes from 74.125.67.100: icmp_seq = 1 ttl = 54 time = 39.4 ms 64 bytes from 74.125.67.100: icmp_seq = 2 ttl = 54 time = 39.9 ms 64 bytes from 74.125.67.100: icmp_seq = 3 ttl = 54 time = 39.3 ms 64 bytes from 74.125.67.100: icmp_seq = 4 ttl = 54 time = 39.1 ms 64 bytes from 74.125.67.100: icmp_seq = 5 ttl = 54 time = 38.8 ms --- google.com ping statistics --- 22 packets transmitted, 22 received, 0% packet loss, time 21017ms rtt min/avg/max/mdev = 38.867/39.334/39.900/0.396 ms $
Se un host non esiste, riceverai il seguente output:
$ping giiiiiigle.com ping: unknown host giiiiigle.com $
L'utilità ftp
Qui, ftp sta per File Ttrasferimento Protocol. Questa utility ti aiuta a caricare e scaricare il tuo file da un computer a un altro computer.
L'utilità ftp ha il proprio set di comandi simili a Unix. Questi comandi ti aiutano a eseguire attività come:
Connettiti e accedi a un host remoto.
Naviga nelle directory.
Elenca il contenuto della directory.
Metti e ottieni file.
Trasferisci file come ascii, ebcdic o binary.
Sintassi
Di seguito è riportata la semplice sintassi per utilizzare il comando ftp:
$ftp hostname or ip-address
Il comando precedente richiederà l'ID di accesso e la password. Una volta autenticato, puoi accedere alla home directory dell'account di accesso e sarai in grado di eseguire vari comandi.
Le tabelle seguenti elencano alcuni comandi importanti:
Sr.No. | Comando e descrizione |
---|---|
1 | put filename Carica il nome del file dalla macchina locale alla macchina remota. |
2 | get filename Scarica il nome del file dalla macchina remota alla macchina locale. |
3 | mput file list Carica più di un file dalla macchina locale alla macchina remota. |
4 | mget file list Scarica più di un file dalla macchina remota alla macchina locale. |
5 | prompt off Disattiva il prompt. Per impostazione predefinita, riceverai una richiesta per caricare o scaricare file utilizzandomput o mget comandi. |
6 | prompt on Attiva il prompt. |
7 | dir Elenca tutti i file disponibili nella directory corrente della macchina remota. |
8 | cd dirname Cambia la directory in dirname sulla macchina remota. |
9 | lcd dirname Cambia la directory in dirname sulla macchina locale. |
10 | quit Aiuta a disconnettersi dall'account di accesso corrente. |
Va notato che tutti i file verrebbero scaricati o caricati nelle o dalle directory correnti. Se desideri caricare i tuoi file in una determinata directory, devi prima passare a quella directory e poi caricare i file richiesti.
Esempio
Di seguito è riportato l'esempio per mostrare il funzionamento di alcuni comandi:
$ftp amrood.com
Connected to amrood.com.
220 amrood.com FTP server (Ver 4.9 Thu Sep 2 20:35:07 CDT 2009)
Name (amrood.com:amrood): amrood
331 Password required for amrood.
Password:
230 User amrood logged in.
ftp> dir
200 PORT command successful.
150 Opening data connection for /bin/ls.
total 1464
drwxr-sr-x 3 amrood group 1024 Mar 11 20:04 Mail
drwxr-sr-x 2 amrood group 1536 Mar 3 18:07 Misc
drwxr-sr-x 5 amrood group 512 Dec 7 10:59 OldStuff
drwxr-sr-x 2 amrood group 1024 Mar 11 15:24 bin
drwxr-sr-x 5 amrood group 3072 Mar 13 16:10 mpl
-rw-r--r-- 1 amrood group 209671 Mar 15 10:57 myfile.out
drwxr-sr-x 3 amrood group 512 Jan 5 13:32 public
drwxr-sr-x 3 amrood group 512 Feb 10 10:17 pvm3
226 Transfer complete.
ftp> cd mpl
250 CWD command successful.
ftp> dir
200 PORT command successful.
150 Opening data connection for /bin/ls.
total 7320
-rw-r--r-- 1 amrood group 1630 Aug 8 1994 dboard.f
-rw-r----- 1 amrood group 4340 Jul 17 1994 vttest.c
-rwxr-xr-x 1 amrood group 525574 Feb 15 11:52 wave_shift
-rw-r--r-- 1 amrood group 1648 Aug 5 1994 wide.list
-rwxr-xr-x 1 amrood group 4019 Feb 14 16:26 fix.c
226 Transfer complete.
ftp> get wave_shift
200 PORT command successful.
150 Opening data connection for wave_shift (525574 bytes).
226 Transfer complete.
528454 bytes received in 1.296 seconds (398.1 Kbytes/s)
ftp> quit
221 Goodbye.
$
L'utilità telnet
Ci sono momenti in cui ci viene richiesto di connetterci a una macchina Unix remota e lavorare su quella macchina da remoto. Telnet è un'utilità che consente a un utente di computer in un sito di stabilire una connessione, accedere e quindi svolgere il lavoro su un computer in un altro sito.
Dopo aver effettuato l'accesso utilizzando Telnet, è possibile eseguire tutte le attività sulla macchina connessa in remoto. Quello che segue è un esempio di sessione Telnet:
C:>telnet amrood.com
Trying...
Connected to amrood.com.
Escape character is '^]'.
login: amrood
amrood's Password:
*****************************************************
* *
* *
* WELCOME TO AMROOD.COM *
* *
* *
*****************************************************
Last unsuccessful login: Fri Mar 3 12:01:09 IST 2009
Last login: Wed Mar 8 18:33:27 IST 2009 on pts/10
{ do your work }
$ logout
Connection closed.
C:>
L'utilità del dito
Il fingercomando visualizza le informazioni sugli utenti su un dato host. L'host può essere locale o remoto.
Il dito può essere disabilitato su altri sistemi per motivi di sicurezza.
Di seguito è riportata la semplice sintassi per utilizzare il comando finger:
Controlla tutti gli utenti che hanno effettuato l'accesso sulla macchina locale -
$ finger
Login Name Tty Idle Login Time Office
amrood pts/0 Jun 25 08:03 (62.61.164.115)
Ottieni informazioni su un utente specifico disponibile sulla macchina locale -
$ finger amrood
Login: amrood Name: (null)
Directory: /home/amrood Shell: /bin/bash
On since Thu Jun 25 08:03 (MST) on pts/0 from 62.61.164.115
No mail.
No Plan.
Controlla tutti gli utenti che hanno effettuato l'accesso sulla macchina remota -
$ finger @avtar.com
Login Name Tty Idle Login Time Office
amrood pts/0 Jun 25 08:03 (62.61.164.115)
Ottieni le informazioni su un utente specifico disponibile sulla macchina remota -
$ finger [email protected]
Login: amrood Name: (null)
Directory: /home/amrood Shell: /bin/bash
On since Thu Jun 25 08:03 (MST) on pts/0 from 62.61.164.115
No mail.
No Plan.
In questo capitolo capiremo come funziona l'Editor vi in Unix. Esistono molti modi per modificare i file in Unix. Modifica dei file utilizzando l'editor di testo orientato allo schermoviè uno dei modi migliori. Questo editor ti consente di modificare le righe nel contesto con altre righe nel file.
Una versione migliorata dell'editor vi che si chiama VIMè ora disponibile anche. Qui, VIM sta perVi IMdimostrato.
vi è generalmente considerato lo standard de facto negli editor Unix perché:
Di solito è disponibile su tutte le versioni del sistema Unix.
Le sue implementazioni sono molto simili su tutta la linea.
Richiede pochissime risorse.
È più user-friendly di altri editor come il ed o il ex.
Puoi usare il file vieditor per modificare un file esistente o per creare un nuovo file da zero. Puoi anche usare questo editor per leggere un file di testo.
Avvio dell'Editor vi
La tabella seguente elenca i comandi di base per utilizzare l'editor vi -
Sr.No. | Comando e descrizione |
---|---|
1 | vi filename Crea un nuovo file se già non esiste, altrimenti apre un file esistente. |
2 | vi -R filename Apre un file esistente in modalità di sola lettura. |
3 | view filename Apre un file esistente in modalità di sola lettura. |
Di seguito è riportato un esempio per creare un nuovo file testfile se già non esiste nella directory di lavoro corrente -
$vi testfile
Il comando precedente genererà il seguente output:
|
~
~
~
~
~
~
~
~
~
~
~
~
"testfile" [New File]
Noterai un file tilde(~) su ogni riga che segue il cursore. Una tilde rappresenta una linea inutilizzata. Se una riga non inizia con una tilde e sembra essere vuota, è presente uno spazio, una tabulazione, una nuova riga o un altro carattere non visualizzabile.
Ora hai un file aperto su cui iniziare a lavorare. Prima di procedere oltre, comprendiamo alcuni concetti importanti.
Modalità operative
Mentre lavoriamo con l'editor vi, di solito ci imbattiamo nelle seguenti due modalità:
Command mode- Questa modalità consente di eseguire attività amministrative come salvare i file, eseguire i comandi, spostare il cursore, tagliare (strappare) e incollare le linee o le parole, nonché trovare e sostituire. In questa modalità, qualunque cosa digiti viene interpretata come un comando.
Insert mode- Questa modalità consente di inserire testo nel file. Tutto ciò che viene digitato in questa modalità viene interpretato come input e inserito nel file.
vi inizia sempre in command mode. Per inserire il testo, è necessario essere nella modalità di inserimento per la quale è sufficiente digitarei. Per uscire dalla modalità di inserimento, premere il tastoEsc tasto, che ti riporterà alla modalità di comando.
Hint- Se non sei sicuro di quale modalità ti trovi, premi due volte il tasto Esc; questo ti porterà alla modalità di comando. Apri un file utilizzando l'editor vi. Inizia digitando alcuni caratteri e poi passa alla modalità di comando per capire la differenza.
Uscire da vi
Il comando per uscire da vi è :q. Una volta in modalità di comando, digita i due punti e "q", seguito da Invio. Se il tuo file è stato modificato in qualche modo, l'editor ti avviserà e non ti permetterà di uscire. Per ignorare questo messaggio, il comando per uscire da vi senza salvare è:q!. Ciò consente di uscire da vi senza salvare le modifiche.
Il comando per salvare il contenuto dell'editor è :w. È possibile combinare il comando precedente con il comando quit o utilizzare:wq e ritorno.
Il modo più semplice per save your changes and exit viè con il comando ZZ. Quando sei in modalità comando, digitaZZ. IlZZ Il comando funziona allo stesso modo del :wq comando.
Se vuoi specificare / indicare un nome particolare per il file, puoi farlo specificandolo dopo il :w. Ad esempio, se si desidera salvare il file su cui si sta lavorando come un altro nome file chiamatofilename2, digiteresti :w filename2 e ritorno.
Spostarsi all'interno di un file
Per spostarti all'interno di un file senza influire sul testo, devi essere in modalità comando (premi Esc due volte). La tabella seguente elenca alcuni comandi che puoi usare per muoverti un personaggio alla volta -
Sr.No. | Comando e descrizione |
---|---|
1 | k Sposta il cursore in alto di una riga |
2 | j Sposta il cursore in basso di una riga |
3 | h Sposta il cursore alla posizione di un carattere a sinistra |
4 | l Sposta il cursore a destra di un carattere |
I seguenti punti devono essere considerati per spostarsi all'interno di un file:
vi distingue tra maiuscole e minuscole. È necessario prestare attenzione alle maiuscole quando si utilizzano i comandi.
La maggior parte dei comandi in vi può essere preceduta dal numero di volte in cui si desidera che l'azione venga eseguita. Per esempio,2j sposta il cursore di due righe in basso rispetto alla posizione del cursore.
Ci sono molti altri modi per spostarsi all'interno di un file in vi. Ricorda che devi essere in modalità comando (press Esc twice). La tabella seguente elenca alcuni comandi per spostarsi nel file:
Sr.No. | Comando e descrizione |
---|---|
1 | 0 or | Posiziona il cursore all'inizio di una riga |
2 | $ Posiziona il cursore alla fine di una riga |
3 | w Posiziona il cursore sulla parola successiva |
4 | b Posiziona il cursore sulla parola precedente |
5 | ( Posiziona il cursore all'inizio della frase corrente |
6 | ) Posiziona il cursore all'inizio della frase successiva |
7 | E Si sposta alla fine della parola delimitata da spazi |
8 | { Sposta indietro un paragrafo |
9 | } Sposta un paragrafo in avanti |
10 | [[ Sposta una sezione indietro |
11 | ]] Sposta una sezione in avanti |
12 | n| Passa alla colonna n nella riga corrente |
13 | 1G Passa alla prima riga del file |
14 | G Passa all'ultima riga del file |
15 | nG Si sposta in nth riga del file |
16 | :n Si sposta in nth riga del file |
17 | fc Va avanti a c |
18 | Fc Torna a c |
19 | H Passa alla parte superiore dello schermo |
20 | nH Si sposta in nth linea dalla parte superiore dello schermo |
21 | M Si sposta al centro dello schermo |
22 | L Spostati nella parte inferiore dello schermo |
23 | nL Si sposta in nth linea dalla parte inferiore dello schermo |
24 | :x I due punti seguiti da un numero posizionano il cursore sul numero di riga rappresentato da x |
Comandi di controllo
I seguenti comandi possono essere utilizzati con il tasto Control per eseguire le funzioni come indicato nella tabella seguente:
Sr.No. | Comando e descrizione |
---|---|
1 | CTRL+d Si sposta in avanti di 1/2 schermata |
2 | CTRL+f Si sposta in avanti di uno schermo intero |
3 | CTRL+u Si sposta indietro di 1/2 schermata |
4 | CTRL+b Torna indietro di uno schermo intero |
5 | CTRL+e Sposta lo schermo in alto di una riga |
6 | CTRL+y Sposta lo schermo in basso di una riga |
7 | CTRL+u Sposta lo schermo in alto di 1/2 pagina |
8 | CTRL+d Sposta lo schermo in basso di 1/2 pagina |
9 | CTRL+b Sposta lo schermo in alto di una pagina |
10 | CTRL+f Sposta lo schermo in basso di una pagina |
11 | CTRL+I Ridisegna lo schermo |
Modifica dei file
Per modificare il file, è necessario essere in modalità di inserimento. Esistono molti modi per accedere alla modalità di inserimento dalla modalità di comando:
Sr.No. | Comando e descrizione |
---|---|
1 | i Inserisce il testo prima della posizione corrente del cursore |
2 | I Inserisce il testo all'inizio della riga corrente |
3 | a Inserisce il testo dopo la posizione corrente del cursore |
4 | A Inserisce il testo alla fine della riga corrente |
5 | o Crea una nuova riga per l'immissione di testo sotto la posizione del cursore |
6 | O Crea una nuova riga per l'immissione di testo sopra la posizione del cursore |
Eliminazione di caratteri
Ecco un elenco di comandi importanti, che possono essere utilizzati per eliminare caratteri e linee in un file aperto:
Sr.No. | Comando e descrizione |
---|---|
1 | x Elimina il carattere sotto la posizione del cursore |
2 | X Elimina il carattere prima della posizione del cursore |
3 | dw Elimina dalla posizione corrente del cursore alla parola successiva |
4 | d^ Elimina dalla posizione corrente del cursore all'inizio della riga |
5 | d$ Elimina dalla posizione corrente del cursore alla fine della riga |
6 | D Elimina dalla posizione del cursore alla fine della riga corrente |
7 | dd Elimina la riga su cui si trova il cursore |
Come accennato in precedenza, la maggior parte dei comandi in vi può essere preceduta dal numero di volte in cui si desidera che l'azione venga eseguita. Per esempio,2x cancella due caratteri sotto la posizione del cursore e 2dd cancella due righe su cui si trova il cursore.
Si raccomanda di fare pratica con i comandi prima di procedere oltre.
Cambia comandi
Hai anche la possibilità di cambiare caratteri, parole o righe in vi senza eliminarli. Ecco i comandi rilevanti:
Sr.No. | Comando e descrizione |
---|---|
1 | cc Rimuove il contenuto della riga, lasciandoti in modalità di inserimento. |
2 | cw Cambia la parola su cui si trova il cursore da cursore a minuscolo w fine della parola. |
3 | r Sostituisce il carattere sotto il cursore. vi torna alla modalità di comando dopo aver immesso la sostituzione. |
4 | R Sovrascrive più caratteri che iniziano con il carattere attualmente sotto il cursore. Devi usareEsc per interrompere la sovrascrittura. |
5 | s Sostituisce il carattere corrente con il carattere digitato. Successivamente, sei lasciato nella modalità di inserimento. |
6 | S Elimina la riga su cui si trova il cursore e la sostituisce con il nuovo testo. Dopo aver immesso il nuovo testo, vi rimane in modalità di inserimento. |
Comandi di copia e incolla
Puoi copiare righe o parole da un punto e poi incollarle in un altro punto utilizzando i seguenti comandi:
Sr.No. | Comando e descrizione |
---|---|
1 | yy Copia la riga corrente. |
2 | yw Copia la parola corrente dal carattere su cui si trova il cursore w minuscolo, fino alla fine della parola. |
3 | p Posiziona il testo copiato dopo il cursore. |
4 | P Mette il testo strappato prima del cursore. |
Comandi avanzati
Ci sono alcuni comandi avanzati che semplificano l'editing quotidiano e consentono un uso più efficiente di vi -
Sr.No. | Comando e descrizione |
---|---|
1 | J Unisce la riga corrente a quella successiva. Un conteggio di comandi j unisce molte righe. |
2 | << Sposta la linea corrente a sinistra di una larghezza di spostamento. |
3 | >> Sposta la linea corrente a destra di una larghezza di spostamento. |
4 | ~ Cambia il caso del carattere sotto il cursore. |
5 | ^G Premere contemporaneamente i tasti Ctrl e G per visualizzare il nome del file corrente e lo stato. |
6 | U Ripristina la riga corrente allo stato in cui si trovava prima che il cursore entrasse nella riga. |
7 | u Ciò consente di annullare l'ultima modifica apportata al file. Digitando di nuovo "u" verrà ripetuta la modifica. |
8 | J Unisce la riga corrente a quella successiva. Un conteggio si unisce a tante righe. |
9 | :f Visualizza la posizione corrente nel file in% e il nome del file, il numero totale di file. |
10 | :f filename Rinomina il file corrente in nomefile. |
11 | :w filename Scrive nel file nomefile. |
12 | :e filename Apre un altro file con nome file. |
13 | :cd dirname Cambia la directory di lavoro corrente in dirname. |
14 | :e # Alterna tra due file aperti. |
15 | :n Nel caso in cui apri più file utilizzando vi, usa :n per passare al file successivo della serie. |
16 | :p Nel caso in cui apri più file utilizzando vi, usa :p per andare al file precedente della serie. |
17 | :N Nel caso in cui apri più file utilizzando vi, usa :N per andare al file precedente della serie. |
18 | :r file Legge il file e lo inserisce dopo la riga corrente. |
19 | :nr file Legge il file e lo inserisce dopo la riga n. |
Ricerca di parole e caratteri
L'editor vi ha due tipi di ricerche: string e character. Per una ricerca di stringhe, il/ e ?vengono utilizzati i comandi. Quando avvii questi comandi, il comando appena digitato verrà mostrato nell'ultima riga dello schermo, dove digiti la particolare stringa da cercare.
Questi due comandi differiscono solo nella direzione in cui avviene la ricerca -
Il / il comando cerca in avanti (verso il basso) nel file.
Il ? il comando cerca all'indietro (verso l'alto) nel file.
Il n e Ni comandi ripetono il precedente comando di ricerca rispettivamente nella stessa direzione o nella direzione opposta. Alcuni caratteri hanno significati speciali. Questi caratteri devono essere preceduti da una barra rovesciata (\) da includere come parte dell'espressione di ricerca.
Sr.No. | Carattere e descrizione |
---|---|
1 | ^ Cerca all'inizio della riga (utilizzare all'inizio di un'espressione di ricerca). |
2 | . Corrisponde a un singolo carattere. |
3 | * Corrisponde a zero o più del carattere precedente. |
4 | $ Fine della riga (utilizzare alla fine dell'espressione di ricerca). |
5 | [ Avvia una serie di espressioni corrispondenti o non corrispondenti. |
6 | < Viene inserito in un'espressione a cui è stato eseguito l'escape con la barra rovesciata per trovare la fine o l'inizio di una parola. |
7 | > Questo aiuta a vedere il '<'descrizione del carattere sopra. |
La ricerca dei caratteri effettua una ricerca all'interno di una riga per trovare un carattere immesso dopo il comando. Ilf e F i comandi cercano un carattere solo nella riga corrente. f cerca in avanti e F ricerca all'indietro e il cursore si sposta sulla posizione del carattere trovato.
Il t e T i comandi cercano un carattere solo sulla riga corrente, ma per t, il cursore si sposta nella posizione prima del carattere e T ricerca la riga all'indietro fino alla posizione dopo il carattere.
Imposta comandi
È possibile modificare l'aspetto della schermata di vi utilizzando quanto segue :setcomandi. Una volta che sei in modalità di comando, digita:set seguito da uno dei seguenti comandi.
Sr.No. | Comando e descrizione |
---|---|
1 | :set ic Ignora il caso durante la ricerca |
2 | :set ai Imposta il rientro automatico |
3 | :set noai Annulla il rientro automatico |
4 | :set nu Visualizza le linee con i numeri di riga sul lato sinistro |
5 | :set sw Imposta la larghezza di un tabstop software. Ad esempio, potresti impostare una larghezza di spostamento di 4 con questo comando::set sw = 4 |
6 | :set ws Se è impostato wrapscan e la parola non viene trovata in fondo al file, proverà a cercarla all'inizio |
7 | :set wm Se questa opzione ha un valore maggiore di zero, l'editor eseguirà automaticamente il "ritorno a capo". Ad esempio, per impostare il margine di ritorno a capo su due caratteri, digita questo::set wm = 2 |
8 | :set ro Cambia il tipo di file in "sola lettura" |
9 | :set term Stampa il tipo di terminale |
10 | :set bf Elimina i caratteri di controllo dall'input |
Comandi in esecuzione
Il vi ha la capacità di eseguire comandi dall'interno dell'editor. Per eseguire un comando, devi solo andare in modalità comando e digitare:! comando.
Ad esempio, se vuoi controllare se esiste un file prima di provare a salvarlo con quel nome, puoi digitare :! ls e vedrai l'output di ls sullo schermo.
È possibile premere qualsiasi tasto (o la sequenza di escape del comando) per tornare alla sessione di vi.
Sostituzione del testo
Il comando di sostituzione (:s/) consente di sostituire rapidamente parole o gruppi di parole all'interno dei file. La seguente è la sintassi per sostituire il testo:
:s/search/replace/g
Il gsta per globalmente. Il risultato di questo comando è che tutte le occorrenze sulla riga del cursore vengono modificate.
Punti importanti da notare
I seguenti punti aumenteranno il tuo successo con vi -
È necessario essere in modalità di comando per utilizzare i comandi. (Premi Esc due volte in qualsiasi momento per assicurarti di essere in modalità di comando.)
Devi stare attento con i comandi. Questi sono sensibili al maiuscolo / minuscolo.
Devi essere in modalità di inserimento per inserire il testo.
UN Shellfornisce un'interfaccia per il sistema Unix. Raccoglie input da te ed esegue programmi basati su quell'input. Quando un programma termina l'esecuzione, visualizza l'output di quel programma.
Shell è un ambiente in cui possiamo eseguire i nostri comandi, programmi e script di shell. Esistono diversi gusti di una shell, così come ci sono diversi gusti di sistemi operativi. Ogni tipo di shell ha il proprio set di comandi e funzioni riconosciuti.
Prompt shell
Il prompt, $, che si chiama command prompt, viene emesso dalla shell. Mentre viene visualizzato il prompt, puoi digitare un comando.
Shell legge l'input dopo aver premuto Enter. Determina il comando che desideri eseguire guardando la prima parola del tuo input. Una parola è un insieme ininterrotto di caratteri. Gli spazi e le tabulazioni separano le parole.
Di seguito è riportato un semplice esempio di date comando, che mostra la data e l'ora correnti -
$date
Thu Jun 25 08:30:19 MST 2009
È possibile personalizzare il prompt dei comandi utilizzando la variabile d'ambiente PS1 spiegata nel tutorial sull'ambiente.
Tipi di conchiglie
In Unix, ci sono due principali tipi di shell:
Bourne shell - Se stai usando una shell di tipo Bourne, il file $ carattere è il prompt predefinito.
C shell - Se stai usando una shell di tipo C, il carattere% è il prompt predefinito.
La Bourne Shell ha le seguenti sottocategorie:
- Bourne shell (sh)
- Conchiglia Korn (ksh)
- Bourne Again Shell (bash)
- Shell POSIX (sh)
I diversi gusci di tipo C seguono:
- Guscio C (csh)
- TENEX / TOPS C shell (tcsh)
La shell Unix originale è stata scritta a metà degli anni '70 da Stephen R. Bourne mentre era agli AT&T Bell Labs nel New Jersey.
Bourne shell è stata la prima shell ad apparire sui sistemi Unix, quindi viene chiamata "la shell".
La Bourne Shell viene solitamente installata come /bin/shsulla maggior parte delle versioni di Unix. Per questo motivo, è la shell preferita per scrivere script che possono essere utilizzati su diverse versioni di Unix.
In questo capitolo tratteremo la maggior parte dei concetti di Shell basati su Borne Shell.
Script di shell
Il concetto di base di uno script di shell è un elenco di comandi, elencati nell'ordine di esecuzione. Un buon script di shell avrà commenti, preceduti da# segno, descrivendo i passaggi.
Esistono test condizionali, come il valore A è maggiore del valore B, cicli che ci consentono di passare attraverso enormi quantità di dati, file per leggere e memorizzare dati e variabili per leggere e memorizzare dati e lo script può includere funzioni.
Scriveremo molti script nelle prossime sezioni. Sarebbe un semplice file di testo in cui metteremo tutti i nostri comandi e molti altri costrutti richiesti che dicono all'ambiente della shell cosa fare e quando farlo.
Gli script e le funzioni della shell vengono interpretati entrambi. Ciò significa che non sono compilati.
Script di esempio
Supponiamo di creare un file test.shscript. Nota che tutti gli script avrebbero l'estensione.shestensione. Prima di aggiungere qualcos'altro allo script, è necessario avvisare il sistema che è stato avviato uno script di shell. Questo viene fatto usando ilshebangcostruire. Ad esempio:
#!/bin/sh
Questo dice al sistema che i comandi che seguono devono essere eseguiti dalla shell Bourne. Si chiama shebang perché il file#il simbolo è chiamato hash e il! il simbolo è chiamato botto .
Per creare uno script contenente questi comandi, inserisci prima la riga shebang e poi aggiungi i comandi:
#!/bin/bash
pwd
ls
Commenti shell
Puoi inserire i tuoi commenti nel tuo script come segue:
#!/bin/bash
# Author : Zara Ali
# Copyright (c) Tutorialspoint.com
# Script follows here:
pwd
ls
Salva il contenuto di cui sopra e rendi eseguibile lo script -
$chmod +x test.sh
Lo script di shell è ora pronto per essere eseguito -
$./test.sh
Dopo l'esecuzione, riceverai il seguente risultato:
/home/amrood
index.htm unix-basic_utilities.htm unix-directories.htm
test.sh unix-communication.htm unix-environment.htm
Note - Per eseguire un programma disponibile nella directory corrente, utilizzare ./program_name
Script di shell estesi
Gli script di shell hanno diversi costrutti richiesti che dicono all'ambiente di shell cosa fare e quando farlo. Ovviamente, la maggior parte degli script è più complessa di quella precedente.
La shell è, dopotutto, un vero linguaggio di programmazione, completo di variabili, strutture di controllo e così via. Non importa quanto sia complicato uno script, è sempre solo un elenco di comandi eseguiti in sequenza.
Lo script seguente utilizza l'estensione read comando che prende l'input dalla tastiera e lo assegna come valore della variabile PERSON e infine lo stampa su STDOUT.
#!/bin/sh
# Author : Zara Ali
# Copyright (c) Tutorialspoint.com
# Script follows here:
echo "What is your name?"
read PERSON
echo "Hello, $PERSON"
Ecco un esempio di esecuzione dello script:
$./test.sh What is your name? Zara Ali Hello, Zara Ali $
In questo capitolo impareremo come usare le variabili Shell in Unix. Una variabile è una stringa di caratteri a cui assegniamo un valore. Il valore assegnato potrebbe essere un numero, testo, nome file, dispositivo o qualsiasi altro tipo di dati.
Una variabile non è altro che un puntatore ai dati effettivi. La shell consente di creare, assegnare ed eliminare variabili.
Nomi variabili
Il nome di una variabile può contenere solo lettere (dalla a alla z o dalla A alla Z), numeri (da 0 a 9) o il carattere di sottolineatura (_).
Per convenzione, le variabili di shell Unix avranno i loro nomi in MAIUSCOLO.
I seguenti esempi sono nomi di variabili validi:
_ALI
TOKEN_A
VAR_1
VAR_2
Di seguito sono riportati gli esempi di nomi di variabili non validi:
2_VAR
-VARIABLE
VAR1-VAR2
VAR_A!
Il motivo per cui non puoi usare altri caratteri come !, *, o - è che questi caratteri hanno un significato speciale per la shell.
Definizione di variabili
Le variabili sono definite come segue:
variable_name=variable_value
Ad esempio:
NAME="Zara Ali"
L'esempio precedente definisce la variabile NOME e le assegna il valore "Zara Ali". Vengono chiamate variabili di questo tiposcalar variables. Una variabile scalare può contenere un solo valore alla volta.
Shell ti consente di memorizzare qualsiasi valore desideri in una variabile. Ad esempio:
VAR1="Zara Ali"
VAR2=100
Accesso ai valori
Per accedere al valore memorizzato in una variabile, anteporre al suo nome il segno del dollaro ($) -
Ad esempio, il seguente script accederà al valore della variabile definita NAME e lo stamperà su STDOUT -
#!/bin/sh
NAME="Zara Ali"
echo $NAME
Lo script sopra produrrà il seguente valore:
Zara Ali
Variabili di sola lettura
Shell fornisce un modo per contrassegnare le variabili come di sola lettura utilizzando il comando di sola lettura. Dopo che una variabile è stata contrassegnata come di sola lettura, il suo valore non può essere modificato.
Ad esempio, il seguente script genera un errore durante il tentativo di modificare il valore di NAME -
#!/bin/sh
NAME="Zara Ali"
readonly NAME
NAME="Qadiri"
Lo script sopra genererà il seguente risultato:
/bin/sh: NAME: This variable is read only.
Disinserimento delle variabili
L'annullamento o l'eliminazione di una variabile indica alla shell di rimuovere la variabile dall'elenco di variabili di cui tiene traccia. Dopo aver annullato l'impostazione di una variabile, non è possibile accedere al valore memorizzato nella variabile.
Di seguito è riportata la sintassi per annullare l'impostazione di una variabile definita utilizzando unset comando -
unset variable_name
Il comando precedente ripristina il valore di una variabile definita. Ecco un semplice esempio che dimostra come funziona il comando:
#!/bin/sh
NAME="Zara Ali"
unset NAME
echo $NAME
L'esempio sopra non stampa nulla. Non è possibile utilizzare il comando unset perunset variabili contrassegnate readonly.
Tipi di variabili
Quando una shell è in esecuzione, sono presenti tre tipi principali di variabili:
Local Variables- Una variabile locale è una variabile presente nell'istanza corrente della shell. Non è disponibile per i programmi avviati dalla shell. Sono impostati al prompt dei comandi.
Environment Variables- Una variabile d'ambiente è disponibile per qualsiasi processo figlio della shell. Alcuni programmi necessitano di variabili d'ambiente per funzionare correttamente. Di solito, uno script di shell definisce solo quelle variabili d'ambiente che sono necessarie ai programmi che esegue.
Shell Variables- Una variabile di shell è una variabile speciale che viene impostata dalla shell ed è richiesta dalla shell per funzionare correttamente. Alcune di queste variabili sono variabili di ambiente mentre altre sono variabili locali.
In questo capitolo, discuteremo in dettaglio delle variabili speciali in Unix. In uno dei nostri capitoli precedenti, abbiamo capito come stare attenti quando usiamo certi caratteri non alfanumerici nei nomi delle variabili. Questo perché quei caratteri sono usati nei nomi di variabili speciali Unix. Queste variabili sono riservate per funzioni specifiche.
Ad esempio, il file $ il carattere rappresenta il numero ID del processo, o PID, della shell corrente -
$echo $$
Il comando precedente scrive il PID della shell corrente -
29949
La tabella seguente mostra una serie di variabili speciali che puoi usare negli script della shell:
Sr.No. | Variabile e descrizione |
---|---|
1 | $0 Il nome del file dello script corrente. |
2 | $n Queste variabili corrispondono agli argomenti con cui è stato richiamato uno script. Quin è un numero decimale positivo corrispondente alla posizione di un argomento (il primo argomento è $1, the second argument is $2 e così via). |
3 | $# Il numero di argomenti forniti a uno script. |
4 | $* Tutti gli argomenti sono doppi. Se uno script riceve due argomenti,$* is equivalent to $1 $ 2. |
5 | $@ Tutti gli argomenti sono singolarmente doppi. Se uno script riceve due argomenti,$@ is equivalent to $1 $ 2. |
6 | $? Lo stato di uscita dell'ultimo comando eseguito. |
7 | $$ Il numero di processo della shell corrente. Per gli script di shell, questo è l'ID del processo con cui vengono eseguiti. |
8 | $! Il numero di processo dell'ultimo comando in background. |
Argomenti della riga di comando
Gli argomenti della riga di comando $1, $2, $3, ...$9 sono parametri posizionali, con $0 pointing to the actual command, program, shell script, or function and $1, $2, $3, ... $ 9 come argomenti del comando.
Lo script seguente utilizza varie variabili speciali relative alla riga di comando:
#!/bin/sh
echo "File Name: $0"
echo "First Parameter : $1" echo "Second Parameter : $2"
echo "Quoted Values: $@" echo "Quoted Values: $*"
echo "Total Number of Parameters : $#"
Ecco un esempio di esecuzione per lo script precedente:
$./test.sh Zara Ali
File Name : ./test.sh
First Parameter : Zara
Second Parameter : Ali
Quoted Values: Zara Ali
Quoted Values: Zara Ali
Total Number of Parameters : 2
Parametri speciali $* and $@
Esistono parametri speciali che consentono di accedere a tutti gli argomenti della riga di comando contemporaneamente. $* e $@ entrambi agiranno allo stesso modo a meno che non siano racchiusi tra virgolette doppie, "".
Entrambi i parametri specificano gli argomenti della riga di comando. In ogni caso, il "$*" special parameter takes the entire list as one argument with spaces between and the "$Il parametro speciale @ "prende l'intero elenco e lo separa in argomenti separati.
Possiamo scrivere lo script di shell come mostrato di seguito per elaborare un numero sconosciuto di argomenti della riga di comando con il $* or $@ parametri speciali -
#!/bin/sh
for TOKEN in $* do echo $TOKEN
done
Ecco un esempio di esecuzione per lo script precedente:
$./test.sh Zara Ali 10 Years Old
Zara
Ali
10
Years
Old
Note - Qui do...done è una sorta di ciclo che verrà trattato in un successivo tutorial.
Stato di uscita
Il $? variabile rappresenta lo stato di uscita del comando precedente.
Lo stato di uscita è un valore numerico restituito da ogni comando al suo completamento. Di norma, la maggior parte dei comandi restituisce uno stato di uscita 0 se hanno avuto successo e 1 se non hanno avuto successo.
Alcuni comandi restituiscono stati di uscita aggiuntivi per motivi particolari. Ad esempio, alcuni comandi distinguono i tipi di errore e restituiranno vari valori di uscita a seconda del tipo specifico di errore.
Di seguito è riportato l'esempio di comando riuscito:
$./test.sh Zara Ali File Name : ./test.sh First Parameter : Zara Second Parameter : Ali Quoted Values: Zara Ali Quoted Values: Zara Ali Total Number of Parameters : 2 $echo $? 0 $
In questo capitolo, discuteremo come usare gli array di shell in Unix. Una variabile di shell è in grado di contenere un singolo valore. Queste variabili sono chiamate variabili scalari.
Shell supporta un diverso tipo di variabile chiamato array variable. Questo può contenere più valori contemporaneamente. Gli array forniscono un metodo per raggruppare un insieme di variabili. Invece di creare un nuovo nome per ogni variabile richiesta, è possibile utilizzare una singola variabile di matrice che memorizza tutte le altre variabili.
Tutte le regole di denominazione discusse per le variabili di shell sarebbero applicabili durante la denominazione degli array.
Definizione dei valori degli array
La differenza tra una variabile array e una variabile scalare può essere spiegata come segue.
Supponiamo che tu stia cercando di rappresentare i nomi di vari studenti come un insieme di variabili. Ciascuna delle singole variabili è una variabile scalare come segue:
NAME01="Zara"
NAME02="Qadir"
NAME03="Mahnaz"
NAME04="Ayan"
NAME05="Daisy"
Possiamo usare un singolo array per memorizzare tutti i nomi sopra menzionati. Di seguito è riportato il metodo più semplice per creare una variabile di matrice. Questo aiuta ad assegnare un valore a uno dei suoi indici.
array_name[index]=value
In questo caso array_name è il nome dell'array, index è l'indice dell'elemento dell'array che si desidera impostare e value è il valore che si desidera impostare per quell'elemento.
Ad esempio, i seguenti comandi:
NAME[0]="Zara"
NAME[1]="Qadir"
NAME[2]="Mahnaz"
NAME[3]="Ayan"
NAME[4]="Daisy"
Se stai usando il file ksh shell, ecco la sintassi dell'inizializzazione dell'array -
set -A array_name value1 value2 ... valuen
Se stai usando il file bash shell, ecco la sintassi dell'inizializzazione dell'array -
array_name=(value1 ... valuen)
Accesso ai valori degli array
Dopo aver impostato una variabile di matrice, accedervi come segue:
${array_name[index]}
Qui array_name è il nome dell'array e index è l'indice del valore a cui accedere. Di seguito è riportato un esempio per comprendere il concetto:
#!/bin/sh
NAME[0]="Zara"
NAME[1]="Qadir"
NAME[2]="Mahnaz"
NAME[3]="Ayan"
NAME[4]="Daisy"
echo "First Index: ${NAME[0]}"
echo "Second Index: ${NAME[1]}"
L'esempio sopra genererà il seguente risultato:
$./test.sh
First Index: Zara
Second Index: Qadir
È possibile accedere a tutti gli elementi di un array in uno dei seguenti modi:
${array_name[*]} ${array_name[@]}
Qui array_name è il nome dell'array a cui sei interessato. L'esempio seguente ti aiuterà a capire il concetto:
#!/bin/sh
NAME[0]="Zara"
NAME[1]="Qadir"
NAME[2]="Mahnaz"
NAME[3]="Ayan"
NAME[4]="Daisy"
echo "First Method: ${NAME[*]}" echo "Second Method: ${NAME[@]}"
L'esempio sopra genererà il seguente risultato:
$./test.sh
First Method: Zara Qadir Mahnaz Ayan Daisy
Second Method: Zara Qadir Mahnaz Ayan Daisy
Ci sono vari operatori supportati da ciascuna shell. In questo capitolo discuteremo in dettaglio della Bourne shell (shell predefinita).
Discuteremo ora i seguenti operatori:
- Operatori aritmetici
- Operatori relazionali
- Operatori booleani
- Operatori di stringa
- Operatori di test dei file
La Bourne Shell originariamente non aveva alcun meccanismo per eseguire semplici operazioni aritmetiche, ma utilizza anche programmi esterni awk o expr.
L'esempio seguente mostra come aggiungere due numeri:
#!/bin/sh
val=`expr 2 + 2`
echo "Total value : $val"
Lo script sopra genererà il seguente risultato:
Total value : 4
I seguenti punti devono essere considerati durante l'aggiunta:
Devono essere presenti degli spazi tra operatori ed espressioni. Ad esempio, 2 + 2 non è corretto; dovrebbe essere scritto come 2 + 2.
L'espressione completa dovrebbe essere racchiusa tra ‘ ‘, chiamato backtick.
Operatori aritmetici
I seguenti operatori aritmetici sono supportati da Bourne Shell.
Assumi variabile a detiene 10 e variabile b tiene 20 quindi -
Mostra esempi
Operatore | Descrizione | Esempio |
---|---|---|
+ (Aggiunta) | Aggiunge valori su entrambi i lati dell'operatore | `expr $a + $b` darà 30 |
- (Sottrazione) | Sottrae l'operando della mano destra dall'operando della mano sinistra | `expr $a - $b` darà -10 |
* (Moltiplicazione) | Moltiplica i valori su entrambi i lati dell'operatore | `expr $a \* $b` darà 200 |
/ (Divisione) | Divide l'operando sinistro per l'operando destro | `expr $b / $a` darà 2 |
% (Modulo) | Divide l'operando di sinistra per l'operando di destra e restituisce il resto | `expr $b % $a` darà 0 |
= (Assegnazione) | Assegna l'operando destro all'operando sinistro | a = $ b assegnerebbe il valore di b in a |
== (uguaglianza) | Confronta due numeri, se entrambi sono uguali restituisce vero. | [$ a == $ b] restituirebbe false. |
! = (Non uguaglianza) | Confronta due numeri, se entrambi sono diversi restituisce vero. | [$ a! = $ b] restituirà true. |
È molto importante capire che tutte le espressioni condizionali dovrebbero essere all'interno di parentesi quadre con spazi intorno, per esempio [ $a == $b ] è corretto mentre, [$a==$b] non è corretto.
Tutti i calcoli aritmetici vengono eseguiti utilizzando numeri interi lunghi.
Operatori relazionali
Bourne Shell supporta i seguenti operatori relazionali specifici per i valori numerici. Questi operatori non funzionano per i valori stringa a meno che il loro valore non sia numerico.
Ad esempio, gli operatori seguenti lavoreranno per verificare una relazione tra 10 e 20 e tra "10" e "20" ma non tra "dieci" e "venti".
Assumi variabile a detiene 10 e variabile b tiene 20 quindi -
Mostra esempi
Operatore | Descrizione | Esempio |
---|---|---|
-eq | Controlla se il valore di due operandi è uguale o meno; se sì, la condizione diventa vera. | [$ a -eq $ b] non è vero. |
-ne | Controlla se il valore di due operandi è uguale o meno; se i valori non sono uguali, la condizione diventa vera. | [$ a -ne $ b] è vero. |
-gt | Controlla se il valore dell'operando sinistro è maggiore del valore dell'operando destro; se sì, la condizione diventa vera. | [$ a -gt $ b] non è vero. |
-lt | Controlla se il valore dell'operando sinistro è inferiore al valore dell'operando destro; se sì, la condizione diventa vera. | [$ a -lt $ b] è vero. |
-ge | Controlla se il valore dell'operando sinistro è maggiore o uguale al valore dell'operando destro; se sì, la condizione diventa vera. | [$ a -ge $ b] non è vero. |
-le | Controlla se il valore dell'operando sinistro è minore o uguale al valore dell'operando destro; se sì, la condizione diventa vera. | [$ a -le $ b] è vero. |
È molto importante capire che tutte le espressioni condizionali devono essere inserite all'interno di parentesi quadre con spazi intorno. Per esempio,[ $a <= $b ] è corretto mentre, [$a <= $b] non è corretto.
Operatori booleani
I seguenti operatori booleani sono supportati da Bourne Shell.
Assumi variabile a detiene 10 e variabile b tiene 20 quindi -
Mostra esempi
Operatore | Descrizione | Esempio |
---|---|---|
! | Questa è la negazione logica. Ciò inverte una condizione vera in falsa e viceversa. | [! false] è vero. |
-o | Questo è logico OR. Se uno degli operandi è vero, la condizione diventa vera. | [$ a -lt 20 -o $ b -gt 100] è vero. |
-a | Questo è logico AND. Se entrambi gli operandi sono veri, la condizione diventa vera altrimenti falsa. | [$ a -lt 20 -a $ b -gt 100] è falso. |
Operatori di stringa
I seguenti operatori di stringa sono supportati da Bourne Shell.
Assumi variabile a contiene "abc" e variabile b tiene "efg" quindi -
Mostra esempi
Operatore | Descrizione | Esempio |
---|---|---|
= | Controlla se il valore di due operandi è uguale o meno; se sì, la condizione diventa vera. | [$ a = $ b] non è vero. |
!= | Controlla se il valore di due operandi è uguale o meno; se i valori non sono uguali, la condizione diventa vera. | [$ a! = $ b] è vero. |
-z | Controlla se la dimensione dell'operando stringa data è zero; se è di lunghezza zero, restituisce vero. | [-z $ a] non è vero. |
-n | Controlla se la dimensione dell'operando stringa data è diversa da zero; se è una lunghezza diversa da zero, restituisce true. | [-n $ a] non è falso. |
str | Controlla se strnon è la stringa vuota; se è vuoto, restituisce false. | [$ a] non è falso. |
Operatori di test dei file
Abbiamo alcuni operatori che possono essere utilizzati per testare varie proprietà associate a un file Unix.
Assumi una variabile file contiene un nome file esistente "test" la cui dimensione è di 100 byte e ha read, write e execute permesso su -
Mostra esempi
Operatore | Descrizione | Esempio |
---|---|---|
-b file | Controlla se il file è un file speciale a blocchi; se sì, la condizione diventa vera. | [-b $ file] è falso. |
-c file | Controlla se il file è un file speciale di caratteri; se sì, la condizione diventa vera. | [-c $ file] è falso. |
-d file | Controlla se il file è una directory; se sì, la condizione diventa vera. | [-d $ file] non è vero. |
-f file | Controlla se il file è un file ordinario anziché una directory o un file speciale; se sì, la condizione diventa vera. | [-f $ file] è vero. |
-g file | Controlla se il file ha il bit impostato per l'ID gruppo (SGID) impostato; se sì, la condizione diventa vera. | [-g $ file] è falso. |
-k file | Controlla se il file ha il suo sticky bit impostato; se sì, la condizione diventa vera. | [-k $ file] è falso. |
-p file | Controlla se il file è una named pipe; se sì, la condizione diventa vera. | [-p $ file] è falso. |
-t file | Controlla se il descrittore di file è aperto e associato a un terminale; se sì, la condizione diventa vera. | [-t $ file] è falso. |
-u file | Controlla se il file ha il bit Set User ID (SUID) impostato; se sì, la condizione diventa vera. | [-u $ file] è falso. |
-r file | Controlla se il file è leggibile; se sì, la condizione diventa vera. | [-r $ file] è vero. |
-w file | Controlla se il file è scrivibile; se sì, la condizione diventa vera. | [-w $ file] è vero. |
-x file | Controlla se il file è eseguibile; se sì, la condizione diventa vera. | [-x $ file] è vero. |
-s file | Controlla se il file ha una dimensione maggiore di 0; se sì, allora la condizione diventa vera. | [-s $ file] è vero. |
-e file | Controlla se il file esiste; è vero anche se file è una directory ma esiste. | [-e $ file] è vero. |
Operatori shell C
Il seguente link ti darà una breve idea sugli operatori C Shell -
Operatori shell C
Operatori Korn Shell
Il seguente collegamento ti aiuta a capire gli operatori di Korn Shell -
Operatori Korn Shell
In questo capitolo capiremo il processo decisionale della shell in Unix. Durante la scrittura di uno script di shell, potrebbe verificarsi una situazione in cui è necessario adottare un percorso tra i due percorsi indicati. Quindi è necessario fare uso di istruzioni condizionali che consentono al programma di prendere decisioni corrette ed eseguire le azioni giuste.
Unix Shell supporta le istruzioni condizionali che vengono utilizzate per eseguire azioni diverse in base a condizioni diverse. Ora capiremo due dichiarazioni decisionali qui:
Il if...else dichiarazione
Il case...esac dichiarazione
Le dichiarazioni if ... else
Le istruzioni If else sono utili dichiarazioni decisionali che possono essere utilizzate per selezionare un'opzione da un dato insieme di opzioni.
Unix Shell supporta le seguenti forme di if…else dichiarazione -
- if ... dichiarazione fi
- if ... else ... dichiarazione fi
- if ... elif ... else ... dichiarazione fi
La maggior parte delle istruzioni if controlla le relazioni utilizzando operatori relazionali discussi nel capitolo precedente.
Il caso ... Dichiarazione esac
Puoi usare più file if...elifistruzioni per eseguire un ramo a più vie. Tuttavia, questa non è sempre la soluzione migliore, soprattutto quando tutti i rami dipendono dal valore di una singola variabile.
Unix Shell supporta case...esac dichiarazione che gestisce esattamente questa situazione, e lo fa in modo più efficiente di quanto ripetuto if...elif dichiarazioni.
C'è solo una forma di case...esac dichiarazione che è stata descritta in dettaglio qui -
- case ... istruzione esac
Il case...esac l'istruzione nella shell Unix è molto simile alla switch...case dichiarazione che abbiamo in altri linguaggi di programmazione come C o C++ e PERL, eccetera.
In questo capitolo, discuteremo dei cicli di shell in Unix. Un ciclo è un potente strumento di programmazione che consente di eseguire ripetutamente una serie di comandi. In questo capitolo esamineremo i seguenti tipi di loop disponibili per i programmatori di shell:
- Il ciclo while
- Il ciclo for
- Il ciclo until
- Il ciclo di selezione
Utilizzerai loop diversi in base alla situazione. Ad esempio, il filewhileloop esegue i comandi dati fino a quando la condizione data rimane vera; iluntil ciclo viene eseguito fino a quando una data condizione diventa vera.
Una volta che hai una buona pratica di programmazione, acquisirai esperienza e quindi inizierai a utilizzare il ciclo appropriato in base alla situazione. Qui,while e for i loop sono disponibili nella maggior parte degli altri linguaggi di programmazione come C, C++ e PERL, eccetera.
Loop di annidamento
Tutti i loop supportano il concetto di annidamento, il che significa che puoi mettere un loop all'interno di un altro simile o diversi loop. Questo annidamento può arrivare fino a un numero illimitato di volte in base alle tue esigenze.
Ecco un esempio di nidificazione whileciclo continuo. Gli altri loop possono essere annidati in base ai requisiti di programmazione in modo simile:
Annidamento in loop
È possibile utilizzare un ciclo while come parte del corpo di un altro ciclo while.
Sintassi
while command1 ; # this is loop1, the outer loop
do
Statement(s) to be executed if command1 is true
while command2 ; # this is loop2, the inner loop
do
Statement(s) to be executed if command2 is true
done
Statement(s) to be executed if command1 is true
done
Esempio
Ecco un semplice esempio di nidificazione dei loop. Aggiungiamo un altro ciclo di conto alla rovescia all'interno del ciclo che hai usato per contare fino a nove -
#!/bin/sh
a=0
while [ "$a" -lt 10 ] # this is loop1 do b="$a"
while [ "$b" -ge 0 ] # this is loop2 do echo -n "$b "
b=`expr $b - 1` done echo a=`expr $a + 1`
done
Questo produrrà il seguente risultato. È importante notare comeecho -nfunziona qui. Qui-n L'opzione consente a echo di evitare di stampare un nuovo carattere di riga.
0
1 0
2 1 0
3 2 1 0
4 3 2 1 0
5 4 3 2 1 0
6 5 4 3 2 1 0
7 6 5 4 3 2 1 0
8 7 6 5 4 3 2 1 0
9 8 7 6 5 4 3 2 1 0
In questo capitolo, discuteremo del controllo del ciclo della shell in Unix. Finora hai esaminato la creazione di loop e il lavoro con i loop per svolgere diverse attività. A volte è necessario interrompere un ciclo o saltare le iterazioni del ciclo.
In questo capitolo impareremo a seguire due istruzioni usate per controllare i cicli della shell:
Il break dichiarazione
Il continue dichiarazione
Il ciclo infinito
Tutti i loop hanno una durata limitata e vengono fuori una volta che la condizione è falsa o vera a seconda del loop.
Un ciclo può continuare all'infinito se la condizione richiesta non viene soddisfatta. Un ciclo che viene eseguito per sempre senza terminare viene eseguito per un numero infinito di volte. Per questo motivo, tali loop sono chiamati loop infiniti.
Esempio
Ecco un semplice esempio che utilizza l'estensione while loop per visualizzare i numeri da zero a nove -
#!/bin/sh
a=10
until [ $a -lt 10 ] do echo $a
a=`expr $a + 1`
done
Questo ciclo continua per sempre perché a è sempre greater than o equal to 10 e non è mai inferiore a 10.
La dichiarazione di rottura
Il breakL'istruzione viene utilizzata per terminare l'esecuzione dell'intero ciclo, dopo aver completato l'esecuzione di tutte le righe di codice fino all'istruzione break. Quindi passa al codice che segue la fine del ciclo.
Sintassi
Il seguente break è usata per uscire da un ciclo -
break
Il comando break può essere utilizzato anche per uscire da un ciclo annidato utilizzando questo formato -
break n
Qui n specifica il nth che racchiude il ciclo all'uscita da.
Esempio
Ecco un semplice esempio che mostra che il ciclo termina non appena a diventa 5 -
#!/bin/sh
a=0
while [ $a -lt 10 ]
do
echo $a if [ $a -eq 5 ]
then
break
fi
a=`expr $a + 1`
done
Dopo l'esecuzione, riceverai il seguente risultato:
0
1
2
3
4
5
Ecco un semplice esempio di ciclo for annidato. Questo script esce da entrambi i cicli sevar1 equals 2 e var2 equals 0 -
#!/bin/sh
for var1 in 1 2 3
do
for var2 in 0 5
do
if [ $var1 -eq 2 -a $var2 -eq 0 ] then break 2 else echo "$var1 $var2"
fi
done
done
Dopo l'esecuzione, riceverai il seguente risultato. Nel ciclo interno, hai un comando break con argomento 2. Ciò indica che se una condizione è soddisfatta dovresti uscire dal ciclo esterno e infine anche dal ciclo interno.
1 0
1 5
L'istruzione continue
Il continue dichiarazione è simile a break comando, tranne per il fatto che fa terminare l'iterazione corrente del ciclo, piuttosto che l'intero ciclo.
Questa istruzione è utile quando si è verificato un errore ma si desidera provare a eseguire l'iterazione successiva del ciclo.
Sintassi
continue
Come con l'istruzione break, è possibile fornire un argomento intero al comando continue per saltare i comandi dai cicli annidati.
continue n
Qui n specifica il nth che racchiude il ciclo da cui continuare.
Esempio
Il ciclo seguente fa uso di continue istruzione che ritorna dall'istruzione continue e inizia l'elaborazione dell'istruzione successiva -
#!/bin/sh
NUMS="1 2 3 4 5 6 7"
for NUM in $NUMS
do
Q=`expr $NUM % 2` if [ $Q -eq 0 ]
then
echo "Number is an even number!!"
continue
fi
echo "Found odd number"
done
Dopo l'esecuzione, riceverai il seguente risultato:
Found odd number
Number is an even number!!
Found odd number
Number is an even number!!
Found odd number
Number is an even number!!
Found odd number
Cos'è la sostituzione?
La shell esegue la sostituzione quando incontra un'espressione che contiene uno o più caratteri speciali.
Esempio
Qui, il valore di stampa della variabile viene sostituito dal suo valore. Contemporaneamente,"\n" è sostituito da una nuova riga -
#!/bin/sh
a=10
echo -e "Value of a is $a \n"
Riceverai il seguente risultato. Qui il file-e opzione abilita l'interpretazione degli escape backslash.
Value of a is 10
Di seguito è riportato il risultato senza -e opzione -
Value of a is 10\n
Ecco le seguenti sequenze di escape che possono essere utilizzate nel comando echo:
Sr.No. | Fuga e descrizione |
---|---|
1 | \\ barra rovesciata |
2 | \a avviso (BEL) |
3 | \b backspace |
4 | \c sopprimere la nuova riga finale |
5 | \f avanzamento modulo |
6 | \n nuova linea |
7 | \r ritorno a capo |
8 | \t scheda orizzontale |
9 | \v scheda verticale |
Puoi usare il file -E opzione per disabilitare l'interpretazione degli escape backslash (impostazione predefinita).
Puoi usare il file -n opzione per disabilitare l'inserimento di una nuova riga.
Sostituzione dei comandi
La sostituzione dei comandi è il meccanismo mediante il quale la shell esegue un determinato insieme di comandi e quindi sostituisce il loro output al posto dei comandi.
Sintassi
La sostituzione del comando viene eseguita quando un comando viene dato come:
`command`
Quando esegui la sostituzione del comando, assicurati di utilizzare la virgoletta, non il carattere di virgoletta singola.
Esempio
La sostituzione del comando viene generalmente utilizzata per assegnare l'output di un comando a una variabile. Ciascuno dei seguenti esempi dimostra la sostituzione del comando:
#!/bin/sh
DATE=`date`
echo "Date is $DATE"
USERS=`who | wc -l`
echo "Logged in user are $USERS" UP=`date ; uptime` echo "Uptime is $UP"
Dopo l'esecuzione, riceverai il seguente risultato:
Date is Thu Jul 2 03:59:57 MST 2009
Logged in user are 1
Uptime is Thu Jul 2 03:59:57 MST 2009
03:59:57 up 20 days, 14:03, 1 user, load avg: 0.13, 0.07, 0.15
Sostituzione variabile
La sostituzione delle variabili consente al programmatore di shell di manipolare il valore di una variabile in base al suo stato.
Di seguito la tabella per tutte le possibili sostituzioni:
Sr.No. | Forma e descrizione |
---|---|
1 | ${var} Sostituisci il valore di var . |
2 | ${var:-word} Se var è nullo o non impostato, parola viene sostituitavar. Il valore di var non cambia. |
3 | ${var:=word} Se var è nullo o non impostato, var è impostato sul valore diword. |
4 | ${var:?message} Se var è nullo o non impostato, il messaggio viene stampato sullo standard error. Questo controlla che le variabili siano impostate correttamente. |
5 | ${var:+word} Se var è impostato, parola viene sostituita da var. Il valore di var non cambia. |
Esempio
Di seguito è riportato l'esempio per mostrare vari stati della sostituzione di cui sopra:
#!/bin/sh
echo ${var:-"Variable is not set"}
echo "1 - Value of var is ${var}" echo ${var:="Variable is not set"}
echo "2 - Value of var is ${var}" unset var echo ${var:+"This is default value"}
echo "3 - Value of var is $var" var="Prefix" echo ${var:+"This is default value"}
echo "4 - Value of var is $var" echo ${var:?"Print this message"}
echo "5 - Value of var is ${var}"
Dopo l'esecuzione, riceverai il seguente risultato:
Variable is not set
1 - Value of var is
Variable is not set
2 - Value of var is Variable is not set
3 - Value of var is
This is default value
4 - Value of var is Prefix
Prefix
5 - Value of var is Prefix
In questo capitolo, discuteremo in dettaglio sui meccanismi di citazione di Shell. Inizieremo discutendo i metacaratteri.
I metacaratteri
Unix Shell fornisce vari metacaratteri che hanno un significato speciale quando vengono utilizzati in qualsiasi script di shell e causa la terminazione di una parola se non citato.
Per esempio, ? corrisponde a un singolo carattere mentre elenca i file in una directory e un file *corrisponde a più di un carattere. Ecco un elenco della maggior parte dei caratteri speciali della shell (chiamati anche metacaratteri):
* ? [ ] ' " \ $ ; & ( ) | ^ < > new-line space tab
Un carattere può essere citato (cioè fatto in modo che stia per se stesso) precedendolo con a \.
Esempio
L'esempio seguente mostra come stampare un file * o a ? -
#!/bin/sh
echo Hello; Word
Dopo l'esecuzione, riceverai il seguente risultato:
Hello
./test.sh: line 2: Word: command not found
shell returned 127
Proviamo ora a usare un carattere citato -
#!/bin/sh
echo Hello\; Word
Dopo l'esecuzione, riceverai il seguente risultato:
Hello; Word
Il $ sign è uno dei metacaratteri, quindi deve essere citato per evitare una gestione speciale da parte della shell -
#!/bin/sh
echo "I have \$1200"
Dopo l'esecuzione, riceverai il seguente risultato:
I have $1200
La tabella seguente elenca le quattro forme di citazione:
Sr.No. | Citazioni e descrizione |
---|---|
1 | Single quote Tutti i caratteri speciali tra queste virgolette perdono il loro significato speciale. |
2 | Double quote La maggior parte dei caratteri speciali tra queste virgolette perdono il loro significato speciale con queste eccezioni:
|
3 | Backslash Any character immediately following the backslash loses its special meaning. |
4 | Back quote Anything in between back quotes would be treated as a command and would be executed. |
The Single Quotes
Consider an echo command that contains many special shell characters −
echo <-$1500.**>; (update?) [y|n]
Putting a backslash in front of each special character is tedious and makes the line difficult to read −
echo \<-\$1500.\*\*\>\; \(update\?\) \[y\|n\]
There is an easy way to quote a large group of characters. Put a single quote (') at the beginning and at the end of the string −
echo '<-$1500.**>; (update?) [y|n]'
Characters within single quotes are quoted just as if a backslash is in front of each character. With this, the echo command displays in a proper way.
If a single quote appears within a string to be output, you should not put the whole string within single quotes instead you should precede that using a backslash (\) as follows −
echo 'It\'s Shell Programming
The Double Quotes
Try to execute the following shell script. This shell script makes use of single quote −
VAR=ZARA
echo '$VAR owes <-$1500.**>; [ as of (`date +%m/%d`) ]'
Upon execution, you will receive the following result −
$VAR owes <-$1500.**>; [ as of (`date +%m/%d`) ]
This is not what had to be displayed. It is obvious that single quotes prevent variable substitution. If you want to substitute variable values and to make inverted commas work as expected, then you would need to put your commands in double quotes as follows −
VAR=ZARA
echo "$VAR owes <-\$1500.**>; [ as of (`date +%m/%d`) ]"
Upon execution, you will receive the following result −
ZARA owes <-$1500.**>; [ as of (07/02) ]
Double quotes take away the special meaning of all characters except the following −
$ for parameter substitution
Backquotes for command substitution
\$ to enable literal dollar signs
\` to enable literal backquotes
\" to enable embedded double quotes
\\ to enable embedded backslashes
All other \ characters are literal (not special)
Characters within single quotes are quoted just as if a backslash is in front of each character. This helps the echo command display properly.
If a single quote appears within a string to be output, you should not put the whole string within single quotes instead you should precede that using a backslash (\) as follows −
echo 'It\'s Shell Programming'
The Backquotes
Putting any Shell command in between backquotes executes the command.
Syntax
Here is the simple syntax to put any Shell command in between backquotes −
var=`command`
Example
The date command is executed in the following example and the produced result is stored in DATA variable.
DATE=`date`
echo "Current Date: $DATE"
Upon execution, you will receive the following result −
Current Date: Thu Jul 2 05:28:45 MST 2009
In this chapter, we will discuss in detail about the Shell input/output redirections. Most Unix system commands take input from your terminal and send the resulting output back to your terminal. A command normally reads its input from the standard input, which happens to be your terminal by default. Similarly, a command normally writes its output to standard output, which is again your terminal by default.
Output Redirection
The output from a command normally intended for standard output can be easily diverted to a file instead. This capability is known as output redirection.
If the notation > file is appended to any command that normally writes its output to standard output, the output of that command will be written to file instead of your terminal.
Check the following who command which redirects the complete output of the command in the users file.
$ who > users
Notice that no output appears at the terminal. This is because the output has been redirected from the default standard output device (the terminal) into the specified file. You can check the users file for the complete content −
$ cat users
oko tty01 Sep 12 07:30
ai tty15 Sep 12 13:32
ruth tty21 Sep 12 10:10
pat tty24 Sep 12 13:07
steve tty25 Sep 12 13:03
$
If a command has its output redirected to a file and the file already contains some data, that data will be lost. Consider the following example −
$ echo line 1 > users
$ cat users line 1 $
You can use >> operator to append the output in an existing file as follows −
$ echo line 2 >> users $ cat users
line 1
line 2
$
Input Redirection
Just as the output of a command can be redirected to a file, so can the input of a command be redirected from a file. As the greater-than character > is used for output redirection, the less-than character < is used to redirect the input of a command.
The commands that normally take their input from the standard input can have their input redirected from a file in this manner. For example, to count the number of lines in the file users generated above, you can execute the command as follows −
$ wc -l users
2 users
$
Upon execution, you will receive the following output. You can count the number of lines in the file by redirecting the standard input of the wc command from the file users −
$ wc -l < users
2
$
Note that there is a difference in the output produced by the two forms of the wc command. In the first case, the name of the file users is listed with the line count; in the second case, it is not.
In the first case, wc knows that it is reading its input from the file users. In the second case, it only knows that it is reading its input from standard input so it does not display file name.
Here Document
UN here document viene utilizzato per reindirizzare l'input in uno script o programma di shell interattivo.
È possibile eseguire un programma interattivo all'interno di uno script di shell senza l'intervento dell'utente fornendo l'input richiesto per il programma interattivo o uno script di shell interattivo.
La forma generale per a here il documento è -
command << delimiter
document
delimiter
Qui la shell interpreta il file <<come istruzione per leggere l'input finché non trova una riga contenente il delimitatore specificato. Tutte le righe di input fino alla riga contenente il delimitatore vengono quindi inserite nello standard input del comando.
Il delimitatore dice alla shell che il file heredocumento è stato completato. Senza di esso, la shell continua a leggere l'input per sempre. Il delimitatore deve essere una singola parola che non contiene spazi o tabulazioni.
Di seguito è riportato l'input per il comando wc -l per contare il numero totale di righe -
$wc -l << EOF
This is a simple lookup program
for good (and bad) restaurants
in Cape Town.
EOF
3
$
Puoi usare il file here document per stampare più righe usando il tuo script come segue:
#!/bin/sh
cat << EOF
This is a simple lookup program
for good (and bad) restaurants
in Cape Town.
EOF
Dopo l'esecuzione, riceverai il seguente risultato:
This is a simple lookup program
for good (and bad) restaurants
in Cape Town.
Il seguente script esegue una sessione con vi editor di testo e salva l'input nel file test.txt.
#!/bin/sh
filename=test.txt
vi $filename <<EndOfCommands
i
This file was created automatically from
a shell script
^[
ZZ
EndOfCommands
Se esegui questo script con vim che funge da vi, probabilmente vedrai un output come il seguente:
$ sh test.sh Vim: Warning: Input is not from a terminal $
Dopo aver eseguito lo script, dovresti vedere quanto segue aggiunto al file test.txt -
$ cat test.txt This file was created automatically from a shell script $
Elimina l'output
A volte sarà necessario eseguire un comando, ma non si desidera che l'output venga visualizzato sullo schermo. In questi casi, è possibile eliminare l'output reindirizzandolo al file/dev/null -
$ command > /dev/null
Qui comando è il nome del comando che vuoi eseguire. Il file/dev/null è un file speciale che scarta automaticamente tutto il suo input.
Per eliminare sia l'output di un comando che il relativo output di errore, utilizzare il reindirizzamento standard per il reindirizzamento STDERR per STDOUT -
$ command > /dev/null 2>&1
Qui 2 rappresenta STDERR e 1 rappresenta STDOUT. È possibile visualizzare un messaggio su STDERR reindirizzando STDOUT in STDERR come segue:
$ echo message 1>&2
Comandi di reindirizzamento
Di seguito è riportato un elenco completo di comandi che è possibile utilizzare per il reindirizzamento:
Sr.No. | Comando e descrizione |
---|---|
1 | pgm > file L'output di pgm viene reindirizzato al file |
2 | pgm < file Il programma pgm legge il suo input dal file |
3 | pgm >> file L'output di pgm viene aggiunto al file |
4 | n > file Uscita dal flusso con descrittore n reindirizzato a file |
5 | n >> file Uscita dal flusso con descrittore n aggiunto al file |
6 | n >& m Unisce l'output dal flusso n con flusso m |
7 | n <& m Unisce l'input dallo stream n con flusso m |
8 | << tag L'input standard arriva da qui al tag successivo all'inizio della riga |
9 | | Prende l'output da un programma o processo e lo invia a un altro |
Notare che il descrittore di file 0 è normalmente lo standard input (STDIN), 1 è l'output standard (STDOUT) e 2 è l'output di errore standard (STDERR).
In questo capitolo, discuteremo in dettaglio delle funzioni della shell. Le funzioni consentono di suddividere la funzionalità complessiva di uno script in sottosezioni logiche più piccole, che possono quindi essere richiamate per eseguire le singole attività quando necessario.
Usare le funzioni per eseguire attività ripetitive è un ottimo modo per creare code reuse. Questa è una parte importante dei moderni principi di programmazione orientata agli oggetti.
Le funzioni della shell sono simili a subroutine, procedure e funzioni in altri linguaggi di programmazione.
Creazione di funzioni
Per dichiarare una funzione, usa semplicemente la seguente sintassi:
function_name () {
list of commands
}
Il nome della tua funzione è function_name, ed è quello che userete per chiamarlo da altrove nei vostri script. Il nome della funzione deve essere seguito da parentesi, seguito da un elenco di comandi racchiusi tra parentesi graffe.
Esempio
L'esempio seguente mostra l'uso della funzione:
#!/bin/sh
# Define your function here
Hello () {
echo "Hello World"
}
# Invoke your function
Hello
Dopo l'esecuzione, riceverai il seguente output:
$./test.sh
Hello World
Passare i parametri a una funzione
È possibile definire una funzione che accetterà parametri durante la chiamata della funzione. Questi parametri sarebbero rappresentati da$1, $2 e così via.
Di seguito è riportato un esempio in cui passiamo due parametri Zara e Ali e quindi acquisiamo e stampiamo questi parametri nella funzione.
#!/bin/sh
# Define your function here
Hello () {
echo "Hello World $1 $2"
}
# Invoke your function
Hello Zara Ali
Dopo l'esecuzione, riceverai il seguente risultato:
$./test.sh
Hello World Zara Ali
Restituzione di valori dalle funzioni
Se esegui un file exit comando dall'interno di una funzione, il suo effetto non è solo quello di terminare l'esecuzione della funzione ma anche del programma shell che ha chiamato la funzione.
Se invece vuoi semplicemente terminare l'esecuzione della funzione, allora c'è un modo per uscire da una funzione definita.
In base alla situazione è possibile restituire qualsiasi valore dalla funzione utilizzando il return comando la cui sintassi è la seguente -
return code
Qui code può essere qualsiasi cosa tu scelga qui, ma ovviamente dovresti scegliere qualcosa che sia significativo o utile nel contesto della tua sceneggiatura nel suo insieme.
Esempio
La funzione seguente restituisce un valore 10 -
#!/bin/sh
# Define your function here
Hello () {
echo "Hello World $1 $2" return 10 } # Invoke your function Hello Zara Ali # Capture value returnd by last command ret=$?
echo "Return value is $ret"
Dopo l'esecuzione, riceverai il seguente risultato:
$./test.sh
Hello World Zara Ali
Return value is 10
Funzioni annidate
Una delle caratteristiche più interessanti delle funzioni è che possono chiamare se stesse e anche altre funzioni. Una funzione che chiama se stessa è nota comerecursive function.
L'esempio seguente mostra l'annidamento di due funzioni:
#!/bin/sh
# Calling one function from another
number_one () {
echo "This is the first function speaking..."
number_two
}
number_two () {
echo "This is now the second function speaking..."
}
# Calling function one.
number_one
Dopo l'esecuzione, riceverai il seguente risultato:
This is the first function speaking...
This is now the second function speaking...
Chiamata di funzione da prompt
Puoi inserire le definizioni per le funzioni di uso comune all'interno del tuo file .profile. Queste definizioni saranno disponibili ogni volta che effettui l'accesso e potrai utilizzarle al prompt dei comandi.
In alternativa, puoi raggruppare le definizioni in un file, ad esempio test.she quindi eseguire il file nella shell corrente digitando -
$. test.sh
Questo ha l'effetto di provocare funzioni definite all'interno test.sh da leggere e definire nella shell corrente come segue:
$ number_one
This is the first function speaking...
This is now the second function speaking...
$
Per rimuovere la definizione di una funzione dalla shell, utilizzare il comando unset con l'estensione .fopzione. Questo comando viene utilizzato anche per rimuovere la definizione di una variabile dalla shell.
$ unset -f function_name
Tutti i comandi Unix sono dotati di una serie di opzioni facoltative e obbligatorie. È molto comune dimenticare la sintassi completa di questi comandi.
Poiché nessuno può ricordare ogni comando Unix e tutte le sue opzioni, abbiamo una guida in linea disponibile per mitigare questo diritto da quando Unix era nella sua fase di sviluppo.
La versione di Unix di Help files sono chiamati man pages. Se c'è un nome di comando e non sei sicuro di come usarlo, le Man Pages ti aiutano in ogni passaggio.
Sintassi
Ecco il semplice comando che ti aiuta a ottenere i dettagli di qualsiasi comando Unix mentre lavori con il sistema:
$man command
Esempio
Supponiamo che ci sia un comando che richiede di ottenere aiuto; presumi che tu voglia saperepwd quindi devi semplicemente usare il seguente comando:
$man pwd
Il comando precedente ti aiuta con le informazioni complete su pwdcomando. Prova tu stesso al prompt dei comandi per ottenere maggiori dettagli.
Puoi ottenere dettagli completi su man comando stesso utilizzando il seguente comando:
$man man
Sezioni della pagina uomo
Le pagine man sono generalmente divise in sezioni, che generalmente variano in base alle preferenze dell'autore della pagina man. La tabella seguente elenca alcune sezioni comuni:
Sr.No. | Sezione e descrizione |
---|---|
1 | NAME Nome del comando |
2 | SYNOPSIS Parametri generali di utilizzo del comando |
3 | DESCRIPTION Descrive cosa fa il comando |
4 | OPTIONS Descrive tutti gli argomenti o le opzioni del comando |
5 | SEE ALSO Elenca altri comandi che sono direttamente correlati al comando nella pagina man o che assomigliano molto alla sua funzionalità |
6 | BUGS Spiega eventuali problemi noti o bug esistenti con il comando o il suo output |
7 | EXAMPLES Esempi di utilizzo comune che danno al lettore un'idea di come il comando può essere utilizzato |
8 | AUTHORS L'autore della pagina man / comando |
Per riassumere, le pagine man sono una risorsa vitale e la prima via di ricerca quando sono necessarie informazioni su comandi o file in un sistema Unix.
Comandi utili della shell
Il seguente collegamento fornisce un elenco dei comandi Unix Shell più importanti e utilizzati più di frequente.
Se non sai come usare alcun comando, usa la pagina man per ottenere i dettagli completi sul comando.
Ecco l'elenco di Unix Shell - Comandi utili
In questo capitolo, discuteremo in dettaglio delle espressioni regolari con SED in Unix.
Un'espressione regolare è una stringa che può essere utilizzata per descrivere diverse sequenze di caratteri. Le espressioni regolari vengono utilizzate da diversi comandi Unix, inclusoed, sed, awk, grepe, in misura più limitata, vi.
Qui SED sta per stream editor. Questo editor orientato al flusso è stato creato esclusivamente per l'esecuzione di script. Pertanto, tutto l'input che inserisci passa attraverso e va a STDOUT e non cambia il file di input.
Invocare sed
Prima di iniziare, assicurati di avere una copia locale di /etc/passwd file di testo con cui lavorare sed.
Come accennato in precedenza, sed può essere invocato inviando dati tramite una pipe come segue:
$ cat /etc/passwd | sed
Usage: sed [OPTION]... {script-other-script} [input-file]...
-n, --quiet, --silent
suppress automatic printing of pattern space
-e script, --expression = script
...............................
Il cat comando scarica il contenuto di /etc/passwd per sedattraverso il tubo nello spazio del modello di sed. Lo spazio del modello è il buffer di lavoro interno che sed utilizza per le sue operazioni.
La sintassi generale di sed
Di seguito è riportata la sintassi generale per sed -
/pattern/action
Qui, pattern è un'espressione regolare e actionè uno dei comandi riportati nella tabella seguente. Sepattern è omesso, action viene eseguita per ogni riga come abbiamo visto sopra.
Il carattere barra (/) che circonda il modello è obbligatorio perché vengono utilizzati come delimitatori.
Sr.No. | Gamma e descrizione |
---|---|
1 | p Stampa la riga |
2 | d Elimina la riga |
3 | s/pattern1/pattern2/ Sostituisce la prima occorrenza di pattern1 con pattern2 |
Eliminazione di tutte le righe con sed
Ora capiremo come eliminare tutte le righe con sed. Invoca nuovamente sed; ma ora si suppone che sed utilizzi l'estensioneediting command delete line, indicato dalla singola lettera d -
$ cat /etc/passwd | sed 'd' $
Invece di invocare sed inviandogli un file tramite una pipe, è possibile istruire il sed a leggere i dati da un file, come nell'esempio seguente.
Il seguente comando fa esattamente la stessa cosa dell'esempio precedente, senza il comando cat -
$ sed -e 'd' /etc/passwd $
Gli indirizzi sed
Il sed supporta anche gli indirizzi. Gli indirizzi sono posizioni particolari in un file o un intervallo in cui deve essere applicato un particolare comando di modifica. Quando il sed non trova indirizzi, esegue le sue operazioni su ogni riga del file.
Il comando seguente aggiunge un indirizzo di base al comando sed che hai utilizzato:
$ cat /etc/passwd | sed '1d' |more daemon:x:1:1:daemon:/usr/sbin:/bin/sh bin:x:2:2:bin:/bin:/bin/sh sys:x:3:3:sys:/dev:/bin/sh sync:x:4:65534:sync:/bin:/bin/sync games:x:5:60:games:/usr/games:/bin/sh man:x:6:12:man:/var/cache/man:/bin/sh mail:x:8:8:mail:/var/mail:/bin/sh news:x:9:9:news:/var/spool/news:/bin/sh backup:x:34:34:backup:/var/backups:/bin/sh $
Si noti che il numero 1 viene aggiunto prima del delete editcomando. Questo indica al sed di eseguire il comando di modifica sulla prima riga del file. In questo esempio, il sed cancellerà la prima riga di/etc/password e stampa il resto del file.
Gli intervalli di indirizzi sed
Ora capiremo come lavorare con the sed address ranges. Quindi cosa succede se si desidera rimuovere più di una riga da un file? È possibile specificare un intervallo di indirizzi con sed come segue:
$ cat /etc/passwd | sed '1, 5d' |more games:x:5:60:games:/usr/games:/bin/sh man:x:6:12:man:/var/cache/man:/bin/sh mail:x:8:8:mail:/var/mail:/bin/sh news:x:9:9:news:/var/spool/news:/bin/sh backup:x:34:34:backup:/var/backups:/bin/sh $
Il comando precedente verrà applicato a tutte le righe da 1 a 5. Ciò elimina le prime cinque righe.
Prova i seguenti intervalli di indirizzi:
Sr.No. | Gamma e descrizione |
---|---|
1 | '4,10d' Linee a partire dal 4 ° fino al 10 ° vengono cancellati |
2 | '10,4d' Viene eliminata solo la decima riga, perché sed non funziona in direzione inversa |
3 | '4,+5d' Questo corrisponde alla riga 4 nel file, elimina quella riga, continua a eliminare le cinque righe successive, quindi cessa la sua eliminazione e stampa il resto |
4 | '2,5!d' Questo cancella tutto tranne l'inizio dalla 2a alla 5a riga |
5 | '1~3d' Ciò elimina la prima riga, passa sopra le tre righe successive e quindi elimina la quarta riga. Sed continua ad applicare questo modello fino alla fine del file. |
6 | '2~2d' Questo dice a sed di eliminare la seconda riga, passare alla riga successiva, eliminare la riga successiva e ripetere fino a raggiungere la fine del file |
7 | '4,10p' Vengono stampate le righe dalla 4ª alla 10ª |
8 | '4,d' Questo genera l'errore di sintassi |
9 | ',10d' Ciò genererebbe anche un errore di sintassi |
Note - Durante l'utilizzo di p action, dovresti usare il -nopzione per evitare la ripetizione della stampa della riga. Controlla la differenza tra i seguenti due comandi:
$ cat /etc/passwd | sed -n '1,3p' Check the above command without -n as follows − $ cat /etc/passwd | sed '1,3p'
Il comando di sostituzione
Il comando di sostituzione, indicato da s, sostituirà qualsiasi stringa specificata con qualsiasi altra stringa specificata.
Per sostituire una stringa con un'altra, il sed deve avere le informazioni su dove finisce la prima stringa e inizia la stringa di sostituzione. Per questo, procediamo con il bookending delle due corde con la barra in avanti (/) personaggio.
Il comando seguente sostituisce la prima occorrenza su una riga della stringa root con lo spago amrood.
$ cat /etc/passwd | sed 's/root/amrood/'
amrood:x:0:0:root user:/root:/bin/sh
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
..........................
È molto importante notare che sed sostituisce solo la prima occorrenza su una riga. Se la radice della stringa si verifica più di una volta su una riga, verrà sostituita solo la prima corrispondenza.
Affinché sed esegua una sostituzione globale, aggiungi la lettera g alla fine del comando come segue:
$ cat /etc/passwd | sed 's/root/amrood/g'
amrood:x:0:0:amrood user:/amrood:/bin/sh
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
...........................
Bandiere di sostituzione
Ci sono una serie di altri flag utili che possono essere passati oltre a g flag e puoi specificarne più di uno alla volta.
Sr.No. | Bandiera e descrizione |
---|---|
1 | g Sostituisce tutte le corrispondenze, non solo la prima |
2 | NUMBER Sostituisce solo NUMERO ° incontro |
3 | p Se è stata eseguita la sostituzione, stampa lo spazio del motivo |
4 | w FILENAME Se è stata eseguita la sostituzione, scrive il risultato in FILENAME |
5 | I or i Corrisponde senza distinzione tra maiuscole e minuscole |
6 | M or m Oltre al normale comportamento dei caratteri speciali delle espressioni regolari ^ e $, this flag causes ^ to match the empty string after a newline and $ per abbinare la stringa vuota prima di una nuova riga |
Utilizzo di un separatore di stringhe alternativo
Supponiamo di dover eseguire una sostituzione su una stringa che include il carattere barra. In questo caso, è possibile specificare un separatore diverso fornendo il carattere designato dopos.
$ cat /etc/passwd | sed 's:/root:/amrood:g'
amrood:x:0:0:amrood user:/amrood:/bin/sh
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
Nell'esempio sopra, abbiamo usato : come la delimiter invece di barra / perché stavamo cercando di cercare /root invece della semplice radice.
Sostituzione con spazio vuoto
Utilizzare una stringa di sostituzione vuota per eliminare la stringa radice dal file /etc/passwd file interamente -
$ cat /etc/passwd | sed 's/root//g'
:x:0:0::/:/bin/sh
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
Sostituzione dell'indirizzo
Se vuoi sostituire la stringa sh con lo spago quiet solo alla riga 10, è possibile specificarlo come segue:
$ cat /etc/passwd | sed '10s/sh/quiet/g'
root:x:0:0:root user:/root:/bin/sh
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh
backup:x:34:34:backup:/var/backups:/bin/quiet
Allo stesso modo, per eseguire una sostituzione dell'intervallo di indirizzi, potresti fare qualcosa di simile al seguente:
$ cat /etc/passwd | sed '1,5s/sh/quiet/g'
root:x:0:0:root user:/root:/bin/quiet
daemon:x:1:1:daemon:/usr/sbin:/bin/quiet
bin:x:2:2:bin:/bin:/bin/quiet
sys:x:3:3:sys:/dev:/bin/quiet
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh
backup:x:34:34:backup:/var/backups:/bin/sh
Come puoi vedere dall'output, le prime cinque righe avevano la stringa sh cambiato in quiet, ma il resto delle righe è rimasto invariato.
Il comando di corrispondenza
Useresti il file p opzione insieme a -n opzione per stampare tutte le righe corrispondenti come segue:
$ cat testing | sed -n '/root/p'
root:x:0:0:root user:/root:/bin/sh
[root@ip-72-167-112-17 amrood]# vi testing
root:x:0:0:root user:/root:/bin/sh
daemon:x:1:1:daemon:/usr/sbin:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh
backup:x:34:34:backup:/var/backups:/bin/sh
Utilizzo dell'espressione regolare
Durante la corrispondenza dei modelli, è possibile utilizzare l'espressione regolare che fornisce maggiore flessibilità.
Controlla il seguente esempio che corrisponde a tutte le righe che iniziano con daemon e quindi le elimina:
$ cat testing | sed '/^daemon/d'
root:x:0:0:root user:/root:/bin/sh
bin:x:2:2:bin:/bin:/bin/sh
sys:x:3:3:sys:/dev:/bin/sh
sync:x:4:65534:sync:/bin:/bin/sync
games:x:5:60:games:/usr/games:/bin/sh
man:x:6:12:man:/var/cache/man:/bin/sh
mail:x:8:8:mail:/var/mail:/bin/sh
news:x:9:9:news:/var/spool/news:/bin/sh
backup:x:34:34:backup:/var/backups:/bin/sh
Di seguito è riportato l'esempio che cancella tutte le righe che terminano con sh -
$ cat testing | sed '/sh$/d'
sync:x:4:65534:sync:/bin:/bin/sync
La tabella seguente elenca quattro caratteri speciali molto utili nelle espressioni regolari.
Sr.No. | Carattere e descrizione |
---|---|
1 | ^ Corrisponde all'inizio delle righe |
2 | $ Corrisponde alla fine delle righe |
3 | . Corrisponde a qualsiasi singolo carattere |
4 | * Corrisponde a zero o più occorrenze del carattere precedente |
5 | [chars] Corrisponde a uno qualsiasi dei caratteri forniti in chars, dove chars è una sequenza di caratteri. È possibile utilizzare il carattere - per indicare un intervallo di caratteri. |
Caratteri corrispondenti
Guarda qualche altra espressione per dimostrare l'uso di metacharacters. Ad esempio, il seguente modello:
Sr.No. | Espressione e descrizione |
---|---|
1 | /a.c/ Trova le righe che contengono stringhe come a+c, a-c, abc, match, e a3c |
2 | /a*c/ Corrisponde alle stesse stringhe insieme a stringhe come ace, yacc, e arctic |
3 | /[tT]he/ Corrisponde alla stringa The e the |
4 | /^$/ Corrisponde a righe vuote |
5 | /^.*$/ Corrisponde a un'intera riga qualunque essa sia |
6 | / */ Corrisponde a uno o più spazi |
7 | /^$/ Partite blank Linee |
La tabella seguente mostra alcuni set di caratteri usati di frequente:
Sr.No. | Imposta e descrizione |
---|---|
1 | [a-z] Corrisponde a una singola lettera minuscola |
2 | [A-Z] Corrisponde a una singola lettera maiuscola |
3 | [a-zA-Z] Corrisponde a una singola lettera |
4 | [0-9] Corrisponde a un singolo numero |
5 | [a-zA-Z0-9] Corrisponde a una singola lettera o numero |
Parole chiave della classe di caratteri
Alcune parole chiave speciali sono comunemente disponibili per regexps, specialmente le utilità GNU che impiegano regexps. Questi sono molto utili per le espressioni regolari sed in quanto semplificano le cose e migliorano la leggibilità.
Ad esempio, i personaggi a through z e i personaggi A through Z, costituiscono una di queste classi di caratteri con la parola chiave [[:alpha:]]
Utilizzando la parola chiave della classe di caratteri alfabetici, questo comando stampa solo quelle righe nel file /etc/syslog.conf file che iniziano con una lettera dell'alfabeto -
$ cat /etc/syslog.conf | sed -n '/^[[:alpha:]]/p'
authpriv.* /var/log/secure
mail.* -/var/log/maillog
cron.* /var/log/cron
uucp,news.crit /var/log/spooler
local7.* /var/log/boot.log
La tabella seguente è un elenco completo delle parole chiave delle classi di caratteri disponibili in GNU sed.
Sr.No. | Classe e descrizione del carattere |
---|---|
1 | [[:alnum:]] Alfanumerico [az AZ 0-9] |
2 | [[:alpha:]] Alfabetico [az AZ] |
3 | [[:blank:]] Caratteri vuoti (spazi o tabulazioni) |
4 | [[:cntrl:]] Caratteri di controllo |
5 | [[:digit:]] Numeri [0-9] |
6 | [[:graph:]] Eventuali caratteri visibili (esclusi gli spazi) |
7 | [[:lower:]] Lettere minuscole [az] |
8 | [[:print:]] Caratteri stampabili (caratteri non di controllo) |
9 | [[:punct:]] Caratteri di punteggiatura |
10 | [[:space:]] Spazio bianco |
11 | [[:upper:]] Lettere maiuscole [AZ] |
12 | [[:xdigit:]] Cifre esadecimali [0-9 af AF] |
Riferimento Aampersand
Il sed metacharacter &rappresenta il contenuto del modello che è stato trovato. Ad esempio, supponi di avere un file chiamatophone.txt pieno di numeri di telefono, come i seguenti:
5555551212
5555551213
5555551214
6665551215
6665551216
7775551217
Vuoi creare il file area code(le prime tre cifre) racchiuse tra parentesi per facilitare la lettura. Per fare ciò, puoi usare il carattere di sostituzione e commerciale -
$ sed -e 's/^[[:digit:]][[:digit:]][[:digit:]]/(&)/g' phone.txt
(555)5551212
(555)5551213
(555)5551214
(666)5551215
(666)5551216
(777)5551217
Qui nella parte del modello stai abbinando le prime 3 cifre e quindi usando & stai sostituendo quelle 3 cifre con il contorno parentheses.
Utilizzo di più comandi sed
È possibile utilizzare più comandi sed in un singolo comando sed come segue:
$ sed -e 'command1' -e 'command2' ... -e 'commandN' files
Qui command1 attraverso commandNsono comandi sed del tipo discusso in precedenza. Questi comandi vengono applicati a ciascuna delle righe nell'elenco di file fornito da file.
Utilizzando lo stesso meccanismo, possiamo scrivere l'esempio di numero di telefono sopra come segue:
$ sed -e 's/^[[:digit:]]\{3\}/(&)/g' \
-e 's/)[[:digit:]]\{3\}/&-/g' phone.txt
(555)555-1212
(555)555-1213
(555)555-1214
(666)555-1215
(666)555-1216
(777)555-1217
Note - Nell'esempio sopra, invece di ripetere la parola chiave della classe di caratteri [[:digit:]] tre volte, l'abbiamo sostituito con \{3\}, il che significa che l'espressione regolare precedente viene trovata tre volte. Abbiamo anche usato\ per dare un'interruzione di riga e questo deve essere rimosso prima che il comando venga eseguito.
Riferimenti indietro
Il ampersand metacharacterè utile, ma ancora più utile è la capacità di definire regioni specifiche nelle espressioni regolari. Queste regioni speciali possono essere utilizzate come riferimento nelle stringhe sostitutive. Definendo parti specifiche di un'espressione regolare, è quindi possibile fare riferimento a quelle parti con un carattere di riferimento speciale.
Fare back references, devi prima definire una regione e poi fare riferimento a quella regione. Per definire una regione, inseriscibackslashed parenthesesintorno a ciascuna regione di interesse. Viene quindi fatto riferimento alla prima regione circondata da barre rovesciate\1, la seconda regione di \2, e così via.
Supponendo phone.txt ha il seguente testo -
(555)555-1212
(555)555-1213
(555)555-1214
(666)555-1215
(666)555-1216
(777)555-1217
Prova il seguente comando:
$ cat phone.txt | sed 's/\(.*)\)\(.*-\)\(.*$\)/Area \
code: \1 Second: \2 Third: \3/'
Area code: (555) Second: 555- Third: 1212
Area code: (555) Second: 555- Third: 1213
Area code: (555) Second: 555- Third: 1214
Area code: (666) Second: 555- Third: 1215
Area code: (666) Second: 555- Third: 1216
Area code: (777) Second: 555- Third: 1217
Note - Nell'esempio precedente, ogni espressione regolare all'interno delle parentesi sarebbe di nuovo referenziata da \1, \2e così via. Abbiamo usato\per dare un'interruzione di riga qui. Questo dovrebbe essere rimosso prima di eseguire il comando.
Un file system è una raccolta logica di file su una partizione o un disco. Una partizione è un contenitore di informazioni e può occupare un intero disco rigido se lo si desidera.
Il tuo disco rigido può avere varie partizioni che di solito contengono un solo file system, ad esempio un file system contenente l'estensione /file system o un altro contenente il file /home file system.
Un file system per partizione consente la manutenzione e la gestione logica di diversi file system.
Tutto in Unix è considerato un file, inclusi dispositivi fisici come DVD-ROM, dispositivi USB e unità floppy.
Struttura delle directory
Unix utilizza una struttura di file system gerarchica, molto simile a un albero capovolto, con root (/) alla base del file system e tutte le altre directory che si estendono da lì.
Un filesystem Unix è una raccolta di file e directory che ha le seguenti proprietà:
Ha una directory principale (/) che contiene altri file e directory.
Ogni file o directory è identificato in modo univoco dal suo nome, dalla directory in cui risiede e da un identificatore univoco, tipicamente chiamato inode.
Per convenzione, la directory root ha un'estensione inode numero di 2 e il lost+found directory ha un'estensione inode numero di 3. Numeri Inode0 e 1non vengono utilizzati. I numeri di inode del file possono essere visualizzati specificando l'estensione-i option per ls command.
È autonomo. Non ci sono dipendenze tra un filesystem e un altro.
Le directory hanno scopi specifici e generalmente contengono gli stessi tipi di informazioni per individuare facilmente i file. Di seguito sono riportate le directory che esistono nelle versioni principali di Unix:
Sr.No. | Directory e descrizione |
---|---|
1 | / Questa è la directory principale che dovrebbe contenere solo le directory necessarie al livello superiore della struttura del file |
2 | /bin Qui è dove si trovano i file eseguibili. Questi file sono disponibili per tutti gli utenti |
3 | /dev Questi sono i driver di dispositivo |
4 | /etc Comandi della directory del supervisore, file di configurazione, file di configurazione del disco, elenchi di utenti validi, gruppi, Ethernet, host, dove inviare messaggi critici |
5 | /lib Contiene file di libreria condivisa e talvolta altri file relativi al kernel |
6 | /boot Contiene file per l'avvio del sistema |
7 | /home Contiene la home directory per utenti e altri account |
8 | /mnt Utilizzato per montare altri file system temporanei, come cdrom e floppy per il CD-ROM guidare e floppy diskette drive, rispettivamente |
9 | /proc Contiene tutti i processi contrassegnati come file da process number o altre informazioni dinamiche al sistema |
10 | /tmp Contiene i file temporanei utilizzati tra gli avviamenti del sistema |
11 | /usr Utilizzato per scopi vari e può essere utilizzato da molti utenti. Include comandi amministrativi, file condivisi, file di libreria e altri |
12 | /var In genere contiene file di lunghezza variabile come file di registro e di stampa e qualsiasi altro tipo di file che può contenere una quantità variabile di dati |
13 | /sbin Contiene file binari (eseguibili), generalmente per l'amministrazione del sistema. Per esempio,fdisk e ifconfig utilità |
14 | /kernel Contiene i file del kernel |
Navigazione nel file system
Ora che hai compreso le basi del file system, puoi iniziare a navigare verso i file che ti servono. I seguenti comandi vengono utilizzati per navigare nel sistema:
Sr.No. | Comando e descrizione |
---|---|
1 | cat filename Visualizza un nome file |
2 | cd dirname Ti sposta nella directory identificata |
3 | cp file1 file2 Copia un file / directory nella posizione specificata |
4 | file filename Identifica il tipo di file (binario, testo, ecc.) |
5 | find filename dir Trova un file / directory |
6 | head filename Mostra l'inizio di un file |
7 | less filename Sfoglia un file dalla fine o dall'inizio |
8 | ls dirname Mostra il contenuto della directory specificata |
9 | mkdir dirname Crea la directory specificata |
10 | more filename Sfoglia un file dall'inizio alla fine |
11 | mv file1 file2 Sposta la posizione o rinomina un file / directory |
12 | pwd Mostra la directory corrente in cui si trova l'utente |
13 | rm filename Rimuove un file |
14 | rmdir dirname Rimuove una directory |
15 | tail filename Mostra la fine di un file |
16 | touch filename Crea un file vuoto o modifica un file esistente o i suoi attributi |
17 | whereis filename Mostra la posizione di un file |
18 | which filename Mostra la posizione di un file se è nel tuo PERCORSO |
È possibile utilizzare la Guida della pagina di manuale per controllare la sintassi completa per ogni comando menzionato qui.
Il comando df
Il primo modo per gestire lo spazio delle partizioni è con l'estensione df (disk free)comando. Il comandodf -k (disk free) visualizza il file disk space usage in kilobytes, come mostrato di seguito -
$df -k Filesystem 1K-blocks Used Available Use% Mounted on /dev/vzfs 10485760 7836644 2649116 75% / /devices 0 0 0 0% /devices $
Alcune delle directory, come /devices, mostra 0 nelle colonne kbyte, usato e disp, nonché 0% per la capacità. Questi sono file system speciali (o virtuali) e sebbene risiedano sul disco sotto /, da soli non consumano spazio su disco.
Il df -kl'output è generalmente lo stesso su tutti i sistemi Unix. Ecco cosa include di solito:
Sr.No. | Colonna e descrizione |
---|---|
1 | Filesystem Il nome del file system fisico |
2 | kbytes Kilobyte totali di spazio disponibile sul supporto di memorizzazione |
3 | used Kilobyte totali di spazio utilizzato (dai file) |
4 | avail Kilobyte totali disponibili per l'uso |
5 | capacity Percentuale dello spazio totale utilizzato dai file |
6 | Mounted on Su cosa è montato il file system |
Puoi usare il file -h (human readable) option per visualizzare l'output in un formato che mostri la dimensione in una notazione più facile da capire.
Il du Command
Il du (disk usage) command consente di specificare le directory per mostrare l'utilizzo dello spazio su disco in una determinata directory.
Questo comando è utile se si desidera determinare lo spazio occupato da una determinata directory. Il comando seguente visualizza il numero di blocchi consumati da ciascuna directory. Un singolo blocco può richiedere 512 byte o 1 chilo byte a seconda del sistema.
$du /etc 10 /etc/cron.d 126 /etc/default 6 /etc/dfs ... $
Il -h l'opzione rende l'output più facile da comprendere -
$du -h /etc 5k /etc/cron.d 63k /etc/default 3k /etc/dfs ... $
Montaggio del file system
Un file system deve essere montato per essere utilizzabile dal sistema. Per vedere cosa è attualmente montato (disponibile per l'uso) sul tuo sistema, usa il seguente comando:
$ mount /dev/vzfs on / type reiserfs (rw,usrquota,grpquota) proc on /proc type proc (rw,nodiratime) devpts on /dev/pts type devpts (rw) $
Il /mntdirectory, secondo la convenzione Unix, è dove si trovano i montaggi temporanei (come unità CDROM, unità di rete remote e unità floppy). Se è necessario montare un file system, è possibile utilizzare il comando mount con la seguente sintassi:
mount -t file_system_type device_to_mount directory_to_mount_to
Ad esempio, se vuoi montare un file CD-ROM nella directory /mnt/cdrom, puoi digitare -
$ mount -t iso9660 /dev/cdrom /mnt/cdrom
Ciò presuppone che venga richiamato il dispositivo CD-ROM /dev/cdrom e su cui vuoi montarlo /mnt/cdrom. Fare riferimento alla pagina man mount per informazioni più specifiche o digitare mount-h nella riga di comando per informazioni sulla guida.
Dopo il montaggio, è possibile utilizzare il comando cd per navigare nel file system appena disponibile attraverso il punto di montaggio appena creato.
Smontaggio del file system
Per smontare (rimuovere) il file system dal sistema, utilizzare l'estensione umount comando identificando il punto di montaggio o il dispositivo.
Per esempio, to unmount cdrom, usa il seguente comando:
$ umount /dev/cdrom
Il mount command ti consente di accedere ai tuoi file system, ma sulla maggior parte dei moderni sistemi Unix, il automount function rende questo processo invisibile all'utente e non richiede alcun intervento.
Quote utente e gruppo
Le quote utente e gruppo forniscono i meccanismi mediante i quali la quantità di spazio utilizzata da un singolo utente o da tutti gli utenti all'interno di un gruppo specifico può essere limitata a un valore definito dall'amministratore.
Le quote operano attorno a due limiti che consentono all'utente di intraprendere un'azione se la quantità di spazio o il numero di blocchi del disco inizia a superare i limiti definiti dall'amministratore:
Soft Limit - Se l'utente supera il limite definito, è previsto un periodo di grazia che consente all'utente di liberare spazio.
Hard Limit - Quando viene raggiunto il limite rigido, indipendentemente dal periodo di grazia, non è possibile allocare ulteriori file o blocchi.
Esistono numerosi comandi per amministrare le quote:
Sr.No. | Comando e descrizione |
---|---|
1 | quota Visualizza l'utilizzo del disco e i limiti per un utente del gruppo |
2 | edquota Questo è un editor di quote. La quota di utenti o gruppi può essere modificata utilizzando questo comando |
3 | quotacheck Esegue la scansione di un filesystem per l'utilizzo del disco, crea, controlla e ripara i file di quota |
4 | setquota Questo è un editor di quote della riga di comando |
5 | quotaon Questo annuncia al sistema che le quote disco dovrebbero essere abilitate su uno o più filesystem |
6 | quotaoff Questo annuncia al sistema che le quote disco dovrebbero essere disabilitate per uno o più filesystem |
7 | repquota Stampa un riepilogo dell'utilizzo del disco e delle quote per i file system specificati |
È possibile utilizzare la Guida della pagina di manuale per controllare la sintassi completa per ogni comando menzionato qui.
In questo capitolo, discuteremo in dettaglio sull'amministrazione degli utenti in Unix.
Esistono tre tipi di account su un sistema Unix:
Account di root
Questo è anche chiamato superusere avrebbe il controllo completo e illimitato del sistema. Un superutente può eseguire qualsiasi comando senza alcuna restrizione. Questo utente dovrebbe essere considerato un amministratore di sistema.
Account di sistema
Gli account di sistema sono quelli necessari per il funzionamento di componenti specifici del sistema, ad esempio account di posta e sshdconti. Questi account sono generalmente necessari per alcune funzioni specifiche del sistema e qualsiasi modifica ad essi potrebbe influire negativamente sul sistema.
Profili utente
Gli account utente forniscono l'accesso interattivo al sistema per utenti e gruppi di utenti. Gli utenti generici sono generalmente assegnati a questi account e di solito hanno accesso limitato a file e directory di sistema critici.
Unix supporta un concetto di account di gruppo che raggruppa logicamente un numero di account. Ogni account farebbe parte di un altro account di gruppo. Un gruppo Unix svolge un ruolo importante nella gestione dei permessi sui file e nella gestione dei processi.
Gestione di utenti e gruppi
Sono disponibili quattro file di amministrazione utente principali:
/etc/passwd- Mantiene l'account utente e le informazioni sulla password. Questo file contiene la maggior parte delle informazioni sugli account nel sistema Unix.
/etc/shadow- Contiene la password crittografata dell'account corrispondente. Non tutti i sistemi supportano questo file.
/etc/group - Questo file contiene le informazioni sul gruppo per ogni account.
/etc/gshadow - Questo file contiene informazioni sull'account di gruppo protetto.
Controlla tutti i file sopra usando il cat comando.
La tabella seguente elenca i comandi disponibili sulla maggior parte dei sistemi Unix per creare e gestire account e gruppi:
Sr.No. | Comando e descrizione |
---|---|
1 | useradd Aggiunge account al sistema |
2 | usermod Modifica gli attributi dell'account |
3 | userdel Elimina gli account dal sistema |
4 | groupadd Aggiunge gruppi al sistema |
5 | groupmod Modifica gli attributi del gruppo |
6 | groupdel Rimuove i gruppi dal sistema |
È possibile utilizzare la Guida della pagina di manuale per controllare la sintassi completa per ogni comando menzionato qui.
Crea un gruppo
Adesso capiremo come creare un gruppo. Per questo, dobbiamo creare gruppi prima di creare qualsiasi account, altrimenti possiamo utilizzare i gruppi esistenti nel nostro sistema. Abbiamo tutti i gruppi elencati in/etc/groups file.
Tutti i gruppi predefiniti sono gruppi specifici dell'account di sistema e non è consigliabile utilizzarli per gli account ordinari. Quindi, la seguente è la sintassi per creare un nuovo account di gruppo:
groupadd [-g gid [-o]] [-r] [-f] groupname
La tabella seguente elenca i parametri:
Sr.No. | Opzione e descrizione |
---|---|
1 | -g GID Il valore numerico dell'ID del gruppo |
2 | -o Questa opzione permette di aggiungere un gruppo con GID non univoco |
3 | -r Questa bandiera istruisce groupadd per aggiungere un account di sistema |
4 | -f Questa opzione fa sì che esca solo con lo stato di successo, se il gruppo specificato esiste già. Con -g, se il GID specificato esiste già, viene scelto un altro GID (univoco) |
5 | groupname Nome effettivo del gruppo da creare |
Se non si specifica alcun parametro, il sistema utilizza i valori predefiniti.
L'esempio seguente crea un gruppo di sviluppatori con valori predefiniti, che è molto accettabile per la maggior parte degli amministratori.
$ groupadd developers
Modifica un gruppo
Per modificare un gruppo, usa il groupmod sintassi -
$ groupmod -n new_modified_group_name old_group_name
Per modificare il nome del gruppo developers_2 in developer, digita -
$ groupmod -n developer developer_2
Ecco come cambierai il GID finanziario in 545 -
$ groupmod -g 545 developer
Elimina un gruppo
Ora capiremo come eliminare un gruppo. Per eliminare un gruppo esistente, tutto ciò di cui hai bisogno è il filegroupdel command e il group name. Per eliminare il gruppo finanziario, il comando è:
$ groupdel developer
Ciò rimuove solo il gruppo, non i file associati a quel gruppo. I file sono ancora accessibili dai rispettivi proprietari.
Crea un account
Vediamo come creare un nuovo account sul tuo sistema Unix. Di seguito è riportata la sintassi per creare un account utente:
useradd -d homedir -g groupname -m -s shell -u userid accountname
La tabella seguente elenca i parametri:
Sr.No. | Opzione e descrizione |
---|---|
1 | -d homedir Specifica la directory home per l'account |
2 | -g groupname Specifica un account di gruppo per questo account |
3 | -m Crea la directory home se non esiste |
4 | -s shell Specifica la shell predefinita per questo account |
5 | -u userid Puoi specificare un ID utente per questo account |
6 | accountname Nome account effettivo da creare |
Se non si specifica alcun parametro, il sistema utilizza i valori predefiniti. Iluseradd il comando modifica il file /etc/passwd, /etc/shadow, e /etc/group file e crea una directory home.
Di seguito è riportato l'esempio che crea un account mcmohd, impostando la sua home directory su /home/mcmohd e il gruppo come developers. A questo utente sarebbe stato assegnato Korn Shell.
$ useradd -d /home/mcmohd -g developers -s /bin/ksh mcmohd
Prima di emettere il comando precedente, assicurati di avere già il gruppo di sviluppatori creato utilizzando ilgroupadd comando.
Una volta creato un account, puoi impostarne la password utilizzando il passwd comando come segue -
$ passwd mcmohd20
Changing password for user mcmohd20.
New UNIX password:
Retype new UNIX password:
passwd: all authentication tokens updated successfully.
Quando digiti passwd accountname, ti dà la possibilità di cambiare la password, a condizione che tu sia un superutente. Altrimenti, puoi cambiare solo la tua password usando lo stesso comando ma senza specificare il tuo nome account.
Modifica un account
Il usermodcomando consente di apportare modifiche a un account esistente dalla riga di comando. Utilizza gli stessi argomenti diuseradd comando, più l'argomento -l, che ti permette di cambiare il nome dell'account.
Ad esempio, per modificare il nome dell'account mcmohd per mcmohd20 e per cambiare la directory home di conseguenza, dovrai emettere il seguente comando:
$ usermod -d /home/mcmohd20 -m -l mcmohd mcmohd20
Elimina un account
Il userdelpuò essere utilizzato per eliminare un utente esistente. Questo è un comando molto pericoloso se non usato con cautela.
È disponibile un solo argomento o opzione per il comando .r, per rimuovere la directory home dell'account e il file di posta.
Ad esempio, per rimuovere l'account mcmohd20 , immetti il seguente comando:
$ userdel -r mcmohd20
Se vuoi mantenere la directory home per scopi di backup, ometti il file -ropzione. È possibile rimuovere la directory home in base alle esigenze in un secondo momento.
In questo capitolo, discuteremo in dettaglio sulle prestazioni del sistema in Unix.
Ti presenteremo alcuni strumenti gratuiti disponibili per monitorare e gestire le prestazioni sui sistemi Unix. Questi strumenti forniscono anche linee guida su come diagnosticare e risolvere i problemi di prestazioni nell'ambiente Unix.
Unix ha i seguenti tipi di risorse principali che devono essere monitorati e ottimizzati:
CPU
Memory
Disk space
Communications lines
I/O Time
Network Time
Applications programs
Componenti delle prestazioni
La tabella seguente elenca i cinque componenti principali che occupano l'ora del sistema:
Sr.No. | Componente e descrizione |
---|---|
1 | User State CPU La quantità di tempo effettiva che la CPU impiega per eseguire il programma utente nello stato utente. Include il tempo impiegato per eseguire le chiamate alla libreria, ma non include il tempo trascorso nel kernel per suo conto |
2 | System State CPU Questa è la quantità di tempo che la CPU trascorre nello stato del sistema per conto di questo programma. TuttiI/O routinesrichiedono i servizi del kernel. Il programmatore può modificare questo valore bloccando i trasferimenti di I / O |
3 | I/O Time and Network Time Questa è la quantità di tempo impiegata per spostare i dati e servire le richieste di I / O |
4 | Virtual Memory Performance Ciò include il cambio di contesto e lo scambio |
5 | Application Program Tempo impiegato per eseguire altri programmi: quando il sistema non serve questa applicazione perché un'altra applicazione ha attualmente la CPU |
Strumenti per le prestazioni
Unix fornisce i seguenti strumenti importanti per misurare e ottimizzare le prestazioni del sistema Unix:
Sr.No. | Comando e descrizione |
---|---|
1 | nice/renice Esegue un programma con priorità di pianificazione modificata |
2 | netstat Stampa connessioni di rete, tabelle di instradamento, statistiche dell'interfaccia, connessioni mascherate e appartenenze multicast |
3 | time Aiuta a cronometrare un semplice comando oa fornire l'utilizzo delle risorse |
4 | uptime Questa è la media del carico di sistema |
5 | ps Riporta un'istantanea dei processi in corso |
6 | vmstat Riporta le statistiche sulla memoria virtuale |
7 | gprof Visualizza i dati del profilo del grafico delle chiamate |
8 | prof Facilita la profilazione dei processi |
9 | top Visualizza le attività di sistema |
È possibile utilizzare la Guida della pagina di manuale per controllare la sintassi completa per ogni comando menzionato qui.
In questo capitolo, discuteremo in dettaglio sulla registrazione del sistema in Unix.
I sistemi Unix hanno un sistema di registrazione molto flessibile e potente, che ti consente di registrare quasi tutto ciò che puoi immaginare e quindi manipolare i log per recuperare le informazioni necessarie.
Molte versioni di Unix forniscono una funzione di registrazione generica chiamata syslog. I singoli programmi che richiedono la registrazione delle informazioni, inviano le informazioni a syslog.
Unix syslog è una funzione di registrazione del sistema uniforme configurabile dall'host. Il sistema utilizza un processo di registrazione del sistema centralizzato che esegue il programma/etc/syslogd o /etc/syslog.
Il funzionamento del logger di sistema è abbastanza semplice. I programmi inviano le loro voci di registro a syslogd , che consulta il file di configurazione/etc/syslogd.conf o /etc/syslog e, quando viene trovata una corrispondenza, scrive il messaggio di registro nel file di registro desiderato.
Ci sono quattro termini di base di syslog che dovresti capire:
Sr.No. | Termine e descrizione |
---|---|
1 | Facility L'identificatore utilizzato per descrivere l'applicazione o il processo che ha inviato il messaggio di registro. Ad esempio, mail, kernel e ftp. |
2 | Priority Un indicatore dell'importanza del messaggio. I livelli sono definiti all'interno di syslog come linee guida, dalle informazioni di debug agli eventi critici. |
3 | Selector Una combinazione di uno o più servizi e livelli. Quando un evento in arrivo corrisponde a un selettore, viene eseguita un'azione. |
4 | Action Cosa succede a un messaggio in arrivo che corrisponde a un selettore: le azioni possono scrivere il messaggio in un file di registro, eseguire l'eco del messaggio su una console o su un altro dispositivo, scrivere il messaggio a un utente connesso o inviare il messaggio a un altro server syslog. |
Strutture Syslog
Ora capiremo le funzionalità di syslog. Ecco i servizi disponibili per il selezionatore. Non tutte le funzionalità sono presenti su tutte le versioni di Unix.
Servizio, struttura | Descrizione |
---|---|
1 | auth Attività relativa alla richiesta di nome e password (getty, su, login) |
2 | authpriv Uguale ad auth ma registrato in un file che può essere letto solo da utenti selezionati |
3 | console Utilizzato per acquisire messaggi generalmente diretti alla console di sistema |
4 | cron Messaggi dallo scheduler di sistema cron |
5 | daemon Demone di sistema catch-all |
6 | ftp Messaggi relativi al demone ftp |
7 | kern Messaggi del kernel |
8 | local0.local7 Strutture locali definite per sito |
9 | lpr Messaggi dal sistema di stampa in linea |
10 | Messaggi relativi al sistema di posta |
11 | mark Pseudo-evento utilizzato per generare timestamp nei file di registro |
12 | news Messaggi relativi al protocollo di notizie di rete (nntp) |
13 | ntp Messaggi relativi al protocollo orario di rete |
14 | user Processi utente regolari |
15 | uucp Sottosistema UUCP |
Priorità di Syslog
Le priorità di syslog sono riassunte nella tabella seguente:
Sr.No. | Priorità e descrizione |
---|---|
1 | emerg Condizione di emergenza, come un arresto anomalo del sistema imminente, di solito trasmessa a tutti gli utenti |
2 | alert Condizione che deve essere corretta immediatamente, ad esempio un database di sistema danneggiato |
3 | crit Condizione critica, come un errore hardware |
4 | err Errore ordinario |
5 | Warning avvertimento |
6 | notice Condizione che non è un errore, ma possibilmente dovrebbe essere gestita in modo speciale |
7 | info Messaggio informativo |
8 | debug Messaggi utilizzati durante il debug dei programmi |
9 | none Livello pseudo utilizzato per specificare di non registrare i messaggi |
La combinazione di strutture e livelli consente di distinguere ciò che viene registrato e dove vanno a finire tali informazioni.
Poiché ogni programma invia diligentemente i propri messaggi al logger di sistema, quest'ultimo prende decisioni su cosa tenere traccia e cosa scartare in base ai livelli definiti nel selettore.
Quando si specifica un livello, il sistema terrà traccia di tutto a quel livello e superiore.
Il file /etc/syslog.conf
Il /etc/syslog.confcontrolla i file in cui vengono registrati i messaggi. Un tipicosyslog.conf il file potrebbe essere simile a questo -
*.err;kern.debug;auth.notice /dev/console
daemon,auth.notice /var/log/messages
lpr.info /var/log/lpr.log
mail.* /var/log/mail.log
ftp.* /var/log/ftp.log
auth.* @prep.ai.mit.edu
auth.* root,amrood
netinfo.err /var/log/netinfo.log
install.* /var/log/install.log
*.emerg *
*.alert |program_name
mark.* /dev/console
Ogni riga del file contiene due parti:
UN message selectorche specifica il tipo di messaggi da registrare. Ad esempio, tutti i messaggi di errore o tutti i messaggi di debug dal kernel.
Un action fieldche dice cosa dovrebbe essere fatto con il messaggio. Ad esempio, inseriscilo in un file o invia il messaggio al terminale di un utente.
Di seguito sono riportati i punti importanti per la configurazione di cui sopra:
I selettori di messaggi hanno due parti: a facility e a priority. Ad esempio, kern.debug seleziona tutti i messaggi di debug (la priorità) generati dal kernel (la struttura).
Il selettore di messaggi kern.debug seleziona tutte le priorità che sono maggiori di debug.
Un asterisco al posto della struttura o della priorità indica "tutto". Per esempio,*.debug significa tutti i messaggi di debug, mentre kern.* indica tutti i messaggi generati dal kernel.
È inoltre possibile utilizzare le virgole per specificare più strutture. È possibile raggruppare due o più selettori utilizzando un punto e virgola.
Azioni di registrazione
Il campo azione specifica una delle cinque azioni:
Registra il messaggio in un file o in un dispositivo. Per esempio,/var/log/lpr.log o /dev/console.
Invia un messaggio a un utente. È possibile specificare più nomi utente separandoli con virgole; ad esempio, root, amrood.
Invia un messaggio a tutti gli utenti. In questo caso, il campo azione è costituito da un asterisco; per esempio, *.
Invia il messaggio a un programma. In questo caso, il programma viene specificato dopo il simbolo pipe Unix (|).
Invia il messaggio al syslog su un altro host. In questo caso, il campo azione è costituito da un nome host, preceduto da un segno di chiocciola; ad esempio, @ tutorialspoint.com.
Il comando logger
Unix fornisce l'estensione loggercomando, che è un comando estremamente utile per gestire la registrazione del sistema. Illogger Il comando invia messaggi di registrazione al demone syslogd e di conseguenza provoca la registrazione di sistema.
Ciò significa che possiamo controllare in qualsiasi momento dalla riga di comando il file syslogddaemon e la sua configurazione. Il comando logger fornisce un metodo per aggiungere voci di una riga al file di registro di sistema dalla riga di comando.
Il formato del comando è:
logger [-i] [-f file] [-p priority] [-t tag] [message]...
Ecco il dettaglio dei parametri -
Sr.No. | Opzione e descrizione |
---|---|
1 | -f filename Utilizza il contenuto del file nomefile come messaggio da registrare. |
2 | -i Registra l'ID di processo del processo di registrazione con ciascuna riga. |
3 | -p priority Immette il messaggio con la priorità specificata (voce del selettore specificata); la priorità del messaggio può essere specificata numericamente o come coppia facility.priority. La priorità predefinita è user.notice. |
4 | -t tag Contrassegna ogni riga aggiunta al registro con il tag specificato. |
5 | message Gli argomenti stringa i cui contenuti sono concatenati insieme nell'ordine specificato, separati da uno spazio. |
È possibile utilizzare la Guida della pagina di manuale per controllare la sintassi completa di questo comando.
Rotazione del registro
I file di registro hanno la propensione a crescere molto velocemente e consumano grandi quantità di spazio su disco. Per abilitare le rotazioni dei log, la maggior parte delle distribuzioni utilizza strumenti comenewsyslog o logrotate.
Questi strumenti dovrebbero essere richiamati in un intervallo di tempo frequente utilizzando il cron daemon. Controlla le pagine man per newsyslog o logrotate per maggiori dettagli.
Posizioni dei registri importanti
Tutte le applicazioni di sistema creano i propri file di registro in formato /var/loge le sue sottodirectory. Di seguito sono riportate alcune applicazioni importanti e le directory di registro corrispondenti:
Applicazione | Directory |
---|---|
httpd | / var / log / httpd |
samba | / var / log / samba |
cron | / var / log / |
posta | / var / log / |
mysql | / var / log / |
In questo capitolo, discuteremo in dettaglio di segnali e trap in Unix.
I segnali sono interruzioni software inviate a un programma per indicare che si è verificato un evento importante. Gli eventi possono variare dalle richieste dell'utente agli errori di accesso alla memoria illegale. Alcuni segnali, come il segnale di interruzione, indicano che un utente ha chiesto al programma di fare qualcosa che non rientra nel normale flusso di controllo.
La tabella seguente elenca i segnali comuni che potresti incontrare e che desideri utilizzare nei tuoi programmi:
Nome segnale | Numero di segnale | Descrizione |
---|---|---|
SIGHUP | 1 | Riagganciare rilevato sul terminale di controllo o morte del processo di controllo |
SIGINT | 2 | Emesso se l'utente invia un segnale di interruzione (Ctrl + C) |
SIGQUIT | 3 | Emesso se l'utente invia un segnale di chiusura (Ctrl + D) |
SIGFPE | 8 | Emesso se viene tentata un'operazione matematica illegale |
SIGKILL | 9 | Se un processo riceve questo segnale, deve chiudersi immediatamente e non eseguirà alcuna operazione di pulizia |
SIGALRM | 14 | Segnale sveglia (utilizzato per i timer) |
SIGTERM | 15 | Segnale di terminazione software (inviato da kill per impostazione predefinita) |
Elenco dei segnali
C'è un modo semplice per elencare tutti i segnali supportati dal tuo sistema. Basta emettere il filekill -l comando e visualizzerà tutti i segnali supportati -
$ kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT
17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU
25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH
29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN
35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4
39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12
47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6
59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
L'elenco effettivo dei segnali varia tra Solaris, HP-UX e Linux.
Azioni predefinite
Ad ogni segnale è associata un'azione predefinita. L'azione predefinita per un segnale è l'azione che uno script o un programma esegue quando riceve un segnale.
Alcune delle possibili azioni predefinite sono:
Termina il processo.
Ignora il segnale.
Dump core. Questo crea un file chiamatocore contenente l'immagine di memoria del processo quando ha ricevuto il segnale.
Interrompi il processo.
Continua un processo interrotto.
Invio di segnali
Esistono diversi metodi per inviare segnali a un programma o uno script. Uno dei più comuni è che un utente digitiCONTROL-C o il INTERRUPT key mentre uno script è in esecuzione.
Quando si preme il pulsante Ctrl+C chiave, a SIGINT viene inviato allo script e come da script di azione predefinito definito termina.
L'altro metodo comune per fornire i segnali è utilizzare il kill command, la cui sintassi è la seguente:
$ kill -signal pid
Qui signal è il numero o il nome del segnale da trasmettere e pidè l'ID del processo a cui deve essere inviato il segnale. Ad esempio -
$ kill -1 1001
Il comando precedente invia il segnale HUP o di riaggancio al programma in esecuzione con process ID 1001. Per inviare un segnale di kill allo stesso processo, utilizzare il seguente comando:
$ kill -9 1001
Questo uccide il processo in esecuzione con process ID 1001.
Segnali di intrappolamento
Quando si preme il tasto Ctrl + C o Break sul terminale durante l'esecuzione di un programma shell, normalmente quel programma viene immediatamente terminato e il prompt dei comandi ritorna. Questo potrebbe non essere sempre desiderabile. Ad esempio, potresti finire per lasciare un mucchio di file temporanei che non verranno ripuliti.
Il trapping di questi segnali è abbastanza semplice e il comando trap ha la seguente sintassi:
$ trap commands signals
Qui command può essere qualsiasi comando Unix valido, o anche una funzione definita dall'utente, e signal può essere un elenco di qualsiasi numero di segnali che si desidera intercettare.
Ci sono due usi comuni per trap negli script di shell:
- Elimina i file temporanei
- Ignora i segnali
Pulizia dei file temporanei
Come esempio del comando trap, quanto segue mostra come rimuovere alcuni file e poi uscire se qualcuno cerca di interrompere il programma dal terminale -
$ trap "rm -f $WORKDIR/work1$$ $WORKDIR/dataout$$; exit" 2
Dal punto nel programma shell in cui viene eseguita questa trap, i due file work1$$ e dataout$$ verrà automaticamente rimosso se il segnale numero 2 viene ricevuto dal programma.
Quindi, se l'utente interrompe l'esecuzione del programma dopo che questa trap è stata eseguita, si può essere certi che questi due file verranno cancellati. Ilexit comando che segue il rm è necessario perché senza di esso l'esecuzione continuerebbe nel programma dal punto in cui si è interrotta quando è stato ricevuto il segnale.
Il segnale numero 1 viene generato per hangup. O qualcuno riattacca intenzionalmente la linea o la linea viene scollegata accidentalmente.
È possibile modificare la trappola precedente per rimuovere anche i due file specificati in questo caso aggiungendo il segnale numero 1 all'elenco dei segnali -
$ trap "rm $WORKDIR/work1$$ $WORKDIR/dataout$$; exit" 1 2
Ora questi file verranno rimossi se la linea viene interrotta o se viene premuto il tasto Ctrl + C.
I comandi specificati per trap devono essere racchiusi tra virgolette, se contengono più di un comando. Si noti inoltre che la shell esegue la scansione della riga di comando nel momento in cui viene eseguito il comando trap e anche quando viene ricevuto uno dei segnali elencati.
Pertanto, nell'esempio precedente, il valore di WORKDIR e $$verrà sostituito nel momento in cui viene eseguito il comando trap. Se si desidera che questa sostituzione avvenga nel momento in cui è stato ricevuto il segnale 1 o 2, è possibile inserire i comandi tra virgolette singole -
$ trap 'rm $WORKDIR/work1$$ $WORKDIR/dataout$$; exit' 1 2
Ignorare i segnali
Se il comando elencato per trap è nullo, il segnale specificato verrà ignorato quando ricevuto. Ad esempio, il comando -
$ trap '' 2
Questo specifica che il segnale di interruzione deve essere ignorato. Potresti voler ignorare alcuni segnali quando esegui un'operazione che non vuoi essere interrotta. È possibile specificare più segnali da ignorare come segue:
$ trap '' 1 2 3 15
Si noti che il primo argomento deve essere specificato affinché un segnale venga ignorato e non è equivalente alla scrittura di quanto segue, che ha un significato separato -
$ trap 2
Se ignori un segnale, anche tutte le subshell ignorano quel segnale. Tuttavia, se si specifica un'azione da intraprendere alla ricezione di un segnale, tutte le subshell eseguiranno comunque l'azione predefinita alla ricezione di quel segnale.
Ripristino delle trap
Dopo aver modificato l'azione predefinita da eseguire alla ricezione di un segnale, è possibile modificarla nuovamente con la trappola se si omette semplicemente il primo argomento; così -
$ trap 1 2
Ciò ripristina l'azione da intraprendere alla ricezione dei segnali 1 o 2 al valore predefinito.