బఫర్ జావాస్క్రిప్ట్ “శ్రేణి”ని పోలి ఉంటుంది, కానీ ఒక తేడాతో అంటే దాని పరిమాణం సెట్ చేయబడిన తర్వాత మార్చబడదు. ఈ మాడ్యూల్ యొక్క సాధారణ లక్షణాలు రాయడం, చదవడం, పోల్చడం, కాపీ చేయడం, మార్చడం మరియు అనేక ఇతరమైనవి. పేర్కొన్న అన్ని కార్యకలాపాలు దాని అంతర్నిర్మిత పద్ధతులు మరియు లక్షణాలను ఉపయోగించి నిర్వహించబడతాయి.
ఈ బ్లాగ్ Node.jsలో బఫర్‌ను కాపీ చేయడం, పోల్చడం మరియు సంగ్రహించడం గురించి సంక్షిప్త వివరణను అందిస్తుంది.
'కాపీ' ఆపరేషన్‌తో ప్రారంభిద్దాం.
Node.jsలో బఫర్‌ని కాపీ చేయడం ఎలా?
ది ' Buffer.copy() ” పద్ధతి వినియోగదారులు ఒక బఫర్ వస్తువును మరొకదానికి కాపీ చేయడానికి అనుమతిస్తుంది. ఈ పద్ధతి ఫలితంగా కొత్తగా నవీకరించబడిన బఫర్‌ను అందిస్తుంది. ఈ పద్ధతి యొక్క పని క్రింది వాక్యనిర్మాణంపై ఆధారపడి ఉంటుంది:
buf. కాపీ ( టార్గెట్ బఫర్ [ , లక్ష్యం ప్రారంభం ] [ , మూలం ప్రారంభం ] [ , sourceEnd ] )
పై వాక్యనిర్మాణం ప్రకారం, “కాపీ()” పద్ధతి కింది పారామితులను పని చేస్తుంది:
- టార్గెట్ బఫర్ : ఇది బఫర్ ఆబ్జెక్ట్‌ని నిర్దేశిస్తుంది, దాని కంటెంట్‌ని మరొక బఫర్ ఆబ్జెక్ట్‌లోకి కాపీ చేయాలి.
- లక్ష్యం ప్రారంభం : ఇది ఆపరేషన్‌కి కాపీ ఎక్కడ ప్రారంభించబడుతుందో సూచిస్తుంది. దీని డిఫాల్ట్ విలువ '0'.
- మూలం ప్రారంభం : ఇది కాపీ ఆపరేషన్ ప్రారంభమయ్యే స్థానాన్ని సూచిస్తుంది. దీని డిఫాల్ట్ విలువ '0'.
- sourceEnd : ఇది కాపీ ఆపరేషన్ ఆగిపోయే ముగింపు స్థానాన్ని సూచిస్తుంది. దీని డిఫాల్ట్ విలువ 'బఫర్ ముగింపు'.
కింది కోడ్ బ్లాక్ “కాపీ()” పద్ధతి యొక్క ఆచరణాత్మక అమలును చూపుతుంది:
ఉంది buf1 = బఫర్. నుండి ( '123' ) ;ఉంది buf2 = బఫర్. కేటాయించండి ( 3 ) ;
buf1. కాపీ ( buf2 ) ;
కన్సోల్. లాగ్ ( 'బఫర్2 యొక్క కంటెంట్:' + buf2. స్ట్రింగ్ ( ) ) ;
పై కోడ్ లైన్లలో:
- ది ' నుండి () ” పద్ధతి పేర్కొన్న పూర్ణాంకాలతో బఫర్ వస్తువును సృష్టిస్తుంది.
- ది ' కేటాయించండి() ” పద్ధతి కేటాయించిన పరిమాణంలో బఫర్ వస్తువును నిర్మిస్తుంది.
- ది ' కాపీ() ” పద్ధతి మొదటి బఫర్‌లో ముందుగా ఉన్న కంటెంట్‌ను రెండవ బఫర్ ఆబ్జెక్ట్‌లోకి కాపీ చేస్తుంది.
- ది ' toString() ” పద్ధతి కాపీ చేసిన కంటెంట్‌ను స్ట్రింగ్ ఫార్మాట్‌లోకి డీకోడ్ చేస్తుంది (మానవ-రీడబుల్) ఆపై దానిని ఉపయోగించి కన్సోల్‌లో ప్రదర్శిస్తుంది console.log() ” పద్ధతి.
అవుట్‌పుట్
“.js” ఫైల్‌ను ప్రారంభించడానికి ఇచ్చిన ఆదేశాన్ని అమలు చేయండి:
ఒక బఫర్ యొక్క కంటెంట్ రెండవ బఫర్‌లోకి కాపీ చేయబడిందని చూడవచ్చు:
Node.jsలో బఫర్‌ని ఎలా పోల్చాలి?
Node.jsలో బఫర్‌ను పోల్చడానికి, అంతర్నిర్మిత “ని ఉపయోగించండి Buffer.compare() ” పద్ధతి. ఈ పద్ధతి రెండు బఫర్‌లను పోలుస్తుంది మరియు నిర్వచించిన తేడాలను చూపే దాని ప్రామాణిక అవుట్‌పుట్‌గా సంఖ్యా విలువను అందిస్తుంది. ఈ సంఖ్యా విలువలు వాటి నిర్వచించిన తేడాలతో పాటు క్రింద ఇవ్వబడ్డాయి:
- 0 : బఫర్‌లు సమానంగా ఉంటాయి.
- 1 : బఫర్ 2 కంటే బఫర్ 1 ఎక్కువ.
- -1 : బఫర్ 1 బఫర్ 2 కంటే తక్కువగా ఉంది.
వాక్యనిర్మాణం
buf. సరిపోల్చండి ( ఇతర బఫర్ ) ;“compare()” పద్ధతి యొక్క వాక్యనిర్మాణం ఒక ముఖ్యమైన వాదనకు మాత్రమే మద్దతు ఇస్తుంది “ ఇతర బఫర్ ”.
పైన నిర్వచించిన సింటాక్స్‌ని ఆచరణాత్మకంగా ఉపయోగించుకుందాం:
ఉంది buf1 = బఫర్. నుండి ( 'Linux' ) ;ఉంది buf2 = బఫర్. నుండి ( 'Linux' ) ;
ఉంది x = బఫర్. సరిపోల్చండి ( buf1 , buf2 ) ;
కన్సోల్. లాగ్ ( x ) ;
ఉంది buf1 = బఫర్. నుండి ( 'ఎల్' ) ;
ఉంది buf2 = బఫర్. నుండి ( 'H' ) ;
ఉంది x = బఫర్. సరిపోల్చండి ( buf1 , buf2 ) ;
కన్సోల్. లాగ్ ( x ) ;
ఉంది buf1 = బఫర్. నుండి ( 'H' ) ;
ఉంది buf2 = బఫర్. నుండి ( 'ఎల్' ) ;
ఉంది x = బఫర్. సరిపోల్చండి ( buf1 , buf2 ) ;
కన్సోల్. లాగ్ ( x ) ;
పై కోడ్ లైన్లలో:
- ది ' నుండి () ” పద్ధతులు పేర్కొన్న స్ట్రింగ్‌తో బహుళ బఫర్ వస్తువులను సృష్టిస్తాయి.
- ది ' సరిపోల్చండి() ” పద్ధతి దాని వాదనగా ఆమోదించబడిన పేర్కొన్న బఫర్ వస్తువులను పోలుస్తుంది.
- ది ' console.log() ” పద్ధతి కన్సోల్‌లో “compare()” పద్ధతి యొక్క ఫలితాన్ని ప్రదర్శిస్తుంది.
అవుట్‌పుట్
దిగువ ఆదేశాన్ని ఉపయోగించి “.js” ఫైల్‌ను అమలు చేయండి:
ఫలిత అవుట్‌పుట్‌గా ప్రదర్శించబడే సంఖ్యా విలువలు నిర్వచించిన వ్యత్యాసాన్ని స్పష్టంగా చూపుతాయి:
ఇప్పుడు, Node.jsలో బఫర్‌ల కలయికకు వెళ్లండి.
Node.jsలో బఫర్‌లను ఎలా కలపాలి?
ది ' concat() ” పద్ధతి ఒకటి కంటే ఎక్కువ బఫర్‌లలో చేరడానికి సహాయపడుతుంది. ఈ పద్ధతి శ్రేణిలోని అన్ని లక్ష్య బఫర్‌లను వాటి కంటెంట్‌లను విలీనం చేయడం ద్వారా ఒక బఫర్ ఆబ్జెక్ట్‌గా కలుస్తుంది.
వాక్యనిర్మాణం
బఫర్. కలుస్తుంది ( అరె , పొడవు ] )పై వాక్యనిర్మాణం క్రింది రెండు పారామితులపై పని చేస్తుంది:
- అరె : ఇది వినియోగదారులు సంగ్రహించాలనుకుంటున్న బఫర్‌ల శ్రేణిని నిర్దేశిస్తుంది.
- పొడవు : ఇది సంగ్రహించిన బఫర్ యొక్క పొడవును సూచిస్తుంది.
కింది కోడ్ స్నిప్పెట్ నిర్వచించిన “concat()” పద్ధతిని ఉపయోగించడం ద్వారా ఇచ్చిన బఫర్‌లను ఆచరణాత్మకంగా సంగ్రహిస్తుంది:
ఉంది buf1 = బఫర్. నుండి ( ' \n Linux \n ' ) ;ఉంది buf2 = బఫర్. నుండి ( 'వెబ్‌సైట్' ) ;
ఉంది buf3 = బఫర్. కలుస్తుంది ( [ buf1 , buf2 ] ) ;
కన్సోల్. లాగ్ ( 'బఫర్3 యొక్క కంటెంట్:' + buf3. స్ట్రింగ్ ( ) ) ;
పై కోడ్ స్నిప్పెట్‌లో:
- ది ' నుండి () ” పద్ధతులు వరుసగా పేర్కొన్న స్ట్రింగ్‌తో రెండు బఫర్ ఆబ్జెక్ట్‌లను సృష్టిస్తాయి.
- ది ' concat() ”పద్ధతి శ్రేణిలో పేర్కొన్న బఫర్‌ను బఫర్ ఆబ్జెక్ట్‌గా జాయింట్ చేస్తుంది.
- ది ' toString() ” పద్దతి సంగ్రహించబడిన బఫర్‌లోని కంటెంట్‌ను స్ట్రింగ్ ఫార్మాట్‌లోకి డీకోడ్ చేస్తుంది (మానవ-రీడబుల్) ఆపై దానిని ఉపయోగించి కన్సోల్‌లో ప్రదర్శిస్తుంది console.log() ” పద్ధతి.
అవుట్‌పుట్
ఇప్పుడు, “.js” ఫైల్‌ను అమలు చేయడానికి దిగువ పేర్కొన్న ఆదేశాన్ని అమలు చేయండి:
అవుట్‌పుట్ కొత్త బఫర్ ఆబ్జెక్ట్‌ను ప్రదర్శిస్తుంది, ఇది పేర్కొన్న బఫర్‌ల సంయోగ ఫలితంలో సృష్టించబడుతుంది:
Nodejsలో బఫర్‌ను కాపీ చేయడం, సరిపోల్చడం మరియు కలపడం ఎలాగో మేము కవర్ చేసాము.
ముగింపు
Nodejsలో బఫర్‌ను కాపీ చేయడానికి, “ని ఉపయోగించండి Buffer.copy() 'మరియు పోలిక ప్రయోజనాల కోసం వర్తించు' Buffer.compare() ” పద్ధతి. అదనంగా, బఫర్‌లను కలపడానికి, “ని ఉపయోగించండి Buffer.concat() ” పద్ధతి. ఈ పద్ధతులన్నీ ముందే నిర్వచించబడినవి, సరళమైనవి మరియు ఉపయోగించడానికి సులభమైనవి. ఈ పోస్ట్ Node.jsలో బఫర్‌ను కాపీ చేయడం, పోల్చడం మరియు సంగ్రహించడం గురించి సంక్షిప్త వివరణను అందించింది.