കൂടുതൽ വിവരണങ്ങൾ നിങ്ങൾക്ക് കൂടുതൽ വ്യക്തമാക്കുന്നതിന്, ഈ PDF ഫയൽ ഡൗൺലോഡ് ചെയ്യുക അല്ലെങ്കിൽ നിങ്ങളുടെ ബ്രൗസറിന്റെ പുതിയ ടാബിൽ ഈ ചിത്രം തുറക്കുക.

മനോഹരമായി കാണപ്പെടുന്ന ഒരു വെബ്‌സൈറ്റ് എല്ലായ്പ്പോഴും "മനോഹരം" ഉപയോഗിക്കുന്നുണ്ടോ എന്ന് ശ്രദ്ധിക്കുന്നത് ചിലപ്പോൾ രസകരമാണ്. html കോഡ്, അതായത്. കൃത്യമായ, ഘടനാപരമായ, പിശകുകളില്ലാത്ത. HTML കോഡ് ഒരു തരം കലയാണ്. ഇത് ചലനാത്മകമായ ഭാഷ പോലെ വികസിതവും വൈവിധ്യപൂർണ്ണവുമല്ല, എന്നിട്ടും അത് വളരെ ഗംഭീരമായും നൈപുണ്യത്തോടെയും എഴുതാൻ കഴിയും.

കോഡ് വൈദഗ്ധ്യത്തോടെ എഴുതിയതാണോ അല്ലയോ എന്ന് നിർണ്ണയിക്കാൻ ഉപയോഗിക്കാവുന്ന സവിശേഷതകളുടെ ഒരു ലിസ്റ്റ് ഇതാ.

1. ഡോക്‌ടൈപ്പ്ശരിയായി നിർവചിച്ചിരിക്കുന്നു. ഈ സ്ട്രിംഗ് നിങ്ങളുടെ കോഡ് തിരിച്ചറിയാൻ മാത്രമല്ല, നിങ്ങളുടെ പേജ് എങ്ങനെ പ്രദർശിപ്പിക്കണമെന്ന് ബ്രൗസറിനോട് "പറയുന്നു".

2. ടാഗുകളിൽ വൃത്തിയുള്ള വിഭാഗം
തലക്കെട്ട് സജ്ജീകരിച്ചിരിക്കുന്നു. എൻകോഡിംഗ് പ്രഖ്യാപിച്ചു. സ്റ്റൈൽ ഷീറ്റുകൾ ബന്ധിപ്പിച്ചിരിക്കുന്നു. സ്ക്രിപ്റ്റുകൾ ഉൾപ്പെടുത്തിയിട്ടുണ്ട്, പക്ഷേ പൂർണ്ണമായി എഴുതിയിട്ടില്ല.

3. നിങ്ങളുടെ ഡോക്യുമെന്റിലേക്ക് ഒരു ഐഡി അസൈൻ ചെയ്യുന്നുഓരോ പേജിനും അദ്വിതീയമായ CSS പ്രോപ്പർട്ടികൾ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് നിങ്ങളുടെ ആവശ്യമുണ്ടാകാം

ടാഗ് പ്രത്യേകമായി കാണപ്പെട്ടു, ഉദാഹരണത്തിന്, ഹോം പേജിൽ. ഇത് നേടുന്നതിന് നിങ്ങളുടെ CSS സ്റ്റൈൽഷീറ്റിൽ നിങ്ങൾക്ക് ഇങ്ങനെ എഴുതാം: #home h2().

4. മെനു വൃത്തിയാക്കുക.ലിസ്റ്റുകൾ മെനുകളായി ഉപയോഗിക്കുന്നത് നിങ്ങൾ പലപ്പോഴും കണ്ടിട്ടുണ്ടാകും. ഇത് വളരെ സൗകര്യപ്രദമാണ്, കാരണം ... അത് നിയന്ത്രിക്കാനുള്ള കഴിവ് നിങ്ങൾക്ക് നൽകുന്നു.

• വീട്


• കുറിച്ച്


• ബന്ധപ്പെടുക

5. എല്ലാ പേജ് ഉള്ളടക്കവും ഒരു പ്രധാന ടാഗിൽ ഉൾപ്പെടുത്തുന്നു

. ഈ ഇനം നിങ്ങൾക്ക് എല്ലാം നിയന്ത്രിക്കാനുള്ള അവസരം നൽകും. അതായത്, നിങ്ങൾക്ക് പരമാവധി കുറഞ്ഞ പേജ് വീതി സജ്ജമാക്കാൻ കഴിയും.

6. പ്രധാനപ്പെട്ട കാര്യങ്ങൾ തുടക്കത്തിൽ സ്ഥാപിക്കണം.കോഡിലെ വാർത്തകളും പ്രധാന സംഭവങ്ങളും ആദ്യം വരണം, മെനുകളും അപ്രധാനമായ ഉള്ളടക്കവും അവസാനം സ്ഥാപിക്കണം.

7. സൈറ്റ് ഘടകങ്ങളുടെ "ഉൾപ്പെടുത്തൽ".മിക്ക സൈറ്റ് ഘടകങ്ങളും എല്ലാ പേജിലും ആവർത്തിക്കുന്നു, അതായത് php കമാൻഡ് ഉപയോഗിച്ച് അവ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്.

8. കോഡ് വിഭാഗങ്ങളായി പട്ടികപ്പെടുത്തിയിരിക്കണം.കോഡിന്റെ ഓരോ വിഭാഗവും ഇൻഡന്റ് ചെയ്തിട്ടുണ്ടെങ്കിൽ, കോഡിന്റെ ഘടന കൂടുതൽ വ്യക്തമാകും. വിന്യസിച്ചിരിക്കുന്ന കോഡ് വായിക്കാനും മനസ്സിലാക്കാനും ബുദ്ധിമുട്ടാണ്.

9. ശരിയായ ക്ലോസിംഗ് ടാഗുകൾ. ജോടിയാക്കാത്ത ടാഗുകളിൽ എൻഡ് ടാഗുകൾ ഒഴിവാക്കുക, പൊരുത്തപ്പെടുന്ന ടാഗുകൾ അടച്ചിട്ടുണ്ടോയെന്ന് പരിശോധിക്കുക.

10. ടൈറ്റിൽ ടാഗുകൾ ഉപയോഗിക്കുക. തലക്കെട്ടുകളുടെ ഉപയോഗം അത്യാവശ്യമാണ് കാരണം... അവർ വിഭാഗങ്ങളുടെ ശ്രേണി കാണിക്കുകയും അവയ്ക്ക് കൂടുതൽ ക്രമം നൽകുകയും ചെയ്യുന്നു.

12. ശൈലികൾ ഇല്ല!നിങ്ങളുടെ html കോഡ് ഘടനയിലും ഉള്ളടക്കത്തിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കണം, പേജ് ഡിസൈനിലല്ല! എല്ലാ ശൈലികളും ഒരു പ്രത്യേക CSS ഫയലിൽ സ്ഥാപിക്കുക.

കോഡ് വികസിപ്പിക്കുമ്പോൾ പാലിക്കേണ്ട അടിസ്ഥാന നിയമങ്ങൾ ഞാൻ നൽകും, അങ്ങനെ ഒരാഴ്ചയ്ക്കുള്ളിൽ നിങ്ങൾക്ക് കോഡ് നോക്കാനും ഏത് ഫംഗ്ഷൻ എന്തുചെയ്യണമെന്ന് നിർണ്ണയിക്കാനും കഴിയും. വായിക്കാവുന്ന കോഡ് എഴുതുന്നതിന്റെ മറ്റൊരു നേട്ടം പിശകുകൾ കണ്ടെത്താനും പരിഹരിക്കാനുമുള്ള എളുപ്പമാണ്. "തെറ്റാണ്" എന്ന് ഞാൻ അടയാളപ്പെടുത്തുന്ന ഉദാഹരണങ്ങൾ അർത്ഥമാക്കുന്നത് അവ പ്രവർത്തിക്കുന്നില്ല എന്നല്ല, മറിച്ച് വായിക്കാവുന്ന കോഡ് വികസിപ്പിക്കുന്നതിന്റെ വീക്ഷണകോണിൽ നിന്ന് അവ തെറ്റാണെന്ന് ഞാൻ ഉടൻ തന്നെ പറയും.

1. ബ്രാക്കറ്റുകളിൽ നിന്ന് വേരിയബിളുകൾ എടുക്കുക

എല്ലായ്‌പ്പോഴും സ്‌ക്രീനിൽ ടെക്‌സ്‌റ്റ് പ്രദർശിപ്പിക്കുമ്പോൾ, ലൈനിലെ വേരിയബിളുകൾ ബ്രാക്കറ്റുകൾക്ക് പുറത്ത് സ്ഥാപിക്കണം. ഇത് കാണുന്നതിന് സൗകര്യപ്രദം മാത്രമല്ല, ഫലപ്രദവുമാണ്, കാരണം ഇത് സ്ക്രീനിലേക്ക് വേഗത്തിൽ ഔട്ട്പുട്ട് നൽകുന്നു.

തെറ്റായ ഉദാഹരണം:

പ്രതിധ്വനി "മൂല്യം $val ആണ്"

ശരിയായ ഉദാഹരണം:

echo "മൂല്യം ".$val ആണ്

2. അഭിപ്രായങ്ങൾ ഉപയോഗിക്കുന്നത് ഉറപ്പാക്കുക

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

3. എക്കോ ഫംഗ്‌ഷന്റെ ഒരു ഷോർട്ട്‌ഹാൻഡ് പതിപ്പ് ഉപയോഗിക്കുക. ഉദാഹരണത്തിന്, ഒരു റെക്കോർഡ് പോലെ

ഉപയോഗിച്ച് എളുപ്പത്തിൽ മാറ്റിസ്ഥാപിക്കാം

4. സാധ്യമെങ്കിൽ, PHP നിർമ്മിതികൾക്ക് പുറത്ത് വലിയ എച്ച്ടിഎംഎൽ ബ്ലോക്കുകൾ നീക്കുക. php ഫംഗ്‌ഷൻ ദുരുപയോഗം ചെയ്യരുത്.

തെറ്റായ ഉദാഹരണം:

"; പ്രതിധ്വനി "മുമ്പത്തെ നമ്പർ ".($i - 1); എക്കോ "
"; } ?>

ശരിയായ ഉദാഹരണം:

നമ്പർ ആണ്
മുമ്പത്തെ നമ്പർ

രണ്ട് php കൺസ്ട്രക്‌റ്റുകൾ ഇവിടെ തുറന്നിരിക്കുന്നു, അവയ്ക്കിടയിൽ HTML ടെക്‌സ്‌റ്റ് ചേർത്തിരിക്കുന്നു. ഒരുപക്ഷേ ഈ ഉദാഹരണം PHP ഘടനയ്ക്ക് പുറത്ത് വാചകം നീക്കുന്നതിന്റെ വ്യക്തമായ ഗുണം കാണിക്കുന്നില്ല, എന്നാൽ വാസ്തവത്തിൽ, നിങ്ങൾക്ക് പട്ടികകൾ കൈകാര്യം ചെയ്യേണ്ടിവരുമ്പോൾ, അത്തരമൊരു നിയമം വളരെ ഉപയോഗപ്രദമാകും.

5. ബ്ലോക്കുകളുമായി ബന്ധപ്പെട്ട് കോഡ് വിന്യസിച്ചിരിക്കണം.

തെറ്റായ ഉദാഹരണം:

ഓർക്കുക, php അതിന്റെ ആരംഭ... അവസാന ബ്ലോക്കുകളുള്ള പാസ്കൽ അല്ല. ഇവിടെ ബ്ലോക്ക് അത് ആരംഭിച്ച അതേ വരിയിൽ തുറക്കുകയും ബ്ലോക്കിന്റെ തുടക്കവുമായി വിന്യസിച്ചിരിക്കുന്ന അടയ്ക്കുകയും വേണം:

6. സങ്കീർണ്ണമായ ഡിസൈനുകൾ ലളിതമാക്കുക. അവയെ ലളിതമായവയായി വിഭജിക്കുക.

തെറ്റായ ഉദാഹരണം:

$res = mysql_result(mysql_query("സെലക്ട് നം ഡിബിയിൽ നിന്ന്"), 0, 0)

ശരിയായ ഉദാഹരണം:

$query = mysql_query("സെലക്ട് നം ഡിബിയിൽ നിന്ന്"); $res = mysql_result($query, 0, 0);

7. കൂടുതൽ ഇടങ്ങളും ശൂന്യമായ വരികളും ഉപയോഗിക്കുക.

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

തെറ്റായ ഉദാഹരണം:

ശരിയായ ഉദാഹരണം:

8. ഗണിതം, സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾക്ക് കുറുക്കുവഴികൾ ഉപയോഗിക്കുക.

