പരിധിയില്ലാത്ത എണ്ണമറ്റ വേരിയബിളുകൾ സൂക്ഷിക്കുന്നതിനായി ജാവാസ്ക്രിപ്റ്റ് അറേ

ജാവാസ്ക്രിപ്റ്റ് ബ്രൌസർ ഭാഷയാണ്, അതിനാൽ എല്ലാ ടാസ്ക്നുകളും സ്വന്തമായി വേരിയബിളുകൾ, അറേകൾ, വസ്തുക്കൾ എന്നിവ ആവശ്യമില്ല. പല സന്ദർഭങ്ങളിലും ഡിഒഎം (പ്രമാണത്തിന്റെ ഒബ്ജക്റ്റ് മോഡൽ) ഉപയോഗിക്കാൻ മാത്രം മതി. അത്തരം സന്ദർഭങ്ങളിൽ ഉപയോഗിച്ചിരിക്കുന്ന വിവരങ്ങളുടെ ശരിയായ വിവരണം എല്ലായ്പ്പോഴും പ്രോഗ്രാം കൂടുതൽ മികച്ചതാക്കുകയും ഉപയോക്തൃ-സൗഹൃദവും പിന്നീട് പരിഷ്കരിക്കുകയും ചെയ്യുന്നു.

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

കോഡ്, ഡേറ്റ ലോജിക്കൽ

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

ഒരു നിശ്ചിത സമയത്ത്, വിവരങ്ങളുടെ കർശനമായ ടൈപ്പിംഗ് ഒരു മതേതരത്വമായി മാറിയിരിക്കുന്നു, ഇപ്പോൾ എല്ലാ ആധുനിക ഭാഷകളിലും ഇത് ഉള്ളടക്കം മാത്രമല്ല, തരം മാറ്റാൻ കഴിയും. നല്ലതോ ചീത്തയോ ആകട്ടെ, അത് കാണപ്പെടും, പക്ഷേ കർശനമായ ടൈപ്പിംഗ് അതിന്റെ നല്ല സവിശേഷതകൾ നൽകുന്നു. എന്നിരുന്നാലും, ഇത് സംഭവിച്ചെങ്കിൽ, മുഴുവൻ പ്രക്രിയയും "വളർന്നുവരരുത്" എന്നല്ലേ?

ഒരു സിദ്ധാന്തത്തിൽ, അതായത്, വാക്യഘടനയ്ക്ക് പുറത്ത്, ഏതെങ്കിലും വേരിയബിൾ കാര്യങ്ങൾ. അത് ഏതെങ്കിലും അവസ്ഥയ്ക്ക് മാറുന്നു. മാറ്റങ്ങളുടെ അനുപാതം ഇതിനകം ഒരു തുകയാണിത്, ജാവാസ്മെന്റിന് ഒരു എലമെന്റ് ശ്രേണിയാണിത്.

മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, പ്രോഗ്രാമർ വേരിയബിളിന്റെ തരം പ്രാധാന്യം ഉറപ്പുവരുത്തിയിരിക്കുകയും, ടൈപ്പുകളുടെ ശരിയായതും സമയബന്ധിതവുമായ പരിവർത്തനത്തിനായി ഭാഷ സ്ഥാപിക്കുകയും ചെയ്തെങ്കിൽ പിന്നെ എന്തിനാണ് ലളിതമാക്കുക: നമ്പർ, സ്ട്രിംഗ്, അറേ അല്ലെങ്കിൽ ഒബ്ജക്റ്റ് - ഇതാണ് തീരുമാനിക്കാനുള്ള കോഡ്. ഇതിലും കൂടുതൽ ശരിയാണ്: ഇത് എന്തുചെയ്യാമെന്നും അത് എങ്ങനെ ചെയ്യാമെന്നും ഇത് സ്വയം തീരുമാനിക്കണം.

ലളിതമായ ഡാറ്റയും വ്യാകരണവും

ലളിതമായ വേരിയബിളുകൾ വ്യത്യസ്ത തരങ്ങളെയാണ് സൂചിപ്പിക്കുന്നത്. ആവശ്യമുള്ളപ്പോൾ കൺട്രിഷനുകൾ സ്വപ്രേരിതമായി നടപ്പാക്കപ്പെടും.

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

അറേകളിലെ ഘടകങ്ങളുടെ എണ്ണം

JavaScript ൽ, അറേ ഒരു അസോസിയേഷൻ അറേ അല്ല. മൂലകങ്ങളിലേക്കുള്ള പ്രവേശനം സംഖ്യാപര കീകളാൽ നടപ്പിലാക്കുന്നു, പരമാവധി എണ്ണം 2 ^{32 ആണ്} , എന്നാൽ നിങ്ങൾ പരിധി നിർണ്ണയിക്കുന്ന അളവിൽ പരീക്ഷിക്കുക പാടില്ല.

