ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ വഴി ലൂപ്പ് ചെയ്യുന്നു

JavaScript ഒബ്ജക്റ്റ് ആവർത്തനം പര്യവേക്ഷണം ചെയ്യുന്നു

ഒരു JavaScript ഒബ്‌ജക്റ്റിൻ്റെ സവിശേഷതകളിലൂടെ ലൂപ്പ് ചെയ്യുന്നത് ഡവലപ്പർമാർ നേരിടുന്ന ഒരു സാധാരണ ജോലിയാണ്. നിങ്ങൾക്ക് കീകൾ, മൂല്യങ്ങൾ, അല്ലെങ്കിൽ ഇവ രണ്ടും ആക്‌സസ് ചെയ്യേണ്ടതുണ്ടെങ്കിലും, ഒബ്‌ജക്റ്റ് പ്രോപ്പർട്ടികൾ എങ്ങനെ ഫലപ്രദമായി കണക്കാക്കാമെന്ന് മനസിലാക്കുന്നത് നിർണായകമാണ്.

ഈ ലേഖനത്തിൽ, ഒരു ഒബ്‌ജക്‌റ്റിൻ്റെ മൂലകങ്ങളെ പുനരാവിഷ്‌കരിക്കുന്നതിനുള്ള വിവിധ രീതികൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. അവസാനത്തോടെ, നിങ്ങളുടെ JavaScript കോഡ് കാര്യക്ഷമവും വായിക്കാവുന്നതുമാണെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് ഒബ്ജക്റ്റ് എണ്ണൽ എളുപ്പത്തിൽ കൈകാര്യം ചെയ്യാനുള്ള അറിവ് നിങ്ങൾക്ക് ലഭിക്കും.

ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് ആവർത്തന സാങ്കേതിക വിദ്യകൾ മനസ്സിലാക്കുന്നു

ദി for...in ഒരു ഒബ്‌ജക്‌റ്റിൻ്റെ എണ്ണിയാലൊടുങ്ങാത്ത ഗുണങ്ങൾ ആവർത്തിക്കാൻ ഉപയോഗിക്കുന്ന ഒരു അടിസ്ഥാന JavaScript നിർമ്മാണമാണ് ലൂപ്പ്. ഉദാഹരണ സ്ക്രിപ്റ്റിൽ, for...in ഒബ്ജക്റ്റിൻ്റെ ഓരോ പ്രോപ്പർട്ടിയിലൂടെയും ലൂപ്പ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു p. ലൂപ്പിനുള്ളിൽ, hasOwnProperty() പ്രോപ്പർട്ടി വസ്തുവിൻ്റെ നേരിട്ടുള്ള സ്വത്താണെന്നും അതിൻ്റെ പ്രോട്ടോടൈപ്പ് ശൃംഖലയിൽ നിന്ന് പാരമ്പര്യമായി ലഭിച്ചതല്ലെന്നും ഉറപ്പാക്കാൻ ഉപയോഗിക്കുന്നു. ഒബ്‌ജക്‌റ്റ് പ്രോപ്പർട്ടികൾ അവകാശമാക്കുമ്പോൾ ഉദ്ദേശിക്കാത്ത ഫലങ്ങൾ ഒഴിവാക്കാൻ ഇത് നിർണായകമാണ്. ലൂപ്പ് പിന്നീട് ഉപയോഗിക്കുന്ന ഓരോ വസ്തുവിൻ്റെയും കീയും മൂല്യവും രേഖപ്പെടുത്തുന്നു console.log, ഒബ്ജക്റ്റിൻ്റെ ഗുണങ്ങളെ ഫലപ്രദമായി കണക്കാക്കുന്നു.

പ്രദർശിപ്പിച്ച മറ്റൊരു രീതി ഉപയോഗിക്കുന്നു Object.entries(), ഇത് ഒബ്‌ജക്‌റ്റിൻ്റെ സ്വന്തം എണ്ണാവുന്ന പ്രോപ്പർട്ടി [കീ, മൂല്യം] ജോഡികളുടെ ഒരു ശ്രേണി നൽകുന്നു. ഈ അറേ ഉപയോഗിച്ച് വീണ്ടും ആവർത്തിക്കുന്നു forEach(), ഓരോ അറേ എലമെൻ്റിനും ഒരു പ്രാവശ്യം നൽകിയിരിക്കുന്ന ഫംഗ്‌ഷൻ എക്‌സിക്യൂട്ട് ചെയ്യുന്ന സൗകര്യപ്രദമായ അറേ രീതി. ഈ രീതി ഓരോ ആവർത്തനത്തിലെയും കീയും മൂല്യവും നേരിട്ട് ആക്‌സസ് ചെയ്‌ത് കോഡ് ലളിതമാക്കുന്നു, ഇത് എണ്ണൽ പ്രക്രിയ ലളിതവും വായിക്കാവുന്നതുമാക്കുന്നു. ദി Object.keys() രീതി സമാനമായി പ്രവർത്തിക്കുന്നു, പക്ഷേ കീകൾ മാത്രം നൽകുന്നു, അത് പിന്നീട് അതിനുള്ളിലെ അനുബന്ധ മൂല്യങ്ങൾ ആക്സസ് ചെയ്യാൻ ഉപയോഗിക്കുന്നു forEach() ലൂപ്പ്.