+1 എന്നത് എല്ലായ്‌പ്പോഴും ++ എന്നതും +n എന്നത് +=n ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കാമെന്നതും ഓർക്കുക.

പകരക്കാരുടെ ഉദാഹരണങ്ങൾ:

$i = $i + 1 എന്നത് $i++ എന്നതിന് തുല്യമാണ്
$i = $i — 1 എന്നത് $i- ന് തുല്യമാണ്
$i = $i + $n എന്നത് $i+=$n എന്നതിന് തുല്യമാണ്
$i = $i."ഹലോ" എന്നത് $i.="ഹലോ" എന്നതിന് തുല്യമാണ്

നല്ല ചീത്ത

മറ്റ് പ്രോഗ്രാമർമാരുടെ ജോലിക്ക് മേൽനോട്ടം വഹിക്കേണ്ട ആവശ്യം നേരിടുമ്പോൾ, ആളുകൾ വളരെ എളുപ്പത്തിലും വേഗത്തിലും പഠിക്കുന്ന കാര്യങ്ങൾക്ക് പുറമേ, പരിഹരിക്കാൻ കാര്യമായ സമയം ആവശ്യമായ പ്രശ്‌നങ്ങളുണ്ടെന്ന് നിങ്ങൾ മനസ്സിലാക്കാൻ തുടങ്ങുന്നു.

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

എന്നാൽ യഥാർത്ഥ കോഡിലേക്ക് വരുമ്പോൾ, കാര്യങ്ങൾ വളരെ വ്യക്തമല്ല. അതെ, നിങ്ങൾക്ക് ദുർബലമായ പോയിന്റുകൾ ചൂണ്ടിക്കാണിക്കാൻ കഴിയും, അവയിൽ എന്താണ് തെറ്റെന്ന് നിങ്ങൾക്ക് വിശദീകരിക്കാൻ പോലും കഴിയും. അടുത്ത തവണ പൂർണ്ണമായും പുതിയ പ്രശ്‌നങ്ങളുള്ള ഒരു അവലോകനം നേടുക.

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

അടിസ്ഥാന അറിവിനെക്കുറിച്ച് പറയുമ്പോൾ, മനോഹരമായ പ്രൊഫഷണൽ കോഡ് എഴുതാനുള്ള കഴിവ് ഒരു കാരണത്താലോ മറ്റൊരു കാരണത്താലോ ഈ അടിസ്ഥാന അറിവ് വ്യതിരിക്തമാണ് എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഒഴിവാക്കി. പകരം, പ്രസക്തമായ സ്ഥാപനങ്ങളിൽ, അതുപോലെ തന്നെ പുസ്തകങ്ങളിൽ, അൽഗോരിതങ്ങൾ, ഭാഷകൾ, OOP തത്വങ്ങൾ, ഡിസൈൻ പാറ്റേണുകൾ എന്നിവയെക്കുറിച്ച് ഞങ്ങളോട് പറയുന്നു.

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

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

എന്നാൽ ഞങ്ങളോടൊപ്പം പ്രവർത്തിക്കുന്ന ആളുകൾ എഴുതിയ കോഡിന്റെ ഗുണനിലവാരം ഞങ്ങൾക്ക് ശരിക്കും പ്രധാനമാണെങ്കിൽ, അത് ഇപ്പോഴും ശ്രമിക്കേണ്ടതാണ്!

2. എന്തുകൊണ്ടാണ് നമുക്ക് മനോഹരമായ കോഡ് വേണ്ടത്?

സാധാരണയായി, ഞങ്ങൾ ഒരു പ്രത്യേക സോഫ്‌റ്റ്‌വെയർ ഉൽപ്പന്നത്തിൽ പ്രവർത്തിക്കുമ്പോൾ, കോഡിന്റെ സൗന്ദര്യാത്മക ഗുണങ്ങൾ നമ്മുടെ ആദ്യത്തെ ആശങ്കയല്ല.
ഞങ്ങളുടെ ഉൽപ്പാദനക്ഷമത, പ്രവർത്തനക്ഷമത നടപ്പിലാക്കുന്നതിന്റെ ഗുണനിലവാരം, അതിന്റെ പ്രവർത്തനത്തിന്റെ സ്ഥിരത, പരിഷ്ക്കരണത്തിന്റെയും വിപുലീകരണത്തിന്റെയും സാധ്യത മുതലായവ ഞങ്ങൾക്ക് വളരെ പ്രധാനമാണ്.

എന്നാൽ കോഡിന്റെ സൗന്ദര്യാത്മക ഗുണങ്ങൾ മുകളിൽ പറഞ്ഞ സൂചകങ്ങളെ നല്ല രീതിയിൽ സ്വാധീനിക്കുന്ന ഒരു ഘടകമാണോ?
എന്റെ ഉത്തരം: അതെ, അതേ സമയം, ഏറ്റവും പ്രധാനപ്പെട്ട ഒന്ന്!

സൗന്ദര്യ സങ്കൽപ്പത്തിന്റെ ആത്മനിഷ്ഠമായ വ്യാഖ്യാനം പരിഗണിക്കാതെ തന്നെ മനോഹരമായ കോഡിന് ഇനിപ്പറയുന്ന (ഒരു പരിധിവരെ അല്ലെങ്കിൽ മറ്റൊന്നിലേക്ക് കുറയ്ക്കാവുന്ന) ഏറ്റവും പ്രധാനപ്പെട്ട ഗുണങ്ങളുണ്ട്:

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

എന്തുകൊണ്ടാണ് ഈ ഗുണങ്ങൾ യഥാർത്ഥത്തിൽ ഏറ്റവും പ്രധാനപ്പെട്ടത്, കൂടാതെ ഖണ്ഡികയുടെ തുടക്കത്തിൽ സൂചിപ്പിച്ചിരിക്കുന്ന സൂചകങ്ങൾ മെച്ചപ്പെടുത്തുന്നതിന് അവ എങ്ങനെ സംഭാവന ചെയ്യുന്നു, പ്രോഗ്രാമിംഗിൽ ഏർപ്പെട്ടിരിക്കുന്ന ആർക്കും വ്യക്തമാണെന്ന് എനിക്ക് ഉറപ്പുണ്ട്.

ഇപ്പോൾ, പൊതുവായ വാക്കുകളിൽ നിന്ന് പ്രത്യേകതകളിലേക്ക് നീങ്ങുന്നതിന്, നമുക്ക് നേരെ വിപരീതമായി പ്രവർത്തിക്കാം, ഇത് വായിക്കാവുന്നതും കൈകാര്യം ചെയ്യാവുന്നതുമായ കോഡാണെന്ന് പറയുക, അത് സാധാരണയായി മനോഹരവും പ്രൊഫഷണലായി എഴുതിയതുമായി ഞങ്ങൾ കാണുന്നു. അതനുസരിച്ച്, ഈ ഗുണങ്ങൾ എങ്ങനെ നേടാം എന്നതിനെക്കുറിച്ച് ഞങ്ങൾ കൂടുതൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കും.

3. മൂന്ന് അടിസ്ഥാന തത്വങ്ങൾ.

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

നിർദ്ദിഷ്ട പ്രോഗ്രാമിംഗ് ഭാഷയും പരിഹരിക്കപ്പെടുന്ന ജോലികളും പരിഗണിക്കാതെ തന്നെ, ഒരു കോഡിന് ഈ രണ്ട് ഗുണങ്ങൾ വേണ്ടത്ര ലഭിക്കുന്നതിന്, ഇത് ഇനിപ്പറയുന്നതായിരിക്കണം:

• കഴിയുന്നത്ര രേഖീയമായി;
• ചെറുത്;
• സ്വയം രേഖപ്പെടുത്തി.

നിങ്ങളുടെ കോഡ് കൂടുതൽ മനോഹരമാക്കാൻ ഉപയോഗിക്കാവുന്ന വിവിധ സൂചനകളും സാങ്കേതിക വിദ്യകളും നിങ്ങൾക്ക് അനന്തമായി പട്ടികപ്പെടുത്താം. എന്നാൽ ഈ മൂന്ന് തത്ത്വങ്ങളിൽ ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നതിലൂടെ ഏറ്റവും മികച്ചതോ കുറഞ്ഞപക്ഷം നല്ലതോ ആയ ഫലങ്ങൾ കൈവരിക്കാൻ കഴിയുമെന്ന് ഞാൻ വാദിക്കുന്നു.

4. കോഡ് ലീനിയറൈസേഷൻ.

മൂന്ന് അടിസ്ഥാന തത്ത്വങ്ങളിൽ, രേഖീയതയാണ് ഏറ്റവും അവ്യക്തവും, മിക്കപ്പോഴും അവഗണിക്കപ്പെടുന്നതും എന്ന് എനിക്ക് തോന്നുന്നു.
പഠനത്തിന്റെ വർഷങ്ങളായി (ഒപ്പം, ഒരുപക്ഷേ, ശാസ്ത്രീയ പ്രവർത്തനങ്ങളും) സ്വാഭാവികമായും രേഖീയമല്ലാത്ത അൽഗോരിതങ്ങൾ പോലുള്ള എസ്റ്റിമേറ്റുകളുമായി ചർച്ച ചെയ്യാൻ ഞങ്ങൾ ശീലിച്ചതുകൊണ്ടായിരിക്കാം O(n3), O(nlogn)തുടങ്ങിയവ.

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

അതിനാൽ, അൽഗോരിതത്തിന്റെ അസിംപ്റ്റോട്ടിക് സങ്കീർണ്ണതയെ ഞാൻ രേഖീയതയുമായി ബന്ധപ്പെടുത്തുന്നില്ല. പരസ്‌പരമുള്ള കോഡ് ബ്ലോക്കുകളുടെ പരമാവധി എണ്ണം, അല്ലെങ്കിൽ ഏറ്റവും ദൈർഘ്യമേറിയ കോഡ് ഉപവിഭാഗത്തിന്റെ നെസ്റ്റിംഗ് നില.

ഉദാഹരണത്തിന്, തികച്ചും രേഖീയ ശകലം:

Do_a(); do_b(); do_c();
രേഖീയമല്ല:

Do_a(); എങ്കിൽ (പരിശോധിക്കുക) (എന്തെങ്കിലും (); ) മറ്റെന്തെങ്കിലും (); എങ്കിൽ (എന്തായാലും ()) ( (എ ഇൻ ബി) (എങ്കിൽ (നല്ലത് (എ)) (എന്തെങ്കിലും (); ) ) )
ചില സാങ്കേതിക വിദ്യകൾ ഉപയോഗിച്ച് ഞങ്ങൾ മാറ്റിയെഴുതാൻ ശ്രമിക്കുന്ന രണ്ടാമത്തെ തരത്തിലുള്ള "കഷണങ്ങൾ" ആണ്.

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

4.1. സാങ്കേതികത 1. അൽഗോരിതത്തിന്റെ പ്രധാന ശാഖ തിരഞ്ഞെടുക്കുക.

ബഹുഭൂരിപക്ഷം കേസുകളിലും, അൽഗോരിതത്തിന്റെ ഏറ്റവും ദൈർഘ്യമേറിയ വിജയകരമായ ലീനിയർ സാഹചര്യം പ്രധാന ശാഖയായി എടുക്കുന്നത് യുക്തിസഹമാണ്.

മുകളിലുള്ള ഡയഗ്രാമിലെ "ഓട്ടോ റിപ്പയർ അൽഗോരിതം" അടിസ്ഥാനമാക്കി ഇത് ചെയ്യാൻ ശ്രമിക്കാം:

1. ഉപഭോക്താവ് അവന്റെ ആഗ്രഹങ്ങൾ അറിയിക്കുന്നു.
2. മാസ്റ്റർ പരിശോധിച്ച് ചെലവ് പറയുന്നു.
3. വൈകല്യങ്ങൾക്കായി തിരയുക.
4. ഞങ്ങൾ സ്പെയർ പാർട്സുകൾക്കായി ഒരു ഓർഡർ നൽകുന്നു.
5. ഞങ്ങൾ ഒരു മുൻകൂർ പേയ്മെന്റ് എടുക്കുകയും ഒരു സമയപരിധി നിശ്ചയിക്കുകയും ചെയ്യുന്നു.
6. ക്ലയന്റ് പോകുന്നു.

ഈ പ്രധാന ശാഖയാണ് നമുക്ക് പൂജ്യം നെസ്റ്റിംഗ് ലെവലിൽ ഉണ്ടായിരിക്കേണ്ടത്.

Listen_client(); എങ്കിൽ (!is_clean()) (... ) check_cost(); എങ്കിൽ (!client_agree()) (... ) find_defects(); എങ്കിൽ (defects_found()) (... ) create_request(); എടുക്കുക_മണി(); ബൈ();
താരതമ്യത്തിനായി, പ്രധാനമായതിന് പകരം പൂജ്യം ലെവലിൽ ഒരു ഇതര ബ്രാഞ്ച് ഉള്ള ഓപ്ഷൻ നമുക്ക് പരിഗണിക്കാം:

