Excel മാക്രോകളിലെ വേരിയബിളുകളും കോൺസ്റ്റന്റുകളും മനസ്സിലാക്കുന്നു

ഈ ലേഖനത്തിൽ, മാക്രോകളിലെ സ്ഥിരാങ്കങ്ങളും വേരിയബിളുകളും എന്താണെന്നും അവ എവിടെ ഉപയോഗിക്കാമെന്നും വ്യത്യസ്ത ഡാറ്റ തരങ്ങൾ തമ്മിലുള്ള പ്രധാന വ്യത്യാസം എന്താണെന്നും നിങ്ങൾ പഠിക്കും. നിങ്ങൾക്ക് ഒരു വേരിയബിൾ എഴുതാനും അത് ഒരിക്കലും മാറ്റാനും കഴിയുമെങ്കിൽ, എന്തുകൊണ്ടാണ് സ്ഥിരാങ്കങ്ങൾ ആവശ്യമായി വരുന്നതെന്നും വെളിപ്പെടുത്തും.

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

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

എക്സൽ ഉപയോക്താവിന് അവയിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യം കാലാകാലങ്ങളിൽ മാറ്റണമെങ്കിൽ വേരിയബിളുകൾ പ്രഖ്യാപിക്കേണ്ടതുണ്ട്. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് sVAT_Rate എന്ന് വിളിക്കുന്ന ഒരു വേരിയബിൾ സജ്ജമാക്കാൻ കഴിയും, അത് ഉൽപ്പന്നത്തിനായുള്ള നിലവിലെ വാറ്റ് നിരക്ക് സംഭരിക്കും. ഇത് മാറുകയാണെങ്കിൽ, നിങ്ങൾക്ക് അത് വേഗത്തിൽ ശരിയാക്കാം. യുണൈറ്റഡ് സ്റ്റേറ്റ്സിൽ ബിസിനസ്സ് ചെയ്യുന്നവർക്ക് ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്, ചില സാധനങ്ങൾ VAT-ന് വിധേയമായിരിക്കില്ല (ഈ നികുതിയും ഓരോ സംസ്ഥാനത്തിനും വ്യത്യാസപ്പെട്ടിരിക്കും).

ഡാറ്റ തരങ്ങൾ

ഓരോ ഡാറ്റ കണ്ടെയ്‌നറും പല തരങ്ങളിൽ ഒന്നായിരിക്കാം. പ്രോസസ്സ് ചെയ്ത വിവരങ്ങളുടെ സ്റ്റാൻഡേർഡ് തരങ്ങൾ വിവരിക്കുന്ന ഒരു പട്ടിക ഇതാ. അവയിൽ പലതും ഉണ്ട്, അവർ പരസ്പരം ആവർത്തിക്കുന്നതായി തുടക്കത്തിൽ ഒരു തുടക്കക്കാരന് തോന്നിയേക്കാം. എന്നാൽ ഇതൊരു മിഥ്യാബോധമാണ്. ശരിയായ ഡാറ്റ തരം വ്യക്തമാക്കുന്നത് എന്തുകൊണ്ട് വളരെ പ്രധാനമാണെന്ന് അറിയാൻ വായിക്കുക.

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

സ്ഥിരാങ്കങ്ങളും വേരിയബിളുകളും പ്രഖ്യാപിക്കുന്നു

ആദ്യം പ്രഖ്യാപിക്കാതെ ഒരു ഡാറ്റ കണ്ടെയ്നർ ഉപയോഗിക്കുന്നത് ശക്തമായി നിരുത്സാഹപ്പെടുത്തുന്നു. അപ്പോൾ നിരവധി പ്രശ്നങ്ങൾ ഉണ്ടാകാം, ഇത് ഒഴിവാക്കാൻ വേരിയബിളുകളുടെയോ സ്ഥിരാങ്കങ്ങളുടെയോ എണ്ണത്തോടുകൂടിയ കുറച്ച് ചെറിയ കോഡ് കോഡുകൾ എഴുതേണ്ടത് ആവശ്യമാണ്.

ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാൻ, ഡിം സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, ഇതുപോലെ:

