Comment lire des entrées consécutives avec le module Node.js Readline ?

Le ' lire la ligne « Le module Node.js est idéal à utiliser dans des scénarios où plusieurs entrées consécutives doivent être prises par l'utilisateur final. Ce module encapsule la sortie et l'entrée standard, ce qui permet de lire le flux d'entrée ligne par ligne sans ignorer les données reçues. Avec l’arrivée du « lire la ligne ', la procédure de récupération des données en temps réel devient beaucoup plus simple et rapide.

Cet article explique la procédure pour lire les entrées consécutives avec le module nodejs readline.

Comment lire des entrées consécutives avec le module Node.js Readline ?

Les entrées consécutives sont celles qui prennent et stockent les réponses à plusieurs questions en même temps et de manière séquentielle. Ces requêtes consécutives sont principalement posées lors de l'inscription à certains cours ou au moment de la vérification. Quelques exemples sont indiqués ci-dessous pour la mise en œuvre de la lecture d'entrées consécutives à l'aide du module readline de Node.js.

Exemple 1 : Lecture d'entrées consécutives à l'aide du module Readline et des tableaux

Dans cet exemple, les entrées consécutives sont prises et lues à l'aide du ' lire la ligne module '. Les entrées sont stockées dans le tableau d'où elles sont affichées sur la console :

const lire la ligne = exiger ( 'lire la ligne' ) ;

const readlineInterface = lire la ligne. créer une interface ( {

saisir : processus. entrée standard ,

sortir : processus. sortie standard

} )

const req0 = 'Peut! Je connais ton surnom ? ;

const req1 = « Quel est votre passe-temps » ;

const req2 = 'Qu'est-ce que tu aimes écouter' ;

const req3 = 'Peut! Je connais ton plat préféré ? ;

const req4 = 'Où habites-tu?' ;

const req5 = 'Quelle est votre couleur préférée' ;

const req6 = 'Qui est ton meilleur ami' ;

const reqArr = [ req0, req1, req2, req3, req4, req5, req6 ] ;

laissez res = '' ;

const reqData = X => {

si ( X < reqArr. longueur ) {

readlineInterface. question ( reqArr [ X ] , ( demandeRéponse ) => {

rés += ' \n ' + demandeRéponse ;

reqData ( X + 1 ) ;

} ) ;

} autre {

console. enregistrer ( `Merci pour partager avec moi ! $ { rés } ` ) ;

readlineInterface. fermer ( ) ;

}

} ;

reqData ( 0 ) ;

La description du code utilisé dans l'extrait de code ci-dessus est indiquée ci-dessous :

Commencez par importer le « lire la ligne » module et stocke son objet dans une variable nommée « lire la ligne ».
Ensuite, créez une interface nommée « readlineInterface ' pour le ' lire la ligne ' objet qui encapsule le processus d'entrée et de sortie standard à l'aide du ' créerInterface() ' méthode. Il associe également chaque demande et réponse à un seul flux d'entrée lisible et de sortie inscriptible à l'aide du « processus ' propriété.
Ensuite, créez sept ' const ' Tapez des variables pour stocker certaines demandes ou questions qui doivent être posées consécutivement. Stockez ces constantes dans le tableau unique nommé « reqArr ».
Créez une nouvelle variable vide ' rés », définissez une fonction flèche nommée « reqData » et passez le seul paramètre de « X ».
Dans cette fonction, utilisez le ' si ' Instruction qui vérifie si la valeur du paramètre fourni est inférieure à la longueur de ' reqArr ' ou non.
Dans le cas de vrai, le « question() 'La méthode est appliquée à l'interface et affiche chaque requête du tableau sur la sortie de manière séquentielle. Ensuite, il transmet les valeurs fournies correspondantes comme argument.
Ces arguments sont stockés dans le tableau déjà créé « rés ».
Une fois que toutes les requêtes sont affichées séquentiellement sur la console, la condition « si » la déclaration devient fausse et dans le « autre ' partie, le ' rés 'Le tableau s'affiche sur la console.
Enfin, l'interface readline se ferme également en appelant le ' fermer() ' méthode. Invoquez également le « reqData() ' fonction et passez une valeur initiale de ' 0 » pour commencer la question par le haut ou par la première question disponible dans le tableau.