Listen_client(); എങ്കിൽ (!is_clean()) (... ) check_cost(); എങ്കിൽ (client_agree()) ( find_defects(); if (defects_found()) (... ) create_request(); take_money(); ) else ( ... ) bye();
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, കോഡിന്റെ ഒരു പ്രധാന ഭാഗത്തിന്റെ നെസ്റ്റിംഗ് നില വർദ്ധിച്ചു, കൂടാതെ കോഡ് മൊത്തത്തിൽ നോക്കുന്നത് സുഖകരമല്ല.

4.2. സാങ്കേതികത 2. ഉപയോഗിക്കുക ബ്രേക്ക്, തുടരുക, മടങ്ങുകഅഥവാ എറിയുകബ്ലോക്കിൽ നിന്ന് രക്ഷപ്പെടാൻ വേറെ.

മോശമായി:

എങ്കിൽ (!client_agree()) (... ) വേറെ (കണ്ടെത്തുക_വൈകല്യങ്ങൾ(); എങ്കിൽ (defects_found()) (... ) create_request(); take_money(); bye();

എങ്കിൽ (!client_agree()) (... return; ) find_defects(); എങ്കിൽ (defects_found()) (... ) create_request(); എടുക്കുക_മണി(); ബൈ();

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

മൂന്നാമതായി, ഒന്നിലധികം ഉപയോഗിക്കുമ്പോൾ ചില ചിലവുകൾ ഉണ്ട് മടങ്ങുകനടപടിക്രമങ്ങളിലും പ്രവർത്തനങ്ങളിലും, ഈ സമീപനത്തെ പലരും പൊതുവെ ഒരു വിരുദ്ധ പാറ്റേണായി കണക്കാക്കുന്നു (എന്റെ വ്യക്തിപരമായ അഭിപ്രായം: സാധാരണയായി ആനുകൂല്യങ്ങൾ ഇപ്പോഴും ഈ ചെലവുകൾ ഉൾക്കൊള്ളുന്നു).

അതിനാൽ, ഈ (മറ്റേതെങ്കിലും) സാങ്കേതികത ഒരു സൂചനയായി കാണണം, അല്ലാതെ പ്രവർത്തനത്തിനുള്ള നിരുപാധിക നിർദ്ദേശമായിട്ടല്ല.

4.3. സാങ്കേതികത 3. ഞങ്ങൾ സങ്കീർണ്ണമായ ഉപ-സാഹചര്യങ്ങൾ പ്രത്യേക നടപടിക്രമങ്ങളാക്കി മാറ്റുന്നു.

കാരണം "റിപ്പയർ അൽഗോരിതം" കാര്യത്തിൽ, ഞങ്ങൾ വളരെ വിജയകരമായി പ്രധാന ബ്രാഞ്ച് തിരഞ്ഞെടുത്തു, എന്നാൽ ഞങ്ങളുടെ ഇതര ശാഖകൾ എല്ലാം വളരെ ചെറുതായിരുന്നു.

അതിനാൽ, അധ്യായത്തിന്റെ തുടക്കം മുതൽ "മോശം" ഉദാഹരണത്തെ അടിസ്ഥാനമാക്കിയുള്ള സാങ്കേതികത ഞങ്ങൾ പ്രദർശിപ്പിക്കും:

Do_a() എങ്കിൽ (പരിശോധിക്കുക) ( എന്തെങ്കിലും (); ) മറ്റെന്തെങ്കിലും (എന്തെങ്കിലും (); എങ്കിൽ (എന്തായാലും ()) ( (a in b) ന് (നല്ലത്(a)) (എന്തെങ്കിലും (); ) ) )
മികച്ചത്:

നടപടിക്രമം do_on_whatever() ( (a-ൽ b) (നല്ലത്(a)) (എന്തെങ്കിലും(); ) ) do_a(); എങ്കിൽ (പരിശോധിക്കുക) (എന്തെങ്കിലും (); ) മറ്റെന്തെങ്കിലും (എന്തെങ്കിലും (); എങ്കിൽ (എന്തായാലും ()) ( do_on_whatever (); ) )
ഹൈലൈറ്റ് ചെയ്‌ത നടപടിക്രമത്തിനായി ശരിയായ പേര് തിരഞ്ഞെടുക്കുന്നതിലൂടെ, ഞങ്ങൾ കോഡിന്റെ സ്വയം ഡോക്യുമെന്റേഷൻ ഉടനടി വർദ്ധിപ്പിക്കുമെന്നത് ശ്രദ്ധിക്കുക. ഇപ്പോൾ ഈ ശകലത്തിന് അത് എന്താണ് ചെയ്യുന്നതെന്നും എന്തുകൊണ്ട് അത് ആവശ്യമാണെന്നും പൊതുവായി വ്യക്തമാക്കണം.

എന്നിരുന്നാലും, അതേ കാര്യം മനസ്സിൽ പിടിക്കണം സ്വയം ഡോക്യുമെന്റേഷൻപുറത്തെടുത്ത കോഡിന്റെ ഭാഗത്തിന് കോഡ് നിർവ്വഹിക്കുന്ന മൊത്തത്തിലുള്ള പൂർത്തിയാക്കിയ ടാസ്‌ക് ഇല്ലെങ്കിൽ അത് വളരെയധികം കഷ്ടപ്പെടും. ഒരു നടപടിക്രമത്തിനായി ശരിയായ പേര് തിരഞ്ഞെടുക്കുന്നതിനുള്ള ബുദ്ധിമുട്ട് അത്തരമൊരു കേസിന്റെ സൂചകമായിരിക്കാം (കാണുക വകുപ്പ് 6.1).

4.4. സാങ്കേതികത 4. സാധ്യമായതെല്ലാം ഞങ്ങൾ ബാഹ്യ യൂണിറ്റിലേക്ക് എടുക്കുന്നു, ആന്തരികത്തിൽ ആവശ്യമുള്ളത് മാത്രം അവശേഷിക്കുന്നു.

മോശമായി:

എങ്കിൽ (പരിശോധിക്കുക) ( do_a (); എന്തെങ്കിലും (); എങ്കിൽ (എന്തായാലും ()) ( (എ ഇൻ ബി) (എങ്കിൽ (നല്ലത് (എ)) (എന്തെങ്കിലും (); ) ) മറ്റെന്തെങ്കിലും ( do_a (); എന്തും ( ); എങ്കിൽ (എന്തായാലും ()) ( (a ഇൻ ബി) (എങ്കിൽ (നല്ലത് (എ)) (എന്തെങ്കിലും (); )) )
മികച്ചത്:

Do_a(); എങ്കിൽ (പരിശോധിക്കുക) (എന്തെങ്കിലും (); ) മറ്റെന്തെങ്കിലും (എന്തെങ്കിലും ();

4.5. ടെക്നിക് 5 (മുമ്പത്തെ ഒരു പ്രത്യേക കേസ്). സ്ഥാപിക്കുക ശ്രമിക്കുക... പിടിക്കുകആവശ്യമുള്ളത് മാത്രം.

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

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

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

4.6. സാങ്കേതികത 6. നെസ്റ്റഡ് ifs സംയോജിപ്പിക്കുക.

എല്ലാം ഇവിടെ വ്യക്തമാണ്. ഇതിനുപകരമായി:

എങ്കിൽ (എ) (എങ്കിൽ (ബി) (_എന്തെങ്കിലും ചെയ്യുക(); ) )
ഞങ്ങള് എഴുതുന്നു:

എങ്കിൽ (a && b) ( do_something(); )

4.7. ടെക്നിക് 7. ടെർനറി ഓപ്പറേറ്റർ ഉപയോഗിക്കുക ( എ? ബി:സി) ഇതിനുപകരമായി എങ്കിൽ.

ഇതിനുപകരമായി:

എങ്കിൽ (a) (var1 = b; ) വേറെ (var1 = c; )
ഞങ്ങള് എഴുതുന്നു:

Var1 = a ? b:c;
ചില സമയങ്ങളിൽ നെസ്റ്റഡ് ടെർനറി ഓപ്പറേറ്റർമാരെ എഴുതുന്നത് പോലും അർത്ഥമാക്കുന്നു, എന്നിരുന്നാലും, ടെർണറി ഓപ്പറേറ്റർ സബ്‌എക്‌സ്‌പ്രഷനുകൾ മൂല്യനിർണ്ണയം ചെയ്യുന്ന മുൻ‌ഗണന വായനക്കാരന് അറിയേണ്ടതുണ്ട്.

എങ്കിൽ (a) (var1 = b; ) else if (aa) (var1 = c; ) else (var1 = d; )
ഞങ്ങള് എഴുതുന്നു:

Var1 = a ? b:aa? സി: ഡി;
എന്നാൽ ഇത് ദുരുപയോഗം ചെയ്യുന്നത് ഒരുപക്ഷേ വിലമതിക്കുന്നില്ല.

വേരിയബിൾ ഇനിഷ്യലൈസേഷൻ ശ്രദ്ധിക്കുക var1ഇപ്പോൾ ഒരൊറ്റ ഓപ്പറേഷനിൽ നടപ്പിലാക്കുന്നു, ഇത് വീണ്ടും സ്വയം ഡോക്യുമെന്റേഷനിൽ വളരെയധികം സംഭാവന ചെയ്യുന്നു (കാണുക വകുപ്പ് 6.8).

4.8. മുകളിൽ പറഞ്ഞവ സംഗ്രഹിച്ചുകൊണ്ട്, റിപ്പയർ അൽഗോരിതം പൂർണ്ണമായി നടപ്പിലാക്കാൻ കഴിയുന്നത്ര രേഖീയമായി എഴുതാൻ ശ്രമിക്കാം.

ലിസൻ_ക്ലയന്റ്(); എങ്കിൽ (!is_clean()) (wash(); ) check_cost(); എങ്കിൽ (! client_agree()) ( pay_for_wash(); bye(); return; ) find_defects(); എങ്കിൽ (defects_found()) ( say_about_defects(); if (! client_agree()) (pa_for_wash_and_dyagnosis(); bye(); return; ) create_request(); എടുക്കുക_മണി(); ബൈ();
ഞങ്ങൾക്ക് ഇവിടെ നിർത്താം, പക്ഷേ ഞങ്ങൾക്ക് 3 തവണ വിളിക്കേണ്ടി വരുന്നത് വളരെ രസകരമല്ല ബൈ()അതനുസരിച്ച്, ഒരു പുതിയ ബ്രാഞ്ച് ചേർക്കുമ്പോൾ, അത് ഓരോ തവണയും റിട്ടേണിന് മുമ്പ് എഴുതേണ്ടിവരുമെന്ന് ഓർക്കുക (വാസ്തവത്തിൽ, ഒന്നിലധികം റിട്ടേണുകളുടെ ചെലവുകൾ).

അതിലൂടെ പ്രശ്നം പരിഹരിക്കാൻ സാധിക്കും ശ്രമിക്കുക...അവസാനം, എന്നാൽ ഇത് പൂർണ്ണമായും ശരിയല്ല, കാരണം ഈ സാഹചര്യത്തിൽ, ഒഴിവാക്കൽ കൈകാര്യം ചെയ്യുന്നതിനെക്കുറിച്ച് സംസാരിക്കുന്നില്ല. അത്തരമൊരു സമീപനം രേഖീയവൽക്കരണ പ്രക്രിയയെ വളരെയധികം തടസ്സപ്പെടുത്തും.

നമുക്ക് ഇത് ചെയ്യാം (വാസ്തവത്തിൽ, ഞാൻ ഉപയോഗിച്ചു ക്ലോസ് 5.1ഞാൻ എഴുതുന്നതിന് മുമ്പ് തന്നെ):

നടപടിക്രമം. ; മടങ്ങുക എങ്കിൽ (!is_clean()) (wash(); ) negotiate_with_client(); ബൈ();
ഞങ്ങൾ ഇപ്പോൾ നിസ്സാരമായ എന്തെങ്കിലും രേഖപ്പെടുത്തിയിട്ടുണ്ടെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ, തത്വത്തിൽ, അത് അങ്ങനെയാണ്. എന്നിരുന്നാലും, പല തത്സമയ പ്രോജക്റ്റുകളിലും ഈ അൽഗോരിതം തികച്ചും വ്യത്യസ്തമായ നിർവ്വഹണം നിങ്ങൾ കാണുമെന്ന് ഞാൻ നിങ്ങൾക്ക് ഉറപ്പ് നൽകുന്നു...

5. കോഡ് മിനിമൈസേഷൻ.

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

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

5.1. സാങ്കേതികത 1. കോഡ് ഡ്യൂപ്ലിക്കേഷൻ ഒഴിവാക്കുക.

കോപ്പി-പേസ്റ്റിനെ കുറിച്ചും അതുണ്ടാക്കുന്ന ദോഷങ്ങളെ കുറിച്ചും ഇതിനോടകം പലതും പറഞ്ഞിട്ടുണ്ട്, പുതിയതായി എന്തെങ്കിലും ചേർക്കുന്നത് ബുദ്ധിമുട്ടായിരിക്കും. എന്നിരുന്നാലും, പ്രോഗ്രാമർമാർ, തലമുറതലമുറയായി, സോഫ്റ്റ്വെയർ പ്രവർത്തനം നടപ്പിലാക്കാൻ ഈ രീതി തീവ്രമായി ഉപയോഗിക്കുന്നു.

തീർച്ചയായും, പ്രശ്നം കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഏറ്റവും വ്യക്തമായ രീതി, വീണ്ടും ഉപയോഗിച്ച കോഡ് പ്രത്യേക നടപടിക്രമങ്ങളിലേക്കും ക്ലാസുകളിലേക്കും മാറ്റുക എന്നതാണ്.
ഈ സാഹചര്യത്തിൽ, പൊതുവായതിൽ നിന്ന് പ്രത്യേകമായി വേർതിരിക്കുന്ന പ്രശ്നം എല്ലായ്പ്പോഴും ഉയർന്നുവരുന്നു. സമാനമായ കോഡുകളിൽ കൂടുതൽ സമാനതകളോ വ്യത്യാസങ്ങളോ ഉള്ളത് എന്താണെന്ന് പലപ്പോഴും വ്യക്തമല്ല. സാഹചര്യത്തിനനുസരിച്ച് മാത്രമാണ് ഇവിടെ തിരഞ്ഞെടുപ്പ് നടത്തുന്നത്. എന്നിരുന്നാലും, പകുതി സ്‌ക്രീനിന്റെ വലുപ്പമുള്ള സമാന വിഭാഗങ്ങളുടെ സാന്നിധ്യം ഈ കോഡിന് വളരെ ചെറുതായി എഴുതാനും എഴുതാനും കഴിയുമെന്ന് ഉടനടി സൂചിപ്പിക്കുന്നു.

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

നടപടിക്രമം proc1() ( init(); do1(); ) നടപടിക്രമം proc2() ( init(); do2();) proc1(); proc2();
നമുക്ക് എഴുതാം:

Init(); do1(); do2();
അല്ലെങ്കിൽ വിപരീത ഓപ്ഷൻ. ഇതിനുപകരമായി:
a = പുതിയ ഒബ്ജക്റ്റ്(); init(a); ചെയ്യുക (എ); b = പുതിയ ഒബ്ജക്റ്റ്(); init(b); do(b);
നമുക്ക് എഴുതാം:
നടപടിക്രമം proc(a) ( init(a); do(a); ) proc(new Object()); proc(പുതിയ ഒബ്ജക്റ്റ്());

5.2. സാങ്കേതികത 2. അനാവശ്യമായ വ്യവസ്ഥകളും പരിശോധനകളും ഒഴിവാക്കുക.

മിക്കവാറും എല്ലാ പ്രോഗ്രാമുകളിലും കാണാവുന്ന ഒരു തിന്മയാണ് അധിക പരിശോധനകൾ. വളരെ നിസ്സാരമായ നടപടിക്രമങ്ങളും അൽഗരിതങ്ങളും വ്യക്തമായി അനാവശ്യവും തനിപ്പകർപ്പും അർത്ഥശൂന്യവുമായ പരിശോധനകളാൽ എങ്ങനെ അടഞ്ഞുപോകുമെന്ന് വിവരിക്കാൻ പ്രയാസമാണ്.

ഇത് പ്രത്യേകിച്ചും, തീർച്ചയായും, പരിശോധനകൾക്ക് ബാധകമാണ് ശൂന്യം. ചട്ടം പോലെ, സർവ്വവ്യാപിയായ പ്രോഗ്രാമർമാരുടെ ശാശ്വതമായ ഭയം മൂലമാണ് ഇത് സംഭവിക്കുന്നത് NPEഅവരിൽ നിന്ന് ഒരിക്കൽ കൂടി സുരക്ഷിതരാകാനുള്ള ആഗ്രഹവും.

അസാധാരണമല്ലാത്ത ഒരു തരത്തിലുള്ള അനാവശ്യ പരിശോധന ഇനിപ്പറയുന്ന ഉദാഹരണമാണ്:

ഒബ്ജ് = പുതിയ ഒബ്ജക്റ്റ്(); ... എങ്കിൽ (obj != null) (obj.call(); )
വ്യക്തമായ അസംബന്ധം ഉണ്ടായിരുന്നിട്ടും, അത്തരം പരിശോധനകൾ ശ്രദ്ധേയമായ ക്രമത്തോടെയാണ് സംഭവിക്കുന്നത്. (ഓപ്പറേറ്റർ ഉള്ള അപൂർവ ഭാഷകൾക്കും പരിതസ്ഥിതികൾക്കും ഉദാഹരണം ബാധകമല്ലെന്ന് ഞാൻ ഉടൻ തന്നെ റിസർവേഷൻ ചെയ്യും പുതിയ()മടങ്ങാം ശൂന്യം. മിക്ക കേസുകളിലും (ജാവ ഉൾപ്പെടെ), ഇത് അടിസ്ഥാനപരമായി അസാധ്യമാണ്.

വ്യക്തമായും പാലിക്കപ്പെട്ട (അല്ലെങ്കിൽ വ്യക്തമായും പാലിക്കാത്ത) ഒരു അവസ്ഥയ്‌ക്കായി നിങ്ങൾക്ക് ഡസൻ കണക്കിന് മറ്റ് തരത്തിലുള്ള ചെക്കുകളും ഇവിടെ ഉൾപ്പെടുത്താം.
ഇവിടെ, ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന കേസ്:

Obj = factory.getObject(); obj.call1(); // obj ശൂന്യമാണെങ്കിൽ, നമ്മൾ ഇതിനകം മരിച്ചുപോയിരിക്കും) എങ്കിൽ (obj != null) (obj.call2(); )
മുമ്പത്തെ തരത്തിലുള്ള പരിശോധനകളേക്കാൾ പലമടങ്ങ് ഇത് സംഭവിക്കുന്നു.

മൂന്നാമത്തെ ഉദാഹരണം ആദ്യ രണ്ടിനേക്കാൾ അൽപ്പം വ്യക്തമാണ്, പക്ഷേ ഇത് സർവ്വവ്യാപിയാണ്:

നടപടിക്രമം proc1(obj) ( if (!is_valid(obj)) return; obj.call1(); ) process proc2(obj) ( if (!is_valid(obj)) return; obj.call2(); ) obj = ഫാക്ടറി. getObject(); if (is_valid(obj) (proc1(obj); proc2(obj); )
നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ സെഗ്‌മെന്റിന്റെ രചയിതാവ് ഒരു അസാധുവായ ഒബ്‌ജക്റ്റിലേക്ക് ഓടുന്നതിൽ ഭയക്കുന്നു, അതിനാൽ ഓരോ തുമ്മലിനും മുമ്പായി അവൻ അത് പരിശോധിക്കുന്നു. അത്തരമൊരു തന്ത്രം ചിലപ്പോൾ ന്യായീകരിക്കപ്പെടാമെങ്കിലും (പ്രത്യേകിച്ച് proc1()ഒപ്പം proc2()ഒരു API ആയി എക്‌സ്‌പോർട്ടുചെയ്‌തു), മിക്ക കേസുകളിലും ഇത് കോഡ് അലങ്കോലമാണ്.

ഇവിടെ ഓപ്ഷനുകൾ വ്യത്യസ്തമായിരിക്കാം:

• ഓരോ നടപടിക്രമത്തിനും, കോളർ ചില സാധുത വ്യവസ്ഥകൾ പാലിക്കാൻ ആവശ്യപ്പെടുന്ന ഒരു ഇൻപുട്ട് കരാർ നിർവചിക്കുക. ഇതിനുശേഷം, സുരക്ഷാ പരിശോധനകൾ നീക്കം ചെയ്യുകയും ഇൻപുട്ട് ഡാറ്റയുടെ സാധുതയ്ക്കുള്ള മുഴുവൻ ഉത്തരവാദിത്തവും കോളിംഗ് കോഡിലേക്ക് മാറ്റുകയും ചെയ്യുക. ഉദാഹരണത്തിന്, ജാവയെ സംബന്ധിച്ചിടത്തോളം, "അപകടകരമായ" രീതികളും ഫീൽഡുകളും ഒരു വ്യാഖ്യാനം ഉപയോഗിച്ച് അടയാളപ്പെടുത്തുന്നത് നല്ല പരിശീലനമായിരിക്കും. @നല്ലബിൾ. അതിനാൽ, മറ്റ് ഫീൽഡുകൾക്കും രീതികൾക്കും ഒരു മൂല്യം സ്വീകരിക്കാൻ / തിരികെ നൽകാനാകുമെന്ന് ഞങ്ങൾ പരോക്ഷമായി സൂചിപ്പിക്കുന്നു ശൂന്യം.
• അസാധുവായ ഒബ്‌ജക്‌റ്റുകൾ സൃഷ്‌ടിക്കരുത്! ഈ സമീപനം ഒബ്‌ജക്റ്റ് സൃഷ്‌ടി ഘട്ടത്തിൽ എല്ലാ മൂല്യനിർണ്ണയ നടപടിക്രമങ്ങളും നടത്തുന്നതിൽ ഉൾപ്പെടുന്നു, അതിനാൽ വിജയകരമായ സൃഷ്ടിയുടെ വസ്തുത ഇതിനകം തന്നെ സാധുത ഉറപ്പ് നൽകുന്നു. തീർച്ചയായും, ഇതിന് കുറഞ്ഞത് ഫാക്ടറി ക്ലാസ് അല്ലെങ്കിൽ ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നതിനുള്ള മറ്റ് സംവിധാനങ്ങൾ നിയന്ത്രിക്കേണ്ടതുണ്ട്. അല്ലെങ്കിൽ നിലവിലുള്ള നടപ്പാക്കൽ ഞങ്ങൾക്ക് അത്തരമൊരു ഉറപ്പ് നൽകുന്നു.

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

മറ്റൊരു ഉപയോഗപ്രദമായ സമീപനം ഒരു പാറ്റേൺ ഉപയോഗിക്കുക എന്നതാണ് NullObject, "അപകടകരമായ" ഒന്നിനുപകരം, ഒന്നും ചെയ്യാത്ത, എന്നാൽ പിശകുകൾ വരുത്താത്ത രീതികളുള്ള ഒരു ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു. ശൂന്യം. ഈ സമീപനത്തിന്റെ ഒരു പ്രത്യേക കേസ്, ശൂന്യമായ ശേഖരങ്ങൾക്ക് അനുകൂലമായി കളക്ഷൻ വേരിയബിളുകൾക്കായി null ഉപയോഗിക്കാൻ വിസമ്മതിക്കുന്നതായി കണക്കാക്കാം.

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

5.3. സാങ്കേതികത 3. "സൈക്കിളുകൾ" എഴുതുന്നത് ഒഴിവാക്കുക. ഞങ്ങൾ റെഡിമെയ്ഡ് പരിഹാരങ്ങൾ പരമാവധി ഉപയോഗിക്കുന്നു.

സൈക്കിളുകൾ ഏതാണ്ട് കോപ്പി പേസ്റ്റ് പോലെയാണ്: ഇത് മോശമാണെന്ന് എല്ലാവർക്കും അറിയാം, എല്ലാവരും അവ പതിവായി എഴുതുന്നു. ഈ തിന്മയോട് പോരാടാൻ ശ്രമിക്കണമെന്ന് മാത്രമേ ഞങ്ങൾക്ക് നിങ്ങളെ ഉപദേശിക്കാൻ കഴിയൂ.

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

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

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

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

5.4. ടെക്നിക് 4. യഥാർത്ഥത്തിൽ ഉപയോഗിക്കുന്നത് മാത്രമാണ് ഞങ്ങൾ കോഡിൽ അവശേഷിക്കുന്നത്.

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

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

അതിനാൽ, അനാവശ്യവും ഉപയോഗിക്കാത്തതുമായ പ്രദേശങ്ങൾ നീക്കം ചെയ്യുന്നതിലൂടെ, ഞങ്ങൾ കോഡിന്റെ വലുപ്പം കുറയ്ക്കുക മാത്രമല്ല, പ്രധാനമായി, അതിലേക്ക് സംഭാവന ചെയ്യുകയും ചെയ്യുന്നു. സ്വയം ഡോക്യുമെന്റേഷൻ.

5.5. സാങ്കേതികത 5. ഭാഷയെക്കുറിച്ചുള്ള നമ്മുടെ അറിവ് ഞങ്ങൾ ഉപയോഗിക്കുകയും ഈ അറിവ് ലഭിക്കുന്നതിന് വായനക്കാരനെ ആശ്രയിക്കുകയും ചെയ്യുന്നു.

നിങ്ങളുടെ കോഡ് ലളിതവും ഹ്രസ്വവും വ്യക്തവുമാക്കുന്നതിനുള്ള ഫലപ്രദമായ മാർഗ്ഗങ്ങളിലൊന്ന് ഒരു നിർദ്ദിഷ്‌ട ഭാഷയുടെ സവിശേഷതകളുടെ സമർത്ഥമായ ഉപയോഗമാണ്: വിവിധ ഡിഫോൾട്ടുകൾ, പ്രവർത്തന മുൻഗണനകൾ, ഹ്രസ്വ രൂപങ്ങൾ മുതലായവ.

ഒരു ചിത്രീകരണമെന്ന നിലയിൽ, ജാവാസ്ക്രിപ്റ്റ് ഭാഷയുടെ ഏറ്റവും മികച്ച ഉദാഹരണം എന്റെ കാഴ്ചപ്പാടിൽ നിന്ന് ഞാൻ നൽകും.

മിക്കപ്പോഴും, സ്ട്രിംഗ് എക്സ്പ്രഷനുകൾ പാഴ്‌സ് ചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന പൈലുകൾ കാണാൻ കഴിയും:
എങ്കിൽ (obj != null && obj != undefined && obj.s != null && obj.s != undefined && obj.s != "") (// എന്തെങ്കിലും ചെയ്യുക)
"രചയിതാവ് മറ്റെന്തെങ്കിലും പരിശോധന മറന്നോ" എന്ന വീക്ഷണത്തിൽ ഉൾപ്പെടെ ഇത് ഭയപ്പെടുത്തുന്നതായി തോന്നുന്നു. വാസ്തവത്തിൽ, ജാവാസ്ക്രിപ്റ്റ് ഭാഷയുടെ പ്രത്യേകതകൾ അറിയുന്നതിലൂടെ, അത്തരം മിക്ക കേസുകളിലും മുഴുവൻ പരിശോധനയും നിസ്സാരമായി ചുരുക്കാം:

എങ്കിൽ (obj && obj.s) ( // എന്തെങ്കിലും ചെയ്യുക )
ബൂളിയനിലേക്ക് ഇംപ്ലിസിറ്റ് കാസ്റ്റ് ചെയ്തതിന് നന്ദി എന്നതാണ് കാര്യം എങ്കിൽ (obj) ()കള നീക്കം ചെയ്യും:

• തെറ്റായ
• ശൂന്യം
• നിർവചിക്കാത്തത്
• ശൂന്യമായ വരി

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

അതുപോലെ, ഇനിപ്പറയുന്ന നൊട്ടേഷൻ ഫോമുകൾ താരതമ്യം ചെയ്യുക:

എങ്കിൽ (!a) ( a = defaultValue; )
ഒപ്പം

A = a || സ്ഥിര മൂല്യം;
സ്ക്രിപ്റ്റിംഗ് ഭാഷകളിലെ ലോജിക്കൽ പ്രവർത്തനങ്ങളുടെ പ്രത്യേക സെമാന്റിക്സിന്റെ ഉപയോഗത്തിന് നന്ദി, രണ്ടാമത്തെ ഓപ്ഷൻ ലളിതമായി തോന്നുന്നു.

6. സ്വയം ഡോക്യുമെന്റിംഗ് കോഡ്.

XML അല്ലെങ്കിൽ JSON പോലുള്ള ഫോർമാറ്റുകളുടെ സവിശേഷതകളെ വിവരിക്കാൻ "സ്വയം-രേഖപ്പെടുത്തൽ" എന്ന പദം മിക്കപ്പോഴും ഉപയോഗിക്കാറുണ്ട്. ഈ സാഹചര്യത്തിൽ, ഫയലിൽ ഒരു കൂട്ടം ഡാറ്റ മാത്രമല്ല, അതിന്റെ ഘടന, ഈ ഡാറ്റ വ്യക്തമാക്കിയിട്ടുള്ള എന്റിറ്റികളുടെ പേരുകൾ, ഫീൽഡുകൾ എന്നിവയെക്കുറിച്ചുള്ള വിവരങ്ങളും അടങ്ങിയിരിക്കുന്നു.

ഒരു എക്സ്എംഎൽ ഫയൽ വായിക്കുമ്പോൾ, സന്ദർഭത്തെക്കുറിച്ച് ഒന്നും അറിയാതെ പോലും, ഫയൽ എന്താണ് വിവരിക്കുന്നത്, ഏത് തരത്തിലുള്ള ഡാറ്റയാണ് അതിൽ അവതരിപ്പിച്ചിരിക്കുന്നത്, ഒരുപക്ഷേ അത് എങ്ങനെ ഉപയോഗിക്കും എന്നതിനെ കുറിച്ച് നമുക്ക് എല്ലായ്പ്പോഴും ഒരു ആശയം ലഭിക്കും.

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

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

6.1. ടെക്നിക് 1. ഫംഗ്ഷനുകൾ, വേരിയബിളുകൾ, ക്ലാസുകൾ എന്നിവയുടെ പേരുകൾ ശ്രദ്ധാപൂർവ്വം തിരഞ്ഞെടുക്കുക. ഞങ്ങളുടെ കോഡ് വായിക്കുന്ന ആളുകളെ നിങ്ങൾ വഞ്ചിക്കരുത്.

സ്വയം ഡോക്യുമെന്റിംഗ് കോഡ് എഴുതുമ്പോൾ അടിസ്ഥാനമായി എടുക്കേണ്ട ഏറ്റവും പ്രധാനപ്പെട്ട നിയമം നിങ്ങളുടെ വായനക്കാരനെ ഒരിക്കലും വഞ്ചിക്കരുത്.

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

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

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

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

വ്യക്തമായും, പേരുള്ള വേരിയബിളുകളുടെ ഉപയോഗം കുറയ്ക്കുന്നതും മൂല്യവത്താണ് ഐ, ജെ, കെ, എസ്. അത്തരം പേരുകളുള്ള വേരിയബിളുകൾക്ക് പ്രാദേശികവും പൊതുവായി അംഗീകരിക്കപ്പെട്ട സെമാന്റിക്‌സ് മാത്രമേ ഉണ്ടാകൂ. എപ്പോൾ ഐ, ജെ, ഇവ ഒരു അറേയിലെ ലൂപ്പ് കൗണ്ടറുകളോ സൂചികകളോ ആകാം. സാധ്യമെങ്കിൽ, ഫോറെച്ച് ലൂപ്പുകൾക്കും ഫംഗ്ഷണൽ എക്സ്പ്രഷനുകൾക്കും അനുകൂലമായി അത്തരം കൗണ്ടറുകൾ ഒഴിവാക്കുന്നത് മൂല്യവത്താണ്.
പേരുകളുള്ള വേരിയബിളുകൾ ii, i1, ijk42, asdsaമുതലായവ ഒരിക്കലും ഉപയോഗിക്കരുത്. ശരി, ഒരുപക്ഷേ നിങ്ങൾ ഗണിതശാസ്ത്ര അൽഗോരിതങ്ങളുമായി പ്രവർത്തിക്കുകയാണെങ്കിൽ ... ഇല്ല, അത് ഒരിക്കലും മികച്ചതല്ല.

6.2. ടെക്നിക് 2. ഒരേ പോലെയുള്ളവയെ ഒരുപോലെയും വ്യത്യസ്തമായവയെ വ്യത്യസ്തമായും വിളിക്കാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു.

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

ഒരേ സ്ഥാപനം/പ്രവർത്തനം/അൽഗരിതം എന്നിവയ്‌ക്കായി വ്യത്യസ്ത പേരുകൾ ഉപയോഗിക്കുമ്പോൾ - "റിവേഴ്സ്" പ്രശ്നത്തെക്കുറിച്ചും ഏകദേശം ഇതുതന്നെ പറയാം. അത്തരം കോഡ് വിശകലനം ചെയ്യുന്നതിനുള്ള സമയം പ്രതീക്ഷിച്ചതിലും ഗണ്യമായി വർദ്ധിച്ചേക്കാം.

ഉപസംഹാരം ലളിതമാണ്: നിങ്ങളുടെ പ്രോഗ്രാമുകളിൽ പര്യായങ്ങളുടെയും ഹോമോണിമുകളുടെയും ആവിർഭാവം നിങ്ങൾ വളരെ ശ്രദ്ധാപൂർവ്വം പരിഗണിക്കുകയും ഇത് ഒഴിവാക്കാൻ പരമാവധി ശ്രമിക്കുകയും വേണം.

6.3. ടെക്നിക് 3. "ഓക്കാമിന്റെ റേസർ". ഞങ്ങൾക്ക് ഇല്ലാതെ ചെയ്യാൻ കഴിയുന്ന എന്റിറ്റികൾ ഞങ്ങൾ സൃഷ്ടിക്കുന്നില്ല.

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

ഇതിൽ നിന്ന് ഏറ്റവും നേരിട്ടുള്ള നിഗമനം പിന്തുടരുന്നു: നിങ്ങൾ കുറച്ച് എന്റിറ്റികൾ നൽകുമ്പോൾ, നിങ്ങളുടെ കോഡ് ലളിതവും മികച്ചതുമായി അവസാനിക്കും.

ഒരു "അധിക" വേരിയബിളിന്റെ ഒരു സാധാരണ ഉദാഹരണം:

Int sum = counSum(); int increaseSum = തുക + 1; പ്രവർത്തിപ്പിക്കുക (വർദ്ധിച്ച തുക); ...
വ്യക്തമായും വേരിയബിൾ വർദ്ധിച്ച തുകഒരു അധിക സ്ഥാപനമാണ്, കാരണം അത് സംഭരിക്കുന്ന വസ്തുവിന്റെ വിവരണം (തുക + 1)തന്നിരിക്കുന്ന ഒബ്ജക്റ്റിനെ ഒരു വേരിയബിളിന്റെ പേരിനേക്കാൾ മികച്ചതും കൂടുതൽ കൃത്യതയോടെയും ചിത്രീകരിക്കുന്നു. അതിനാൽ, കോഡ് ഇനിപ്പറയുന്ന രീതിയിൽ മാറ്റിയെഴുതണം ("ഇൻലൈൻ" വേരിയബിൾ):

Int sum = counSum(); പ്രവർത്തിപ്പിക്കുക (തുക + 1); ...
തുക കോഡിൽ എവിടെയും ഉപയോഗിച്ചിട്ടില്ലെങ്കിൽ, നിങ്ങൾക്ക് കൂടുതൽ മുന്നോട്ട് പോകാം:

പ്രവർത്തിപ്പിക്കുക(countSum() + 1); ...
നിങ്ങളുടെ കോഡ് ചെറുതും ലളിതവും ലളിതവുമാക്കുന്നതിനുള്ള ഒരു മാർഗമാണ് അനാവശ്യ വേരിയബിളുകൾ ഇൻലൈൻ ചെയ്യുന്നത് കൂടുതൽ വ്യക്തമാണ്.

എന്നിരുന്നാലും, ഈ സാങ്കേതികത സ്വയം ഡോക്യുമെന്റേഷൻ പ്രോത്സാഹിപ്പിക്കുകയും അതിന് വിരുദ്ധമല്ലെങ്കിൽ മാത്രമേ ഇത് ഉപയോഗിക്കാവൂ. ഉദാഹരണത്തിന്:

ഇരട്ട descr = b * b - 4 * a *c; ഇരട്ട x1 = -b + sqrt (descr) / (2 * a);
ഈ സാഹചര്യത്തിൽ, ഇൻലൈൻ വേരിയബിൾ descrവായനാക്ഷമത പ്രയോജനപ്പെടുത്താൻ സാധ്യതയില്ല, കാരണം ഈ വേരിയബിൾ സബ്ജക്ട് ഏരിയയിൽ നിന്നുള്ള ഒരു നിർദ്ദിഷ്ട എന്റിറ്റിയെ പ്രതിനിധീകരിക്കാൻ ഉപയോഗിക്കുന്നു, അതിനാൽ, ഒരു വേരിയബിളിന്റെ സാന്നിധ്യം കോഡിന്റെ സ്വയം-ഡോക്യുമെന്റേഷനിലേക്ക് സംഭാവന ചെയ്യുന്നു, കൂടാതെ വേരിയബിൾ തന്നെ ഓക്കാമിന്റെ റേസറിന് കീഴിൽ വരുന്നില്ല.

ഈ ഉദാഹരണത്തിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്ന തത്ത്വം സംഗ്രഹിച്ചുകൊണ്ട്, നമുക്ക് ഇനിപ്പറയുന്നവ നിഗമനം ചെയ്യാം: വിഷയ മേഖലയിൽ പ്രോട്ടോടൈപ്പുകൾ ഉണ്ടെങ്കിൽ മാത്രം നിങ്ങളുടെ പ്രോഗ്രാമിൽ വേരിയബിളുകൾ / ഫംഗ്ഷനുകൾ / ഒബ്ജക്റ്റുകൾ സൃഷ്ടിക്കുന്നത് ഉചിതമാണ്. അതേ സമയം, അനുസരിച്ച് വകുപ്പ് 6.1, ഈ വസ്തുക്കളുടെ പേര് ഈ കത്തിടപാടുകൾ കഴിയുന്നത്ര വ്യക്തമായി പ്രകടിപ്പിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ ഞങ്ങൾ ശ്രമിക്കണം. അത്തരം കത്തിടപാടുകൾ ഇല്ലെങ്കിൽ, ഒരു വേരിയബിൾ/ഫംഗ്ഷൻ/ഒബ്ജക്റ്റ് ഉപയോഗിക്കുന്നത് നിങ്ങളുടെ കോഡ് ഓവർലോഡ് ചെയ്യാൻ മാത്രമേ സാധ്യമാകൂ, അവ നീക്കം ചെയ്യുന്നത് പ്രോഗ്രാമിന് ഗുണം ചെയ്യും.

പൊതുവായ തത്ത്വം ലളിതമാണ്: വ്യക്തമായി എഴുതിയ ഏതെങ്കിലും അൽഗോരിതങ്ങൾ അല്ലെങ്കിൽ വ്യവസ്ഥകൾ ഇതിനകം തന്നെ സ്വയം-രേഖപ്പെടുത്തുന്നതാണ്, കാരണം അവയുടെ ഉദ്ദേശ്യവും പ്രവർത്തന തത്വവും ഇതിനകം തന്നെ വിവരിച്ചിട്ടുണ്ട്. നേരെമറിച്ച്, പാർശ്വഫലങ്ങളുള്ള ഏതെങ്കിലും പരോക്ഷ വ്യവസ്ഥകളും പ്രവർത്തനങ്ങളും എന്താണ് സംഭവിക്കുന്നതെന്നതിന്റെ സാരാംശം മനസ്സിലാക്കാൻ വളരെ ബുദ്ധിമുട്ടാണ്.

നിങ്ങൾക്ക് ഒരു ഏകദേശ ഉദാഹരണം നൽകാം, ജീവിതം പലപ്പോഴും അത്തരം ഉദാഹരണങ്ങൾ എറിയുന്നു എന്ന് സൂചിപ്പിക്കുന്നു.

പരോക്ഷമായ അവസ്ഥ:

എങ്കിൽ (i == abs(i)) ( )
നേരിട്ടുള്ള അവസ്ഥ:

എങ്കിൽ (i >= 0) ( )
വായനാക്ഷമതയിലെ വ്യത്യാസം വിലയിരുത്തുന്നത് ബുദ്ധിമുട്ടുള്ള കാര്യമല്ലെന്ന് ഞാൻ കരുതുന്നു.

6.5. സാങ്കേതികത 5. സ്വകാര്യമായി (സംരക്ഷിതമായി) മറയ്ക്കാൻ കഴിയുന്നതെല്ലാം അവിടെ മറയ്ക്കണം. എൻക്യാപ്‌സുലേഷൻ ആണ് നമുക്ക് എല്ലാം.

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

6.6. ടെക്നിക് 6. (മുമ്പത്തെ ഒന്നിന്റെ പൊതുവൽക്കരണം) ഞങ്ങൾ എല്ലാ വസ്തുക്കളും സാധ്യമായ ഇടുങ്ങിയ പരിധിയിൽ പ്രഖ്യാപിക്കുന്നു.

ഓരോ ഒബ്ജക്റ്റിന്റെയും വ്യാപ്തി പരമാവധി പരിമിതപ്പെടുത്തുക എന്ന തത്വം സാധാരണ OOP എൻക്യാപ്‌സുലേഷനേക്കാൾ വിശാലമാക്കാം.

ലളിതമായ ഉദാഹരണം:

ഒബ്ജക്റ്റ് someobj = createSomeObj(); എങ്കിൽ (some_check()) (// ഇവിടെ ചിലത് ആവശ്യമില്ല ) വേറെ ( someobj.call(); )
വ്യക്തമായും, someobj വേരിയബിളിന്റെ അത്തരമൊരു പ്രഖ്യാപനം അതിന്റെ ഉദ്ദേശ്യം മനസ്സിലാക്കുന്നത് ബുദ്ധിമുട്ടാക്കുന്നു, കാരണം നിങ്ങളുടെ കോഡിന്റെ റീഡർ അത് ഉപയോഗിക്കുന്നതിലും യഥാർത്ഥത്തിൽ ആവശ്യമുള്ളതിലും വളരെ വിശാലമായ പ്രദേശത്ത് കോളുകൾക്കായി നോക്കും.

ഈ കോഡ് എങ്ങനെ കുറച്ചുകൂടി മികച്ചതാക്കാമെന്ന് മനസിലാക്കാൻ പ്രയാസമില്ല:

എങ്കിൽ (some_check()) (// ഇവിടെ ചിലത് ആവശ്യമില്ല) വേറെ (ഒബ്ജക്റ്റ് someobj = createSomeObj(); someobj.call(); )

ശരി, അല്ലെങ്കിൽ, ഒരൊറ്റ കോളിന് വേരിയബിൾ ആവശ്യമാണെങ്കിൽ, നിങ്ങൾക്കും ഉപയോഗിക്കാം വകുപ്പ് 6.3:

എങ്കിൽ (some_check()) (// ഇവിടെ ചിലത് ആവശ്യമില്ല ) വേറെ ( createSomeObj().call(); )
വെവ്വേറെ, ഈ സാങ്കേതികവിദ്യ പ്രവർത്തിക്കാത്തതോ അല്ലെങ്കിൽ അതിന്റെ ദോഷം വരുത്തുന്നതോ ആയ സാഹചര്യം പരാമർശിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. ഇവ ലൂപ്പുകൾക്ക് പുറത്ത് ആരംഭിക്കുന്ന വേരിയബിളുകളാണ്. ഉദാഹരണത്തിന്:

ഒബ്ജക്റ്റ് someobj = createSomeObj(); വേണ്ടി (int i = 0; i< 10; i++) { someobj.call(); }
വഴി ഒരു വസ്തു സൃഷ്ടിക്കുകയാണെങ്കിൽ createSomeObj()- ഒരു ചെലവേറിയ പ്രവർത്തനം, അത് ഒരു ലൂപ്പിലേക്ക് അവതരിപ്പിക്കുന്നത്, വായനാക്ഷമത മെച്ചപ്പെടുത്തിയാലും, പ്രോഗ്രാം പ്രകടനത്തിൽ അസുഖകരമായ സ്വാധീനം ചെലുത്തും.

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

6.7. ടെക്നിക് 7. സ്റ്റാറ്റിക്, ഡൈനാമിക് സന്ദർഭം ഞങ്ങൾ വ്യക്തമായി വേർതിരിക്കുന്നു. വസ്തുവിന്റെ അവസ്ഥയെ ആശ്രയിക്കാത്ത രീതികൾ നിശ്ചലമായിരിക്കണം.

സ്റ്റാറ്റിക്, ഡൈനാമിക് സന്ദർഭങ്ങൾ തമ്മിലുള്ള ആശയക്കുഴപ്പം അല്ലെങ്കിൽ വേർതിരിവിന്റെ അഭാവം ഏറ്റവും മോശമായ കാര്യമല്ല, മറിച്ച് വളരെ സാധാരണമായ ഒരു തിന്മയാണ്.

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

അതിനാൽ, ഈ വശം ശ്രദ്ധിക്കാൻ ശ്രമിക്കേണ്ടത് ആവശ്യമാണ്, വസ്തുവിന്റെ അവസ്ഥയെ ആശ്രയിക്കാത്ത രീതികൾ വ്യക്തമായി എടുത്തുകാണിക്കുന്നു.

6.8. ടെക്നിക് 8. ഒബ്ജക്റ്റിന്റെ പ്രഖ്യാപനവും സമാരംഭവും വേർതിരിക്കാതിരിക്കാൻ ഞങ്ങൾ ശ്രമിക്കുന്നു.

ഒരു വസ്തുവിന്റെ പേരിന്റെ പ്രഖ്യാപനവും ഒബ്ജക്റ്റ് എന്താണെന്നതിന്റെ ഉടനടി വിവരണവും സംയോജിപ്പിക്കാൻ ഈ സാങ്കേതികവിദ്യ നിങ്ങളെ അനുവദിക്കുന്നു. സെൽഫ് ഡോക്യുമെന്റേഷന്റെ തത്വം പിന്തുടരുന്നതിന്റെ വ്യക്തമായ ഉദാഹരണമാണിത്.

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

അതുകൊണ്ടാണ്, ഉദാഹരണത്തിന്, പ്രവർത്തനപരമായ പ്രവർത്തനങ്ങൾ apache CollectionUtilsഒപ്പം പേരക്ക ശേഖരങ്ങൾ2ജാവ ബിൽറ്റ്-ഇന്നുകളേക്കാൾ പലപ്പോഴും അഭികാമ്യമാണ് ഫോറെച്ച്ലൂപ്പുകൾ - ഒരു ശേഖരത്തിന്റെ പ്രഖ്യാപനവും സമാരംഭവും സംയോജിപ്പിക്കാൻ അവ നിങ്ങളെ അനുവദിക്കുന്നു.

നമുക്ക് താരതമ്യം ചെയ്യാം:

ലോവർകേസ് സ്ട്രിംഗ്സ് = പുതിയ അറേ ലിസ്റ്റ് (); /* ശേഖരം ഇവിടെ അൺഇനീഷ്യലൈസ് ചെയ്‌തിരിക്കുന്നു, (സ്‌ട്രിംഗുകൾ: ചില സ്‌ട്രിംഗുകൾ) (ലോവർകേസ്‌സ്ട്രിംഗ്സ്.add(StringUtils.lowerCase(s)); ) എന്നതിനായുള്ള ഇനീഷ്യലൈസേഷൻ അന്വേഷിക്കേണ്ടതുണ്ട്.
സി:
// എങ്ങനെയെങ്കിലും "സോംസ്ട്രിംഗ്സ്" ശേഖരം നേടുന്നു ... ശേഖരണം ചെറിയ അക്ഷരങ്ങൾ = ശേഖരങ്ങൾ () (@Override public String apply(Strings) ( തിരികെ StringUtils.lowerCase(s); ) ));
നമ്മൾ Java 8 ഉപയോഗിക്കുകയാണെങ്കിൽ, നമുക്ക് ഇത് കുറച്ചുകൂടി ചുരുക്കി എഴുതാം:

സമാഹാരം ലോവർകേസ് സ്ട്രിംഗ്സ് = somestrings.stream() .map(StringUtils::lowerCase).collect(Collectors.toList());
ശരി, വേരിയബിളുകളുടെ ഡിക്ലറേഷനും ഇനീഷ്യലൈസേഷനും എങ്ങനെയെങ്കിലും വേർതിരിക്കേണ്ടിവരുമ്പോൾ കേസ് പരാമർശിക്കേണ്ടതാണ്. ബ്ലോക്കുകളിൽ ഒരു വേരിയബിൾ ഉപയോഗിക്കുന്ന ഒരു സാഹചര്യമാണിത് ഒടുവിൽഒപ്പം പിടിക്കുക(ഉദാഹരണത്തിന്, ചില വിഭവങ്ങൾ റിലീസ് ചെയ്യാൻ). വേരിയബിൾ മുമ്പ് പ്രഖ്യാപിക്കുകയല്ലാതെ ഇവിടെ ഒന്നും ചെയ്യാനില്ല ശ്രമിക്കുക, ബ്ലോക്കിനുള്ളിൽ ആരംഭിക്കുക ശ്രമിക്കുക.

6.9. ടെക്നിക് 9. എന്താണ് സംഭവിക്കുന്നതെന്നതിന്റെ സാരാംശം മറയ്ക്കുന്നതിനുപകരം സൂചിപ്പിക്കാൻ ഞങ്ങൾ ഒരു ഡിക്ലറേറ്റീവ് സമീപനവും പ്രവർത്തനപരമായ പ്രോഗ്രാമിംഗ് ടൂളുകളും ഉപയോഗിക്കുന്നു.

മുമ്പത്തെ ഖണ്ഡികയിൽ നിന്നുള്ള ഉദാഹരണത്തിലൂടെ ഈ തത്വം ചിത്രീകരിക്കാൻ കഴിയും, അതിൽ ഞങ്ങളുടെ കോഡ് കൂടുതൽ വ്യക്തമാക്കുന്നതിന് ഞങ്ങൾ ജാവയിലെ പ്രവർത്തന സമീപനത്തിന്റെ അനുകരണം ഉപയോഗിച്ചു.

കൂടുതൽ വ്യക്തതയ്ക്കായി, ജാവാസ്ക്രിപ്റ്റിലെ ഒരു ഉദാഹരണം കൂടി പരിഗണിക്കാം (ഇവിടെ നിന്ന് എടുത്തത്: http://habrahabr.ru/post/154105).

നമുക്ക് താരതമ്യം ചെയ്യാം:

Var str = "പരാമർശിച്ചത്"; for(var i =0; l= tweeps.length; i< l; ++i){ str += tweeps[i].name; if(i< tweeps.length-1) {str += ", "} }
സി:

Var str = "പരാമർശിച്ചത് " + tweeps.map(function(t)( return t.name; )).join(", ");
ശരി, വായനാക്ഷമതയെ നശിപ്പിക്കുന്ന പ്രവർത്തനപരമായ സമീപനം ഉപയോഗിക്കുന്നതിന്റെ ഉദാഹരണങ്ങൾ... ഈ സമയം നമ്മുടെ ഞരമ്പുകളെ സംരക്ഷിച്ച് അവയില്ലാതെ ചെയ്യാം.

6.10. സാങ്കേതികത 10. അവയില്ലാതെ എന്താണ് സംഭവിക്കുന്നതെന്ന് വ്യക്തമല്ലെങ്കിൽ മാത്രമേ ഞങ്ങൾ അഭിപ്രായങ്ങൾ എഴുതുകയുള്ളൂ.

മുകളിൽ സൂചിപ്പിച്ചതുപോലെ, സെൽഫ് ഡോക്യുമെന്റിംഗ് കോഡിന്റെ തത്വം അഭിപ്രായങ്ങൾ ഉപയോഗിച്ച് രേഖപ്പെടുത്തുന്നതിന് എതിരാണ്. അഭിപ്രായങ്ങൾ ഇത്ര മോശമായിരിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് ചുരുക്കമായി വിശദീകരിക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു:

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

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

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

7. തത്വശാസ്ത്രപരമായ ഉപസംഹാരം.

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

ഞങ്ങളുടെ കാര്യത്തിൽ, കോഡ് കഴിയുന്നത്ര വായിക്കാവുന്നതും കൈകാര്യം ചെയ്യാവുന്നതുമാക്കുക എന്നതാണ് ലക്ഷ്യം. അതേ സമയം ഒരു സൗന്ദര്യാത്മക വീക്ഷണകോണിൽ നിന്ന് അത് മനോഹരമായിരിക്കും.

നിലവിലെ ലേഖനത്തിൽ നൽകിയിരിക്കുന്ന ഉദാഹരണങ്ങൾ പഠിക്കുമ്പോൾ, യഥാർത്ഥ തത്വങ്ങളും (ലീനിയറിറ്റി, മിനിമലിറ്റി, സെൽഫ് ഡോക്യുമെന്റേഷൻ) നിർദ്ദിഷ്ട സാങ്കേതികതകളും പരസ്പരം സ്വതന്ത്രമല്ലെന്ന് ഒരാൾക്ക് എളുപ്പത്തിൽ ശ്രദ്ധിക്കാനാകും. ഒരു സാങ്കേതികത ഉപയോഗിക്കുന്നതിലൂടെ, നമുക്ക് പരോക്ഷമായി തികച്ചും വ്യത്യസ്തമായ ഒന്ന് പിന്തുടരാനും കഴിയും. ടാർഗെറ്റ് ഇൻഡിക്കേറ്ററുകളിൽ ഒന്ന് മെച്ചപ്പെടുത്തുന്നതിലൂടെ, മറ്റുള്ളവരുടെ മെച്ചപ്പെടുത്തലിന് നമുക്ക് സംഭാവന ചെയ്യാൻ കഴിയും.

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

പ്രോഗ്രാമിംഗിൽ, മനുഷ്യ പ്രവർത്തനത്തിന്റെ മറ്റ് മേഖലകളിലെന്നപോലെ, നിർവ്വഹണത്തിന് സാർവത്രിക നിർദ്ദേശങ്ങൾ ഉണ്ടാകില്ല. ഓരോ സാഹചര്യത്തിനും പ്രത്യേക പരിഗണനയും വിശകലനവും ആവശ്യമാണ്, സാഹചര്യത്തിന്റെ പ്രത്യേകതകളെക്കുറിച്ചുള്ള ധാരണയുടെ അടിസ്ഥാനത്തിലാണ് തീരുമാനം എടുക്കേണ്ടത്.

പൊതുവേ, ഈ വസ്തുത ഒരു തരത്തിലും പൊതുവായ തത്ത്വങ്ങൾ ഊഹിക്കുന്നതിനും മനസ്സിലാക്കുന്നതിനും അവ നടപ്പിലാക്കുന്നതിനുള്ള പ്രത്യേക രീതികളിൽ പ്രാവീണ്യം നേടുന്നതിനുമുള്ള ഉപയോഗത്തെ നിഷേധിക്കുന്നില്ല. അതുകൊണ്ടാണ് ലേഖനത്തിൽ പറഞ്ഞിരിക്കുന്നതെല്ലാം പല പ്രോഗ്രാമർമാർക്കും ശരിക്കും ഉപയോഗപ്രദമാകുമെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

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

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

ആദ്യം, ഒരു ചെറിയ സിദ്ധാന്തം. ഒരേ കോഡ് വ്യത്യസ്ത രീതികളിൽ എഴുതാം. കോഡ് ആയിരിക്കാം നടപടിക്രമം, പ്രവർത്തനയോഗ്യമായഒപ്പം ഒബ്ജക്റ്റ് ഓറിയന്റഡ്.

നടപടിക്രമ സമീപനം

നടപടിക്രമ സമീപനം ഏറ്റവും ലളിതമാണ്. കമാൻഡുകൾ എഴുതുകയും പ്രാഥമിക PHP ഫംഗ്ഷനുകൾ വിളിക്കുകയും ചെയ്യുന്ന ഒരു സ്ക്രിപ്റ്റ് എന്നാണ് ഇതിനർത്ഥം.
ഉദാഹരണത്തിന്:

$a = 10;
$c = $a % $b;
$e + $d;
എക്കോ റൗണ്ട് ($e);
?>

നിങ്ങൾക്ക് വളരെ ചെറിയ ഒരു കോഡ് ഉണ്ടെങ്കിലോ അല്ലെങ്കിൽ അത് കർശനമായി ഒരു ടാസ്‌ക് നിർവഹിക്കുന്നുണ്ടെങ്കിലോ (ഉദാഹരണത്തിന്, ഒരു ചിത്രം സൃഷ്ടിക്കൽ) അവർ പറയുന്നതുപോലെ, "വലത്തോട്ടോ ഇടത്തോട്ടോ ചുവടുവെക്കരുത്" എന്ന് പറഞ്ഞാൽ ഈ സമീപനം ഉചിതമാണ്.

പ്രവർത്തനപരമായ സമീപനം

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

ഇനി ശ്രമിക്കാം പ്രവർത്തനയോഗ്യമായ.

//ചെലവ് തിരികെ നൽകും
ഫംഗ്‌ഷൻ getPrice($price, $weight) (
$result_price * $ഭാരം;
$result_price തിരികെ നൽകുക;
}
//എല്ലാ ഭാരങ്ങളും തിരികെ നൽകുക
ഫംഗ്ഷൻ getWeights() (
റിട്ടേൺ അറേ (5, 12, 14, 16, 22, 135, 150, 200, 254, 300, 400);
}

//ഭാരങ്ങൾ വേരിയബിളിലേക്ക് കൊണ്ടുവരിക
$എല്ലാ പഴങ്ങളുടെയും ഭാരം
foreach ($പഴങ്ങൾ $fruit ആയി) (
foreach ($ഭാരം പോലെ $ഭാരം) (
പ്രതിധ്വനി $fruit["name"] . " " . $ഭാരം. "കിലോ വില". getPrice($fruit["price"], $weight) . " തടവുക.
";
}
}
?>

കോഡ് കൂടുതൽ വായിക്കാവുന്നതേയുള്ളൂ. പ്രവർത്തനത്തിൽ തൂക്കങ്ങൾ വ്യക്തമാക്കിയിട്ടുണ്ട് getWeightsഒപ്പം ലളിതമായ കൂട്ടിച്ചേർക്കലിലൂടെഓരോ പഴത്തിന്റെയും വ്യത്യസ്‌ത ഭാരത്തിന് എത്ര വില വരും എന്ന് അവിടെ എണ്ണുക.
ഞാൻ എല്ലാ പഴങ്ങളിലൂടെയും കടന്നുപോയി, ഓരോ തിരയലിലും ഞാൻ എല്ലാ ഭാരങ്ങളിലൂടെയും കടന്നുപോയി. അത് മറ്റൊരു തരത്തിൽ ചെയ്യാമായിരുന്നു.
പേസ്റ്റ്ബിൻ ഉറവിടം http://pastebin.com/07QTBihX

ഒടുവിൽ നടപ്പാക്കലും OOP.

ക്ലാസ് ഫ്രൂട്ടിംഗ് (
പൊതു $പഴങ്ങൾ;
പൊതു $ഭാരങ്ങൾ;

പബ്ലിക് ഫംഗ്‌ഷൻ സെറ്റ് ഡാറ്റ($പഴങ്ങൾ, $ഭാരം) (
$this->പഴങ്ങൾ = $പഴങ്ങൾ;
$this->ഭാരം = $ഭാരം;
}

സ്വകാര്യ പ്രവർത്തനം getPrice($price, $weight) (
$result_price = $price * $weight;
$result_price തിരികെ നൽകുക;
}

പൊതു പ്രവർത്തനം getResult() (
//എല്ലാ പഴങ്ങളും അടുക്കുക
foreach ($this->പഴങ്ങൾ $fruit ആയി) (
// ഓരോ പഴത്തിനും വേണ്ടിയുള്ള എല്ലാ ഭാരങ്ങളിലൂടെയും ആവർത്തിക്കുക
foreach ($this->ഭാരം $weight ആയി) (
പ്രതിധ്വനി $fruit["name"] . " " . $ഭാരം. "കിലോ വില". self::getPrice($fruit["price"], $weight) . " തടവുക.
";
}
}
}
}

$ഫ്രൂട്ടിംഗ് = പുതിയ ഫ്രൂട്ടിംഗ്();
$fruiting->setData($പഴങ്ങൾ, അറേ(5, 12, 14, 16, 22, 135, 150, 200, 254, 300, 400));
$fruiting->getResult();
?>

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

മെറ്റീരിയൽ എഴുതുമ്പോൾ, @ontofractal ന്റെ ഉപദേശം പിന്തുടരാൻ ഞാൻ ശ്രമിച്ചു :)

പി.എസ്.നിങ്ങൾ കോഡ് എഴുതുമ്പോൾ, നിങ്ങൾ എവിടെയാണ് താമസിക്കുന്നതെന്ന് അറിയാവുന്ന ഒരു മാനസിക അസ്ഥിര ഭ്രാന്തൻ അത് പരിപാലിക്കുമെന്ന് സങ്കൽപ്പിക്കുക.

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

ഓൺലൈൻ സ്റ്റോറുകൾ, ബ്ലോഗുകൾ, വിദ്യാഭ്യാസ സേവനങ്ങൾ, മറ്റ് ഉറവിടങ്ങൾ എന്നിവയുടെ ഡെവലപ്പർമാർ കൂടുതൽ കൂടുതൽ പുതിയതും അസാധാരണവുമായ മാപ്പുകൾ പരീക്ഷിക്കുകയും സൃഷ്ടിക്കുകയും ചെയ്യുന്നു. ലേഖനം വായിച്ചതിനുശേഷം, എല്ലാത്തരം നാവിഗേഷൻ പാനലുകളും ഏതൊക്കെ പ്രധാന ഗ്രൂപ്പുകളായി തിരിച്ചിരിക്കുന്നുവെന്ന് നിങ്ങൾ പഠിക്കും, നിങ്ങൾക്ക് അവ ഓരോന്നും പരീക്ഷിക്കാൻ കഴിയും, കൂടാതെ ഒരു html വെബ്‌സൈറ്റിനായി മെനു കോഡ് എങ്ങനെ എഴുതാമെന്ന് മനസിലാക്കുക. ഇനി നമുക്ക് കാര്യത്തിലേക്ക് കടക്കാം!

ഒരു നാവിഗേഷൻ ബാർ സൃഷ്ടിക്കുന്നതിനുള്ള ഉപകരണങ്ങൾ

മാർക്ക്അപ്പ് ഭാഷയിൽ ഒരു മെനു സൃഷ്ടിക്കാൻ നിരവധി മാർഗങ്ങളുണ്ട്. അവരുടെ അടിസ്ഥാന ആശയം ഒരു അസംഖ്യം ലിസ്റ്റ് ഉപയോഗിക്കുക എന്നതാണ്. അതിനാൽ, നമുക്ക് പരിചിതമായ html 4 ൽ, ഡെവലപ്പർമാർ പേജിൽ ടാഗുകൾ എഴുതുന്നു

ഒപ്പം
• .

  ൽ പറഞ്ഞിരിക്കുന്നത് പോലെ മുൻ പ്രസിദ്ധീകരണങ്ങൾ, ജോടി ഘടകം

  ഒരു ബുള്ളറ്റഡ് ലിസ്റ്റ് സൃഷ്ടിക്കുന്നു ഒപ്പം
  • - പട്ടികയിലെ ഒരു ഘടകം. വ്യക്തതയ്ക്കായി, ഒരു ലളിതമായ മെനുവിനുള്ള കോഡ് എഴുതാം:

    സൈറ്റ് നാവിഗേഷൻ

    • വീട്
    • ആഴ്ചയിലെ വാർത്തകൾ
    • സാങ്കേതിക മുന്നേറ്റങ്ങൾ
    • ചാറ്റ്
    
    
    

    എന്നിരുന്നാലും, പ്ലാറ്റ്‌ഫോമിന്റെ വരവോടെ, മാർക്ക്അപ്പ് ഭാഷ അധിക ടാഗുകൾ ഉപയോഗിച്ച് നിറച്ചു. അതുകൊണ്ടാണ് ആധുനിക വെബ്‌സൈറ്റുകളുടെ മെനു ഒരു പ്രത്യേകം ഉപയോഗിച്ച് സൃഷ്ടിച്ചിരിക്കുന്നത് ടാഗ്< മെനു>. ഉപയോഗത്തിൽ, ഈ ഘടകം ബുള്ളറ്റഡ് ലിസ്റ്റുകളിൽ നിന്ന് വ്യത്യസ്തമല്ല.

    ഒന്നിന് പകരം < ul>നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു < മെനു>. എന്നിരുന്നാലും, ജോലിയുടെ ഭാഗത്ത് നിന്ന് വിലയിരുത്തുമ്പോൾ കാര്യമായ വ്യത്യാസങ്ങൾ പ്രത്യക്ഷപ്പെടുന്നു. അതിനാൽ, രണ്ടാമത്തെ ഉദാഹരണം ജോലി വേഗത്തിലാക്കുന്നു തിരയൽ പ്രോഗ്രാമുകൾഒപ്പം റോബോട്ടുകളും. സൈറ്റ് ഘടന വിശകലനം ചെയ്യുമ്പോൾ, ഈ കോഡ് സൈറ്റ് മാപ്പിന് ഉത്തരവാദിയാണെന്ന് അവർ ഉടൻ മനസ്സിലാക്കുന്നു.

    തിരശ്ചീന, ലംബ, ഡ്രോപ്പ്-ഡൗൺ മെനുകൾ ഉണ്ട്. ചിലപ്പോൾ നാവിഗേഷൻ ബാർ ഒരു ചിത്രമായി രൂപകൽപ്പന ചെയ്തിട്ടുണ്ട്. ടെക്‌നോളജി വിഭാഗം വികസിച്ചതിനാൽ, വെബ് സേവനങ്ങൾ അഡാപ്റ്റീവ് ആക്കുന്നു, അതായത്. പേജ് ഘടന സ്വയമേവ ഉപകരണ സ്‌ക്രീൻ വലുപ്പവുമായി പൊരുത്തപ്പെടുന്നു. പട്ടികപ്പെടുത്തിയിരിക്കുന്ന മെനു ഗ്രൂപ്പുകൾ നോക്കാം.

    നമുക്ക് ഒരു തിരശ്ചീന നാവിഗേഷൻ മോഡൽ സൃഷ്ടിക്കാം

    ഇത്തരത്തിലുള്ള നാവിഗേഷൻ ഏറ്റവും ജനപ്രിയമാണ്. പാനൽ തിരശ്ചീനമായി രൂപകൽപ്പന ചെയ്യുമ്പോൾ, എല്ലാ മെനു ഇനങ്ങളും പേജ് ഹെഡറിലോ "ഫൂട്ടറിലോ" സ്ഥിതി ചെയ്യുന്നു (ചിലപ്പോൾ നാവിഗേഷൻ ഘടകങ്ങൾ തനിപ്പകർപ്പാണ്, മുകളിലും താഴെയുമായി ഒരേസമയം ദൃശ്യമാകും).

    ഒരു ഉദാഹരണമായി, ഞങ്ങൾ ഒരു തിരശ്ചീന പാനൽ സൃഷ്ടിക്കും, അതിന്റെ മെനു ഇനങ്ങൾ CSS (കാസ്കേഡിംഗ് സ്റ്റൈൽ ഷീറ്റുകൾ) ഉപയോഗിച്ച് രൂപകൽപ്പന ചെയ്യും അല്ലെങ്കിൽ രൂപാന്തരപ്പെടും. അതെ, എല്ലാവരും പ്രത്യേക ഘടകംഒരു വളഞ്ഞ ദീർഘചതുരത്തിൽ സ്ഥിതിചെയ്യും. കൗതുകമുണ്ടോ?

    പരിവർത്തനത്തിനായി ഞങ്ങൾ ഒരു css പ്രോപ്പർട്ടി ഉപയോഗിക്കുന്നു രൂപാന്തരപ്പെടുത്തുക. ഒരു പരിവർത്തനം വ്യക്തമാക്കുന്നതിന്, ബിൽറ്റ്-ഇൻ ഫംഗ്ഷൻ ഉപയോഗിക്കുക skewX, അതിൽ ചെരിവിന്റെ കോൺ ഡിഗ്രിയിൽ സൂചിപ്പിച്ചിരിക്കുന്നു.

    നിർഭാഗ്യവശാൽ, ഓരോ ബ്രൗസറും ഈ പ്രോപ്പർട്ടിയുമായി അതിന്റേതായ രീതിയിൽ പ്രവർത്തിക്കുന്നു, നിർദ്ദിഷ്ട മാനദണ്ഡങ്ങൾ ഉണ്ടായിരുന്നിട്ടും. അതിനാൽ, ഇത് സൂചിപ്പിക്കാൻ പ്രത്യേക പ്രിഫിക്സുകൾ സൃഷ്ടിച്ചു:

    • -ms- (ഇന്റർനെറ്റ് എക്സ്പ്ലോറർ)
    • -o- (ഓപ്പറ)
    • -വെബ്കിറ്റ്- (ക്രോം, സഫാരി)
    • -moz- (ഫയർഫോക്സ്)

    ഇപ്പോൾ നമുക്ക് ഒരു ഉദാഹരണം എഴുതാൻ നേടിയ അറിവ് പ്രയോഗിക്കാം.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

    വീട് കമ്പനിയെ കുറിച്ച് ഉൽപ്പന്നങ്ങൾ ബന്ധങ്ങൾ

    വീട്
    കമ്പനിയെ കുറിച്ച്
    ഉൽപ്പന്നങ്ങൾ
    ബന്ധങ്ങൾ
    
    
    

    ഇപ്പോൾ ലംബമായി. ഞാൻ ലംബമായി പറഞ്ഞു!

    രണ്ടാമത്തെ പ്രോഗ്രാമിനായി ഞങ്ങൾ മുൻ കോഡ് അടിസ്ഥാനമായി ഉപയോഗിക്കുന്നു. എന്റെ ലംബമായ മെനു ഇനങ്ങൾക്ക് വളഞ്ഞവയല്ല വൃത്താകൃതിയിലുള്ള കോണുകൾ ഉണ്ടായിരിക്കണമെന്ന് ഞാൻ ആഗ്രഹിച്ചു.
    

    ഇതിനായി ഞാൻ മറ്റൊന്ന് ഉപയോഗിച്ചു css പ്രോപ്പർട്ടി ബോർഡർ-റേഡിയസ്.

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

    വീട്
    കമ്പനിയെ കുറിച്ച്
    ഉൽപ്പന്നങ്ങൾ
    ബന്ധങ്ങൾ
    
    
    

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

    മെനുവിലെ ഉപ-ഇനങ്ങൾ: ഡ്രോപ്പ്-ഡൗൺ ലിസ്റ്റ്

    ഞങ്ങൾ പ്രധാന ഗ്രൂപ്പുകൾ പരിശോധിച്ചു നാവിഗേഷൻ ബാറുകൾ, എന്നിരുന്നാലും, നിരവധി ഇനങ്ങൾ ഉണ്ട്, അല്ലെങ്കിൽ അതിലും മികച്ച കൂട്ടിച്ചേർക്കലുകൾ.

    

    ചില പോയിന്റുകൾ പ്രധാനവയെ പൂരകമാക്കുമ്പോൾ ചിലപ്പോൾ സാഹചര്യങ്ങൾ ഉണ്ടാകുന്നു. ഈ സാഹചര്യത്തിൽ, ഡ്രോപ്പ്-ഡൗൺ ലിസ്റ്റുകൾ ഇല്ലാതെ നിങ്ങൾക്ക് ചെയ്യാൻ കഴിയില്ല. css ടൂളുകൾ ഉപയോഗിച്ചുള്ള പരിവർത്തനങ്ങളിലൂടെയാണ് അവ സൃഷ്ടിക്കുന്നത്.

    നടപ്പിലാക്കുന്ന ഒരു ചെറിയ പ്രോഗ്രാമിന്റെ കോഡ് ഞാൻ ചുവടെ ചേർത്തിട്ടുണ്ട് ഈ സമീപനം.

    1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

    വീട് ഉൽപ്പന്നങ്ങൾ മിഠായികൾ കേക്കുകൾ കുക്കി ബന്ധങ്ങൾ

    • വീട്
    • ഉൽപ്പന്നങ്ങൾ
      • മിഠായികൾ
      • കേക്കുകൾ
      • കുക്കി
    • ബന്ധങ്ങൾ
    
    
    

    IN ഈ ഉദാഹരണത്തിൽഞാൻ മെനു യൂണിറ്റുകളെ രണ്ട് ക്ലാസുകളായി തിരിച്ചിരിക്കുന്നു:

    1. m-മെനു
    2. s-മെനു

    പ്രധാന മെനുവിന് ഒന്നാം ക്ലാസ് ഉത്തരവാദിയാണ്, ഉപമെനുവിന് എസ്-മെനു ഉത്തരവാദിയാണ്.

    കോഡിൽ നിങ്ങൾക്ക് അത്തരമൊരു സാങ്കേതികത കണ്ടെത്താം .m-menu > li:hoverഅഥവാ .m-menu > li.

    അതിനാൽ, ഹോവർ ഉപയോഗിച്ച്, മൂലകത്തിന് മുകളിൽ ഹോവർ ചെയ്യുമ്പോൾ അത് എങ്ങനെ പ്രവർത്തിക്കുമെന്ന് നിങ്ങൾ വ്യക്തമാക്കുന്നു.

    ഈ സാഹചര്യത്തിൽ, ">" ചിഹ്നം സെലക്‌ടറിനെ പരിഷ്‌ക്കരിക്കുന്നതിനാൽ മുകളിലെ തലത്തിലുള്ള ഒബ്‌ജക്റ്റുകൾ മാത്രം ബ്ലോക്ക്-ലോവർകേസ് ആകും.

    തുടക്കത്തിൽ ഉപമെനു സജ്ജമാക്കി പ്രദർശിപ്പിക്കുക:ഒന്നുമില്ല, ഈ ഒബ്ജക്റ്റ് മറയ്ക്കാൻ ഹാൻഡ്ലറെ അറിയിക്കുന്നു. സൂചിപ്പിക്കുന്ന ഒരു നാവിഗേഷൻ ഘടകത്തിന് മുകളിൽ ഹോവർ ചെയ്ത ശേഷം ഹോവർ ചെയ്യുക, വസ്തുവിന്റെ മൂല്യം ഡിസ്പ്ലേഎന്നതിലേക്ക് മാറുന്നു തടയുകഅങ്ങനെ ഒരു ഡ്രോപ്പ്ഡൗൺ ലിസ്റ്റ് തുറക്കുന്നു.

    നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഈ സാങ്കേതികവിദ്യ നടപ്പിലാക്കുന്നത് വളരെ ലളിതമാണ്.

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

    ആശംസകളോടെ, റോമൻ ചുഷോവ്

    വായിക്കുക: 1010 തവണ