ഒരു നല്ല അല്ഗോരിതം എല്ലായ്പ്പോഴും വ്യക്തമായ ഡാറ്റയാണ്, കൂടാതെ അതിന്റെ ഉള്ളടക്കങ്ങളുടെ പശ്ചാത്തലത്തിൽ ശ്രേണിയുടെ വലുപ്പം നിയന്ത്രിക്കാൻ JavaSscript Array നീളം നിർമ്മിക്കുന്നത് സിന്റാക്സിൽ ചേർത്തിട്ടില്ല.

AChe.length ന്റെ മൂല്യം എല്ലായ്പ്പോഴും മൂലകങ്ങളുടെ യഥാർത്ഥ എണ്ണം അല്ല. ജാവാസ്ക്രിയിൽ, ശ്രേണിയിൽ അടങ്ങിയിട്ടുള്ളതും അതിനകത്ത് എന്തൊക്കെ അയച്ചിരിക്കുന്നുവെന്നും അതിൽ അടങ്ങിയിരിക്കാമെങ്കിലും എത്രമാത്രം നിങ്ങൾ കഠിനമായി അധ്വാനിക്കണം എന്ന് കണ്ടെത്താൻ കഴിയും.

ഈ ഉദാഹരണത്തിൽ, aCheck [5] എന്ന എക്സ്പ്രഷൻ ശ്രേണിയെ ആറു ഘടകങ്ങളാക്കി വർദ്ധിപ്പിക്കുന്നു. 4 ന്റെ മൂല്യം ഒരു മൂല്യം നൽകുന്നതല്ല എന്ന ആശയം വിലമതിക്കാനാവാത്തതാണ്.

അസോസിയേറ്റ് അറേസ്

സാധാരണയായി, JavaScript ശ്രേണി സാധാരണ ആകാം, അതായത്, ഘടകങ്ങളിലേക്കുള്ള ആക്സസ് സംഖ്യ സൂചികകൾ ഉപയോഗിച്ച് നടത്തുക. എന്നിരുന്നാലും, വാസ്തവത്തിൽ, നിങ്ങൾ സഹവർത്തിത്വ ആശയങ്ങൾ ഉപയോഗിക്കാം.

പട്ടിക നിരകൾ ക്രമപ്പെടുത്തൽ ലളിതവും സാധാരണവുമായ ഒരു നിര അസോസിയേഷൻ ശ്രേണി ഉപയോഗിച്ച് പരിഹരിക്കാവുന്നതാണ്. നിരയുടെ പേരിനു തൊട്ടടുത്ത വലതുഭാഗത്ത്, ഡ്രോപ്പ് അർത്ഥമാക്കുന്നത്, മുകളിലേക്കുള്ള അമ്പടയാളം, താഴേക്കുള്ള അമ്പടയാളം ആരോഹണത്തിലാണ്. നിരയിലെ ദിശകളിൽ മാറ്റം വരുത്തുന്ന വഴിയിൽ ക്ലിക്ക് ചെയ്യുക (ജാവാസ്ക്രിപ്റ്റിലെ യാഥാർത്ഥ്യത്തിന്റെ ഒരു വകഭേദം).

ഈ ഉദാഹരണത്തിൽ, array cSortCols ൽ, ഓരോ നിരയിലേയും ക്രമപ്പെടുത്തൽ ദിശകൾ രൂപീകരിക്കും (S, C, W, ...). ദിശകളുടെ മൂല്യങ്ങൾ മാത്രമാണ് u, d. പ്രസ്താവനയ്ക്കായി, എല്ലാം ഒരു വരിയിലേക്ക് (നിര കോഡും ദിശ രണ്ടും) രണ്ടും ഒന്നാക്കിയിരിക്കും. ഈ ലൂപ്പ് ശ്രേണിയിലെ എല്ലാ ഘടകങ്ങളിലൂടെയും കാണപ്പെടുന്നു, കൂടാതെ നിങ്ങൾ ജേണൽ നിര ദൈർഘ്യമുള്ള പ്രവർത്തനം ഉപയോഗിക്കേണ്ടതില്ല.

ജാവയിൽ ഒരു ശ്രേണി സൃഷ്ടിച്ച് അടുക്കുക

