Cosa si legge?
Read è un comando integrato di bash che legge il contenuto di una riga in una variabile. Consente la suddivisione delle parole che è legata alla speciale variabile di shell IFS. Viene utilizzato principalmente per catturare l'input dell'utente, ma può essere utilizzato per implementare funzioni che prendono input dall'input standard.
Bash legge l'aiuto del comando integrato
Prima di approfondire come utilizzare il comando read negli script bash, ecco come ottenere aiuto. Lì dovresti vedere tutte le opzioni disponibili per il comando read insieme alle descrizioni che proveremo a trattare negli esempi.
Riga di comando
aiuto leggere
Produzione
leggere:leggere [-ers] [-un array] [-d condividi] [-i testo] [-n caratteri] [-N caratteri]
[-p prompt] [-t timeout] [-u fd] [nome ...]
Leggere una riga dallo standard input edivisoesso nei campi.
Legge una singola riga dallo standard input o dafiledescrittore FD
Seil-ul'opzione è fornita. La linea èdivisonei campicomecon la parola
scissione, e la prima parola è assegnata al primo NOME, il secondo
parola al secondo NOME, e così via, con eventuali parole rimanenti assegnate a
ilUltimoNOME. Solo i caratteri trovatiin $IFSsono riconosciuticomeparola
Delimitatori.
Se non vengono forniti NOMI, la rigaleggereè memorizzatoinla variabile RISPOSTA.
Opzioni:
-aarray assegna le paroleleggereagli indici sequenziali dell'array
ARRAY variabile, a partire da zero
-DdelimContinua fino ail primo carattere di DELIM èleggere, piuttosto
di newline
-e usa Readline per ottenere la rigainuna shell interattiva
-iotesto usa TESTOcomeil testo inizialeperLinea di lettura
-nncharRestituzionedopo aver letto i caratteri NCHARS invece di aspettare
peruna nuova riga, ma rispetta un delimitatoreSemeno di
I caratteri NCHARS sonoleggereprima del delimitatore
-NncharRestituzionesolo dopo aver letto esattamente i caratteri NCHARS, a meno che
Si incontra EOF oleggere voltefuori, ignorando qualsiasi
delimitatore
-Pprompt restituisce la stringa PROMPT senza una nuova riga finale prima
tentare dileggere
-Rfarenon consentire alle barre rovesciate di sfuggire a nessun carattere
-Sfarenonbuttato fuoriingresso proveniente da un terminale
-Ttempo scadutotempofuori eRestituzionefallimentoSeacompletarelinea di
l'ingresso non èleggereentro TIMEOUT secondi. Il valore di
La variabile TMOUT è il timeout predefinito. TIMEOUT potrebbe essere un
numero frazionario. Se TIMEOUT è0,leggereritorna
subito, senza cercare dileggerequalsiasi dato, restituendo
solo successoSel'ingresso è disponibile su specificato
filedescrittore. IlUscitalo stato è maggiore di128
Seil timeout è superato
-ufdleggerea partire dalfiledescrittore FD invece dello standard input
Stato di uscita:
IlRestituzioneil codice è zero, a meno che non venga incontrata la fine del file,leggere voltefuori
(in quale Astuccioessoè maggiore di 128), un'assegnazione di variabile err
Catturare l'input dell'utente
Gli script bash interattivi non sono nulla senza catturare l'input dell'utente. L'integrato read fornisce metodi che l'input dell'utente può essere catturato all'interno di uno script bash.
Catturare una linea di input
Per catturare una riga di input, i nomi e le opzioni non sono richiesti da read. Quando NAME non è specificato, viene utilizzata una variabile denominata REPLY per memorizzare l'input dell'utente.
Comandi
{buttato fuori -n 'Digita qualcosa e premi invio: ';
leggere;
buttato fuorihai digitato${RISPONDI}
}
Produzione
Digita qualcosa e premi invio: qualcosa(nuova linea)Hai digitato qualcosa
Catturare una parola di input
Per catturare una parola di input, è richiesta l'opzione -d. Nel caso di una parola, metteremmo -d su uno spazio, leggeremo '-d'. Cioè quando l'utente preme la barra spaziatrice read caricherà REPLY con la parola.
Nota che quando l'opzione -d è impostata, il backspace non funziona come previsto. Per tornare indietro, durante il tentativo di catturare una parola di input, è possibile utilizzare l'opzione -e, leggere -e '-d '.
Comandi
buttato fuori -n 'Digita qualcosa e premi spazio: ';
leggere '-D ';
buttato fuori '';
buttato fuori 'Hai digitato${RISPONDI}'
}
Produzione
Digita qualcosa e premi spazio: qualcosa(spazio)Hai digitato qualcosa
Richiedi all'utente
Negli script bash interattivi, la richiesta di un utente potrebbe richiedere un messaggio per indicare all'utente quale input è previsto. Possiamo sempre farlo usando l'eco integrato. Tuttavia, risulta che esiste un'opzione che utilizza read.
Chiedi una parola all'utente
Nel catturare una parola di input, abbiamo usato echo per scrivere Digitare qualcosa e premere lo spazio: sullo standard output prima di leggere '-d'. L'opzione -p consente di visualizzare un messaggio prima della lettura dallo standard input.
Comandi
{leggere -P 'Digita qualcosa e premi spazio: ' '-D ';
buttato fuori '';
buttato fuori 'Hai digitato${RISPONDI}'
}
Produzione
Digita qualcosa e premi spazio: qualcosa(spazio)Hai digitato qualcosa
Richiedi un segreto all'utente
Quando si rileva l'input dell'utente senza che venga visualizzato nel terminale, l'opzione -s è utile. read -s -p consente di catturare e nascondere l'input dell'utente come segue.
Comandi
{leggere -S -P 'Digita qualcosa che prometto di tenerlo segreto: '
buttato fuori '';
buttato fuori 'Il tuo segreto è al sicuro con me';non settatoRISPONDERE ;
buttato fuori '${RISPONDI}'
}
Produzione
Scrivi qualcosa che prometto di tenerlo segreto:il tuo segreto è al sicuro con me
Funzioni che utilizzano read
Ecco alcuni esempi di funzioni in bash che utilizzano read e input standard
Concetto principale
Le funzioni che utilizzano read utilizzano parametri e input standard con pipe. L'input principale da elaborare, ad esempio le righe in un file, viene passato tramite l'input standard tramite una pipe. Altri input if-any e option vengono passati come parametri.
leggere -T 1NOME1 NOME2 ...leggereè unincorporato comando
-t 1 impedisce allo script bash di attendere indefinitamente la restituzione di una riga tramite l'input standard. Se lo standard input è inizialmente vuoto, la funzione ritorna con un codice di uscita 142 a significare che non è stata letta alcuna data entro il periodo di timeout impostato
NAME1 NAME2 sono nomi di variabili... possono essere elencati molti nomi di variabili
Ora che le basi sono impostate, vediamo come appaiono le funzioni familiari implementate usando read.
Funzione di join utilizzando read
Supponiamo di volere una funzione join che prenda un elenco di parole e restituisca un altro elenco di parole unite da un delimitatore. Ecco come possiamo implementare una funzione di join usando read.
sceneggiatura#!/bin/bash
## aderire
## versione 0.0.2 - correzione dei parametri di ricorsione
#################################################
aderire() { { Localelimitatore;limitatore='$ {1-}';Localedelimitatore;
delimitatore='$ {2-.}';}
Localemacchina
Localecdr
LocaleIFS
IFS='${indelimitatore}'
leggere -T 1auto cdr|| Restituzione
test '${cdr}' || { buttato fuori '${auto}';Restituzione;}
buttato fuori '${auto}${delimitatore}${cdr}' | ${NOMEFUNZIONE} '${indelimitatore}'
'${delimitatore}'
}
#################################################
## generato da create-stub2.sh v0.1.2
## il Lun, 17 Giu 2019 12:24:59 +0900
## vedere
#################################################
Fonte: join.sh
Riga di comando
Produzione
a.bRiga di comando
buttato fuoriun b| aderire | aderire. |Produzione
a|BFunzioni della mappa utilizzando read
Supponiamo di volere una funzione map che prenda una lista e ne restituisca un'altra contenente lo stesso numero di elementi che sono stati modificati da un'altra funzione. Ecco come possiamo implementare una funzione map usando read.
sceneggiatura#!/bin/bash
## carta geografica
## versione 0.0.1 - iniziale
#################################################
carta geografica() { { Localenome_funzione ;nome_funzione='$ {1}';}
Localemacchina
Localecdr
LocaleIFS
IFS='${indelimitatore- }'
leggere -T 1auto cdr|| Restituzione
test '$( dichiara -f ${nome_funzione} )' || Restituzione
test '${auto}' || { vero;Restituzione;}
${nome_funzione} ${auto}
buttato fuori '${cdr}' | ${NOMEFUNZIONE} '${nome_funzione}'
}
#################################################
## generato da create-stub2.sh v0.1.2
## il mar, 18 giu 2019 08:33:49 +0900
## vedere
#################################################
Fonte: map.sh
Comandi
buttato fuori {1..10} |mappa pow
Produzione
14
9
16
25
36
49
64
81
100
Funzione di filtro tramite lettura
Supponiamo di volere una funzione di filtro che prenda una lista e restituisca una sottolista di elementi che soddisfino le condizioni impostate da un'altra funzione. Ecco come possiamo implementare una funzione di filtro usando read.
sceneggiatura#!/bin/bash
## filtro
## versione 0.0.1 - iniziale
#################################################
filtro() { { Localenome_funzione ;nome_funzione='$ {1}';}
Localemacchina
Localecdr
LocaleIFS
IFS='${indelimitatore- }'
leggere -T 1auto cdr|| Restituzione
test '$( dichiara -f ${nome_funzione} )' || Restituzione
test '${auto}' || { vero;Restituzione;}
${nome_funzione} '${auto}' || buttato fuori -n '${auto}'
buttato fuori '${cdr}' | ${NOMEFUNZIONE} '${nome_funzione}'
}
#################################################
## generato da create-stub2.sh v0.1.2
## il mar, 18 giu 2019 13:19:54 +0900
## vedere
#################################################
Fonte: filtro.sh
Comandi
strano() { Locale -io io=$ {1};test !$((io% 2 )) -eq 1;}buttato fuori {1..10} |filtro dispari
Produzione
1 3 5 7 9Cicli usando read
I cicli che utilizzano read consentono di scorrere le righe di un file che deve essere generato o esiste già.
Loop di base durante la lettura per il lato sinistro (lhs)
Abbiamo un comando o una funzione (lhs) che può generare righe in un file che può essere eseguito in loop utilizzando read e un ciclo while.
Costruirelhs| mentre leggere
fare
vero
fatto
lhs è uncomandoche restituisce un elenco di righe
Comandi
seguito 5 | mentre leggereiofare
buttato fuori ${i}
fatto
Produzione
12
3
4
5
Loop di base durante la lettura per il lato destro (destro)
Abbiamo un file (rhs) con linee che possono essere ripetute usando read e un ciclo while.
Costruirementre leggere
fare
vero
fatto <rhs
rhs è unfilecontenente linee
Comandi
seguito 5 >rhsmentre leggereio
fare
buttato fuori ${i}
fatto <rhs
Produzione
1
2
3
4
5
Lhs personalizzato durante il ciclo usando read
Abbiamo un flusso di parole che vorremmo scorrere usando read.
Costruire(
IFS=''
lhs| mentre leggere
fare
vero
fatto
)
lhs è una lista di parole
Comandi
(IFS=''
buttato fuori {1..5} | mentre leggereio
fare
buttato fuori '${i}
fatto
)
Produzione
1 2 3 4 5Lettura da qualsiasi fd invece dello standard input
L'opzione integrata read spesso lasciata intatta è quella che ti permette di specificare da quale descrittore di file leggere, read -u FD. Per impostazione predefinita, FD è considerato input standard.
Concetto principale
Quando un file aperto vengono assegnati descrittori di file. Il reindirizzamento IO in bash consente di lasciare aperto un file con un descrittore di file specifico. Ci è permesso scrivere sul file, leggerlo e chiuderlo quando abbiamo finito.
_(){
gatto /sviluppo/nullo>miofifo;# vuoto myfifo
dirigere 3<miofifo;# apri il file myfifo come fd 3
buttato fuori 'Ciao mondo! - da fd 3' >miofifo;# scrivi a myfifo
leggere -u 3;# legge la riga da fd 3
dirigere 3> &-;# chiudi fd 3
buttato fuori ${RISPONDI} # riga di output letta da fd 3 prima della chiusura
}
_# Ciao mondo! da fd 3
Costruire un treno con descrittori di file e leggere -u FD
Solo per divertimento ho deciso di costruire un treno con descrittori di file e leggere -u FD. Ad ogni descrittore di file viene scritto un numero. Ciascun descrittore di file legge dal descrittore di file 1 di seguito e si aggiunge a se stesso.
Riga di comando
bashlinuxhint.com/costruire/test-read-fd.sh train10Produzione
inizializzazione fds...inizializzazione fd3...
fd3inizializzato
inizializzazione fd4...
fd4inizializzato
fds inizializzato
leggendo da fd3e4...
4 3
fds prima di pulire
0 1 2 3 4 5
pulire ...
pulizia fds...
fattoripulire fds
fds dopo la pulizia
0 1 2 3
Funzione di salto usando read -u FD
Se stai correndo
il tuo nome -aMINGW64_NT-10.0DESKTOP-XVVVVVV 2.7.0(0,307/5/3)
2017.-02-17 14:ventix86_64 Msys
bash --versione
GNUbash, versione 4.4.12(1)-pubblicazione(x86_64-pc-msys)
potrebbe essere possibile a causa di un bug implementare una funzione skip che salta la riga seguente in uno script bash al di fuori delle funzioni prima che venga letto il sorgente dello script. Nota che non funziona sulla maggior parte dei sistemi. Per esempio,
il tuo nome -aLinux 4.9.0-8-amd64#1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU/Linux
bash --versione
GNUbash, versione 4.4.12(1)-pubblicazione(x86_64-pc-linux-gnu)
salta non vola.
Funzione
Salta() { leggere -u 31;}
Comandi
Saltabuttato fuorilinea saltata
vero
Produzione
(vuoto)Linea di fondo
Il read integrato in bash fa di più che catturare l'input dell'utente. Può essere utilizzato in funzioni, loop e scambi tra descrittori di file utilizzati negli script bash. A volte l'esplorazione utilizzando descrittori di lettura e file può produrre uova di Pasqua.