ജാവാസ്ക്രിപ്റ്റ്: പ്രോപ്പർട്ടി മൂല്യമനുസരിച്ച് ഒബ്ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുന്നു

സ്ട്രിംഗ് പ്രോപ്പർട്ടി പ്രകാരം ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റുകൾ അടുക്കുന്നു

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

ഈ ലേഖനത്തിൽ, ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി മൂല്യമനുസരിച്ച് JavaScript ഒബ്‌ജക്റ്റുകളുടെ ഒരു ശ്രേണി എങ്ങനെ അടുക്കാമെന്ന് ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. ഞങ്ങൾ `sort()` രീതിയുടെ ഉപയോഗം പരിശോധിക്കുകയും ഒബ്‌ജക്‌റ്റുകളിലേക്ക് ഒരു `toString()` രീതി ചേർക്കുന്നത് പോലുള്ള അധിക ഘട്ടങ്ങൾ ആവശ്യമാണോ എന്ന് ചർച്ച ചെയ്യുകയും ചെയ്യും.

ജാവാസ്ക്രിപ്റ്റ് ഒബ്ജക്റ്റ് സോർട്ടിംഗിൻ്റെ വിശദമായ വിശദീകരണം

മുകളിൽ നൽകിയിരിക്കുന്ന സ്‌ക്രിപ്റ്റുകൾ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നത് ജാവാസ്ക്രിപ്റ്റ് ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിരയെ സ്‌ട്രിംഗ് പ്രോപ്പർട്ടിയുടെ മൂല്യമനുസരിച്ച് അടുക്കുന്നതിനാണ്. last_nom. ആദ്യ ഉദാഹരണത്തിൽ, ഞങ്ങൾ ഉപയോഗിക്കുന്നു sort(function(a, b) {...}) ഒരു ഇഷ്‌ടാനുസൃത സോർട്ടിംഗ് ഫംഗ്‌ഷൻ നിർവചിക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്ന രീതി. ഈ പ്രവർത്തനം താരതമ്യം ചെയ്യുന്നു last_nom ഓരോ വസ്തുവിൻ്റെയും സ്വത്ത്. ആദ്യ വസ്തുവാണെങ്കിൽ last_nom രണ്ടാമത്തെ വസ്തുവിനേക്കാൾ കുറവാണ് last_nom, അത് -1 നൽകുന്നു, ആദ്യ ഒബ്ജക്റ്റ് രണ്ടാമത്തേതിന് മുമ്പ് വരണമെന്ന് സൂചിപ്പിക്കുന്നു. ആദ്യ വസ്തുവാണെങ്കിൽ last_nom വലുതാണ്, അത് 1 നൽകുന്നു, അതായത് ആദ്യത്തെ ഒബ്ജക്റ്റ് രണ്ടാമത്തേതിന് ശേഷം വരണം. അവ തുല്യമാണെങ്കിൽ, അത് 0 നൽകുന്നു, അവരുടെ സ്ഥാനങ്ങൾ മാറ്റമില്ലാതെ തുടരണമെന്ന് സൂചിപ്പിക്കുന്നു.

രണ്ടാമത്തെ സ്ക്രിപ്റ്റ് കൂടുതൽ സംക്ഷിപ്തമായ ES6 വാക്യഘടന ഉപയോഗിക്കുന്നു. ദി localeCompare() എന്നതിനുള്ളിൽ രീതി ഉപയോഗിക്കുന്നു sort() താരതമ്യം ചെയ്യുന്നതിനുള്ള പ്രവർത്തനം last_nom വസ്തുക്കളുടെ സവിശേഷതകൾ. ഒരു സ്ട്രിംഗ് മുമ്പോ ശേഷമോ വരുമോ അതോ നിലവിലെ ലൊക്കേലിലെ മറ്റൊരു സ്‌ട്രിങ്ങിന് സമാനമാണോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു നമ്പർ ഈ രീതി നൽകുന്നു. ദി console.log() സ്ഥിരീകരണത്തിനായി അടുക്കിയ അറേ കൺസോളിലേക്ക് ഔട്ട്പുട്ട് ചെയ്യുന്നതിന് രണ്ട് സ്ക്രിപ്റ്റുകളിലും ഫംഗ്ഷൻ ഉപയോഗിക്കുന്നു. രണ്ട് രീതികളും ഒബ്‌ജക്റ്റുകളുടെ ശ്രേണിയെ ഫലപ്രദമായി അടുക്കുന്നു last_nom സ്വത്ത്, JavaScript-ൽ ഒബ്‌ജക്റ്റ് പ്രോപ്പർട്ടി സോർട്ടിംഗ് എങ്ങനെ കൈകാര്യം ചെയ്യണമെന്ന് കാണിക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റിലെ ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ഒബ്ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുന്നു