മങ്ങിയ വേരിയബിൾ_നെയിം പൂർണ്ണസംഖ്യയായി

വേരിയബിളിന്റെ പേരാണ് വേരിയബിൾ_നെയിം. അടുത്തതായി, As operator എന്ന് എഴുതിയിരിക്കുന്നു, ഡാറ്റ തരം സൂചിപ്പിക്കുന്നു. "Variable_Name", "Integer" എന്നീ സ്ട്രിംഗുകൾക്ക് പകരം, നിങ്ങൾക്ക് നിങ്ങളുടെ സ്വന്തം പേരും ഡാറ്റാ തരവും ചേർക്കാവുന്നതാണ്.

സ്ഥിരാങ്കങ്ങളും പ്രഖ്യാപിക്കാം, എന്നാൽ നിങ്ങൾ ആദ്യം അവയുടെ മൂല്യം വ്യക്തമാക്കണം. ഓപ്ഷനുകളിലൊന്ന് ഇതാണ്:

കോൺസ്റ്റ് iMaxCount = 5000

ന്യായമായി പറഞ്ഞാൽ, ചില സന്ദർഭങ്ങളിൽ നിങ്ങൾക്ക് ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കാതെ തന്നെ ചെയ്യാൻ കഴിയും, എന്നാൽ ഈ സാഹചര്യത്തിൽ അവ സ്വയമേവ തരം വേരിയന്റ് നൽകപ്പെടും. എന്നിരുന്നാലും, ഇനിപ്പറയുന്ന കാരണങ്ങളാൽ ഇത് ശുപാർശ ചെയ്യുന്നില്ല:

1. വേരിയന്റ് വളരെ സാവധാനത്തിലാണ് പ്രോസസ്സ് ചെയ്യുന്നത്, അത്തരം നിരവധി വേരിയബിളുകൾ ഉണ്ടെങ്കിൽ, ദുർബലമായ കമ്പ്യൂട്ടറുകളിൽ വിവര പ്രോസസ്സിംഗ് ഗണ്യമായി മന്ദഗതിയിലാക്കാം. ആ നിമിഷങ്ങൾ തീരുമാനിക്കുമെന്ന് തോന്നുന്നു? എന്നാൽ നിങ്ങൾക്ക് ധാരാളം കോഡ് ലൈനുകൾ എഴുതുകയും പിന്നീട് അത് ദുർബലമായ കമ്പ്യൂട്ടറുകളിൽ പ്രവർത്തിപ്പിക്കുകയും ചെയ്യണമെങ്കിൽ (ഇപ്പോഴും വിൽക്കുന്നവ, ആധുനിക ഓഫീസ് സ്യൂട്ടുകൾക്ക് ധാരാളം റാം ആവശ്യമുള്ളതിനാൽ), നിങ്ങൾക്ക് ജോലി പൂർണ്ണമായും നിർത്താം. മാക്രോകൾ തെറ്റായി എഴുതുന്നത് ചെറിയ അളവിലുള്ള റാം ഉള്ളതും സങ്കീർണ്ണമായ ജോലികൾ ചെയ്യാൻ രൂപകൽപ്പന ചെയ്തിട്ടില്ലാത്തതുമായ സ്മാർട്ട്ബുക്കുകൾ മരവിപ്പിക്കുന്നതിലേക്ക് നയിച്ച സന്ദർഭങ്ങളുണ്ട്. 
2. പേരുകളിൽ തെറ്റിദ്ധാരണകൾ അനുവദനീയമാണ്, ഇത് ഓപ്‌ഷൻ സ്പഷ്ടമായ പ്രസ്താവന ഉപയോഗിച്ച് തടയാൻ കഴിയും, അത് കണ്ടെത്തിയാൽ പ്രഖ്യാപിക്കാത്ത വേരിയബിൾ കണ്ടെത്താൻ നിങ്ങളെ അനുവദിക്കുന്നു. ചെറിയ അക്ഷരത്തെറ്റ് വ്യാഖ്യാതാവിന് വേരിയബിൾ തിരിച്ചറിയാൻ കഴിയാത്തതിനാൽ പിശകുകൾ കണ്ടെത്താനുള്ള എളുപ്പവഴിയാണിത്. നിങ്ങൾ വേരിയബിൾ ഡിക്ലറേഷൻ മോഡ് ഓണാക്കുകയാണെങ്കിൽ, മൊഡ്യൂളിന്റെ തുടക്കത്തിൽ തന്നെ പ്രഖ്യാപിച്ചിട്ടില്ലാത്ത ഡാറ്റ കണ്ടെയ്‌നറുകൾ കണ്ടെത്തിയാൽ, മാക്രോ പ്രവർത്തിപ്പിക്കാൻ ഇന്റർപ്രെട്ടർ നിങ്ങളെ അനുവദിക്കില്ല.
3. ഡാറ്റ തരവുമായി പൊരുത്തപ്പെടാത്ത വേരിയബിൾ മൂല്യങ്ങൾ മൂലമുണ്ടാകുന്ന പിശകുകൾ ഒഴിവാക്കുക. സാധാരണയായി, ഒരു പൂർണ്ണസംഖ്യ വേരിയബിളിലേക്ക് ഒരു ടെക്സ്റ്റ് മൂല്യം നൽകുന്നത് ഒരു പിശക് സൃഷ്ടിക്കും. അതെ, ഒരു വശത്ത്, ഒരു പ്രഖ്യാപനമില്ലാതെ ഒരു ജനറിക് തരം അസൈൻ ചെയ്‌തിരിക്കുന്നു, എന്നാൽ അവ മുൻകൂട്ടി പ്രഖ്യാപിച്ചാൽ, ക്രമരഹിതമായ പിശകുകൾ ഒഴിവാക്കാനാകും.

