JavaScript ഒബ്ജക്റ്റ് ആവർത്തനം പര്യവേക്ഷണം ചെയ്യുന്നു
ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റുകൾ കീ-വാല്യൂ ജോഡികളിൽ ഡാറ്റ സംഭരിക്കുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനും അടിസ്ഥാനമാണ്. ഈ ഒബ്‌ജക്‌റ്റുകൾക്കൊപ്പം പ്രവർത്തിക്കുമ്പോൾ, കീകളും മൂല്യങ്ങളും ആക്സസ് ചെയ്യുന്നതിന് അവയുടെ പ്രോപ്പർട്ടികളിലൂടെ ലൂപ്പ് ചെയ്യേണ്ടത് പലപ്പോഴും ആവശ്യമാണ്.
ഈ ട്യൂട്ടോറിയൽ ഒരു JavaScript ഒബ്‌ജക്റ്റിലെ പ്രോപ്പർട്ടികൾ എണ്ണുന്നതിനുള്ള വിവിധ രീതികളിലൂടെ നിങ്ങളെ നയിക്കും. നിങ്ങൾ JavaScript-ൽ പുതിയ ആളാണെങ്കിലും അല്ലെങ്കിൽ നിങ്ങളുടെ കഴിവുകൾ മെച്ചപ്പെടുത്താൻ നോക്കുന്നവരാണെങ്കിലും, ഫലപ്രദമായ കോഡിംഗിന് ഈ സാങ്കേതിക വിദ്യകൾ മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്.
| കമാൻഡ് | വിവരണം |
|---|---|
| for...in | ഒരു വസ്തുവിൻ്റെ എണ്ണമറ്റ ഗുണങ്ങളിലൂടെ ലൂപ്പ് ചെയ്യുന്നു. |
| hasOwnProperty() | ഒബ്‌ജക്‌റ്റിന് അതിൻ്റെ സ്വത്തായി നിർദ്ദിഷ്ട പ്രോപ്പർട്ടി ഉണ്ടോയെന്ന് പരിശോധിക്കുന്നു. |
| Object.keys() | തന്നിരിക്കുന്ന ഒബ്ജക്റ്റിൻ്റെ സ്വന്തം കണക്കാക്കാവുന്ന പ്രോപ്പർട്ടി നാമങ്ങളുടെ ഒരു ശ്രേണി നൽകുന്നു. |
| forEach() | ഓരോ അറേ എലമെൻ്റിനും ഒരിക്കൽ നൽകിയിരിക്കുന്ന ഫംഗ്ഷൻ എക്‌സിക്യൂട്ട് ചെയ്യുന്നു. |
| Object.entries() | തന്നിരിക്കുന്ന ഒബ്ജക്റ്റിൻ്റെ സ്വന്തം എണ്ണാവുന്ന സ്ട്രിംഗ്-കീഡ് പ്രോപ്പർട്ടി [കീ, മൂല്യം] ജോഡികളുടെ ഒരു ശ്രേണി നൽകുന്നു. |
ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് ആവർത്തന സാങ്കേതിക വിദ്യകൾ മനസ്സിലാക്കുന്നു
നൽകിയിരിക്കുന്ന സ്‌ക്രിപ്റ്റുകൾ ഒരു JavaScript ഒബ്ജക്റ്റിൻ്റെ പ്രോപ്പർട്ടികൾ ഉപയോഗിച്ച് ആവർത്തിക്കാൻ വ്യത്യസ്ത രീതികൾ വാഗ്ദാനം ചെയ്യുന്നു. ആദ്യ സ്ക്രിപ്റ്റ് എ ഉപയോഗിക്കുന്നു ലൂപ്പ്, ഇത് ഒരു വസ്തുവിൻ്റെ എല്ലാ എണ്ണമറ്റ ഗുണങ്ങളെയും ആവർത്തിക്കുന്നു. ഈ ലൂപ്പിനുള്ളിൽ, ദി പൈതൃക സ്വത്തുക്കൾ ഉൾപ്പെടുത്തിയിട്ടില്ലെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് വസ്തുവിന് സ്വന്തം സ്വത്തായി നിർദ്ദിഷ്ട സ്വത്ത് ഉണ്ടോ എന്ന് രീതി പരിശോധിക്കുന്നു. ലോഗിംഗ് അല്ലെങ്കിൽ മൂല്യങ്ങൾ പരിഷ്‌ക്കരിക്കുന്നത് പോലെ ഒരു ഒബ്ജക്റ്റിൻ്റെ ഓരോ പ്രോപ്പർട്ടിയിലും നിങ്ങൾ പ്രവർത്തനങ്ങൾ നടത്തേണ്ടിവരുമ്പോൾ ഈ രീതി ഉപയോഗപ്രദമാണ്.
രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് സ്വാധീനിക്കുന്നു രീതി ദി എന്നതിനെ അപേക്ഷിച്ച് ലളിതവും കൂടുതൽ വായിക്കാവുന്നതുമായ സമീപനം നൽകിക്കൊണ്ട് ഈ അറേയിൽ ആവർത്തിക്കാൻ രീതി ഉപയോഗിക്കുന്നു ലൂപ്പ്. മൂന്നാമത്തെ സ്ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു Object.entries(), ഇത് ഒബ്ജക്റ്റിൻ്റെ സ്വന്തം എണ്ണാവുന്ന സ്ട്രിംഗ്-കീഡ് പ്രോപ്പർട്ടി [കീ, മൂല്യം] ജോഡികളുടെ ഒരു ശ്രേണി നൽകുന്നു. എ ഈ ജോഡികളിൽ ആവർത്തിക്കാൻ ലൂപ്പ് ഉപയോഗിക്കുന്നു, കീകളും മൂല്യങ്ങളും ഒരേസമയം ആക്സസ് ചെയ്യുന്നതിനുള്ള ഒരു സംക്ഷിപ്ത മാർഗം വാഗ്ദാനം ചെയ്യുന്നു.
ജാവാസ്ക്രിപ്റ്റിലെ ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ വഴി ലൂപ്പ് ചെയ്യുന്നു
JavaScript ES6 രീതികൾ ഉപയോഗിക്കുന്നു
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};for (const key in p) {if (p.hasOwnProperty(key)) {console.log(key + ": " + p[key]);}}
ജാവാസ്ക്രിപ്റ്റിലെ ഒബ്ജക്റ്റ് കീകൾക്കും മൂല്യങ്ങൾക്കും മേലെ ആവർത്തിക്കുന്നു
JavaScript ഒബ്ജക്റ്റ് രീതികൾ ഉപയോഗിക്കുന്നു
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};Object.keys(p).forEach(key => {console.log(key + ": " + p[key]);});
JavaScript-ൽ ഒബ്ജക്റ്റ് കീകളും മൂല്യങ്ങളും വേർതിരിച്ചെടുക്കുന്നു
JavaScript Object.entries() രീതി ഉപയോഗിക്കുന്നു
const p = {"p1": "value1", "p2": "value2", "p3": "value3"};for (const [key, value] of Object.entries(p)) {console.log(key + ": " + value);}
ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റുകൾക്ക് മേൽ ആവർത്തനത്തിനുള്ള വിപുലമായ സാങ്കേതിക വിദ്യകൾ
മുമ്പ് വിവരിച്ച രീതികൾക്ക് പുറമേ, JavaScript ഒബ്ജക്റ്റുകൾ ഉപയോഗിച്ച് ആവർത്തിക്കുന്നതിനുള്ള മറ്റൊരു ഉപയോഗപ്രദമായ സാങ്കേതികത ഉപയോഗിക്കുന്നു രീതി. ഈ രീതി ഒബ്ജക്റ്റിൻ്റെ സ്വന്തം കണക്കാക്കാവുന്ന പ്രോപ്പർട്ടി മൂല്യങ്ങളുടെ ഒരു നിര നൽകുന്നു. നിങ്ങൾക്ക് മൂല്യങ്ങൾ മാത്രം ആവശ്യമുള്ളപ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്, കീകളല്ല. അപ്പോൾ നിങ്ങൾക്ക് ഉപയോഗിക്കാം അല്ലെങ്കിൽ ഈ മൂല്യങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള മറ്റ് അറേ രീതികൾ. ഈ രീതി, കൈയിലുള്ള ചുമതലയുമായി കീകൾ അപ്രസക്തമാകുന്ന സാഹചര്യങ്ങളെ ലളിതമാക്കുന്നു.
മറ്റൊരു വിപുലമായ രീതി ഉപയോഗിക്കുന്നു , ഇത് എണ്ണമറ്റതും പ്രതീകാത്മകവുമായ പ്രോപ്പർട്ടികൾ ഉൾപ്പെടെ എല്ലാ പ്രോപ്പർട്ടികളുടെയും ഒരു ശ്രേണി നൽകുന്നു. ഈ രീതി കൂടുതൽ സമഗ്രമാണ് ഒപ്പം . കൂടിച്ചേർന്നപ്പോൾ for...of, ഒരു ഒബ്ജക്റ്റിൻ്റെ എല്ലാ ഗുണങ്ങളും ഒരു ഏകീകൃത രീതിയിൽ ആവർത്തിക്കാൻ ഇത് ഡവലപ്പർമാരെ അനുവദിക്കുന്നു. ഈ നൂതന രീതികൾ മനസ്സിലാക്കുന്നത് സങ്കീർണ്ണമായ ഒബ്ജക്റ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള നിങ്ങളുടെ ടൂൾകിറ്റ് വികസിപ്പിക്കുകയും നിങ്ങൾക്ക് വിപുലമായ ആവർത്തന സാഹചര്യങ്ങൾ ഫലപ്രദമായി കൈകാര്യം ചെയ്യാൻ കഴിയുമെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുന്നു.
- ഒരു ഒബ്ജക്റ്റിൻ്റെ ഗുണങ്ങളിലൂടെ ഞാൻ എങ്ങനെ ലൂപ്പ് ചെയ്യാം?
- നിങ്ങൾക്ക് എ ഉപയോഗിക്കാം ലൂപ്പ് അല്ലെങ്കിൽ കൂടെ .
- എന്താണ് തമ്മിലുള്ള വ്യത്യാസം ഒപ്പം ?
- പ്രോപ്പർട്ടി പേരുകളുടെ ഒരു നിര നൽകുന്നു, അതേസമയം പ്രോപ്പർട്ടി മൂല്യങ്ങളുടെ ഒരു നിര നൽകുന്നു.
- ഒരു വസ്തുവിൻ്റെ കീകളും മൂല്യങ്ങളും എങ്ങനെ ലഭിക്കും?
- ഉപയോഗിക്കുക [കീ, മൂല്യം] ജോഡികളുടെ ഒരു ശ്രേണി ലഭിക്കാൻ, തുടർന്ന് ഉപയോഗിച്ച് ആവർത്തിക്കുക .
- എണ്ണപ്പെടാത്ത പ്രോപ്പർട്ടികൾ എനിക്ക് ആവർത്തിക്കാനാകുമോ?
- അതെ, ഉപയോഗിക്കുക അഥവാ എണ്ണമറ്റ സ്വത്തുക്കൾ ഉൾപ്പെടുത്താൻ.
- ഒരു പ്രോപ്പർട്ടി വസ്തുവിൻ്റെ സ്വന്തം സ്വത്താണോ എന്ന് ഞാൻ എങ്ങനെ പരിശോധിക്കും?
- ഉപയോഗിക്കുക സ്വത്ത് അനന്തരാവകാശമല്ലെന്ന് ഉറപ്പാക്കാൻ ഒരു ലൂപ്പിനുള്ളിൽ.
- ഒരു വസ്തുവിൻ്റെ ചിഹ്നങ്ങളിൽ ഞാൻ എങ്ങനെ ആവർത്തിക്കും?
- ഉപയോഗിക്കുക ചിഹ്ന ഗുണങ്ങളുടെ ഒരു നിര ലഭിക്കുന്നതിന്.
- ഒബ്ജക്റ്റിൻ്റെ ഗുണങ്ങളെ ആവർത്തിച്ച് പറയുന്നതിനുള്ള ഏറ്റവും നല്ല രീതി ഏതാണ്?
- ഇത് നിങ്ങളുടെ ആവശ്യങ്ങളെ ആശ്രയിച്ചിരിക്കുന്നു. ഉപയോഗിക്കുക ലാളിത്യത്തിന്, നിർദ്ദിഷ്ട പ്രോപ്പർട്ടി പേരുകൾക്കായി, കൂടാതെ കീകൾക്കും മൂല്യങ്ങൾക്കും.
ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് ആവർത്തനം പൊതിയുന്നു
JavaScript ഒബ്ജക്റ്റുകൾ കാര്യക്ഷമമായി ആവർത്തിക്കുന്നതിന് വ്യത്യസ്ത രീതികളും അവയുടെ ഉചിതമായ ഉപയോഗ സാഹചര്യങ്ങളും മനസ്സിലാക്കേണ്ടതുണ്ട്. ലളിതമായതിൽ നിന്ന് കൂടുതൽ നൂതന സാങ്കേതിക വിദ്യകൾ ഉപയോഗിച്ച് ലൂപ്പ് ചെയ്യുന്നു ഒപ്പം , ഓരോ സമീപനത്തിനും അതിൻ്റെ ഗുണങ്ങളുണ്ട്. ഈ രീതികളിൽ പ്രാവീണ്യം നേടുന്നത് വൈവിധ്യമാർന്ന പ്രോഗ്രാമിംഗ് സാഹചര്യങ്ങൾ കൈകാര്യം ചെയ്യാനുള്ള നിങ്ങളുടെ കഴിവ് വർദ്ധിപ്പിക്കും, നിങ്ങളുടെ JavaScript ആപ്ലിക്കേഷനുകളിൽ ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ ഫലപ്രദമായി കൈകാര്യം ചെയ്യാനും കൈകാര്യം ചെയ്യാനും നിങ്ങൾക്ക് കഴിയുമെന്ന് ഉറപ്പാക്കുന്നു.