ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் மறு செய்கையை ஆராய்கிறது
ஜாவாஸ்கிரிப்ட் பொருள்கள் முக்கிய மதிப்பு ஜோடிகளில் தரவைச் சேமித்து நிர்வகிப்பதில் அடிப்படை. இந்த பொருள்களுடன் பணிபுரியும் போது, விசைகள் மற்றும் மதிப்புகளை அணுக அவற்றின் பண்புகளை அடிக்கடி சுழற்ற வேண்டிய அவசியம் ஏற்படுகிறது.
இந்த டுடோரியல் ஜாவாஸ்கிரிப்ட் பொருளில் உள்ள பண்புகளை கணக்கிடுவதற்கான பல்வேறு முறைகள் மூலம் உங்களுக்கு வழிகாட்டும். நீங்கள் JavaScriptக்கு புதியவராக இருந்தாலும் அல்லது உங்கள் திறமைகளை மேம்படுத்த விரும்பினாலும், பயனுள்ள குறியீட்டு முறைக்கு இந்த நுட்பங்களைப் புரிந்துகொள்வது அவசியம்.
| கட்டளை | விளக்கம் |
|---|---|
| for...in | ஒரு பொருளின் எண்ணிலடங்கா பண்புகள் மூலம் சுழல்கிறது. |
| hasOwnProperty() | பொருள் குறிப்பிட்ட சொத்து அதன் சொந்த சொத்தாக உள்ளதா என சரிபார்க்கிறது. |
| Object.keys() | கொடுக்கப்பட்ட பொருளின் சொந்த எண்ணக்கூடிய சொத்துப் பெயர்களின் வரிசையை வழங்குகிறது. |
| forEach() | ஒவ்வொரு வரிசை உறுப்புக்கும் ஒரு முறை வழங்கப்பட்ட செயல்பாட்டை செயல்படுத்துகிறது. |
| Object.entries() | கொடுக்கப்பட்ட பொருளின் சொந்த எண்ணக்கூடிய சரம்-விசை சொத்து [விசை, மதிப்பு] ஜோடிகளின் வரிசையை வழங்குகிறது. |
ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் மறு செய்கை நுட்பங்களைப் புரிந்துகொள்வது
வழங்கப்பட்ட ஸ்கிரிப்டுகள் ஜாவாஸ்கிரிப்ட் பொருளின் பண்புகளை மீண்டும் செய்ய வெவ்வேறு முறைகளை வழங்குகின்றன. முதல் ஸ்கிரிப்ட் a ஐப் பயன்படுத்துகிறது for...in லூப், இது ஒரு பொருளின் அனைத்து எண்ணிடக்கூடிய பண்புகளையும் மீண்டும் மீண்டும் செய்கிறது. இந்த வளையத்திற்குள், தி hasOwnProperty() பொருள் குறிப்பிடப்பட்ட சொத்தை அதன் சொந்த சொத்தாகக் கொண்டிருக்கிறதா என்பதைச் சரிபார்த்து, பரம்பரைப் பண்புகள் சேர்க்கப்படவில்லை என்பதை உறுதிப்படுத்துகிறது. பதிவு செய்தல் அல்லது மதிப்புகளை மாற்றுதல் போன்ற ஒரு பொருளின் ஒவ்வொரு சொத்தின் மீதும் செயல்பாடுகளைச் செய்ய வேண்டியிருக்கும் போது இந்த முறை பயனுள்ளதாக இருக்கும்.
இரண்டாவது ஸ்கிரிப்ட், தி Object.keys() முறை, இது பொருளின் சொந்த எண்ணக்கூடிய சொத்துப் பெயர்களின் வரிசையை வழங்குகிறது. தி forEach() இந்த வரிசையை மீண்டும் மீண்டும் செய்ய முறை பயன்படுத்தப்படுகிறது, இது ஒப்பிடும்போது எளிமையான மற்றும் படிக்கக்கூடிய அணுகுமுறையை வழங்குகிறது for...in வளைய. மூன்றாவது ஸ்கிரிப்ட் பயன்படுத்துகிறது Object.entries(), இது பொருளின் சொந்த எண்ணிடக்கூடிய சரம்-விசை சொத்து [விசை, மதிப்பு] ஜோடிகளின் வரிசையை வழங்குகிறது. ஏ for...of லூப் இந்த ஜோடிகளை மீண்டும் செய்ய பயன்படுத்தப்படுகிறது, விசைகள் மற்றும் மதிப்புகள் இரண்டையும் ஒரே நேரத்தில் அணுக ஒரு சுருக்கமான வழியை வழங்குகிறது.
ஜாவாஸ்கிரிப்டில் பொருள் பண்புகள் மூலம் லூப்பிங்
JavaScript ES6 முறைகளைப் பயன்படுத்துதல்
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};for (const key in p) {if (p.hasOwnProperty(key)) {console.log(key + ": " + p[key]);}}
ஜாவாஸ்கிரிப்டில் ஆப்ஜெக்ட் கீகள் மற்றும் மதிப்புகள் மீது மீண்டும் மீண்டும்
ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் முறைகளைப் பயன்படுத்துதல்
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};Object.keys(p).forEach(key => {console.log(key + ": " + p[key]);});
ஜாவாஸ்கிரிப்டில் ஆப்ஜெக்ட் கீகள் மற்றும் மதிப்புகளை பிரித்தெடுத்தல்
JavaScript Object.entries() முறையைப் பயன்படுத்துதல்
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};for (const [key, value] of Object.entries(p)) {console.log(key + ": " + value);}
ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களை மீண்டும் மீண்டும் செய்வதற்கான மேம்பட்ட நுட்பங்கள்
முன்பு விவரிக்கப்பட்ட முறைகளுக்கு கூடுதலாக, ஜாவாஸ்கிரிப்ட் பொருள்களை மீண்டும் மீண்டும் செய்வதற்கான மற்றொரு பயனுள்ள நுட்பத்தைப் பயன்படுத்துகிறது Object.values() முறை. இந்த முறை பொருளின் சொந்த எண்ணிடக்கூடிய சொத்து மதிப்புகளின் வரிசையை வழங்குகிறது. உங்களுக்கு மதிப்புகள் மட்டுமே தேவைப்படும் போது இது மிகவும் பயனுள்ளதாக இருக்கும் மற்றும் விசைகள் அல்ல. பின்னர் நீங்கள் பயன்படுத்தலாம் forEach() அல்லது இந்த மதிப்புகளைச் செயலாக்குவதற்கான பிற வரிசை முறைகள். விசைகள் கையில் உள்ள பணிக்கு பொருத்தமற்றதாக இருக்கும் காட்சிகளை இந்த முறை எளிதாக்குகிறது.
மற்றொரு மேம்பட்ட முறை பயன்படுத்தப்படுகிறது Reflect.ownKeys(), இது கணக்கிட முடியாத மற்றும் குறியீட்டு பண்புகள் உட்பட அனைத்து பண்புகளின் வரிசையை வழங்குகிறது. இந்த முறை மிகவும் விரிவானது Object.keys() மற்றும் Object.getOwnPropertyNames(). இணைந்து போது for...of, டெவலப்பர்கள் ஒரு பொருளின் அனைத்து பண்புகளையும் ஒருங்கிணைக்கப்பட்ட முறையில் மீண்டும் செய்ய அனுமதிக்கிறது. இந்த மேம்பட்ட முறைகளைப் புரிந்துகொள்வது சிக்கலான பொருட்களைக் கையாள்வதற்கான உங்கள் கருவித்தொகுப்பை விரிவுபடுத்துகிறது மற்றும் நீங்கள் பரந்த அளவிலான மறு செய்கை காட்சிகளை திறம்பட கையாள முடியும் என்பதை உறுதிப்படுத்துகிறது.
ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் மறு செய்கை பற்றிய பொதுவான கேள்விகள்
- ஒரு பொருளின் பண்புகளை நான் எவ்வாறு சுழற்றுவது?
- நீங்கள் ஒரு பயன்படுத்தலாம் for...in வளைய அல்லது Object.keys() உடன் forEach().
- என்ன வித்தியாசம் Object.keys() மற்றும் Object.values()?
- Object.keys() சொத்துப் பெயர்களின் வரிசையை வழங்குகிறது Object.values() சொத்து மதிப்புகளின் வரிசையை வழங்குகிறது.
- ஒரு பொருளின் விசைகள் மற்றும் மதிப்புகள் இரண்டையும் எவ்வாறு பெறுவது?
- பயன்படுத்தவும் Object.entries() [விசை, மதிப்பு] ஜோடிகளின் வரிசையைப் பெற, பின் மீண்டும் செய்யவும் for...of.
- எண்ணிலடங்கா பண்புகளை நான் மீண்டும் கூற முடியுமா?
- ஆம், பயன்படுத்தவும் Object.getOwnPropertyNames() அல்லது Reflect.ownKeys() எண்ணிலடங்கா சொத்துக்களை சேர்க்க.
- ஒரு சொத்து என்பது பொருளின் சொந்த சொத்தா என்பதை நான் எவ்வாறு சரிபார்க்க வேண்டும்?
- பயன்படுத்தவும் hasOwnProperty() சொத்து மரபுரிமையாக இல்லை என்பதை உறுதிப்படுத்த ஒரு வளையத்திற்குள்.
- ஒரு பொருளின் சின்னங்களை நான் எவ்வாறு மீண்டும் கூறுவது?
- பயன்படுத்தவும் Object.getOwnPropertySymbols() குறியீட்டு பண்புகளின் வரிசையைப் பெற.
- ஒரு பொருளின் பண்புகளை மீண்டும் மீண்டும் செய்ய சிறந்த முறை எது?
- இது உங்கள் தேவைகளைப் பொறுத்தது. பயன்படுத்தவும் for...in எளிமைக்காக, Object.keys() குறிப்பிட்ட சொத்து பெயர்களுக்கு, மற்றும் Object.entries() விசைகள் மற்றும் மதிப்புகள் இரண்டிற்கும்.
ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட் மறு செய்கையை மூடுகிறது
ஜாவாஸ்கிரிப்ட் ஆப்ஜெக்ட்களை திறம்பட மறுபரிசீலனை செய்வதற்கு வெவ்வேறு முறைகள் மற்றும் அவற்றின் பொருத்தமான பயன்பாட்டு நிகழ்வுகளைப் புரிந்து கொள்ள வேண்டும். எளிய இருந்து for...in பயன்படுத்தி மேலும் மேம்பட்ட நுட்பங்களை சுழல்கள் Object.entries() மற்றும் Reflect.ownKeys(), ஒவ்வொரு அணுகுமுறைக்கும் அதன் நன்மைகள் உள்ளன. இந்த முறைகளில் தேர்ச்சி பெறுவது, உங்கள் ஜாவாஸ்கிரிப்ட் அப்ளிகேஷன்களில் ஆப்ஜெக்ட் பண்புகளை திறம்பட நிர்வகிக்கவும் கையாளவும் முடியும்.