GNU/Linux >> Linux Esercitazione > >> Linux

Quali sono gli operatori di controllo e reindirizzamento di The Shell?

Vedo spesso tutorial online che collegano vari comandi con simboli diversi. Ad esempio:

command1 |  command2
command1 &  command2
command1 || command2    
command1 && command2

Altri sembrano collegare i comandi ai file:

command1  > file1
command1  >> file1

Cosa sono queste cose? Come si chiamano? Cosa fanno? Ce ne sono altri?

Meta thread su questa domanda..

Risposta accettata:

Questi sono chiamati operatori di shell e sì, ce ne sono di più. Darò una breve panoramica delle più comuni tra le due classi principali, gli operatori di controllo e gli operatori di reindirizzamento, e come funzionano rispetto alla shell bash.

A. Operatori di controllo

Definizione POSIX

Nel linguaggio dei comandi della shell, un token che esegue una funzione di controllo.
È uno dei seguenti simboli:

&   &&   (   )   ;   ;;   <newline>   |   ||

E |& in bash.

Un ! è non un operatore di controllo ma una Parola Riservata. Diventa un NOT logico [operatore di negazione] all'interno di espressioni aritmetiche e all'interno di costrutti di test (pur richiedendo ancora un delimitatore di spazio).

A.1 Elenca i terminatori

; :eseguirà un comando dopo che l'altro è terminato, indipendentemente dall'esito del primo.
```
command1 ; command2
```
Primo command1 viene eseguito, in primo piano e, una volta terminato, command2 verrà eseguito.

Una nuova riga che non è in una stringa letterale o dopo determinate parole chiave è non equivalente all'operatore punto e virgola. Un elenco di ; comandi semplici delimitati è ancora un elenco – come nel parser della shell bisogna comunque continuare a leggere nei semplici comandi che seguono un ; comando semplice delimitato prima dell'esecuzione, mentre una nuova riga può delimitare un intero elenco di comandi o un elenco di elenchi. La differenza è sottile, ma complicata:dato che la shell non ha alcun imperativo precedente per leggere i dati dopo una nuova riga, la nuova riga segna un punto in cui la shell può iniziare a valutare i semplici comandi che ha già letto, mentre un ; il punto e virgola no.
& :Questo eseguirà un comando in background, permettendoti di continuare a lavorare nella stessa shell.
```
 command1 & command2
```
Qui, command1 viene avviato in background e command2 inizia immediatamente a funzionare in primo piano, senza attendere il command1 per uscire.

Una nuova riga dopo command1 è facoltativo.

A.2 Operatori logici

&& :Usato per costruire liste AND, ti permette di eseguire un comando solo se un altro è terminato con successo.
```
 command1 && command2
```
Qui, command2 verrà eseguito dopo command1 è terminato e solo se command1 ha avuto successo (se il suo codice di uscita era 0). Entrambi i comandi vengono eseguiti in primo piano.

Questo comando può anche essere scritto
```
if command1
then command2
else false
fi
```
o semplicemente if command1; then command2; fi se lo stato del reso viene ignorato.
|| :Utilizzato per creare elenchi OR, consente di eseguire un comando solo se un altro è terminato senza successo.
```
 command1 || command2
```
Qui, command2 verrà eseguito solo se command1 fallito (se ha restituito uno stato di uscita diverso da 0). Entrambi i comandi vengono eseguiti in primo piano.

Questo comando può anche essere scritto
```
if command1
then true
else command2
fi
```
o in modo più breve if ! command1; then command2; fi .

Nota che && e || sono associativi a sinistra; vedere Precedenza degli operatori logici della shell &&, || per ulteriori informazioni.
! :questa è una parola riservata che funge da operatore "non" (ma deve avere un delimitatore), utilizzata per negare lo stato di ritorno di un comando — restituire 0 se il comando restituisce uno stato diverso da zero, restituire 1 se restituisce lo stato 0 .Anche un NOT logico per il test utilità.
```
! command1

[ ! a = a ]
```
E un vero operatore NOT all'interno di Espressioni aritmetiche:
```
$ echo $((!0)) $((!23))
1 0
```

A.3 Operatore di tubazioni

| :L'operatore pipe, passa l'output di un comando come input a un altro. Un comando creato dall'operatore pipe è chiamato pipeline.
```
 command1 | command2
```
Qualsiasi output stampato da command1 viene passato come input a command2 .
|& :Questa è una scorciatoia per 2>&1 | in bash e zsh. Passa sia lo standard output che l'errore standard di un comando come input per un altro.
```
command1 |& command2
```

A.4 Altra punteggiatura dell'elenco

;; viene utilizzato esclusivamente per contrassegnare la fine di una dichiarazione del caso. Ksh, bash e zsh supportano anche ;& per passare al caso successivo e ;;& (non in ATT ksh) per andare avanti e testare i casi successivi.

Correlati:elencare i file a cui si accede da un programma?

( e ) sono usati per raggruppare i comandi e lanciarli in una subshell. { e } raggruppano anche i comandi, ma non li lanciano in una subshell. Vedi questa risposta per una discussione sui vari tipi di parentesi, parentesi e parentesi graffe nella sintassi della shell.

B. Operatori di reindirizzamento

Definizione POSIX di Operatore di Reindirizzamento

Nel linguaggio dei comandi della shell, un token che esegue una funzione di reindirizzamento. È uno dei seguenti simboli:

<     >     >|     <<     >>     <&     >&     <<-     <>

Questi ti consentono di controllare l'input e l'output dei tuoi comandi. Possono apparire ovunque all'interno di un semplice comando o possono seguire un comando. I reindirizzamenti vengono elaborati nell'ordine in cui appaiono, da sinistra a destra.