ക്ലയൻ്റ് സൈഡ് JavaScript

var objs = [
    {first_nom: 'Laszlo', last_nom: 'Jamf'},
    {first_nom: 'Pig', last_nom: 'Bodine'},
    {first_nom: 'Pirate', last_nom: 'Prentice'}
];

objs.sort(function(a, b) {
    if (a.last_nom < b.last_nom) {
        return -1;
    }
    if (a.last_nom > b.last_nom) {
        return 1;
    }
    return 0;
});

console.log(objs);

ES6 വാക്യഘടന ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുന്നു

ES6 ജാവാസ്ക്രിപ്റ്റ്

const objs = [
    {first_nom: 'Laszlo', last_nom: 'Jamf'},
    {first_nom: 'Pig', last_nom: 'Bodine'},
    {first_nom: 'Pirate', last_nom: 'Prentice'}
];

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

console.log(objs);

ജാവാസ്ക്രിപ്റ്റിലെ ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ഒബ്ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുന്നു

ക്ലയൻ്റ് സൈഡ് JavaScript

var objs = [
    {first_nom: 'Laszlo', last_nom: 'Jamf'},
    {first_nom: 'Pig', last_nom: 'Bodine'},
    {first_nom: 'Pirate', last_nom: 'Prentice'}
];

objs.sort(function(a, b) {
    if (a.last_nom < b.last_nom) {
        return -1;
    }
    if (a.last_nom > b.last_nom) {
        return 1;
    }
    return 0;
});

console.log(objs);

ES6 വാക്യഘടന ഉപയോഗിച്ച് ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുന്നു

ES6 ജാവാസ്ക്രിപ്റ്റ്

const objs = [
    {first_nom: 'Laszlo', last_nom: 'Jamf'},
    {first_nom: 'Pig', last_nom: 'Bodine'},
    {first_nom: 'Pirate', last_nom: 'Prentice'}
];

objs.sort((a, b) => a.last_nom.localeCompare(b.last_nom));

console.log(objs);

ജാവാസ്ക്രിപ്റ്റിൽ ഒബ്ജക്റ്റുകൾ അടുക്കുന്നതിനുള്ള വിപുലമായ സാങ്കേതിക വിദ്യകൾ

ജാവാസ്ക്രിപ്റ്റിലെ ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുമ്പോൾ, അതിൻ്റെ സങ്കീർണതകൾ മനസ്സിലാക്കേണ്ടത് അത്യാവശ്യമാണ്. sort() രീതി. സ്ഥിരസ്ഥിതിയായി, the sort() രീതി മൂലകങ്ങളെ സ്ട്രിംഗുകളായി അടുക്കുന്നു. അക്കങ്ങളോ പ്രത്യേക പ്രതീകങ്ങളോ കൈകാര്യം ചെയ്യുമ്പോൾ ഇത് അപ്രതീക്ഷിത ഫലങ്ങളിലേക്ക് നയിച്ചേക്കാം. കൃത്യമായ സോർട്ടിംഗ് ഉറപ്പാക്കാൻ, പ്രത്യേകിച്ച് സ്ട്രിംഗ് പ്രോപ്പർട്ടികൾക്കൊപ്പം, നിങ്ങൾ ഒരു ഇഷ്‌ടാനുസൃത താരതമ്യം ഫംഗ്‌ഷൻ ഉപയോഗിക്കണം. ഇതിനുപുറമെ localeCompare(), മറ്റൊരു ഉപയോഗപ്രദമായ സാങ്കേതികത കേസ് സെൻസിറ്റിവിറ്റി കൈകാര്യം ചെയ്യുക എന്നതാണ്. JavaScript-ൻ്റെ സ്ട്രിംഗ് താരതമ്യം ഡിഫോൾട്ടായി കേസ് സെൻസിറ്റീവ് ആണ്, അതിനാൽ 'a' എന്നത് 'A' എന്നതിനേക്കാൾ കുറവായി കണക്കാക്കും. ഇത് ഒഴിവാക്കാൻ, നിങ്ങളുടെ താരതമ്യം ഫംഗ്‌ഷനിൽ എല്ലാ സ്‌ട്രിംഗുകളും ലോവർ അല്ലെങ്കിൽ വലിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാം.