അതിനാൽ, എല്ലാം ഉണ്ടായിരുന്നിട്ടും, Excel മാക്രോകളിൽ എല്ലാ വേരിയബിളുകളും പ്രഖ്യാപിക്കാൻ വളരെ ശുപാർശ ചെയ്യുന്നു.

വേരിയബിളുകൾ പ്രഖ്യാപിക്കുമ്പോൾ ശ്രദ്ധിക്കേണ്ട മറ്റൊരു കാര്യം കൂടിയുണ്ട്. ഒരു വേരിയബിളിനെ പ്രഖ്യാപിക്കുമ്പോൾ അതിന് മൂല്യങ്ങളൊന്നും നൽകാതിരിക്കാൻ കഴിയും, എന്നാൽ ഈ സാഹചര്യത്തിൽ അത് ഒരു സ്ഥിരസ്ഥിതി മൂല്യം നേടുന്നു. ഉദാഹരണത്തിന്:

1. ലൈനുകൾ ശൂന്യമാക്കിയിരിക്കുന്നു.
2. അക്കങ്ങൾ മൂല്യം 0 എടുക്കുന്നു.
3. ബൂളിയൻ തരം വേരിയബിളുകൾ തുടക്കത്തിൽ തെറ്റായി കണക്കാക്കുന്നു.
4. ഡിഫോൾട്ട് തീയതി ഡിസംബർ 30, 1899 ആണ്.

ഉദാഹരണത്തിന്, മുമ്പ് ഒരു മൂല്യവും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ, നിങ്ങൾ ഒരു പൂർണ്ണസംഖ്യ വേരിയബിളിന് മൂല്യം 0 നൽകേണ്ടതില്ല. അവൾ ഇതിനകം ഈ നമ്പർ ഉൾക്കൊള്ളുന്നു.

ഓപ്ഷൻ വ്യക്തമായ പ്രസ്താവന

