Qu'est-ce qui est lu ?
Read est une commande intégrée de bash qui lit le contenu d'une ligne dans une variable. Il permet le fractionnement de mots lié à la variable shell spéciale IFS. Il est principalement utilisé pour capturer les entrées utilisateur, mais peut être utilisé pour implémenter des fonctions prenant des entrées à partir d'une entrée standard.
Aide de la commande intégrée de lecture Bash
Avant de nous plonger dans l'utilisation de la commande read dans les scripts bash, voici comment obtenir de l'aide. Vous devriez y voir toutes les options disponibles pour la commande read ainsi que les descriptions que nous essaierons de couvrir dans les exemples.
Ligne de commande
aider lire
Sortir
lire:lire [-ers] [-un tableau] [-d partager] [-je Texte] [-n nchars] [-N nchars]
[-p invite] [-t délai d'attente] [-u fd] [Nom ...]
Lire une ligne de l'entrée standard etdiviserdans les champs.
Lit une seule ligne depuis l'entrée standard ou depuisdéposerdescripteur FD
siles-ul'option est fournie. La ligne estdiviserdans les champscommeavec mot
fractionnement, et le premier mot est attribué au premier NOM, le second
mot au deuxième NOM, et ainsi de suite, avec tous les mots restants attribués à
lesdernierNOM. Seuls les personnages trouvésdans $IFSsont reconnuscommemot
délimiteurs.
Si aucun nom n'est fourni, la lignelireest stockédansla variable REPONSE.
Options :
-àtableau assigner les motslireaux indices séquentiels du tableau
variable ARRAY, commençant à zéro
-rédécaperContinuez jusqu'àle premier caractère de DELIM estlire, plutôt
que la nouvelle ligne
-e utilise Readline pour obtenir la lignedansune coquille interactive
-jetexte utiliser TEXTEcommele texte initialpourLigne de lecture
-nncharsreveniraprès avoir lu les caractères NCHARS plutôt que d'attendre
pourune nouvelle ligne, mais respectez un délimiteursimoins que
Les personnages NCHARS sontlireavant le délimiteur
-Nncharsrevenirqu'après avoir lu exactement les caractères NCHARS, à moins que
EOF est rencontré oulire foisdehors, en ignorant tout
délimiteur
-pprompt affiche la chaîne PROMPT sans retour à la ligne avant
essayer delire
-rfairene pas autoriser les barres obliques inverses à échapper à des caractères
-sfairene paschassèrententrée provenant d'un terminal
-ttemps libretempsdehors etreveniréchecsiàAchevéeligne de
l'entrée n'est pasliredans les secondes TIMEOUT. La valeur de la
La variable TMOUT est le délai d'attente par défaut. TIMEOUT peut être un
nombre fractionnaire. Si TIMEOUT est0,lireRetour
immédiatement, sans essayer deliretoutes les données, retour
succès seulementsil'entrée est disponible sur le
déposerdescripteur. Lessortirle statut est supérieur à128
sile délai d'attente est dépassé
-ufdlirededéposerdescripteur FD au lieu de l'entrée standard
État de sortie :
Lesrevenirle code est zéro, à moins que la fin du fichier ne soit rencontrée,lire foisdehors
(dans lequel Casceest supérieur à 128), une erreur d'affectation de variable
Capturer l'entrée de l'utilisateur
Les scripts bash interactifs ne sont rien sans capturer les entrées de l'utilisateur. La fonction intégrée read fournit des méthodes selon lesquelles l'entrée de l'utilisateur peut être interceptée dans un script bash.
Attraper une ligne d'entrée
Pour attraper une ligne d'entrée, les NOMS et les options ne sont pas requis par read. Lorsque NAME n'est pas spécifié, une variable nommée REPLY est utilisée pour stocker l'entrée utilisateur.
Commandes
{chassèrent -n « Tapez quelque chose et appuyez sur Entrée : »;
lire;
chassèrentvous avez tapé${REPLY}
}
Sortir
Tapez quelque chose et appuyez sur Entrée : quelque chose(nouvelle ligne)Vous avez tapé quelque chose
Attraper un mot d'entrée
Pour capturer un mot d'entrée, l'option -d est requise. Dans le cas d'un mot, nous définirions -d sur un espace, lisez '-d'. C'est à ce moment-là que l'utilisateur appuie sur la barre d'espacement read chargera REPLY avec le mot.
Notez que lorsque l'option -d est définie, le retour arrière ne fonctionne pas comme prévu. Pour revenir en arrière, tout en essayant d'attraper un mot d'entrée, l'option -e peut être utilisée, lisez -e '-d '.
Commandes
chassèrent -n « Tapez quelque chose et appuyez sur espace : »;
lire '-ré ';
chassèrent '';
chassèrent 'Vous avez tapé${REPLY}'
}
Sortir
Tapez quelque chose et appuyez sur espace : quelque chose(espacer)Vous avez tapé quelque chose
Inviter l'utilisateur
Dans les scripts bash interactifs, l'invite d'un utilisateur peut nécessiter un message pour indiquer à l'utilisateur quelle entrée est attendue. Nous pouvons toujours accomplir cela en utilisant la fonction echo intégrée. Cependant, il s'avère qu'il existe une option utilisant read.
Demander un mot à l'utilisateur
En attrapant un mot d'entrée, nous avons utilisé echo pour écrire Tapez quelque chose et appuyez sur espace : sur la sortie standard avant de lire « -d ». L'option -p permet d'afficher un message avant la lecture depuis l'entrée standard.
Commandes
{lire -p « Tapez quelque chose et appuyez sur espace : » '-ré ';
chassèrent '';
chassèrent 'Vous avez tapé${REPLY}'
}
Sortir
Tapez quelque chose et appuyez sur espace : quelque chose(espacer)Vous avez tapé quelque chose
Demander à l'utilisateur un secret
Lors de la capture d'entrées utilisateur sans qu'elles ne s'affichent dans le terminal, l'option -s est pratique. read -s -p vous permet d'attraper et de masquer les entrées de l'utilisateur comme suit.
Commandes
{lire -s -p « Tapez quelque chose que je promets de garder secret : »
chassèrent '';
chassèrent 'Ton secret est en sécurité avec moi';désarméRÉPONDRE ;
chassèrent '${REPLY}'
}
Sortir
Tapez quelque chose que je promets de garder secret :Ton secret est en sécurité avec moi
Fonctions utilisant read
Voici des exemples de fonctions dans bash qui utilisent la lecture et l'entrée standard
Concept de base
Les fonctions utilisant read utilisent l'entrée et les paramètres standard canalisés. Les entrées principales à traiter, telles que les lignes d'un fichier, sont transmises via l'entrée standard via un tube. Les autres entrées if-any et option sont transmises en tant que paramètres.
lire -t 1NOM1 NOM2 ...lireest unintégré commander
-t 1 empêche le script bash d'attendre indéfiniment qu'une ligne soit renvoyée via l'entrée standard. Si l'entrée standard est initialement vide, la fonction retourne avec un code de sortie de 142 signifiant qu'aucune date n'a été lue dans le délai d'attente défini
NAME1 NAME2 sont des noms de variables... de nombreux noms de variables peuvent être répertoriés
Maintenant que les bases sont posées, voyons à quoi ressemblent les fonctions familières implémentées à l'aide de read.
Rejoindre la fonction en utilisant read
Supposons que nous voulions une fonction de jointure qui prend une liste de mots et renvoie une autre liste de mots joints par un délimiteur. Voici comment nous pouvons implémenter une fonction de jointure en utilisant read.
Scénario#!/bin/bash
## rejoindre
## version 0.0.2 - correction des paramètres de récursivité
#####################################################
rejoindre() { { locallimiteur;limiteur='{1-} $';localdélimiteur;
délimiteur='{2-.} $';}
localauto
localcdr
localIFS
IFS='${indelimiter}'
lire -t 1cdr de voiture|| revenir
test '${cdr}' || { chassèrent '${voiture}';revenir;}
chassèrent '${voiture}${outdelimiter}${cdr}' | ${FUNCNAME} '${indelimiter}'
'${outdelimiter}'
}
#####################################################
## généré par create-stub2.sh v0.1.2
## on Mon, 17 Jun 2019 12:24:59 +0900
## voir
#####################################################
La source: rejoindre.sh
Ligne de commande
Sortir
un BLigne de commande
chassèrentun B| rejoindre | rejoindre. |Sortir
à|bMapper les fonctions à l'aide de read
Supposons que nous voulions une fonction map qui prenne une liste et renvoie une autre liste contenant le même nombre d'éléments qui sont modifiés par une autre fonction. Voici comment nous pouvons implémenter une fonction map en utilisant read.
Scénario#!/bin/bash
## carte
## version 0.0.1 - initiale
#####################################################
carte() { { localnom_fonction ;nom_fonction='$ {1}';}
localauto
localcdr
localIFS
IFS='${indelimiter- }'
lire -t 1cdr de voiture|| revenir
test '$( declare -f ${function_name} )' || revenir
test '${voiture}' || { vrai;revenir;}
${function_name} ${voiture}
chassèrent '${cdr}' | ${FUNCNAME} '${function_name}'
}
#####################################################
## généré par create-stub2.sh v0.1.2
## le mar. 18 juin 2019 08:33:49 +0900
## voir
#####################################################
La source: map.sh
Commandes
chassèrent {1..dix} |carte pow
Sortir
14
9
16
25
36
49
64
81
100
Fonction de filtrage à l'aide de read
Supposons que nous voulions une fonction de filtrage qui prenne une liste et renvoie une sous-liste d'éléments satisfaisant les conditions définies par une autre fonction. Voici comment nous pouvons implémenter une fonction de filtre en utilisant read.
Scénario#!/bin/bash
## filtre
## version 0.0.1 - initiale
#####################################################
filtre() { { localnom_fonction ;nom_fonction='$ {1}';}
localauto
localcdr
localIFS
IFS='${indelimiter- }'
lire -t 1cdr de voiture|| revenir
test '$( declare -f ${function_name} )' || revenir
test '${voiture}' || { vrai;revenir;}
${function_name} '${voiture}' || chassèrent -n '${voiture}'
chassèrent '${cdr}' | ${FUNCNAME} '${function_name}'
}
#####################################################
## généré par create-stub2.sh v0.1.2
## le mar. 18 juin 2019 13:19:54 +0900
## voir
#####################################################
La source: filtre.sh
Commandes
impair() { local -je je=$ {1};test !$((je% 2 )) -eq 1;}chassèrent {1..dix} |filtre impair
Sortir
1 3 5 7 9Boucles utilisant read
Les boucles utilisant read permettent de parcourir les lignes d'un fichier qui doit être généré ou qui existe déjà.
Boucle de lecture basique pour le côté gauche (gauche)
Nous avons une commande ou une fonction (lhs) qui peut générer des lignes dans un fichier qui peuvent être parcourues en boucle en utilisant read et une boucle while.
Constructionlhs| tandis que lire
faire
vrai
terminé
lhs est uncommanderqui renvoie une liste de lignes
Commandes
seq 5 | tandis que lirejefaire
chassèrent ${i}
terminé
Sortir
12
3
4
5
Boucle de lecture basique pour le côté droit (droite)
Nous avons un fichier (rhs) avec des lignes qui peuvent être parcourues en boucle en utilisant read et une boucle while.
Constructiontandis que lire
faire
vrai
terminé <rhs
rhs est undéposercontenant des lignes
Commandes
seq 5 >rhstandis que lireje
faire
chassèrent ${i}
terminé <rhs
Sortir
1
2
3
4
5
Boucle personnalisée lhs while en utilisant read
Nous avons un flux de mots que nous aimerions parcourir en boucle en utilisant read.
Construction(
IFS=''
lhs| tandis que lire
faire
vrai
terminé
)
lhs est une liste de mots
Commandes
(IFS=''
chassèrent {1..5} | tandis que lireje
faire
chassèrent '${i}
terminé
)
Sortir
1 2 3 4 5Lecture à partir de n'importe quel fd au lieu de l'entrée standard
L'option intégrée read souvent laissée intacte est celle qui vous permet de spécifier à partir de quel descripteur de fichier lire, read -u FD. Par défaut, FD est considéré comme une entrée standard.
Concept de base
Lorsqu'un fichier est ouvert, des descripteurs de fichier sont attribués. La redirection IO dans bash permet de laisser un fichier ouvert avec un descripteur de fichier spécifique. Nous sommes autorisés à écrire dans le fichier, à le lire et à le fermer lorsque nous avons terminé.
_(){
chat /développeur/nul>myfifo;# myfifo vide
l'exécutif 3<myfifo;# ouvrir le fichier myfifo en tant que fd 3
chassèrent 'Bonjour le monde! - à partir de fd 3' >myfifo;# écrire à myfifo
lire -u 3;# lire la ligne de fd 3
l'exécutif 3> &-;# fermer fd 3
chassèrent ${REPLY} # ligne de sortie lue à partir de fd 3 avant la fermeture
}
_# Bonjour le monde! de fd 3
Construire un train avec des descripteurs de fichiers et lire -u FD
Juste pour m'amuser, j'ai décidé de construire un train avec des descripteurs de fichiers et de lire -u FD. Pour chaque descripteur de fichier, un numéro est écrit. Chaque descripteur de fichier lit à partir du descripteur de fichier 1 ci-dessous et s'ajoute à lui-même.
Ligne de commande
frapperlinuxhint.com/construire/test-lecture-fd.sh traindixSortir
initialisation de fds ...initialisation de fd3...
fd3initialisé
initialisation de fd4...
fd4initialisé
fds initialisé
lecture de fd3et4...
4 3
fds avant de nettoyer
0 1 2 3 4 5
nettoyer ...
nettoyage de fds...
terminénettoyage de fds
fds après nettoyage
0 1 2 3
Fonction de saut en utilisant read -u FD
Si vous courez
ton nom -àMINGW64_NT-10,0BUREAU-XVVVVVV 2.7.0(0,307/5/3)
2017.-02-17 14:vingtx86_64 Msys
frapper --version
GNOUfrapper, version 4.4.12(1)-Libération(x86_64-pc-msys)
il peut être possible en raison d'un bogue d'implémenter une fonction skip qui saute la ligne suivante dans un script bash en dehors des fonctions avant que la source du script ne soit lue. Notez qu'il ne fonctionne pas sur la plupart des systèmes. Par exemple,
ton nom -àLinux 4.9.0-8-amd64#1 Debian SMP 4.9.144-3.1 (2019-02-19) x86_64 GNU/Linux
frapper --version
GNOUfrapper, version 4.4.12(1)-Libération(x86_64-pc-linux-gnu)
sauter ne vole pas.
Fonction
sauter() { lire -u 31;}
Commandes
sauterchassèrentligne sautée
vrai
Sortir
(vide)En bout de ligne
La fonction read intégrée dans bash fait plus que capturer les entrées de l'utilisateur. Il peut être utilisé dans des fonctions, des boucles et des échanges entre descripteurs de fichiers utilisés dans les scripts bash. À l'occasion, l'exploration à l'aide de descripteurs de lecture et de fichier peut produire des œufs de Pâques.