జావాస్క్రిప్ట్ నాన్-ప్రిమిటివ్ డేటా రకంతో వస్తుంది “ వస్తువు ” ఇది ఆదిమ (అంతర్నిర్మిత) డేటా రకాల సహాయంతో తీసుకోబడింది. జావాస్క్రిప్ట్ సభ్యులను యాక్సెస్ చేయడానికి “ఆబ్జెక్ట్” ఒక ఉదాహరణగా పనిచేస్తుంది. ఇది ఆదిమ డేటా రకాలు చేయలేని నిర్దిష్ట విధిని నిర్వహించడానికి జావాస్క్రిప్ట్ ఫంక్షన్‌ను అమలు చేయడానికి ఉపయోగించబడుతుంది. అయితే, ఈ డేటా రకం యొక్క ఒక ప్రతికూలత ఏమిటంటే, ఇది కంటెంట్ ఆధారంగా కాకుండా దాని గుర్తింపు ఆధారంగా పోలిక ఆపరేషన్‌ను నిర్వహిస్తుంది. ఈ సమస్యను పరిష్కరించడానికి JavaScript కొత్త డేటా రకాన్ని అందిస్తుంది ' రికార్డులు ” ఇది ఖచ్చితంగా దాని కంటెంట్‌ల ఆధారంగా పోల్చి చూస్తుంది, గుర్తింపు కాదు.
ఈ గైడ్ జావాస్క్రిప్ట్ రికార్డ్‌లను వివరిస్తుంది.
'రికార్డులు' అంటే ఏమిటి?
జావాస్క్రిప్ట్' రికార్డులు ” అనేది అంతర్నిర్మిత మాదిరిగానే ఒక కొత్త ఆదిమ రకం(తీగలు, సంఖ్యలు, చిహ్నాలు). . ఒకే తేడా ఏమిటంటే “రికార్డ్‌లు” పూర్తిగా మార్పులేనివి అంటే వాటి కీలు ప్రారంభించబడిన తర్వాత వాటి విలువ మార్చబడదు.
వాక్యనిర్మాణం
యొక్క వాక్యనిర్మాణం ' రికార్డ్ చేయండి ” అనేది “ఆబ్జెక్ట్”తో సమానంగా ఉంటుంది, కానీ దీనికి “” అవసరం # 'రికార్డ్'గా సూచించే కర్లీ జంట కలుపుల ముందు (హాష్)' గుర్తు:
const recoredName = #{
/*
కీ: విలువ
/*
}
కొత్త రికార్డును సృష్టించడానికి పైన పేర్కొన్న సింటాక్స్‌ని ఉపయోగిస్తాము.
రికార్డులు సృష్టించడం ఎలా?
రికార్డ్ సృష్టించడానికి, దిగువ కోడ్ బ్లాక్‌లో చూపిన విధంగా కర్లీ జంట కలుపుల ప్రారంభంలో “#(హాష్)” చిహ్నాన్ని పేర్కొనండి:
స్థిర వ్యక్తి = #{
పేరు: 'లేదా' ,
పేరు: 'ఉస్మాన్' ,
వయస్సు: ఇరవై ఒకటి ,
}
console.log ( వ్యక్తి.పేరు )
console.log ( వ్యక్తి.పేరు )
console.log ( వ్యక్తి.వయస్సు )
పై కోడ్ బ్లాక్‌లో:
-
- ది ' వ్యక్తి ” అనేది కింది “fname”, “lname” మరియు “వయస్సు” కీలను కలిగి ఉన్న కొత్త “రికార్డ్”ని సూచిస్తుంది.
- తరువాత, ' కన్సోల్. లాగ్ () ” పద్ధతి “వ్యక్తి” కీ విలువలను వరుసగా ఒక్కొక్కటిగా ప్రదర్శిస్తుంది.
గమనిక: వినియోగదారు 'రికార్డ్స్' కంటెంట్‌ను కూడా ఇలా ఒక లైన్‌లో పేర్కొనవచ్చు:
స్థిర వ్యక్తి = #{fname: 'అలీ', పేరు: 'ఉస్మాన్', వయస్సు: 21}
అవుట్‌పుట్
సృష్టించిన రికార్డ్ “వ్యక్తి” యొక్క అన్ని కీలక విలువలను అవుట్‌పుట్ ప్రదర్శిస్తుందని చూడవచ్చు.
రికార్డుల పరిమితి
'రికార్డ్' దాని కీగా 'అరే' మరియు 'ఆబ్జెక్ట్'ని అంగీకరించదు. వినియోగదారు వాటిని రికార్డ్‌కు పంపితే, కంపైలర్ ' టైప్ ఎర్రర్ ”. కింది కోడ్ బ్లాక్ దీన్ని ఆచరణాత్మకంగా చూపుతుంది:
const newRecord = #{అరె: [ 'HTML' , 'CSS' , 'జావాస్క్రిప్ట్' ]
}
console.log ( వ్యక్తి.arr )
పై కోడ్ లైన్లలో:
-
- ది ' కొత్త రికార్డ్ ”అర్రే అనే అర్రేని దాని కీగా ప్రారంభిస్తుంది.
- తరువాత, ' కన్సోల్. లాగ్ () ”న్యూ రికార్డ్‌లో పేర్కొన్న “arr” కీ విలువను ప్రదర్శిస్తుంది.
అవుట్‌పుట్
కన్సోల్ “TypeError(అనుకోని రకాన్ని దాటుతోంది)”ని ప్రదర్శిస్తుంది ఎందుకంటే “రికార్డ్స్” శ్రేణిని కీగా అంగీకరించదు.
ఉదాహరణలను ఉపయోగించి జావాస్క్రిప్ట్ రికార్డ్‌లను అర్థం చేసుకోవడం
ఈ విభాగం ఇచ్చిన ఉదాహరణల సహాయంతో ఆచరణాత్మకంగా 'రికార్డ్స్' యొక్క ఉపయోగాలను కలిగి ఉంటుంది.
మొదటి ఉదాహరణతో ప్రారంభిద్దాం.
ఉదాహరణ 1: రికార్డులు లోతుగా మార్పులేనివి
జావాస్క్రిప్ట్' రికార్డులు ” లోతుగా మార్పులేని ఆదిమ రకాలు. 'డీప్లీ ఇమ్యుటబుల్' అంటే రికార్డ్ యొక్క అన్ని కీలక విలువలు సెట్ చేయబడిన తర్వాత ఏ స్థాయిలోనూ సవరించబడవు లేదా మార్చబడవు. 'ప్రిమిటివ్' రకాలు స్ట్రింగ్, నంబర్, శూన్య, నిర్వచించబడని మరియు అనేక ఇతర జావాస్క్రిప్ట్ డేటా రకాలను సూచిస్తాయి.
కింది కోడ్ బ్లాక్ పేర్కొన్న భావనను ఆచరణాత్మకంగా చూపుతుంది:
const myRecord = #{పేరు: 'లేదా' ,
వయస్సు: ఇరవై ఒకటి ,
}
myRecord.name= 'హరూన్'
పై కోడ్ బ్లాక్‌లో, “ నా రికార్డ్ 'కీ' పేరు ” విలువ దాని ప్రారంభించిన తర్వాత సవరించబడుతుంది.
అవుట్‌పుట్
'న్యూ రికార్డ్' కీ విలువను సవరించడంలో కంపైలర్ 'టైప్ ఎర్రర్'ని చూపుతుందని గమనించవచ్చు.
ఉదాహరణ 2: రికార్డులు తులనాత్మకమైనవి
'రికార్డ్స్' యొక్క ప్రధాన ప్రయోజనం ఏమిటంటే అవి గుర్తింపు ఆధారంగా కాకుండా వాటి విలువల ఆధారంగా పోల్చబడతాయి. అయితే 'వస్తువులు' వాటి గుర్తింపుల ప్రకారం సరిపోల్చండి, విలువలు కాదు. రెండు రికార్డ్‌ల విలువలు సమానంగా ఉంటే, కంపైలర్ ఒప్పును తిరిగి పొందుతుంది.
ఇచ్చిన కోడ్ లైన్ల సహాయంతో ఆచరణాత్మకంగా చూద్దాం:
const myRecord = #{పేరు: 'లేదా' ,
వయస్సు: ఇరవై ఒకటి ,
}
console.log ( myRecord === #{
పేరు: 'లేదా' ,
వయస్సు: ఇరవై ఒకటి ,
} ) ;
ఇక్కడ, పై కోడ్ స్నిప్పెట్ '' సహాయంతో పోల్చబడిన రెండు రికార్డ్‌లను సృష్టిస్తుంది. కఠినమైన సమానత్వం (===)” ఆపరేటర్.
అవుట్‌పుట్
అవుట్‌పుట్ ఒక “ని అందిస్తుంది నిజం ”బూలియన్ విలువ అంటే పేర్కొన్న ఆపరేటర్లు అంటే “రికార్డ్‌లు” సమానం.
ఉదాహరణ 3: రికార్డ్‌ను ఆబ్జెక్ట్‌గా మార్చండి
జావాస్క్రిప్ట్ “రికార్డ్స్” కూడా “ఆబ్జెక్ట్” కన్స్ట్రక్టర్ సహాయంతో “ఆబ్జెక్ట్” డేటా రకంగా మార్చబడుతుంది. దాని ఆచరణాత్మక అమలు ఇక్కడ ఉంది:
వీలు myRecord = #{ ఒకటి: 1, రెండు: 2 }console.log ( వస్తువు ( నా రికార్డ్ ) )
console.log ( నా రికార్డ్ రకం )
పై కోడ్ లైన్లలో:
-
- మొదటి ' lconsole.and() ” పద్ధతిని మార్చడానికి “ఆబ్జెక్ట్” కన్స్ట్రక్టర్‌ని ఉపయోగిస్తుంది నా రికార్డ్ 'వస్తువుగా.
- రెండవ “console.log()” పద్ధతి “ని ఉపయోగిస్తుంది రకం 'మైరికార్డ్' రకాన్ని తనిఖీ చేయడానికి కీవర్డ్.
అవుట్‌పుట్
అవుట్‌పుట్ మార్చబడిన “న్యూ రికార్డ్”ని “”గా చూపుతుంది వస్తువు 'న్యూ రికార్డ్' విజయవంతంగా 'ఆబ్జెక్ట్'గా మార్చబడిందని నిర్ధారించే రకం.
ఉదాహరణ 4: ఆబ్జెక్ట్‌ను రికార్డ్‌గా మార్చండి
'' సహాయంతో పోలిక ప్రయోజనాల కోసం వినియోగదారు 'ఆబ్జెక్ట్' ను 'రికార్డ్'గా మార్చవచ్చు రికార్డ్() ” పద్ధతి. ఆచరణాత్మకంగా చేద్దాం:
వీలు myObj = { ఒకటి: 1 , రెండు: 2 }వీలు myRecord = రికార్డు ( myObj )
console.log ( నా రికార్డ్ )
ఇప్పుడు, పై కోడ్ స్నిప్పెట్ “ని ఉపయోగిస్తుంది రికార్డ్() ”ఇచ్చిన “myObj” ఆబ్జెక్ట్‌ని “myRecord”గా మార్చే పద్ధతి.
అవుట్‌పుట్
అవుట్‌పుట్ మార్చబడిన ఆబ్జెక్ట్ “myObj”ని “myRecord” కంటెంట్‌గా విజయవంతంగా చూపుతుంది.
ఉదాహరణ 5: ఇప్పటికే ఉన్న రికార్డుల నుండి కొత్త రికార్డ్‌లను సృష్టించండి
మొదటి ఉదాహరణలో చర్చించినట్లుగా, “రికార్డులు” మార్పులేనివి అంటే వాటి కీలక విలువలు సవరించబడవు. అయితే, వినియోగదారు కొన్ని ఇతర విలువల జోడింపుతో పాటు ఇప్పటికే ఉన్న 'రికార్డ్' నుండి కొత్త 'రికార్డ్'ని సృష్టించవచ్చు.
ఇప్పటికే ఉన్న దాని నుండి కొత్త రికార్డ్‌ను సృష్టించడానికి ఇచ్చిన కోడ్ స్నిప్పెట్‌ని అనుసరించండి:
వీలు oldRecord = #{A: 1, B: 2};వీలు కొత్త రికార్డ్ = #{ ...myRecord, C: 3, D:4}
console.log ( కొత్త రికార్డ్ )
పై జావాస్క్రిప్ట్ కోడ్‌లో:
-
- ది ' పాత రికార్డు ” అనేది రెండు కీలక విలువలను కలిగి ఉన్న ప్రస్తుత రికార్డును సూచిస్తుంది.
- తదుపరి ' కొత్త రికార్డ్ ” అనేది ఇప్పటికే ఉన్న “ఓల్డ్‌రికార్డ్” సహాయంతో మరియు కొత్త పేర్కొన్న కీ విలువలను జోడించడం ద్వారా సృష్టించబడిన కొత్త రికార్డ్‌కు అనుగుణంగా ఉంటుంది.
- చివరగా, ' కన్సోల్. లాగ్ () 'న్యూ రికార్డ్' పేరుతో కొత్తగా సృష్టించబడిన రికార్డ్‌ను ప్రదర్శిస్తుంది.
అవుట్‌పుట్
అవుట్‌పుట్ కొత్తగా సృష్టించబడిన రికార్డ్ యొక్క అన్ని కీలక విలువలను ప్రదర్శిస్తుంది.
ఉదాహరణ 6: “Object.keys()” పద్ధతిని ఉపయోగించి రికార్డ్‌లను యాక్సెస్ చేయండి
వినియోగదారు అంతర్నిర్మిత జావాస్క్రిప్ట్‌ను ఉపయోగించవచ్చు ' కీలు() 'పద్ధతి' వస్తువు ” రికార్డ్ కీలను యాక్సెస్ చేయడానికి. ఈ దృష్టాంతంలో, ఇది 'myRecord' కీలను యాక్సెస్ చేయడానికి ఉపయోగించబడుతుంది:
వీలు myRecord = #{A: 1, B: 2};వీలు recordKeys = ఆబ్జెక్ట్.కీలు ( నా రికార్డ్ ) ;
console.log ( రికార్డ్ కీలు )
పై కోడ్ స్నిప్పెట్ “ని ఉపయోగిస్తుంది Object.keys() 'మై రికార్డ్'లో ఉన్న అన్ని కీలను యాక్సెస్ చేసే పద్ధతి.
అవుట్‌పుట్
అవుట్‌పుట్ “myRecord” యొక్క అన్ని కీలను శ్రేణి ఆకృతిలో మరియు వాటి సూచికలతో కీ-విలువ జత ఆకృతిలో చూపుతుంది.
ముగింపు
జావాస్క్రిప్ట్' రికార్డులు ” అనేవి లోతైన మార్పులేని అధునాతన స్థాయి డేటా రకం. ఇది 'ఆబ్జెక్ట్' లాగానే పని చేస్తుంది కానీ ప్రధాన వ్యత్యాసం ఏమిటంటే, దాని విలువను సెట్ చేసిన తర్వాత మార్చవచ్చు లేదా నవీకరించవచ్చు. డిక్లరేషన్ కోసం కర్లీ బ్రేస్‌ల ముందు దీనికి “#(హాష్)” గుర్తు అవసరం లేకుంటే అది వస్తువుగా పనిచేస్తుంది. ఈ గైడ్ జావాస్క్రిప్ట్ రికార్డ్స్ డేటా రకాన్ని క్లుప్తంగా వివరించింది.