VBA കോഡിൽ ഉപയോഗിക്കുന്ന എല്ലാ വേരിയബിളുകളും പ്രഖ്യാപിക്കാനും കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് ഏതെങ്കിലും പ്രഖ്യാപിക്കാത്ത കണ്ടെയ്‌നറുകളുടെ സാന്നിധ്യം നിർണ്ണയിക്കാനും ഈ പ്രസ്താവന നിങ്ങളെ അനുവദിക്കുന്നു. ഈ ഫീച്ചർ ഉപയോഗിക്കുന്നതിന്, മാക്രോ കോഡിന്റെ ഏറ്റവും മുകളിൽ ഓപ്ഷൻ സ്പഷ്ടമായ കോഡിന്റെ ഒരു വരി എഴുതുക.

ഓരോ തവണയും നിങ്ങളുടെ കോഡിൽ ഈ പ്രസ്താവന ഉൾപ്പെടുത്തണമെങ്കിൽ, VBA എഡിറ്ററിലെ ഒരു പ്രത്യേക ക്രമീകരണം ഉപയോഗിച്ച് നിങ്ങൾക്ക് അങ്ങനെ ചെയ്യാൻ കഴിയും. ഈ ഓപ്ഷൻ പ്രവർത്തനക്ഷമമാക്കാൻ, നിങ്ങൾ ഇനിപ്പറയുന്നവ ചെയ്യണം:

1. പാതയിലൂടെയുള്ള വികസന പരിതസ്ഥിതിയിലേക്ക് പോകുക - ഉപകരണങ്ങൾ > ഓപ്ഷനുകൾ.
2. ഇതിനുശേഷം തുറക്കുന്ന വിൻഡോയിൽ, എഡിറ്റർ ടാബ് തുറക്കുക.
3. അവസാനം, വേരിയബിൾ ഡിക്ലറേഷൻ ഇനത്തിന് അടുത്തുള്ള ബോക്സ് ചെക്കുചെയ്യുക.

ഈ ഘട്ടങ്ങൾ പൂർത്തിയാക്കിയ ശേഷം, "ശരി" ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുക. 

അത്രയേയുള്ളൂ, ഇപ്പോൾ ഓരോ പുതിയ മാക്രോയും എഴുതുമ്പോൾ, ഈ വരി കോഡിന്റെ മുകളിൽ സ്വയമേവ ചേർക്കും.

സ്ഥിരാങ്കങ്ങളുടെയും വേരിയബിളുകളുടെയും വ്യാപ്തി

ഓരോ വേരിയബിളിനും സ്ഥിരാങ്കത്തിനും പരിമിതമായ വ്യാപ്തി മാത്രമേയുള്ളൂ. അത് നിങ്ങൾ എവിടെ പ്രഖ്യാപിക്കുന്നു എന്നതിനെ ആശ്രയിച്ചിരിക്കുന്നു.

നമുക്ക് ഒരു ഫംഗ്ഷൻ ഉണ്ടെന്ന് കരുതുക മൊത്തം ചെലവ്(), കൂടാതെ ഇത് വേരിയബിൾ ഉപയോഗിക്കുന്നു sVAT_റേറ്റ്. മൊഡ്യൂളിലെ സ്ഥാനത്തെ ആശ്രയിച്ച്, ഇതിന് വ്യത്യസ്തമായ വ്യാപ്തി ഉണ്ടായിരിക്കും:

വേരിയബിൾ മറ്റ് മൊഡ്യൂളുകൾ വായിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾ ഡിം കീവേഡിന് പകരം പൊതു കീവേഡ് ഉപയോഗിക്കണം. അതുപോലെ, ഡിം എന്ന വാക്കിന് പകരം എഴുതിയിരിക്കുന്ന പബ്ലിക് സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു വേരിയബിളിന്റെ വ്യാപ്തി നിലവിലെ മൊഡ്യൂളിലേക്ക് പരിമിതപ്പെടുത്താം.