പരിഗണിക്കേണ്ട മറ്റൊരു പ്രധാന വശം ഒന്നിലധികം പ്രോപ്പർട്ടികൾ പ്രകാരം അടുക്കുക എന്നതാണ്. ഉദാഹരണത്തിന്, രണ്ട് വസ്തുക്കൾക്ക് സമാനമാണെങ്കിൽ last_nom മൂല്യം, നിങ്ങൾ അവയെ കൂടുതൽ അടുക്കാൻ ആഗ്രഹിച്ചേക്കാം first_nom. അധിക വ്യവസ്ഥകൾ ഉൾപ്പെടുത്തുന്നതിനായി ഇഷ്‌ടാനുസൃത താരതമ്യ പ്രവർത്തനം വിപുലീകരിക്കുന്നതിലൂടെ ഇത് നേടാനാകും. അത്തരം മൾട്ടി-ലെവൽ സോർട്ടിംഗ്, കൂടുതൽ അർത്ഥവത്തായ ഫലങ്ങൾ നൽകിക്കൊണ്ട് ഡാറ്റ സമഗ്രമായി ക്രമീകരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുന്നു. ഈ വിപുലമായ സോർട്ടിംഗ് ടെക്നിക്കുകൾ മനസ്സിലാക്കുകയും പ്രയോഗിക്കുകയും ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റ സോർട്ടിംഗ് സാഹചര്യങ്ങൾ JavaScript-ൽ ഫലപ്രദമായി കൈകാര്യം ചെയ്യാൻ കഴിയും.

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

1. ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി ഉപയോഗിച്ച് നിങ്ങൾ എങ്ങനെയാണ് ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുന്നത്?
2. ഉപയോഗിക്കുക sort() ഒരു ഇഷ്‌ടാനുസൃത താരതമ്യം ഫംഗ്‌ഷനുള്ള രീതി, ഉപയോഗപ്പെടുത്തുന്നു localeCompare() സ്ട്രിംഗ് താരതമ്യത്തിനായി.
3. JavaScript അടുക്കുന്നത് കേസ് സെൻസിറ്റീവ് ആണോ?
4. അതെ, സ്ഥിരസ്ഥിതിയായി. ഇത് ഒഴിവാക്കാൻ താരതമ്യ ഫംഗ്‌ഷനിൽ സ്ട്രിംഗുകൾ ലോവർ അല്ലെങ്കിൽ വലിയക്ഷരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുക.
5. ഒന്നിലധികം പ്രോപ്പർട്ടികളാൽ അടുക്കുന്നത് നിങ്ങൾ എങ്ങനെയാണ് കൈകാര്യം ചെയ്യുന്നത്?
6. ദ്വിതീയ പ്രോപ്പർട്ടികൾ പ്രകാരം അടുക്കുന്നതിനുള്ള അധിക വ്യവസ്ഥകൾ ഉൾപ്പെടുത്തുന്നതിന് ഇഷ്‌ടാനുസൃത താരതമ്യം ഫംഗ്‌ഷൻ വിപുലീകരിക്കുക.
7. നിങ്ങൾ ഒരു ചേർക്കേണ്ടതുണ്ടോ toString() നിങ്ങളുടെ ഒബ്‌ജക്‌റ്റുകൾ അടുക്കുന്നതിനുള്ള രീതി?
8. ഇല്ല, ഒരു ഇഷ്‌ടാനുസൃത താരതമ്യം ഫംഗ്‌ഷൻ ഉപയോഗിച്ചാൽ മതി.
9. എന്താണ് ചെയ്യുന്നത് localeCompare() ചെയ്യണോ?
10. ഇത് നിലവിലെ ലൊക്കേലിലെ രണ്ട് സ്ട്രിംഗുകൾ താരതമ്യം ചെയ്യുകയും അവയുടെ ക്രമം സൂചിപ്പിക്കുന്ന ഒരു സംഖ്യ നൽകുകയും ചെയ്യുന്നു.
11. സമാന രീതി ഉപയോഗിച്ച് നിങ്ങൾക്ക് സംഖ്യാ ഗുണങ്ങളാൽ ഒബ്ജക്റ്റുകൾ അടുക്കാൻ കഴിയുമോ?
12. അതെ, സംഖ്യാ താരതമ്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിനായി നിങ്ങൾക്ക് താരതമ്യം ഫംഗ്ഷൻ ഇഷ്ടാനുസൃതമാക്കാം.
13. അടുക്കിയ അറേ എങ്ങനെ ഔട്ട്പുട്ട് ചെയ്യും?
14. ഉപയോഗിക്കുക console.log() സ്ഥിരീകരണത്തിനായി അടുക്കിയ അറേ കൺസോളിലേക്ക് പ്രിൻ്റ് ചെയ്യാൻ.
15. താരതമ്യം ഫംഗ്‌ഷനിലെ റിട്ടേൺ മൂല്യങ്ങളുടെ പ്രാധാന്യം എന്താണ്?
16. മൂലകങ്ങളുടെ ക്രമം അവർ നിർണ്ണയിക്കുന്നു: -1-ൽ കുറവും, 1-ൽ കൂടുതലും, 0-ന് തുല്യവും.

ജാവാസ്ക്രിപ്റ്റിൽ ഒബ്ജക്റ്റ് സോർട്ടിംഗ് പൊതിയുന്നു

ജാവാസ്ക്രിപ്റ്റിലെ ഒരു സ്ട്രിംഗ് പ്രോപ്പർട്ടി ഉപയോഗിച്ച് ഒബ്‌ജക്റ്റുകളുടെ ഒരു നിര അടുക്കുന്നത് ഇത് ഉപയോഗിച്ച് കാര്യക്ഷമമായി നേടാനാകും sort() ഒരു ഇഷ്‌ടാനുസൃത താരതമ്യം ഫംഗ്‌ഷനുള്ള രീതി. പ്രയോജനപ്പെടുത്തുന്നതിലൂടെ localeCompare() കൂടാതെ കേസ് സെൻസിറ്റിവിറ്റി കൈകാര്യം ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് കൃത്യവും അർത്ഥപൂർണ്ണവുമായ ഡാറ്റ സോർട്ടിംഗ് ഉറപ്പാക്കാൻ കഴിയും. ഈ സങ്കേതങ്ങൾ മനസ്സിലാക്കുന്നത്, കൂടുതൽ സങ്കീർണ്ണമായ സാഹചര്യങ്ങളെ അനായാസമായി കൈകാര്യം ചെയ്യുന്നതിനും ഡാറ്റയുടെ മികച്ച കൃത്രിമത്വത്തിനും അവതരണത്തിനും അനുവദിക്കുന്നു. കൂടാതെ, ഒന്നിലധികം പ്രോപ്പർട്ടികൾ ഉപയോഗിച്ച് അടുക്കുന്നത് സങ്കീർണ്ണതയുടെ മറ്റൊരു തലം ചേർക്കുന്നു, ഇത് അടുക്കിയ ഔട്ട്പുട്ടിനെ കൂടുതൽ പ്രസക്തവും സംഘടിതവുമാക്കുന്നു.