ఈ వ్రాత-అప్ nodejs రీడ్‌లైన్ మాడ్యూల్‌తో వరుస ఇన్‌పుట్‌లను చదివే విధానాన్ని వివరిస్తుంది.
Node.js రీడ్‌లైన్ మాడ్యూల్‌తో వరుస ఇన్‌పుట్‌లను ఎలా చదవాలి?
వరుస ఇన్‌పుట్‌లు ఒకే సమయంలో అనేక ప్రశ్నలకు సమాధానాలను క్రమ పద్ధతిలో తీసుకొని నిల్వ చేస్తాయి. కొన్ని కోర్సుల్లో చేరేటప్పుడు లేదా వెరిఫికేషన్ సమయంలో ఈ వరుస ప్రశ్నలు ఎక్కువగా అడిగారు. Node.js రీడ్‌లైన్ మాడ్యూల్‌ని ఉపయోగించి వరుసగా ఇన్‌పుట్‌లను చదవడం కోసం కొన్ని ఉదాహరణలు క్రింద పేర్కొనబడ్డాయి.
ఉదాహరణ 1: రీడ్‌లైన్ మాడ్యూల్ మరియు అర్రేలను ఉపయోగించి వరుస ఇన్‌పుట్‌లను చదవడం
ఈ ఉదాహరణలో, వరుసగా ఇన్‌పుట్‌లు తీసుకోబడతాయి మరియు చదవబడతాయి “ రీడ్‌లైన్ ” మాడ్యూల్. ఇన్‌పుట్‌లు కన్సోల్‌లో ప్రదర్శించబడే శ్రేణిలో నిల్వ చేయబడతాయి:
స్థిరంగా రీడ్‌లైన్ = అవసరం ( 'రీడ్‌లైన్' ) ;
స్థిరంగా రీడ్‌లైన్ ఇంటర్ఫేస్ = రీడ్‌లైన్. ఇంటర్ఫేస్ సృష్టించండి ( {
ఇన్పుట్ : ప్రక్రియ. stdin ,
అవుట్పుట్ : ప్రక్రియ. stdout
} )
స్థిరంగా req0 = 'మే! నీ ముద్దుపేరు నాకు తెలుసా?' ;
స్థిరంగా req1 = 'మీ అభిరుచి ఏమిటి' ;
స్థిరంగా req2 = 'మీరు వినడానికి ఇష్టపడేది ఏమిటి' ;
స్థిరంగా req3 = 'మే! నీకు ఇష్టమైన వంటకం నాకు తెలుసా?' ;
స్థిరంగా req4 = 'మీరు ఎక్కడ నివసిస్తున్నారు?' ;
స్థిరంగా req5 = 'నీకు ఇష్టమైన రంగు ఏమిటి' ;
స్థిరంగా req6 = 'నీ ప్రాణ స్నెహితుడు ఎవరు' ;
స్థిరంగా reqArr = [ req0, req1, req2, req3, req4, req5, req6 ] ;
res వీలు = '' ;
స్థిరంగా reqData = x => {
ఉంటే ( x < reqArr. పొడవు ) {
రీడ్‌లైన్ ఇంటర్ఫేస్. ప్రశ్న ( reqArr [ x ] , ( ప్రతిస్పందన ) => {
res += ' \n ' + ప్రతిస్పందన ;
reqData ( x + 1 ) ;
} ) ;
} లేకపోతే {
కన్సోల్. లాగ్ ( `ధన్యవాదాలు కోసం నాతో పంచుకుంటున్నాను ! $ { res } ` ) ;
రీడ్‌లైన్ ఇంటర్ఫేస్. దగ్గరగా ( ) ;
}
} ;
reqData ( 0 ) ;
పై కోడ్ స్నిప్పెట్‌లో ఉపయోగించిన కోడ్ యొక్క వివరణ క్రింద పేర్కొనబడింది:
- దిగుమతి చేయడం ద్వారా ప్రారంభించండి ' రీడ్‌లైన్ 'మాడ్యూల్ మరియు దాని వస్తువును' అనే వేరియబుల్‌లో నిల్వ చేయండి రీడ్‌లైన్ ”.
- తరువాత, '' అనే ఇంటర్‌ఫేస్‌ను సృష్టించండి రీడ్‌లైన్ ఇంటర్ఫేస్ ' కొరకు ' రీడ్‌లైన్ 'ఆబ్జెక్ట్‌ను ఉపయోగించి ప్రామాణిక ఇన్పుట్ మరియు అవుట్పుట్ ప్రక్రియను చుట్టేస్తుంది' క్రియేట్ ఇంటర్ఫేస్() ” పద్ధతి. ఇది ప్రతి అభ్యర్థన మరియు ప్రతిస్పందనను ఒకే ఇన్పుట్ రీడబుల్ మరియు అవుట్పుట్ రైటబుల్ స్ట్రీమ్‌తో అనుబంధిస్తుంది ' ప్రక్రియ ”ఆస్తి.
- అప్పుడు, ఏడు సృష్టించు ' స్థిరంగా ”వరుసగా అడగవలసిన కొన్ని అభ్యర్థనలు లేదా ప్రశ్నలను నిల్వ చేయడానికి వేరియబుల్స్ టైప్ చేయండి. ఈ స్థిరాంకాలను '' అనే ఒకే శ్రేణిలో నిల్వ చేయండి reqArr ”.
- కొత్త ఖాళీ వేరియబుల్ సృష్టించు ' res ”, పేరు గల బాణం ఫంక్షన్‌ను నిర్వచించండి reqData 'మరియు' యొక్క ఒకే పరామితిని పాస్ చేయండి x ”.
- ఈ ఫంక్షన్ లోపల, 'ని ఉపయోగించండి ఉంటే అందించిన పరామితి యొక్క విలువ పొడవు కంటే తక్కువగా ఉందో లేదో తనిఖీ చేసే ప్రకటన reqArr ” లేదా.
- నిజం విషయంలో, ' ప్రశ్న() ” పద్ధతి ఇంటర్‌ఫేస్‌కు వర్తించబడుతుంది మరియు ఇది శ్రేణి నుండి ప్రతి అభ్యర్థనను అవుట్‌పుట్‌పై వరుసగా ప్రదర్శిస్తుంది. అప్పుడు అది వారి సంబంధిత అందించిన విలువలను ఆర్గ్యుమెంట్‌గా పాస్ చేస్తుంది.
- ఈ వాదనలు ఇప్పటికే సృష్టించబడిన శ్రేణిలో నిల్వ చేయబడ్డాయి ' res ”.
- అన్ని అభ్యర్థనలు కన్సోల్‌లో వరుసగా ప్రదర్శించబడిన తర్వాత, '' ఉంటే 'ప్రకటన తప్పు అవుతుంది మరియు 'లో లేకపోతే 'భాగం,' res ”అరే కన్సోల్‌పై ప్రదర్శించబడుతుంది.
- చివరగా, రీడ్‌లైన్ ఇంటర్ఫేస్ కూడా “ని ప్రారంభించడం ద్వారా మూసివేయబడుతుంది. దగ్గరగా() ” పద్ధతి. అలాగే, “ని పిలవండి reqData() 'ఫంక్షన్ మరియు ' యొక్క ప్రారంభ విలువను పాస్ చేయండి 0 ” ప్రశ్నను ఎగువ నుండి లేదా శ్రేణిలో అందుబాటులో ఉన్న మొదటి ప్రశ్న నుండి ప్రారంభించడానికి.
ఇప్పుడు, ఈ ఫైల్‌ని ఎంటర్ చేయడం ద్వారా అమలు చేయండి నోడ్ ' వెనుక కీవర్డ్ ' ఫైల్ పేరు 'టెర్మినల్‌లో:
నోడ్ వ్రాయండి
ప్రోగ్రామ్ వరుస ఇన్‌పుట్‌లను చదివిందని మరియు వాటన్నింటినీ ఒకేసారి అందించిందని అవుట్పుట్ చూపిస్తుంది:
ఉదాహరణ 2: రీడ్‌లైన్ మాడ్యూల్ మరియు రికర్సివ్ ఫంక్షన్‌ని ఉపయోగించి వరుస ఇన్‌పుట్‌లను చదవడం
పద్ధతిలో, పునరావృత విధానం 'తో ఉపయోగించబడుతుంది. రీడ్‌లైన్ ”ఇన్పుట్ స్ట్రీమ్‌లో వినియోగదారు నుండి వరుస ఇన్‌పుట్‌లను చదవడానికి Node.js మాడ్యూల్:
స్థిరంగా చదవండి = అవసరం ( 'రీడ్‌లైన్' ) ;
స్థిరంగా రీడ్‌లైన్ ఇంటర్ఫేస్ = చదవండి. ఇంటర్ఫేస్ సృష్టించండి ( {
ఇన్పుట్ : ప్రక్రియ. stdin ,
అవుట్పుట్ : ప్రక్రియ. stdout
} )
reqArr ఉంది = [ ]
ఫంక్షన్ reqData ( x ) {
ఉంటే ( x > 3 )
{
var సగటు = 0
కోసం ( reqArr లో j )
{
సగటు += సంఖ్య ( reqArr [ జె ] )
}
కన్సోల్. లాగ్ ( సగటు / 3 ) ;
}
లేకపోతే
{
రీడ్‌లైన్ ఇంటర్ఫేస్. ప్రశ్న ( 'నమోదు చేయండి' + x + '3లో సంఖ్య:' , ఫంక్షన్ ( ప్రతిస్పందన ) {
reqArr. పుష్ ( ప్రతిస్పందన )
reqData ( x + 1 )
} )
}
}
reqData ( 1 ) ;
పై కోడ్ యొక్క వివరణ బుల్లెట్ పాయింట్ల రూపంలో క్రింద వివరించబడింది:
- మొదట, దిగుమతి చేసుకోండి ' రీడ్‌లైన్ 'కొత్తగా సృష్టించబడిన' లో వ్రాయండి.js ” ఫైల్ చేసి మెథడ్ ఆబ్జెక్ట్‌ని ఒక “లో భద్రపరుచుకోండి చదవండి ” వేరియబుల్. 'ని నిల్వచేసే ఇంటర్‌ఫేస్‌ను సృష్టించండి రీడ్‌లైన్ 'ఇంటర్ఫేస్' ద్వారా సృష్టించబడింది క్రియేట్ ఇంటర్ఫేస్() ” పద్ధతి.
- ఇప్పుడు, ' పేరుతో ఖాళీ శ్రేణిని సృష్టించండి reqArr 'మరియు' నిర్వచించండి reqData() 'ఫంక్షన్ ఇది' అనే ఒకే పారామీటర్‌ను కూడా అంగీకరిస్తుంది x ”.
- అందించిన విలువ ' కంటే ఎక్కువగా ఉంటే ఫంక్షన్ మొదట తనిఖీ చేస్తుంది 3 ” లేదా. నిజం విషయంలో, ''లో వస్తున్న విలువలు తిరిగి పొందబడ్డాయి. x 'వేరియబుల్ శ్రేణిలో నిల్వ చేయబడుతుంది మరియు ' అనే సింగిల్ వేరియబుల్‌కు జోడించబడుతుంది సగటు ”.
- ఆ తరువాత, ' సగటు 'వేరియబుల్' ద్వారా విభజించబడింది 3 అనుమతించబడిన గరిష్ట సంఖ్య యొక్క పొడవుగా సగటును కనుగొనడానికి ' 3 ” మరియు ఫలితం కన్సోల్‌లో ప్రదర్శించబడుతుంది.
- మిగిలిన భాగంలో, ' ప్రశ్న() 'పద్ధతి ఇంటర్‌ఫేస్‌తో జతచేయబడింది' రీడ్‌లైన్ఇనెర్‌ఫేస్ ”. ఈ పద్ధతి కన్సోల్‌పై సందేశాన్ని ప్రదర్శిస్తుంది మరియు అనామక ఫంక్షన్‌ను నిర్వచిస్తుంది.
- ఫంక్షన్ వినియోగదారు ఇన్పుట్ డేటాను అంగీకరిస్తుంది మరియు ఆ డేటాను శ్రేణికి జోడిస్తుంది “ reqArr ”. ఇది '' విలువను కూడా నవీకరిస్తుంది x 'ప్రతిసారీ మరియు నవీకరించబడిన విలువను 'కి పంపుతుంది reqData() ” ఫంక్షన్. వినియోగదారు '' నుండి ప్రారంభించి మూడు కంటే తక్కువ విలువలను మాత్రమే ఇన్పుట్ చేస్తారని ఇది నిర్ధారిస్తుంది. 0 ”. చివరగా, 'ని పిలవండి reqData() 'ఎగ్జిక్యూషన్ ప్రాసెస్‌ను ప్రారంభించడానికి ఫంక్షన్.
ఇప్పుడు, 'ని కలిగి ఉన్న దీన్ని అమలు చేయండి వ్రాయండి.js 'ఫైల్' ఎంటర్ చేయడం ద్వారా నోడ్ ' వెనుక కీవర్డ్ ' ఫైల్ పేరు 'టెర్మినల్‌లో:
నోడ్ వ్రాయండిపునరావృత విధానం మరియు రీడ్‌లైన్ మాడ్యూల్ కలయికను ఉపయోగించి కన్సోల్‌లో వరుసగా ఇన్‌పుట్‌లు చదవబడతాయని మరియు వాటి సగటు ప్రదర్శించబడుతుందని అవుట్పుట్ నిర్ధారిస్తుంది:
ఈ గైడ్ Node.js రీడ్‌లైన్ మాడ్యూల్‌తో వరుస ఇన్‌పుట్‌లను చదివే విధానాన్ని వివరిస్తుంది.
ముగింపు
Node.js రీడ్‌లైన్ మాడ్యూల్‌తో వరుస ఇన్‌పుట్‌లను చదవడానికి, ముందుగా ఈ మాడ్యూల్‌ని వర్కింగ్ ఫైల్‌లో దిగుమతి చేయండి మరియు “ని ఉపయోగించి ఇంటర్‌ఫేస్‌ను సృష్టించండి క్రియేట్ ఇంటర్ఫేస్() ” పద్ధతి. ఈ ఇంటర్ఫేస్ ' ప్రశ్న() ” పద్ధతి. ఇది వినియోగదారుకు వరుసగా అభ్యర్థనలను పంపుతుంది మరియు అవసరాలకు అనుగుణంగా కొన్ని కార్యకలాపాలను వర్తింపజేయడానికి ప్రతి అభ్యర్థన యొక్క సంబంధిత ప్రతిస్పందనలను కాల్‌బ్యాక్ ఫంక్షన్‌కు పంపుతుంది. మీరు రీడ్‌లైన్ మాడ్యూల్‌ని ఉపయోగించి వరుసగా ఇన్‌పుట్‌లను చదివే ప్రక్రియను నేర్చుకున్నారు.