ఈ బ్లాగ్ పోస్ట్ జావాస్క్రిప్ట్‌లోని ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించే విధానాన్ని నిర్వచిస్తుంది.
జావాస్క్రిప్ట్‌లో ఒక వస్తువులోని కీల సంఖ్యను ఎలా లెక్కించాలి?
ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించడానికి, ఈ క్రింది పద్ధతులను ఉపయోగించండి:
- పొడవు ఆస్తితో Object.keys().
- కలయిక కోసం 'లూప్ తో' లో ” కీవర్డ్
ఈ విధానాలను ఒక్కొక్కటిగా పరిశీలిద్దాం!
విధానం 1: Object.keys() పద్ధతిని ఉపయోగించి ఒక వస్తువులోని కీల సంఖ్యను లెక్కించడం
ది ' Object.keys() ”పద్ధతి ఒక శ్రేణిని స్ట్రింగ్‌లతో అవుట్‌పుట్‌గా అందిస్తుంది, ఇది ఆబ్జెక్ట్‌పై ఇప్పటికే ఉన్న లెక్కించబడిన లక్షణాలకు అనుగుణంగా ఉంటుంది. మీరు వస్తువు యొక్క లక్షణాల ద్వారా మాన్యువల్‌గా లూప్ చేసినప్పుడు లక్షణాల జాబితా అదే క్రమంలో కనిపిస్తుంది. ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించడానికి, ' Object.key() 'పద్ధతి 'తో ఉపయోగించబడుతుంది పొడవు ”ఆస్తి.
వాక్యనిర్మాణం
ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించడానికి దిగువ ఇవ్వబడిన సింటాక్స్‌ని ఉపయోగించండి:
వస్తువు . కీలు ( వస్తువు ) . పొడవు
- ' కీలు() ' అనేది ' యొక్క పద్ధతి వస్తువు 'రకం మరియు' వస్తువు ” అనేది ఒక వాదన, దీని కీలు/గుణాలు లెక్కించబడతాయి.
- ఇది వస్తువులోని కీల సంఖ్యను అందిస్తుంది.
ఉదాహరణ
మొదట, '' అనే వస్తువును సృష్టించండి సమాచారం 'నాలుగు లక్షణాలతో' మొదటి పేరు ',' చివరి పేరు ',' వయస్సు 'మరియు' సంప్రదించండి 'కీ-విలువ జతలో:
మొదటి పేరు : 'స్టీఫెన్' ,
చివరి పేరు : 'కెయిన్' ,
వయస్సు : 28 ,
సంప్రదించండి : 090394809
} ;
కాల్ చేయండి' Object.keys() 'తో పద్ధతి' పొడవు 'ఒక వస్తువును దాటే ఆస్తి' సమాచారం ” ఒక ఆబ్జెక్ట్‌లోని కీలను లెక్కించే వాదనగా:
కన్సోల్. లాగ్ ( వస్తువు . కీలు ( సమాచారం ) . పొడవు ) ;
అవుట్పుట్ ప్రదర్శిస్తుంది ' 4 'ఇది వస్తువులోని కీల గణన' సమాచారం ”:
మీకు కౌంట్‌కు బదులుగా ఆబ్జెక్ట్‌లోని కీల పేర్లు మాత్రమే కావాలంటే, '' అని కాల్ చేయండి Object.keys() ”ఒక వస్తువును ఆర్గ్యుమెంట్‌గా పాస్ చేయడం ద్వారా పద్ధతి:
కన్సోల్. లాగ్ ( వస్తువు . కీలు ( సమాచారం ) ) ;అవుట్పుట్ ఆబ్జెక్ట్‌లోని కీల పేర్లను శ్రేణిలో ప్రదర్శిస్తుంది:
విధానం 2: 'ఇన్' కీవర్డ్‌తో 'ఫర్' లూప్ ఉపయోగించి ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించడం
ఒక వస్తువు యొక్క కీలు కూడా 'ని ఉపయోగించి లెక్కించబడతాయి. కోసం 'లూప్ తో' లో ” కీవర్డ్. ది ' కోసం 'లూప్ వస్తువు యొక్క లక్షణాలపై మళ్ళిస్తుంది మరియు ' లో ” కీవర్డ్ దాని నుండి లక్షణాలను తిరిగి పొందుతుంది. ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించడానికి “ కోసం_ఇన్ ” లూప్, దిగువ ఉదాహరణలలో ఉపయోగించబడే క్రింది వాక్యనిర్మాణాన్ని అనుసరించండి.
వాక్యనిర్మాణం
కోసం ( ఉంది కీ లో వస్తువు ) {.........
}
ఉదాహరణ 1: ఒక వస్తువులోని కీల సంఖ్యను లెక్కించండి
ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించడానికి, అదే వస్తువును పరిగణించండి ' సమాచారం ” పై ఉదాహరణలో సృష్టించబడింది. అప్పుడు, ఒక వేరియబుల్ సృష్టించండి ' లెక్కించండి ” మరియు ఒక విలువను కేటాయించండి 0 దానికి:
వస్తువును పాస్ చేయండి ' సమాచారం ” for_in లూప్‌కి:
కోసం ( ఉంది కీ లో సమాచారం ) {లెక్కించండి ++;
}
చివరగా, ఆబ్జెక్ట్‌లోని కీల గణనను 'ని ఉపయోగించి ప్రింట్ చేయండి console.log() 'పద్ధతి:
కన్సోల్. లాగ్ ( లెక్కించండి ) ;అవుట్పుట్
ఉదాహరణ 2: వారసత్వంగా వచ్చిన వస్తువులలో కీల సంఖ్యను లెక్కించండి
ది ' కోసం ”లూప్ వారసత్వంగా వచ్చిన లక్షణాలను కూడా లెక్కిస్తుంది. ఇక్కడ, మేము ఒక వస్తువును సృష్టిస్తాము ' ఉద్యోగి 'రెండు లక్షణాలతో' లింగం ', మరియు' చేరిన తేది 'అది వస్తువు నుండి వారసత్వంగా వస్తుంది' సమాచారం ”:
లింగం : 'పురుషుడు' ,
చేరిన తేది : 'జనవరి, 2020'
} ;
వస్తువును వారసత్వంగా పొందండి ' ఉద్యోగి 'తో' సమాచారం 'వస్తువు యొక్క ఆస్తిని ఉపయోగించడం' __అందుకే__ ”:
సమాచారం. __అందుకే__ = ఉద్యోగివస్తువును పాస్ చేయండి ' సమాచారం ' కు ' కోసం_ లో ” లూప్ చేసి, ప్రతి పునరావృతంలో గణనను పెంచండి. ఇది వస్తువు యొక్క లక్షణాలను కూడా గణిస్తుంది ' ఉద్యోగి 'ఎందుకంటే అది వస్తువు నుండి వారసత్వంగా వస్తుంది' సమాచారం ”:
కోసం ( ఉంది కీ లో సమాచారం ) {లెక్కించండి ++;
}
అవుట్పుట్ ' 6 'ఈ విధానం రెండు వస్తువుల కీలను లెక్కిస్తుంది' అని సూచిస్తుంది. సమాచారం 'మరియు దాని వారసత్వ వస్తువు' ఉద్యోగి ”:
ఉదాహరణ 3: చైల్డ్ ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించండి
మీరు పిల్లల వస్తువు యొక్క కీలను పొందాలనుకుంటే ' ఉద్యోగి ', ఉపయోగించడానికి ' సొంత ఆస్తి() లూప్ లోపల పద్ధతి:
ఉంటే ( ఉద్యోగి. స్వంత ఆస్తిని కలిగి ఉంది ( కీ ) ) {
లెక్కించండి ++;
}
}
అవుట్పుట్
ముగింపు
జావాస్క్రిప్ట్‌లోని ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించడానికి, “ని ఉపయోగించండి పొడవు 'జావాస్క్రిప్ట్ యొక్క ఆస్తి' వస్తువు 'రకం పద్ధతి' కీలు() 'వలే' Object.keys() 'లేదా' కలయిక కోసం 'లూప్ తో' లో ” కీవర్డ్. ది ' కోసం_ఇన్ ' విధానం వారసత్వంగా వచ్చిన లక్షణాలను కూడా లెక్కిస్తుంది ' Object.keys() ” పద్ధతి లింక్ చేయబడిన లక్షణాలను లెక్కించదు; ఇది వస్తువు యొక్క స్వంత లక్షణాలను మాత్రమే లెక్కిస్తుంది. ఈ బ్లాగ్ పోస్ట్‌లో, జావాస్క్రిప్ట్‌లోని ఆబ్జెక్ట్‌లోని కీల సంఖ్యను లెక్కించే విధానాన్ని మేము నిర్వచించాము.