< :fornisce input a un comando.
```
command < file.txt
```
Quanto sopra eseguirà command sul contenuto di file.txt .
<> :come sopra, ma il file è aperto in lettura+scrittura modalità invece di sola lettura :
```
command <> file.txt
```
Se il file non esiste, verrà creato.

Questo operatore è usato raramente perché i comandi generalmente si limitano a lettura dal loro stdin, anche se può tornare utile in una serie di situazioni specifiche.
> :Dirige l'output di un comando in un file.
```
command > out.txt
```
Quanto sopra salverà l'output di command come out.txt . Se il file esiste, il suo contenuto verrà sovrascritto e se non esiste verrà creato.

Questo operatore viene spesso utilizzato anche per scegliere se stampare qualcosa in errore standard o output standard:
```
command >out.txt 2>error.txt
```
Nell'esempio sopra, > reindirizzerà lo standard output e 2> reindirizza l'errore standard. L'output può anche essere reindirizzato utilizzando 1> ma, poiché questa è l'impostazione predefinita, 1 di solito viene omesso ed è scritto semplicemente come > .

Quindi, per eseguire command su file.txt e salvane l'output in out.txt ed eventuali messaggi di errore in error.txt correresti:
```
command < file.txt > out.txt 2> error.txt
```
>| :Funziona come > , ma sovrascriverà il target, anche se la shell è stata configurata per rifiutare la sovrascrittura (con set -C o set -o noclobber ).
```
command >| out.txt
```
Se out.txt esiste, l'output di command sostituirà il suo contenuto. Se non esiste verrà creato.
>> :Funziona come > , tranne per il fatto che se il file di destinazione esiste, i nuovi dati vengono aggiunti.
```
command >> out.txt
```
Se out.txt esiste, l'output di command sarà aggiunto ad esso, dopo tutto ciò che è già in esso. Se non esiste verrà creato.
>& :(secondo le specifiche POSIX) quando è circondato da cifre (1>&2 ) o - sul lato destro (1>&- ) reindirizza solo uno descrittore di file o lo chiude (>&- ).

Un >& seguito da un numero di descrittore di file è un modo portatile per reindirizzare un descrittore di file e >&- è un modo portatile per chiudere un descrittore di file.

Se il lato destro di questo reindirizzamento è un file, leggi la voce successiva.
>& , &> , >>& e &>> :(leggi anche sopra) Reindirizza sia l'errore standard che l'output standard, sostituendo o aggiungendo, rispettivamente.
```
command &> out.txt
```
Sia l'errore standard che l'output standard di command verrà salvato in out.txt , sovrascrivendone il contenuto o creandolo se non esiste.
```
command &>> out.txt
```
Come sopra, tranne che se out.txt esiste, l'output e l'errore di command verrà aggiunto ad esso.

Il &> la variante ha origine in bash , mentre il >& la variante deriva da csh (decenni prima). Entrambi sono in conflitto con altri operatori di shell POSIX e non dovrebbero essere usati in sh portatile script.
<< :Un qui documento. Viene spesso utilizzato per stampare stringhe su più righe.
```
 command << WORD
     Text
 WORD
```
Qui, command prenderà tutto finché non trova la prossima occorrenza di WORD , Text nell'esempio sopra, come input . Mentre WORD è spesso EoF o sue variazioni, può essere qualsiasi stringa alfanumerica (e non solo) di tuo gradimento. Quando WORD viene citato, il testo nel documento here viene trattato alla lettera e non vengono eseguite espansioni (sulle variabili per esempio). Se non è tra virgolette, le variabili verranno espanse. Per maggiori dettagli, consulta il manuale di bash.

Se vuoi reindirizzare l'output del command << WORD ... WORD direttamente in un altro comando o comandi, devi mettere la pipe sulla stessa riga di << WORD , non puoi metterlo dopo la WORD che termina o nella riga successiva. Ad esempio:
Comando
```
 command << WORD | command2 | command3...
     Text
 WORD
```
<<< :stringhe Here, simili ai documenti here, ma destinate a una singola riga. Questi esistono solo nel port Unix o rc (dove ha avuto origine), zsh, alcune implementazioni di ksh, yash e bash.
```
command <<< WORD
```
Qualunque cosa sia data come WORD viene espanso e il suo valore viene passato come input a command . Questo è spesso usato per passare il contenuto delle variabili come input a un comando. Ad esempio:
```
 $ foo="bar"
 $ sed 's/a/A/' <<< "$foo"
 bAr
 # as a short-cut for the standard:
 $ printf '%sn' "$foo" | sed 's/a/A/'
 bAr
 # or
 sed 's/a/A/' << EOF
 $foo
 EOF
```

Alcuni altri operatori (>&- , x>&y x<&y ) può essere utilizzato per chiudere o duplicare i descrittori di file. Per i dettagli su di essi, consulta la sezione pertinente del manuale della tua shell (qui ad esempio per bash).

Correlati:come differire l'espansione delle variabili?

Questo copre solo gli operatori più comuni di shell tipo Bourne. Alcune shell hanno alcuni propri operatori di reindirizzamento aggiuntivi.

Ksh, bash e zsh hanno anche costrutti <(…) , >(…) e =(…) (quell'ultimo in zsh solo). Questi non sono reindirizzamenti, ma sostituzioni di processi.

Quando è necessaria la doppia virgoletta?

Implicazioni sulla sicurezza di dimenticare di citare una variabile in shell Bash/posix?

Linux

Che cos'è Intel SGX e quali sono i vantaggi?

Qual è la differenza tra InnoDB e MyISAM?

Qual è la differenza tra Linux e Unix?

Quali sono i separatori di parole Readline?

Quali sono le relazioni tra l'attuale terminale di controllo e `/dev/tty`?

Quali sono le differenze tra cPanel e WHM?