ഇത് 'var xMass = []; അല്ലെങ്കിൽ 'var yArr = {};'. ആദ്യ കാര്യത്തിൽ, രണ്ടാമത്തെ കേസിൽ - സഹധ്വനിയിൽ സാധാരണ ശ്രേണി നിർവചിക്കപ്പെടുന്നു. നിങ്ങൾക്ക് JavaScript പുതിയ Array () ഓപ്ഷൻ ഉപയോഗിക്കാം, എന്നാൽ സാധാരണയായി ഈ ഡിസൈൻ മറ്റ് ഉദ്ദേശ്യങ്ങൾക്കായി ഉപയോഗിക്കുന്നു, പ്രധാനമായും വസ്തുക്കളുമായി പ്രവർത്തിക്കാൻ.

സൃഷ്ടിക്കപ്പെട്ട ശ്രേണി ഒരു തവണ വേരിയബിളുകൾ കൊണ്ട് നിറയും, പക്ഷേ, ഒരു ഭരണം എന്ന നിലയിൽ, ചലനാത്മകതയിലെ ശ്രേണിയുടെ യഥാർത്ഥ പൂരിപ്പിക്കൽ, കൃത്രിമത്വം, പ്രോഗ്രാം നടപ്പിലാക്കുമ്പോൾ. നിങ്ങൾക്ക് അടുക്കൽ ആവശ്യമുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഇഷ്ടാനുസൃതമല്ലാത്ത JavaScript ക്രമപ്പെടുത്തിയ ശ്രേണി നിർമ്മിക്കാം, പക്ഷേ നിങ്ങളുടെ സ്വന്തം പ്രവർത്തനത്തിലൂടെ പ്രക്രിയ നിയന്ത്രിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

കോൾ: arr.sort () ASCII പട്ടികയുടെ ചിഹ്നങ്ങളുടെ ക്രമത്തിൽ ക്രമപ്പെടുത്തുന്നു. വിപരീത പ്രവർത്തനം എന്നത് ഘടകങ്ങളുടെ പരിവർത്തനമാണ്: arr.reverse (). ഈ പ്രവർത്തനം നിര ഘടകങ്ങളുടെ ക്രമം മാറ്റുന്നു.