ഇതുകൂടാതെ, Object.values() ഒബ്ജക്റ്റിൻ്റെ മൂല്യങ്ങളുടെ ഒരു നിര നൽകുന്ന മറ്റൊരു ഉപയോഗപ്രദമായ രീതിയാണ്. ഉപയോഗിച്ച് ഈ അറേയിൽ ആവർത്തിച്ചുകൊണ്ട് forEach(), നമുക്ക് ഓരോ മൂല്യവും നേരിട്ട് ആക്സസ് ചെയ്യാനും ലോഗ് ചെയ്യാനും കഴിയും. ഈ രീതികൾ -for...in, Object.entries(), Object.keys(), ഒപ്പം Object.values()- JavaScript-ൽ ഒബ്‌ജക്‌റ്റുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ശക്തമായ ഉപകരണങ്ങളാണ്. വ്യത്യസ്‌ത ആവശ്യങ്ങളും മുൻഗണനകളും നിറവേറ്റുന്ന, ഒബ്‌ജക്‌റ്റ് പ്രോപ്പർട്ടികൾ നിങ്ങൾ എങ്ങനെ ആക്‌സസ് ചെയ്യുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനും അവ വഴക്കം നൽകുന്നു. ഓരോ രീതിക്കും അതിൻ്റേതായ ഗുണങ്ങളുണ്ട്, അവ മനസ്സിലാക്കുന്നത് ഡെവലപ്പർമാർക്ക് അവരുടെ നിർദ്ദിഷ്ട ഉപയോഗത്തിന് ഏറ്റവും അനുയോജ്യമായ ഒന്ന് തിരഞ്ഞെടുക്കാൻ അനുവദിക്കുന്നു, കാര്യക്ഷമവും ഫലപ്രദവുമായ കോഡ് നിർവ്വഹണം ഉറപ്പാക്കുന്നു.

ലൂപ്പിനായി ഉപയോഗിക്കുന്ന ഒബ്‌ജക്റ്റ് പ്രോപ്പർട്ടികളുടെ ഓവർ ആവർത്തനം

ജാവാസ്ക്രിപ്റ്റ് - ലൂപ്പിന് വേണ്ടി

var p = {"p1":"value1","p2":"value2","p3":"value3"};
for (var key in p) {
  if (p.hasOwnProperty(key)) {
    console.log(key + " -> " + p[key]);
  }
}
// Output:
// p1 -> value1
// p2 -> value2
// p3 -> value3

Object.entries() ഉപയോഗിച്ച് ഒബ്ജക്റ്റ് കീകളിലൂടെയും മൂല്യങ്ങളിലൂടെയും ലൂപ്പ് ചെയ്യുന്നു

JavaScript - Object.entries()

var p = {"p1":"value1","p2":"value2","p3":"value3"};
Object.entries(p).forEach(([key, value]) => {
  console.log(key + " -> " + value);
});
// Output:
// p1 -> value1
// p2 -> value2
// p3 -> value3

Object.keys() ഉപയോഗിച്ച് ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ എണ്ണുന്നു

JavaScript - Object.keys()

var p = {"p1":"value1","p2":"value2","p3":"value3"};
Object.keys(p).forEach(key => {
  console.log(key + " -> " + p[key]);
});
// Output:
// p1 -> value1
// p2 -> value2
// p3 -> value3

Object.values() ഉപയോഗിച്ച് ഒബ്‌ജക്റ്റ് മൂല്യങ്ങളിലൂടെ ആവർത്തിക്കുന്നു

JavaScript - Object.values()

var p = {"p1":"value1","p2":"value2","p3":"value3"};
Object.values(p).forEach(value => {
  console.log(value);
});
// Output:
// value1
// value2
// value3

JavaScript ഒബ്ജക്റ്റ് ആവർത്തനത്തിലേക്ക് ആഴത്തിൽ മുങ്ങുന്നു