Maintenant, exécutez ce fichier contenant en entrant le « nœud ' mot-clé derrière le ' nom de fichier » sur le terminal :

écriture du nœud

La sortie montre que le programme a lu les entrées consécutives et les a toutes renvoyées en même temps :

Exemple 2 : Lecture d'entrées consécutives à l'aide du module Readline et de la fonction récursive

Dans la méthode, l’approche récursive est utilisée avec le « lire la ligne » Module Node.js pour lire les entrées consécutives de l'utilisateur sur le flux d'entrée :

const lire = exiger ( 'lire la ligne' ) ;
const readlineInterface = lire. créer une interface ( {
saisir : processus. entrée standard ,
sortir : processus. sortie standard
} )
était requisArr = [ ]
fonction reqData ( X ) {
si ( X > 3 )
{
moyenne var = 0
pour ( j dans reqArr )
{
moyenne += Nombre ( reqArr [ j ] )
}
console. enregistrer ( moyenne / 3 ) ;
}
autre
{
readlineInterface. question ( 'Entrer le ' + X + ' nombre sur 3 :' , fonction ( demandeRéponse ) {
reqArr. pousser ( demandeRéponse )
reqData ( X + 1 )
} )
}
}

reqData ( 1 ) ;

L'explication du code ci-dessus est décrite ci-dessous sous forme de puces :

Tout d’abord, importez le « lire la ligne ' dans un nouveau créé ' écrire.js ' et stockez l'objet méthode dans un ' lire » variables. Créez une interface qui stocke le ' lire la ligne ' interface qui est créée via l'interface ' créerInterface() ' méthode.
Maintenant, créez un tableau vide nommé « reqArr » et définir le « reqData() ' fonction qui accepte également un seul paramètre nommé ' X ».
La fonction vérifie d'abord si la valeur fournie est supérieure à ' 3 ' ou non. Dans le cas de true, les valeurs récupérées qui arrivent dans le « X 'La variable est stockée dans un tableau et ajoutée à la variable unique nommée' moyenne ».
Après cela, le « moyenne ' La variable est divisée par ' 3 ' pour trouver la moyenne car la longueur du nombre maximum autorisé est ' 3 » et le résultat s’affiche sur la console.
Dans la partie else, le « question() ' La méthode est jointe à l'interface ' readlineInerface ». Cette méthode affiche le message sur la console et définit une fonction anonyme.
La fonction accepte les données d'entrée de l'utilisateur et ajoute ces données au tableau ' reqArr ». Il met également à jour la valeur de « X ' à chaque fois et transmet la valeur mise à jour au ' reqData() ' fonction. Cela garantira que l'utilisateur ne saisit que des valeurs inférieures à trois à partir de ' 0 ». Enfin, invoquez le « reqData() 'fonction pour démarrer le processus d'exécution.

Maintenant, exécutez ceci contenant le ' écrire.js ' en saisissant le ' nœud ' mot-clé derrière le ' nom de fichier » sur le terminal :

écriture du nœud

La sortie confirme que les entrées consécutives sont lues et leur moyenne est affichée sur la console en utilisant la combinaison de l'approche récursive et du module readline :

Ce guide explique la procédure pour lire les entrées consécutives avec le module readline de Node.js.

Conclusion

Pour lire les entrées consécutives avec le module readline de Node.js, importez d'abord ce module dans un fichier de travail et créez une interface à l'aide du ' créerInterface() ' méthode. Cette interface invoque le « question() ' méthode. Il envoie des requêtes à l'utilisateur consécutivement et transmet les réponses correspondantes de chaque requête à la fonction de rappel pour appliquer certaines opérations en fonction des exigences. Vous avez appris le processus de lecture d'entrées consécutives à l'aide du module readline.

Comment lire des entrées consécutives avec le module Node.js Readline ?