രണ്ട് സന്ദർഭങ്ങളിലും, arr എന്നത് ഒരു അറേയാണ്. ആദ്യ സന്ദർഭത്തിൽ, നിങ്ങൾക്ക് സ്വന്തമായ രീതി ഉപയോഗപ്പെടുത്താം, അതായത്, arr.sort (myfunc (a, b) എന്ന ആഹ്വാനം, സ്വന്തം ഫംഗ്ഷൻ myfuct എന്നു വിളിക്കും, ഇത് ഡാറ്റയെ ആശ്രയിച്ച് ഫലമുണ്ടാക്കാം: a, b. ആദ്യം രണ്ടാമത്തേതിനേക്കാൾ കുറവാണെങ്കിൽ -1 ന് പകരം 1, പിന്നെ ഒരു = b, 0 എന്നിവ എങ്കിൽ. താരതമ്യ മാനദണ്ഡം പ്രോഗ്രാമിന് myfunc ൽ നിർണ്ണയിക്കുന്നു.

സജീവ ഘടകം എന്ന ആശയം

സോർട്ടിംഗ് പ്രോസസ്സിംഗ് സമയത്ത് വിളിക്കപ്പെടുന്ന പ്രവർത്തനം വിവിധ പ്രവർത്തനങ്ങൾ നിർവഹിക്കാൻ കഴിയും. രൂപകൽപ്പനയിലെ കാഴ്ചപ്പാടിൽ നിന്ന് ഇത് പ്രയോഗിക്കുന്ന രൂപത്തിൽ നിന്ന് ഇൻപുട്ട് പാരാമീറ്ററുകളോട് പ്രതികരിക്കേണ്ടതില്ല, അതിന്റെ ഫലം -1, 1, 0 എന്നീ സംഖ്യകളാണ് മാത്രമല്ല, ഓരോ ഘടകത്തിലേക്കും ചാക്രികമായി ഒരു അറേയിൽ പ്രയോഗിച്ചാൽ, അത് നിര പുനർനിർമ്മിക്കാൻ കഴിയും.

ഒരു ശ്രേണി ഒരു പ്രത്യേക അർത്ഥമാണെന്നു കരുതുന്നുണ്ടെങ്കിൽ, ഒരു നിർദ്ദിഷ്ട ഡാറ്റ ഘടന, തുടർന്ന് ജാവാസ്വർ അറേ ഒരു വേരിയബിൾ ഉള്ളടക്കം ഉപയോഗിച്ച് വേരിയബിളായി മാറുന്നു.

നമ്മൾ അതിന്റെ ഉള്ളടക്കമായി അറേയിലുള്ള ആദ്യ അല്ലെങ്കിൽ അവസാനത്തെ ഘടകത്തെ ഉപയോഗിക്കുമ്പോൾ, സറക്റ്റ് ഫംഗ്ഷന്റെ എക്സിക്യൂട്ട് അറേ രൂപാന്തരപ്പെടുത്താവുന്നതാണ്, അതിനാൽ ചുമതലയുടെ സാഹചര്യത്തിൽ ആവശ്യമുള്ളതുപോലെ ആദ്യ / അവസാന ഘടകം മറ്റൊരു ഘടകമായി മാറുന്നു.

അത്തരമൊരു ആശയം നിങ്ങൾക്ക് പരിഹാരം ആൽഗോരിതം പുനർനിർമിക്കാൻ അനുവദിച്ചേക്കാം, പ്രത്യേകിച്ച്, () {{else} {0}, സ്വിച്ച് () {case '': ...; കേസ് '': ...; ...}.

ഒരു അറേയുടെ ഉള്ളടക്കങ്ങൾ കൈകാര്യം ചെയ്യുന്നത്, അതിനകത്ത് നിങ്ങൾക്ക് ഘടകങ്ങൾ നീക്കാൻ കഴിയും, അതുവഴി ആദ്യ അല്ലെങ്കിൽ അവസാന ഘടകങ്ങളിൽ നിന്നും ലഭിക്കുന്ന ബാഹ്യ പ്രവർത്തനം മാറുന്നു.

JavaScript ശ്രേണി: യുക്തിപരമായ ഉപയോഗം

ഡാറ്റയുടെ ഘടനയും ഉള്ളടക്കവും മാറ്റാൻ മാത്രമല്ല, യഥാർത്ഥ കോഡ് മാറ്റാനും എല്ലാ ഭാഷകളും നല്ലതാണ്. ഒരു വേരിയബിളിനെ ഒരു മാതൃചിത്രമായി കണക്കാക്കുന്നതിനുള്ള ആശയം, അതായത്, തുടക്കത്തിൽ അതിന്റെ മാതൃകാ നിലവാരം പുലർത്തുന്നില്ല, പുതിയ ചക്രവാളം തുറക്കുന്നു.

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

ഉദാഹരണമായി, ടെക്സ്റ്റ് വായിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഈ "ടെക്സ്റ്റ്" എന്ന് വിവരിക്കാൻ കഴിയും, അത് വാക്യങ്ങളാക്കി വിഭജിക്കപ്പെടും - "പോയിന്റ്" മാനദണ്ഡം (സന്ദർഭത്തിൽ, അതായത്, സ്വീകരിച്ച വാക്യത്തിലെ വാക്യഘടന കണക്കിലെടുക്കുമ്പോൾ). വാക്യങ്ങൾ ശൈലികളായി (സന്ദർഭത്തിൽ, കോമ, അനുയോജ്യമായ വാക്യഘടന) വേർതിരിച്ചിരിക്കുന്നു. അടുത്ത വാക്കുകളും അക്ഷരങ്ങളും.

ഫലം: നിങ്ങൾക്ക് ടെക്സ്റ്റുകൾ, വാക്യങ്ങൾ, പദങ്ങളുടെ നിലവാരത്തിൽ പ്രവർത്തിക്കാൻ കഴിയും. ഓരോ തലത്തിലും, നിങ്ങൾക്ക് സമാനമായതോ സമാനമോ ആവാം എന്നു തിരിച്ചറിയാൻ കഴിയുന്ന "അദ്വതതത്തിന്റെ" പ്രവർത്തനങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയും. വാചകങ്ങളും വാക്യങ്ങളും മറ്റ് ഡാറ്റകളിലേക്ക് പ്രയോഗിക്കുന്നതിന് നിങ്ങൾക്ക് ഫംഗ്ഷനുകൾ സൃഷ്ടിക്കാൻ കഴിയും.

ആധുനിക പ്രോഗ്രാമിങ് കുറെക്കാലമായി ഡോക്ടറായിട്ടില്ല. എന്നാൽ, കഴിഞ്ഞ ദശകങ്ങളിൽ സിന്റാക്റ്റിക്കൽ നിർമ്മാണവും പരിചയവും കണ്ടെത്തിയതുകൊണ്ടാണ് ഭാഷാ വികസിപ്പിച്ചവർ പുതുതായി രൂപകൽപ്പന ചെയ്തിട്ടില്ലാത്ത പുതിയ ചക്രവാളങ്ങൾ തുറന്ന് ഉപയോഗിക്കുകയും ഉപയോഗിക്കുകയും ചെയ്യുന്നത്.