ജാവാസ്ക്രിപ്റ്റിലെ ഒബ്ജക്റ്റ് ആവർത്തനത്തെ കൈകാര്യം ചെയ്യുന്നതിനുള്ള മറ്റൊരു ശക്തമായ മാർഗ്ഗം ഇതിൻ്റെ ഉപയോഗമാണ് Map വസ്തു. സാധാരണ വസ്തുക്കളിൽ നിന്ന് വ്യത്യസ്തമായി, Map ഒബ്‌ജക്‌റ്റുകൾ നിങ്ങളെ ഏത് തരത്തിലുള്ള ഡാറ്റാ തരത്തിലായാലും കീ മൂല്യമുള്ള ജോഡികൾ സംഭരിക്കാൻ അനുവദിക്കുന്നു. ഒബ്‌ജക്‌റ്റുകൾ അല്ലെങ്കിൽ ഫംഗ്‌ഷനുകൾ പോലുള്ള സങ്കീർണ്ണമായ കീകളെ മൂല്യങ്ങളുമായി ബന്ധപ്പെടുത്തേണ്ട സാഹചര്യങ്ങളിൽ ഈ വഴക്കം പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും. നിങ്ങൾക്ക് എ-യിൽ എളുപ്പത്തിൽ ആവർത്തിക്കാനാകും Map പോലുള്ള അതിൻ്റെ അന്തർനിർമ്മിത രീതികൾ ഉപയോഗിക്കുന്നു Map.prototype.forEach(), Map.prototype.keys(), ഒപ്പം Map.prototype.values(), സ്ഥിരതയുള്ളതും പ്രവചിക്കാവുന്നതുമായ ഒരു ആവർത്തന ക്രമം നൽകുന്നു, അതായത് ഇൻസേർഷൻ ഓർഡർ.

ഇതിനുപുറമെ Map, JavaScript എന്നിവയും വാഗ്ദാനം ചെയ്യുന്നു WeakMap, സാമ്യമുള്ളതും എന്നാൽ ദുർബലമായി പരാമർശിച്ചിരിക്കുന്ന കീകളുള്ളതും, വസ്തുവിനെക്കുറിച്ച് മറ്റ് പരാമർശങ്ങളൊന്നും ഇല്ലെങ്കിൽ അവ മാലിന്യ ശേഖരണത്തെ തടയില്ല എന്നാണ്. ചില ആപ്ലിക്കേഷനുകളിൽ മെമ്മറി കൂടുതൽ കാര്യക്ഷമമായി കൈകാര്യം ചെയ്യാൻ ഇത് സഹായിക്കും. രണ്ടും Map ഒപ്പം WeakMap കീ-വാല്യൂ ജോഡികളുടെ ശേഖരം കൈകാര്യം ചെയ്യുന്നതിനുള്ള ശക്തമായ ഒരു കൂട്ടം രീതികൾ നൽകുക. അവ പ്ലെയിൻ ഒബ്‌ജക്‌റ്റുകൾക്ക് നേരിട്ടുള്ള പകരക്കാരല്ലെങ്കിലും, കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റാ ഘടനകളിലും അൽഗോരിതങ്ങളിലും പ്രയോജനപ്പെടുത്താൻ കഴിയുന്ന ഫ്ലെക്സിബിലിറ്റിയുടെയും മെമ്മറി മാനേജ്‌മെൻ്റിൻ്റെയും കാര്യത്തിൽ അവ സവിശേഷമായ നേട്ടങ്ങൾ വാഗ്ദാനം ചെയ്യുന്നു.

JavaScript ഒബ്ജക്റ്റ് ആവർത്തനത്തെക്കുറിച്ചുള്ള പൊതുവായ ചോദ്യങ്ങൾ