സമാനമായ രീതിയിൽ നിങ്ങൾക്ക് സ്ഥിരാങ്കങ്ങളുടെ വ്യാപ്തി സജ്ജമാക്കാൻ കഴിയും, എന്നാൽ ഇവിടെ കീവേഡ് കോൺസ്റ്റ് ഓപ്പറേറ്ററുമായി ചേർന്നാണ് എഴുതിയിരിക്കുന്നത്.

സ്ഥിരാങ്കങ്ങളും വേരിയബിളുകളും ഉപയോഗിച്ച് ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ മികച്ച ഉദാഹരണമുള്ള ഒരു പട്ടിക ഇതാ.

എന്തുകൊണ്ടാണ് സ്ഥിരാങ്കങ്ങളും വേരിയബിളുകളും ആവശ്യമായി വരുന്നത്

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

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

മാക്രോ നിരവധി പ്രോഗ്രാമർമാർ എഴുതുമ്പോൾ ഇത് വളരെ പ്രധാനമാണ്. ചില വേരിയബിളുകൾ മാറാൻ പാടില്ല എന്ന് ഒരാൾക്ക് അറിയാം. മറ്റൊന്നുമല്ല. നിങ്ങൾ കോൺസ്റ്റ് ഓപ്പറേറ്റർ വ്യക്തമാക്കുകയാണെങ്കിൽ, ഈ മൂല്യം മാറുന്നില്ലെന്ന് മറ്റൊരു ഡവലപ്പർക്ക് അറിയാം.

അല്ലെങ്കിൽ, ഒരു പേരിൽ ഒരു സ്ഥിരാങ്കം ഉണ്ടെങ്കിൽ, വേരിയബിളിന് വ്യത്യസ്തമായ, എന്നാൽ സമാനമായ പേര് ഉണ്ടെങ്കിൽ. ഡവലപ്പർക്ക് അവരെ ആശയക്കുഴപ്പത്തിലാക്കാൻ കഴിയും. ഉദാഹരണത്തിന്, മാറ്റേണ്ടതില്ലാത്ത ഒരു വേരിയബിളിനെ വേരിയബിൾ 11 എന്നും എഡിറ്റ് ചെയ്യാൻ കഴിയുന്ന മറ്റൊന്നിനെ വേരിയബിൾ 1 എന്നും വിളിക്കുന്നു. ഒരു വ്യക്തിക്ക് സ്വയമേവ, കോഡ് എഴുതുമ്പോൾ, അബദ്ധവശാൽ ഒരു അധിക യൂണിറ്റ് ഒഴിവാക്കാനും അത് ശ്രദ്ധിക്കാതിരിക്കാനും കഴിയും. തൽഫലമായി, മൂല്യങ്ങൾക്കായുള്ള കണ്ടെയ്നർ മാറ്റപ്പെടും, അത് തൊടാൻ പാടില്ല.

അല്ലെങ്കിൽ ഏതൊക്കെ വേരിയബിളുകളാണ് തനിക്ക് സ്പർശിക്കാനാകുന്നത്, ഏതൊക്കെ ചെയ്യാൻ കഴിയില്ലെന്ന് ഡവലപ്പർ തന്നെ മറന്നേക്കാം. കോഡ് നിരവധി ആഴ്ചകൾ എഴുതുമ്പോൾ ഇത് പലപ്പോഴും സംഭവിക്കുന്നു, അതിന്റെ വലുപ്പം വലുതായിത്തീരുന്നു. ഈ സമയത്ത്, ഈ അല്ലെങ്കിൽ ആ വേരിയബിൾ എന്താണ് അർത്ഥമാക്കുന്നത് എന്ന് പോലും മറക്കാൻ വളരെ എളുപ്പമാണ്.

അതെ, ഈ സാഹചര്യത്തിൽ നിങ്ങൾക്ക് അഭിപ്രായങ്ങൾ ചെയ്യാൻ കഴിയും, എന്നാൽ കോൺസ്റ്റ് എന്ന വാക്ക് വ്യക്തമാക്കുന്നത് എളുപ്പമല്ലേ?

നിഗമനങ്ങളിലേക്ക്

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

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