Comando di lettura Bash

Bash Read Command

Leggere o morire amici. Il comando read è importante tanto quanto i parametri posizionali e il comando echo. In quale altro modo puoi catturare l'input dell'utente, accettare password, scrivere funzioni, eseguire il ciclo e dare un'occhiata ai descrittori di file? Continuare a leggere.

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

buttato fuoriun b| aderire

Produzione

a.b

Riga di comando

buttato fuoriun b| aderire | aderire. |

Produzione

a|B

Funzioni 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

NS() { Locale -io io=$ {1};buttato fuori$((io** 2 ));}
buttato fuori {1..10} |mappa pow

Produzione

1
4
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 9

Cicli 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.

Costruire

lhs| mentre leggere
fare
vero
fatto
lhs è uncomandoche restituisce un elenco di righe

Comandi

seguito 5 | mentre leggereio
fare
buttato fuori ${i}
fatto

Produzione

1
2
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.

Costruire

mentre leggere
fare
vero
fatto <rhs

rhs è unfilecontenente linee

Comandi

seguito 5 >rhs
mentre 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 5

Lettura 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 train10

Produzione

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 -a
MINGW64_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 -a
Linux 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

Salta
buttato 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.