1. JavaScript-ൽ ഒരു ഒബ്‌ജക്റ്റിൻ്റെ പ്രോപ്പർട്ടികൾ എനിക്ക് എങ്ങനെ ആവർത്തിക്കാനാകും?
2. നിങ്ങൾക്ക് ഉപയോഗിക്കാം for...in, Object.keys(), Object.values(), അഥവാ Object.entries() ഒരു ഒബ്ജക്റ്റിൻ്റെ ഗുണങ്ങളെ കുറിച്ച് ആവർത്തിക്കാൻ.
3. എന്താണ് തമ്മിലുള്ള വ്യത്യാസം for...in ഒപ്പം Object.keys()?
4. for...in പ്രോട്ടോടൈപ്പ് ശൃംഖലയിലൂടെ പാരമ്പര്യമായി ലഭിച്ചവ ഉൾപ്പെടെ, എണ്ണാവുന്ന എല്ലാ പ്രോപ്പർട്ടികളിലും ആവർത്തിക്കുന്നു Object.keys() ഒബ്ജക്റ്റിൻ്റെ സ്വന്തം എണ്ണാവുന്ന ഗുണങ്ങൾ മാത്രം നൽകുന്നു.
5. എങ്ങിനെയാണ് Object.entries() ജോലി?
6. Object.entries() ഒബ്‌ജക്‌റ്റിൻ്റെ സ്വന്തം എണ്ണാവുന്ന പ്രോപ്പർട്ടി [കീ, മൂല്യം] ജോഡികളുടെ ഒരു ശ്രേണി നൽകുന്നു, അത് ഒരു ഉപയോഗിച്ച് ആവർത്തിക്കാം forEach ലൂപ്പ്.
7. എനിക്ക് ഉപയോഗിക്കാമോ forEach ഒരു വസ്തുവിൽ നേരിട്ട്?
8. ഇല്ല, forEach അറേകളുടെ ഒരു രീതിയാണ്, എന്നാൽ നിങ്ങൾക്ക് ഇത് തിരികെ നൽകിയ അറേകളിൽ ഉപയോഗിക്കാം Object.keys(), Object.values(), അഥവാ Object.entries().
9. എന്തൊക്കെയാണ് Map ഒപ്പം WeakMap?
10. Map ഏതെങ്കിലും തരത്തിലുള്ള കീകൾ അനുവദിക്കുകയും ഇൻസേർഷൻ ഓർഡർ നിലനിർത്തുകയും ചെയ്യുന്നു. WeakMap ദുർബലമായി പരാമർശിച്ചിരിക്കുന്നതും മാലിന്യം ശേഖരിക്കാവുന്നതുമായ കീകൾ ഉണ്ട്.
11. എങ്ങനെ ചെയ്യും Map.prototype.forEach() ഒപ്പം Array.prototype.forEach() വ്യത്യാസം?
12. അവർ സമാനമായി പ്രവർത്തിക്കുന്നു, പക്ഷേ Map.prototype.forEach() മാപ്പ് എൻട്രികളിൽ (കീ-മൂല്യം ജോഡികൾ) ആവർത്തിക്കുന്നു, അതേസമയം Array.prototype.forEach() അറേ മൂലകങ്ങൾക്ക് മുകളിലൂടെ ആവർത്തിക്കുന്നു.
13. എന്തിനാണ് ഉപയോഗിക്കുന്നത് Object.values()?
14. ഉപയോഗിക്കുക Object.values() ഒരു ഒബ്ജക്റ്റിൻ്റെ ഗുണങ്ങളുടെ മൂല്യങ്ങൾ നേരിട്ട് ആവർത്തിക്കേണ്ടിവരുമ്പോൾ.

JavaScript ഒബ്ജക്റ്റ് ആവർത്തനത്തെക്കുറിച്ചുള്ള അന്തിമ ചിന്തകൾ

ഫലപ്രദമായ പ്രോഗ്രാമിംഗിന് JavaScript-ൽ ഒബ്ജക്റ്റ് ആവർത്തനം മാസ്റ്റേഴ്സ് ചെയ്യുന്നത് അത്യന്താപേക്ഷിതമാണ്. പോലുള്ള രീതികൾ ഉപയോഗിച്ച് for...in, Object.keys(), Object.values(), ഒപ്പം Object.entries(), ഡെവലപ്പർമാർക്ക് ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ കാര്യക്ഷമമായി ആക്സസ് ചെയ്യാനും കൈകാര്യം ചെയ്യാനും കഴിയും. ഈ ടെക്നിക്കുകൾ വഴക്കം നൽകുന്നു, നിങ്ങളുടെ കോഡ് ശുദ്ധവും കാര്യക്ഷമവും മനസ്സിലാക്കാൻ എളുപ്പവുമാണെന്ന് ഉറപ്പാക്കുന്നു. നിങ്ങൾ കൈകാര്യം ചെയ്യുന്നത് ലളിതമോ സങ്കീർണ്ണമോ ആയ ഒബ്‌ജക്റ്റുകളാണെങ്കിലും, ഈ രീതികൾ അറിയുന്നത് നിങ്ങളുടെ കോഡിംഗ് കഴിവുകൾ വർദ്ധിപ്പിക്കുകയും നിങ്ങളുടെ JavaScript ആപ്ലിക്കേഷനുകൾ ഒപ്റ്റിമൈസ് ചെയ്യുകയും ചെയ്യും.