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

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

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

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

ഈ പുസ്തകം ക്ലാസിക്, ആധുനിക ജാവാസ്ക്രിപ്റ്റ് പ്രോഗ്രാമിംഗ് പാറ്റേണുകൾ ഉൾക്കൊള്ളുന്നു. പൊതുവേ, ഇത് തുടക്കക്കാരായ പ്രോഗ്രാമർമാരെ ലക്ഷ്യം വച്ചുള്ളതാണ്.

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

JS ഉപയോഗിച്ച് വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ ഉദ്ദേശിക്കുന്നവർക്ക് വേണ്ടിയുള്ളതാണ് ഈ പുസ്തകം. ഇത് ഭാഷയുടെ സവിശേഷതകൾ, ഉപയോഗപ്രദമായ ടൂളുകൾ, ടെംപ്ലേറ്റുകൾ എന്നിവ വിവരിക്കുന്നു, ലിസ്റ്റ് ഇതിൽ മാത്രം പരിമിതപ്പെടുന്നില്ല.

ഈ പുസ്തകം നിങ്ങൾക്ക് ജാവാസ്ക്രിപ്റ്റിനെക്കുറിച്ചുള്ള പൊതുവായ അറിവ് നൽകും, അതിന്റെ പൊതുവായ യുക്തിയും വിശദാംശങ്ങളും മനസ്സിലാക്കുന്നു. ഒബ്ജക്റ്റ് ഓറിയന്റഡ് പ്രോഗ്രാമിംഗിന്റെ തത്വങ്ങളും PHP, Ruby, Python, C++ അല്ലെങ്കിൽ Java പോലുള്ള ഒരു ഭാഷയും വായനക്കാരന് ഇതിനകം പരിചിതമാണെന്ന് രചയിതാവ് അനുമാനിക്കുന്നു.

നിങ്ങളുടെ വെബ് പ്രോഗ്രാമിംഗ് പരിശീലനത്തിൽ ഒരു പടി കൂടി മുന്നോട്ട് പോയി HTML, CSS എന്നിവയിലെ കോഡിംഗിൽ നിന്ന് പൂർണ്ണമായ ചലനാത്മക പേജുകൾ സൃഷ്ടിക്കുന്നതിലേക്ക് മാറാൻ നിങ്ങൾ തയ്യാറാണോ? അപ്പോൾ ഏറ്റവും ചൂടേറിയ പ്രോഗ്രാമിംഗ് ഭാഷ - ജാവാസ്ക്രിപ്റ്റ് പരിചയപ്പെടാൻ സമയമായി!

ഈ പുസ്തകം വായിച്ചതിനുശേഷം, ജാവാസ്ക്രിപ്റ്റ് ഭാഷയെക്കുറിച്ച് നിങ്ങൾ എല്ലാം പഠിക്കും: വേരിയബിളുകൾ മുതൽ ലൂപ്പുകൾ വരെ. വ്യത്യസ്ത ബ്രൗസറുകൾ കോഡിനോട് വ്യത്യസ്‌തമായി പ്രതികരിക്കുന്നത് എന്തുകൊണ്ടാണെന്നും എല്ലാ ബ്രൗസറുകളും പിന്തുണയ്‌ക്കുന്ന യൂണിവേഴ്‌സൽ കോഡ് എങ്ങനെ എഴുതാമെന്നും നിങ്ങൾ മനസ്സിലാക്കും. എന്തുകൊണ്ടാണ് JS ഭാവിയെന്ന് നിങ്ങൾ മനസ്സിലാക്കുകയും ഒരു യഥാർത്ഥ ഫ്രണ്ട്-എൻഡ് ഡെവലപ്പർ ആകുകയും ചെയ്യും.

മൂന്നാം കക്ഷി ചട്ടക്കൂടുകളോ ലൈബ്രറികളോ ഉപയോഗിക്കാതെ JS-ൽ ഫ്രണ്ട്-എൻഡ് ആപ്ലിക്കേഷനുകൾ എങ്ങനെ എഴുതാമെന്ന് ഈ പുസ്തകം നിങ്ങളെ കാണിക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റ് തത്വങ്ങളെക്കുറിച്ചുള്ള പൊതുവായ അറിവ് കൂടാതെ, ഈ പുസ്തകം നിങ്ങൾക്ക് JSON അല്ലെങ്കിൽ NoSQL പോലുള്ള അനുബന്ധ മേഖലകളെക്കുറിച്ചുള്ള അറിവും വെബ് ആപ്ലിക്കേഷനുകൾ പൊതുവായി എങ്ങനെ എഴുതപ്പെടുന്നു എന്നതിനെക്കുറിച്ചുള്ള ധാരണയും നൽകും.

ശീർഷകം സൂചിപ്പിക്കുന്നത് പോലെ, ഈ പുസ്തകം സിംഗിൾ പേജ് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നതിനെക്കുറിച്ചാണ്. ഇത് നിർദ്ദിഷ്ട സാങ്കേതികവിദ്യകളും ചട്ടക്കൂടുകളും വിവരിക്കുന്നില്ല, പക്ഷേ ഇത് പൊതുവായ പാറ്റേണുകളും സമ്പ്രദായങ്ങളും നന്നായി വിവരിക്കുന്നു.

DOM (ഡോക്യുമെന്റ് ഒബ്‌ജക്റ്റ് മോഡൽ) ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ ഈ പുസ്തകം സമർപ്പിക്കപ്പെട്ടിരിക്കുന്നു - ഒരുപക്ഷേ എല്ലാ വെബ് ഡെവലപ്പർമാർക്കും ജാവാസ്ക്രിപ്റ്റിലെ ഏറ്റവും പ്രധാനപ്പെട്ട കാര്യം.

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

പ്രശസ്ത അധ്യാപകനായ കൈൽ സിംപ്സൺ എഴുതിയ ഈ പരമ്പരയിൽ 6 പുസ്തകങ്ങൾ അടങ്ങിയിരിക്കുന്നു, ഓരോന്നിനും ഭാഷയുടെ വ്യത്യസ്ത വിഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു. ഈ പുസ്‌തകങ്ങളുടെ പ്രധാന നേട്ടം, അവ വേണ്ടത്ര ചെറുതായതിനാൽ നിങ്ങൾക്ക് ശ്രദ്ധ തിരിക്കാൻ സമയമില്ല എന്നതാണ്. റഷ്യൻ ഭാഷയിൽ പേപ്പർ പതിപ്പിൽ ഈ സീരീസിൽ നിന്ന് നിങ്ങൾക്ക് "ES6 ആൻഡ് ബിയോണ്ട്" എന്ന പുസ്തകം വാങ്ങാം.

ഇന്റർനെറ്റ് പേജുകൾ സംവേദനാത്മകവും ചലനാത്മകവുമാക്കുന്നതിനും ഉയർന്ന പ്രകടനം കൈവരിക്കുന്നതിനും നിങ്ങളെ അനുവദിക്കുന്ന വെബ് ഡെവലപ്പർമാരുടെ പ്രധാന ഉപകരണമാണ് JavaScript. ഇത് പഠിക്കാൻ എളുപ്പമുള്ളതല്ല, എന്നാൽ വളരെ ജനപ്രിയമായ ഭാഷ വേഗത്തിൽ പഠിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന JavaScript-നുള്ള നന്നായി ചിട്ടപ്പെടുത്തിയ ഗൈഡാണ്. പുസ്തകത്തിലെ jQuery ലൈബ്രറിയിൽ വളരെയധികം ശ്രദ്ധ ചെലുത്തുന്നു. നിരവധി ഉദാഹരണങ്ങളും വിശദമായ ജോലികളും ഉണ്ട്.

സമഗ്രമായ ഗൈഡ് വായിച്ചതിനുശേഷം, നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ചെയ്യാൻ കഴിയും:

• നിങ്ങളുടെ വെബ്‌സൈറ്റ് പേജുകൾ സംവേദനാത്മകമാക്കുക.
• jQuery UI പ്ലഗിന്റെ ഏറ്റവും പുതിയ പതിപ്പ് മാസ്റ്റർ ചെയ്യുക.
• യാന്ത്രിക ഡാറ്റ മൂല്യനിർണ്ണയവും തിരുത്തലും ഉപയോഗിച്ച് സൗകര്യപ്രദമായ ഫോമുകൾ സൃഷ്ടിക്കുക.
• AJAX സാങ്കേതികവിദ്യ ഉപയോഗിക്കുക.
• ഈ മേഖലയിൽ നിങ്ങളുടെ അറിവ് ആഴത്തിലാക്കുകയും ഒരു പ്രൊഫഷണലാകുകയും ചെയ്യുക.

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

ഇതിനകം ക്ലാസിക് ആയി മാറിയ ഒരു പുസ്തകം. അതിന്റെ ഏറ്റവും പുതിയ പതിപ്പ് HTML5, ECMAScript 6 എന്നിവ ഉൾക്കൊള്ളുന്നു - ഇന്നത്തെ ഏറ്റവും പ്രസക്തമായ സാങ്കേതികവിദ്യകൾ. ഇത് jQuery, സെർവർ സൈഡ് JavaScript എന്നിവയിലും പുതിയ അധ്യായങ്ങൾ ചേർക്കുന്നു. സമ്പൂർണ്ണ തുടക്കക്കാർക്കും ജാവാസ്ക്രിപ്റ്റിനെക്കുറിച്ചുള്ള അറിവ് പൂർണ്ണതയിലേക്ക് വികസിപ്പിക്കാൻ ആഗ്രഹിക്കുന്നവർക്കും ഈ ഗൈഡ് ഉപയോഗപ്രദമാകും.

“ആറാഴ്ചയ്ക്കുള്ളിൽ ഫുൾ-സ്റ്റാക്ക് ജാവാസ്ക്രിപ്റ്റ്: എ കരിക്കുലം ഗൈഡ്” എന്ന ലേഖനത്തിന്റെ വിവർത്തനം.

പുതിയ പ്രോഗ്രാമർമാർക്കിടയിൽ ഏറ്റവും ലളിതവും അതിനാൽ ജനപ്രിയവുമായ മേഖലകളിലൊന്നാണ് വെബ് വികസനം. ഏതെങ്കിലും ടെക്സ്റ്റ് എഡിറ്ററും ബ്രൗസറും പ്രവർത്തിക്കാൻ മതിയാകും; വിപുലമായ തലത്തിൽ അൽഗോരിതം പഠിക്കേണ്ട ആവശ്യമില്ല, ഒരു പ്രോഗ്രാം എഴുതുന്നതിന്റെ ഓരോ ഘട്ടത്തിന്റെയും ഫലം വ്യക്തമാണ് - പൊതുവേ, ധാരാളം ഗുണങ്ങളുണ്ട്. വെബ് വികസനത്തിന്റെ പശ്ചാത്തലത്തിൽ ഒരു പ്രധാന വൈദഗ്ദ്ധ്യം ജാവാസ്ക്രിപ്റ്റിനെക്കുറിച്ചുള്ള അറിവാണ്.

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

എന്തുകൊണ്ട് ജാവാസ്ക്രിപ്റ്റ്?

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

അടിസ്ഥാനകാര്യങ്ങൾ

ആദ്യം നിങ്ങൾ JavaScript, വെബ് വികസനം, പ്രോഗ്രാമിംഗ് എന്നിവയുടെ അടിസ്ഥാന ആശയങ്ങൾ പഠിക്കേണ്ടതുണ്ട്:

• ഒബ്ജക്റ്റ്-ഓറിയന്റഡ് JS - കൺസ്ട്രക്റ്ററുകളും ഫാക്ടറികളും, അനന്തരാവകാശം;
• ഫങ്ഷണൽ JS - ഉയർന്ന ഓർഡർ ഫംഗ്ഷനുകൾ, ക്ലോഷറുകൾ, ആവർത്തനം;
• ജാസ്മിൻ ടെസ്റ്റ് സവിശേഷതകൾ;
• HTML, CSS, jQuery എന്നിവയുടെ അടിസ്ഥാനകാര്യങ്ങൾ.

Git

ഡെവലപ്പർമാർക്ക് അത്യന്താപേക്ഷിതമായ ഒരു ഉപകരണമാണ് Git, അതിനാൽ കഴിയുന്നതും വേഗം ഇത് ആരംഭിക്കുക. നിങ്ങൾക്ക് ഉണ്ടായിരിക്കേണ്ട അടിസ്ഥാന കഴിവുകൾ ഇതാ:

• ഡയറക്ടറികളിൽ ഫയലുകൾ സൃഷ്ടിക്കുകയും നീക്കുകയും ചെയ്യുക;
• Git-ലെ സമാരംഭവും പ്രതിബദ്ധതയും;
• GitHub-ൽ റിപ്പോസിറ്ററികൾ സജ്ജീകരിക്കുന്നു.

അൽഗോരിതങ്ങളും ഡാറ്റാ ഘടനകളും

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

BackendNode.js

10 വർഷം മുമ്പ് ജാവാസ്ക്രിപ്റ്റ് ഫ്രണ്ട് എൻഡ് വികസനത്തിന് മാത്രമേ ഉപയോഗിക്കാനാകൂ. ഇപ്പോൾ, Node.js-ന് നന്ദി, കാര്യം ഒരു "മുന്നിൽ" മാത്രമായി പരിമിതപ്പെടുത്തിയിട്ടില്ല. സെർവർ സൈഡിൽ JS കോഡ് പ്രവർത്തിപ്പിക്കുന്നതിനുള്ള ഒരു പരിതസ്ഥിതിയാണ് നോഡ്, അതിനാൽ നിങ്ങൾക്ക് പുതിയ വാക്യഘടനയൊന്നും പഠിക്കേണ്ടതില്ല, എന്നാൽ നിങ്ങൾ ഫയലുകൾ ഇറക്കുമതി ചെയ്യുകയും കയറ്റുമതി ചെയ്യുകയും കോഡ് മോഡുലറൈസ് ചെയ്യുകയും npm പാക്കേജ് മാനേജർ ഉപയോഗിക്കുകയും വേണം.

സെർവറുകൾ, HTTP, Express.js

നോഡ് പഠിച്ചതിന് ശേഷം, ബാക്കെൻഡ് ഡെവലപ്‌മെന്റ്, സെർവറുകളും റൂട്ടിംഗും മനസ്സിലാക്കൽ എന്നിവയുമായി നിങ്ങളുടെ പരിചയം തുടരുന്നത് മൂല്യവത്താണ്. നിങ്ങൾക്ക് HTTP-യിൽ ഊന്നൽ നൽകി പോർട്ടുകളും പ്രോട്ടോക്കോളുകളും ഉപയോഗിച്ച് ആരംഭിക്കാം, തുടർന്ന് അഭ്യർത്ഥനകൾ പ്രോസസ്സ് ചെയ്യുന്നതിനുള്ള ഒരു നോഡ് ലൈബ്രറിയായ എക്സ്പ്രസിലേക്ക് പോകാം.

അസിൻക്രണസ് ജാവാസ്ക്രിപ്റ്റ് ഡാറ്റാബേസുകൾ, സ്കീമകൾ, മോഡലുകൾ, ORM-കൾ

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

FrontendHTML, CSS എന്നിവ

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

jQuery, DOM കൃത്രിമത്വം

HTML, CSS എന്നിവ ഉപയോഗിച്ച് നിങ്ങളുടെ പേജിന്റെ രൂപവും ഭാവവും സൃഷ്ടിച്ചുകഴിഞ്ഞാൽ, DOM കൈകാര്യം ചെയ്യാൻ നിങ്ങൾ jQuery ഉപയോഗിക്കും. jQuery ഉപയോഗശൂന്യമാണെന്നും അത് ഉടൻ തന്നെ ആംഗുലറും റിയാക്‌റ്റും ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുമെന്നും പലരും കരുതുന്നു, പക്ഷേ ഇത് വളരെ ജനപ്രിയമാണ്, അതിനാൽ അത് അറിയേണ്ടതാണ്. കൂടാതെ, ഒരു റിയാക്റ്റ് മൈക്രോസ്കോപ്പ് ഉപയോഗിച്ച് നഖങ്ങൾ അടിക്കുന്നത് നിങ്ങൾക്ക് അസൗകര്യമുണ്ടാക്കുന്ന ഒരു സാഹചര്യത്തിൽ ഒരു ദിവസം നിങ്ങൾ സ്വയം കണ്ടെത്തും, തുടർന്ന് ഭാരം കുറഞ്ഞ jQuery നിങ്ങളുടെ സഹായത്തിന് വരും.

Chrome ഡെവലപ്പർ ടൂളുകൾ

വളരെയധികം സാധ്യതകൾ നൽകുന്ന Chrome ടൂളുകളെ അവഗണിക്കുന്നത് പൊറുക്കാനാവാത്തതാണ്. അവ ഉപയോഗിച്ച് നിങ്ങൾക്ക് DOM ഘടകങ്ങൾ പരിശോധിക്കാനും കൺസോൾ വഴി ഡീബഗ് ചെയ്യാനും റൂട്ടുകൾ കണ്ടെത്താനും മറ്റും കഴിയും. പതിവ് ജോലികൾ എളുപ്പമാക്കുന്ന Chrome കൺസോളിന്റെ നിരവധി ഹാൻഡി ഫീച്ചറുകൾ ഞങ്ങൾ വിവരിക്കുന്നു.

അജാക്സ്

ഓരോ ഡാറ്റാബേസ് പ്രവർത്തനത്തിനും ശേഷം നിങ്ങളുടെ ആപ്ലിക്കേഷൻ പേജുകൾ റീലോഡ് ചെയ്യരുതെന്ന് നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് തീർച്ചയായും AJAX ആവശ്യമാണ് - ഇത് പശ്ചാത്തല അസിൻക്രണസ് HTTP അഭ്യർത്ഥനകൾ അയയ്ക്കുന്നു, പ്രതികരണങ്ങൾ ഡിസ്പ്ലേയുടെ ഒരു ഭാഗം മാത്രം അപ്ഡേറ്റ് ചെയ്യുന്നു. .ajax രീതി ഉപയോഗിച്ച് jQuery വഴി നിങ്ങൾക്ക് AJAX-ൽ പ്രവർത്തിക്കാം.

വിപുലമായ വിഷയങ്ങൾ ടെസ്റ്റ് പ്രേരിതമായ വികസനം

അല്ലെങ്കിൽ TDD എന്നത് ഒരു വികസന സാങ്കേതികതയാണ്, അതിൽ സോഫ്റ്റ്വെയർ സൃഷ്ടിയെ നിരവധി ചെറിയ സൈക്കിളുകളായി തിരിച്ചിരിക്കുന്നു: ആദ്യം, ആവശ്യമുള്ള മാറ്റം ഉൾക്കൊള്ളുന്ന ടെസ്റ്റുകൾ എഴുതുന്നു, തുടർന്ന് ഈ ടെസ്റ്റുകളിൽ വിജയിക്കുന്ന കോഡ് എഴുതുന്നു. ഇതിനുശേഷം, കോഡ് പുനർനിർമ്മിക്കുകയും ആവശ്യമെങ്കിൽ പുതിയ ടെസ്റ്റുകൾ എഴുതുകയും ചെയ്യുന്നു. കോഡിന്റെ ഒരു വിഭാഗം ചില പരിശോധനകളിൽ പരാജയപ്പെട്ടാൽ, ഇത് ശരിയാക്കും.

വെബ്‌സോക്കറ്റുകൾ

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

ES6, ബാബെൽ, വെബ്‌പാക്ക്

നിലവിൽ, പ്രധാന സ്റ്റാൻഡേർഡ് ES6 (ES2015) ആണ്, എന്നാൽ ES2016 ഇതിനകം സ്വീകരിച്ചു, ES2017 വികസിപ്പിച്ചുകൊണ്ടിരിക്കുന്നു, അതിനാൽ നിങ്ങൾ എല്ലായ്പ്പോഴും അപ്ഡേറ്റുകളെക്കുറിച്ച് അറിഞ്ഞിരിക്കുകയും അവ ഉപയോഗിക്കുകയും വേണം. രണ്ട് ഉപകരണങ്ങൾ ഉപയോഗിച്ച് അനുയോജ്യത പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ കഴിയും:

• ബാബെൽ - എല്ലാ ബ്രൗസറുകളും പിന്തുണയ്ക്കുന്ന ES5-ലേക്ക് ES6 കോഡ് (ES2016 പിന്തുണ ഉടൻ വരുന്നു) സമാഹരിക്കുന്നു. JSX/React ഘടകങ്ങൾ എങ്ങനെ കംപൈൽ ചെയ്യാമെന്ന് പോലും ഇതിന് അറിയാം, അത് ഏതൊരു വെബ് ഡെവലപ്പർക്കും അത് ഒഴിച്ചുകൂടാനാവാത്തതാക്കുന്നു;
• Webpack - നിങ്ങളുടെ എല്ലാ ഉറവിട ഫയലുകളും (ചിത്രങ്ങൾ, ഫോണ്ടുകൾ, സ്റ്റൈൽഷീറ്റുകൾ, JS ഫയലുകൾ മുതലായവ) ഒരൊറ്റ ഡിപൻഡൻസി ഗ്രാഫിലേക്ക് ശേഖരിക്കുന്നു. ചെറിയ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുമ്പോൾ ഇത് ഉപയോഗപ്രദമാകില്ല, എന്നാൽ റിയാക്ടിനൊപ്പം പ്രവർത്തിക്കുമ്പോൾ അതിന്റെ സഹായം വിലമതിക്കാനാവാത്തതാണ്.

റിയാക്ടും റിഡക്സും

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

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

പ്രാമാണീകരണം, സെഷനുകൾ, കുക്കികൾ

ആപ്ലിക്കേഷനുകൾ ഉപയോക്താക്കളുമായി എങ്ങനെ ഇടപഴകുന്നു, അക്കൗണ്ട് ലോഗിനുകളും ലോഗ്ഔട്ടുകളും പ്രോസസ്സ് ചെയ്യുന്നതും പ്രത്യേകാവകാശങ്ങൾ നൽകുന്നതും നിങ്ങൾ മനസ്സിലാക്കണം. ഒരു സെഷനിൽ ഉപയോക്താവിന്റെ ഐഡന്റിറ്റി ട്രാക്ക് ചെയ്യുന്നതിന്, കുക്കികൾ ഉപയോഗിക്കുന്നു - ഒരു HTTP അഭ്യർത്ഥനയ്ക്ക് മറുപടിയായി സെർവർ ബ്രൗസറിലേക്ക് അയച്ച ചെറിയ ടെക്സ്റ്റ് ഫയലുകൾ. ഡാറ്റാബേസും അംഗീകാര പേജുകളും തമ്മിലുള്ള ബന്ധം ഉറപ്പാക്കാൻ, നിങ്ങൾക്ക് എക്സ്പ്രസ്-സെഷൻ ലൈബ്രറി ഉപയോഗിക്കാം.

വെബ് സുരക്ഷ

അവസാനമായി, നിങ്ങൾ സുരക്ഷയിൽ ശ്രദ്ധിക്കണം. ആക്രമണ രീതികളും അവയിൽ നിന്ന് പ്രതിരോധിക്കാനുള്ള വഴികളും പഠിക്കേണ്ടത് പ്രധാനമാണ്.

• വിവർത്തനം

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

പ്രിമിറ്റീവ് ഡാറ്റ തരങ്ങൾ JavaScript-ന് ഇനിപ്പറയുന്ന പ്രാകൃത ഡാറ്റാ തരങ്ങളുണ്ട്: നമ്പർ, ബൂളിയൻ, സ്ട്രിംഗ്, നിർവചിക്കാത്തത്, നൾ. പ്രിമിറ്റീവ് ഡാറ്റ തരങ്ങളുമായി പ്രവർത്തിക്കുമ്പോൾ, ഉദാഹരണത്തിന്, സ്ട്രിംഗ് ലിറ്ററലുകൾ, വ്യക്തമായ പരിവർത്തനം നടത്താതെ തന്നെ നമുക്ക് അവയുടെ രീതികളും സവിശേഷതകളും ആക്‌സസ് ചെയ്യാൻ കഴിയുമെന്നത് ഉടനടി ശ്രദ്ധിക്കേണ്ടതാണ്. അത്തരം പ്രവർത്തനങ്ങൾ നടത്താൻ ശ്രമിക്കുമ്പോൾ, അക്ഷരങ്ങൾ സ്വയമേവ അനുയോജ്യമായ ഒബ്‌ജക്റ്റ് റാപ്പർ കൊണ്ട് സജ്ജീകരിച്ചിരിക്കുന്നു എന്നതാണ് ഇവിടെയുള്ള കാര്യം. ചില പദപ്രയോഗങ്ങൾ കണക്കാക്കുന്നതിന്റെ ഫലങ്ങൾ ഗണിതശാസ്ത്രപരമായി തെറ്റാണ് എന്ന വസ്തുതയിലേക്ക് ഇത് നയിക്കുന്നു. JS-ൽ 0.1 + 0.2 എന്ന പദപ്രയോഗത്തിന്റെ മൂല്യം 0.3 ന് തുല്യമല്ലെന്ന് നിങ്ങൾക്ക് ഇതിനകം അറിയാമായിരിക്കും. അതേ സമയം, പൂർണ്ണസംഖ്യകളിൽ പ്രവർത്തിക്കുമ്പോൾ, അത്തരം പ്രശ്നങ്ങൾ നിരീക്ഷിക്കപ്പെടുന്നില്ല, അതായത്, 1 + 2 === 3.

ജാവാസ്ക്രിപ്റ്റിന് ഒരു നമ്പർ ഒബ്‌ജക്‌റ്റ് ഉണ്ട്, അത് സംഖ്യാ മൂല്യങ്ങൾക്കുള്ള ഒബ്‌ജക്റ്റ് റാപ്പറാണ്. var a = new Number(10) പോലുള്ള ഒരു കമാൻഡ് ഉപയോഗിച്ച് നമ്പറിന്റെ തരം ഒബ്‌ജക്റ്റുകൾ സൃഷ്‌ടിക്കാവുന്നതാണ്, അല്ലെങ്കിൽ മുകളിൽ വിവരിച്ച സിസ്റ്റത്തിന്റെ സ്വയമേവയുള്ള പ്രവർത്തനരീതിയെ നിങ്ങൾക്ക് ആശ്രയിക്കാവുന്നതാണ്. സംഖ്യാ ലിറ്ററലുകളിൽ പ്രയോഗിക്കുമ്പോൾ Number.prototype-ൽ സംഭരിച്ചിരിക്കുന്ന രീതികളെ വിളിക്കാൻ ഇത് പ്രത്യേകം അനുവദിക്കുന്നു:

(123).toString(); //"123" (1.23).toFixed(1); //"1.2"
മറ്റ് തരത്തിലുള്ള മൂല്യങ്ങളെ ഒരു സംഖ്യാ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ രൂപകൽപ്പന ചെയ്ത ആഗോള ഫംഗ്ഷനുകളുണ്ട്. ഇവയാണ് parseInt() , parseFloat() കൂടാതെ Number() കൺസ്ട്രക്‌റ്റും, ഈ സാഹചര്യത്തിൽ തരം പരിവർത്തനം നടത്തുന്ന ഒരു സാധാരണ ഫംഗ്‌ഷനായി ഇത് പ്രവർത്തിക്കുന്നു:

ParseInt("1") //1 parseInt("text") //NaN parseFloat("1.234") //1.234 Number("1") //1 Number("1.234") //1.234
അക്കങ്ങളുള്ള ഒരു പ്രവർത്തനം ഒരു സംഖ്യയല്ലാത്ത എന്തെങ്കിലും ഉണ്ടാക്കുകയാണെങ്കിൽ (ചില കണക്കുകൂട്ടലിനിടെ, അല്ലെങ്കിൽ എന്തെങ്കിലും ഒരു സംഖ്യയാക്കി മാറ്റാൻ ശ്രമിക്കുമ്പോൾ), JavaScript ഒരു പിശക് വരുത്തില്ല, പക്ഷേ അത്തരം ഒരു പ്രവർത്തനത്തിന്റെ ഫലത്തെ ഒരു NaN മൂല്യമായി പ്രതിനിധീകരിക്കും ( ഒരു സംഖ്യയല്ല, ഒരു സംഖ്യയല്ല). ഒരു മൂല്യം NaN ആണോ എന്ന് പരിശോധിക്കാൻ, നിങ്ങൾക്ക് isNaN() ഫംഗ്ഷൻ ഉപയോഗിക്കാം.

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

1 + 1 //2 "1" + "1" //"11" 1 + "1" //"11"

▍JavaScript-ലെ Strings Strings എന്നത് യൂണികോഡ് പ്രതീകങ്ങളുടെ ക്രമങ്ങളാണ്. ഇരട്ട ഉദ്ധരണികൾ ("") അല്ലെങ്കിൽ ഒറ്റ ഉദ്ധരണികൾ ("") എന്നിവയ്ക്കുള്ളിൽ അടങ്ങിയിരിക്കേണ്ട വാചകം ഉൾപ്പെടുത്തിയാണ് സ്ട്രിംഗ് ലിറ്ററലുകൾ സൃഷ്ടിക്കുന്നത്. ഇതിനകം സൂചിപ്പിച്ചതുപോലെ, സ്ട്രിംഗ് ലിറ്ററലുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, നമുക്ക് അനുബന്ധ ഒബ്‌ജക്റ്റ് റാപ്പറിനെ ആശ്രയിക്കാം, ഇതിന്റെ പ്രോട്ടോടൈപ്പിന് സബ്‌സ്ട്രിംഗ് (), ഇൻഡെക്സ്ഓഫ് (), കോൺകാറ്റ് () ഉൾപ്പെടെ നിരവധി ഉപയോഗപ്രദമായ രീതികളുണ്ട്.

"text".substring(1,3) //ex "text".indexOf("x") //2 "text".concat(" end") //text end
മറ്റ് പ്രാകൃത മൂല്യങ്ങളെപ്പോലെ സ്ട്രിംഗുകളും മാറ്റമില്ലാത്തവയാണ്. ഉദാഹരണത്തിന്, കോൺകാറ്റ്() രീതി നിലവിലുള്ള ഒരു സ്‌ട്രിംഗിനെ പരിഷ്‌ക്കരിക്കില്ല, പുതിയ ഒരെണ്ണം സൃഷ്‌ടിക്കുന്നു.

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

വാചകം = ""; if(text) ( console.log("ഇത് ശരിയാണ്"); ) else ( console.log("ഇത് തെറ്റാണ്"); )

ഒബ്‌ജക്‌റ്റുകൾ കീ-വാല്യൂ ജോഡികളാൽ നിർമ്മിച്ച ചലനാത്മക ഘടനയാണ് ഒബ്‌ജക്റ്റുകൾ. മൂല്യങ്ങൾ പ്രാകൃത ഡാറ്റാ തരങ്ങളോ ഒബ്‌ജക്റ്റുകളോ ഫംഗ്‌ഷനുകളോ ആകാം.

ഒബ്ജക്റ്റ് ലിറ്ററൽ വാക്യഘടന ഉപയോഗിച്ച് ഒബ്ജക്റ്റുകൾ ഏറ്റവും എളുപ്പത്തിൽ സൃഷ്ടിക്കപ്പെടുന്നു:

obj = ( സന്ദേശം: "ഒരു സന്ദേശം", doSomething: function() () )
ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ എപ്പോൾ വേണമെങ്കിലും വായിക്കാനും ചേർക്കാനും എഡിറ്റ് ചെയ്യാനും ഇല്ലാതാക്കാനും കഴിയും. ഇത് എങ്ങനെ ചെയ്യുന്നുവെന്ന് ഇതാ:

• വായനാ സവിശേഷതകൾ: object.name, object .
• പ്രോപ്പർട്ടികളിലേക്ക് ഡാറ്റ എഴുതുന്നു (ആക്സസ് ചെയ്യുന്ന പ്രോപ്പർട്ടി നിലവിലില്ലെങ്കിൽ, നിർദ്ദിഷ്ട കീ ഉള്ള ഒരു പുതിയ പ്രോപ്പർട്ടി ചേർക്കുന്നു): object.name = മൂല്യം, ഒബ്ജക്റ്റ് = മൂല്യം.
• പ്രോപ്പർട്ടികൾ ഇല്ലാതാക്കുന്നു: object.name ഇല്ലാതാക്കുക , ഒബ്ജക്റ്റ് ഇല്ലാതാക്കുക .

ചില ഉദാഹരണങ്ങൾ ഇതാ:

obj = (); // ഒരു ശൂന്യമായ ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നു obj.message = "ഒരു സന്ദേശം"; // ഒരു പുതിയ പ്രോപ്പർട്ടി ചേർക്കുന്നു obj.message = "ഒരു പുതിയ സന്ദേശം"; // പ്രോപ്പർട്ടി എഡിറ്റുചെയ്യൽ object.message ഇല്ലാതാക്കുക; // ഒരു പ്രോപ്പർട്ടി ഇല്ലാതാക്കുന്നു
ഭാഷയിലെ ഒബ്ജക്റ്റുകൾ ഹാഷ് ടേബിളുകളായി നടപ്പിലാക്കുന്നു. Object.create(null) കമാൻഡ് ഉപയോഗിച്ച് ഒരു ലളിതമായ ഹാഷ് ടേബിൾ ഉണ്ടാക്കാം:

ഫ്രഞ്ച് ആകട്ടെ = Object.create(null); ഫ്രഞ്ച് ["അതെ"] = "ഔയി"; ഫ്രഞ്ച് ["നോ"] = "അല്ല"; ഫ്രഞ്ച്["അതെ"];//"oui"
നിങ്ങൾക്ക് ഒരു ഒബ്ജക്റ്റ് മാറ്റമില്ലാത്തതാക്കണമെങ്കിൽ, നിങ്ങൾക്ക് Object.freeze() കമാൻഡ് ഉപയോഗിക്കാം.

ഒരു ഒബ്‌ജക്റ്റിന്റെ എല്ലാ ഗുണങ്ങളും ആവർത്തിക്കാൻ, നിങ്ങൾക്ക് Object.keys() കമാൻഡ് ഉപയോഗിക്കാം:

ഫംഗ്ഷൻ logProperty(name)( console.log(name); //property name console.log(obj); //property value ) Object.keys(obj).forEach(logProperty);

▍ആദിമ തരങ്ങളുടെയും വസ്തുക്കളുടെയും മൂല്യങ്ങളുടെ താരതമ്യം പ്രാകൃത മൂല്യങ്ങളുമായി പ്രായോഗികമായി പ്രവർത്തിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഇതിനകം പറഞ്ഞതുപോലെ, അവ വസ്തുക്കളല്ലെങ്കിലും ഗുണങ്ങളും രീതികളും ഉള്ള വസ്തുക്കളായി അവയെ മനസ്സിലാക്കാൻ കഴിയും. പ്രാകൃത മൂല്യങ്ങൾ മാറ്റമില്ലാത്തവയാണ്, കൂടാതെ ഒബ്‌ജക്റ്റുകളുടെ ആന്തരിക ഘടന മാറാം. വേരിയബിളുകൾ JavaScript-ൽ, var, let, const എന്നീ കീവേഡുകൾ ഉപയോഗിച്ച് വേരിയബിളുകൾ പ്രഖ്യാപിക്കാം.

var കീവേഡ് ഉപയോഗിക്കുമ്പോൾ, നിങ്ങൾക്ക് ഒരു വേരിയബിൾ പ്രഖ്യാപിക്കുകയും ആവശ്യമെങ്കിൽ ഒരു നിശ്ചിത മൂല്യം ഉപയോഗിച്ച് അത് ആരംഭിക്കുകയും ചെയ്യാം. ഒരു വേരിയബിൾ ആരംഭിച്ചിട്ടില്ലെങ്കിൽ, അതിന്റെ മൂല്യം നിർവചിക്കപ്പെട്ടിട്ടില്ല. var കീവേഡ് ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച വേരിയബിളുകൾക്ക് പ്രവർത്തന വ്യാപ്തിയുണ്ട്.

ലെറ്റ് കീവേഡ് var എന്നതിനോട് വളരെ സാമ്യമുള്ളതാണ്, ലെറ്റ് കീവേഡ് ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച വേരിയബിളുകൾക്ക് ബ്ലോക്ക് സ്കോപ്പ് ഉണ്ട് എന്നതാണ് വ്യത്യാസം.

കോൺസ്റ്റ് കീവേഡ് ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച വേരിയബിളുകൾക്ക് ബ്ലോക്ക് സ്കോപ്പുമുണ്ട്, അത്തരം വേരിയബിളുകളുടെ മൂല്യങ്ങൾ മാറ്റാൻ കഴിയില്ല എന്നതിനാൽ, കൂടുതൽ ശരിയായി "സ്ഥിരങ്ങൾ" എന്ന് വിളിക്കപ്പെടും. കോൺസ്റ്റ് കീവേഡ്, അത് ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച വേരിയബിളിന്റെ മൂല്യം മരവിപ്പിക്കുന്നു, ഒബ്ജക്റ്റുകളെ ഫ്രീസ് ചെയ്യുന്ന Object.freeze() രീതിയുമായി താരതമ്യം ചെയ്യാം.

ഒരു ഫങ്ഷനു പുറത്ത് ഒരു വേരിയബിൾ പ്രഖ്യാപിച്ചാൽ, അതിന്റെ വ്യാപ്തി ആഗോളമാണ്.

അറേകൾ ജാവാസ്ക്രിപ്റ്റിലെ അറേകൾ ഒബ്ജക്റ്റുകൾ ഉപയോഗിച്ചാണ് നടപ്പിലാക്കുന്നത്. തൽഫലമായി, നമ്മൾ അറേകളെക്കുറിച്ച് സംസാരിക്കുമ്പോൾ, യഥാർത്ഥത്തിൽ നമ്മൾ സംസാരിക്കുന്നത് അറേ പോലുള്ള ഒബ്‌ജക്റ്റുകളെക്കുറിച്ചാണ്. നിങ്ങൾക്ക് അവയുടെ സൂചികകൾ ഉപയോഗിച്ച് അറേ ഘടകങ്ങളുമായി പ്രവർത്തിക്കാൻ കഴിയും. സംഖ്യാ സൂചികകൾ സ്ട്രിംഗുകളായി പരിവർത്തനം ചെയ്യുകയും അറേ എലമെന്റ് മൂല്യങ്ങൾ ആക്‌സസ് ചെയ്യുന്നതിന് പേരുകളായി ഉപയോഗിക്കുകയും ചെയ്യുന്നു. ഉദാഹരണത്തിന്, arr പോലെയുള്ള ഒരു നിർമ്മാണം arr ["1"] പോലെയുള്ള ഒരു നിർമ്മാണത്തിന് സമാനമാണ്, കൂടാതെ രണ്ടും ഒരേ മൂല്യത്തിലേക്ക് ആക്സസ് നൽകും: arr === arr["1"] . മുകളിൽ പറഞ്ഞവയെ അടിസ്ഥാനമാക്കി, ലെറ്റ് arr = ["A", "B", "C"] ഉപയോഗിച്ച് പ്രഖ്യാപിച്ച ഒരു ലളിതമായ അറേ ഇതുപോലെയുള്ള ഒരു വസ്തുവായി പ്രതിനിധീകരിക്കുന്നു:

("0": "A", "1": "B", "2": "C")
ഡിലീറ്റ് കമാൻഡ് ഉപയോഗിച്ച് ഒരു അറേയിൽ നിന്ന് ഘടകങ്ങൾ നീക്കംചെയ്യുന്നത് അതിൽ ദ്വാരങ്ങൾ അവശേഷിക്കുന്നു. ഈ പ്രശ്നം ഒഴിവാക്കാൻ, നിങ്ങൾക്ക് splice() കമാൻഡ് ഉപയോഗിക്കാം, പക്ഷേ അത് മന്ദഗതിയിലാണ്, കാരണം, ഒരു ഘടകം നീക്കം ചെയ്ത ശേഷം, അത് അറേയുടെ ശേഷിക്കുന്ന ഘടകങ്ങളെ നീക്കുന്നു, വാസ്തവത്തിൽ, അവയെ അറേയുടെ തുടക്കത്തിലേക്ക്, ഇടത്തേക്ക് മാറ്റുന്നു.

arr = ["A", "B", "C"]; arr ഇല്ലാതാക്കുക; console.log(arr); // ["A", ശൂന്യം, "C"] console.log(arr.length); // 3
അറേ രീതികൾ സ്റ്റാക്കുകളും ക്യൂകളും പോലുള്ള ഡാറ്റാ ഘടനകൾ നടപ്പിലാക്കുന്നത് എളുപ്പമാക്കുന്നു:

// സ്റ്റാക്ക് ലെറ്റ് സ്റ്റാക്ക് = ; stack.push(1); // stack.push(2); // ലാസ്റ്റ് = stack.pop(); // console.log(അവസാനം); // 2 // ക്യൂ ലെറ്റ് ക്യൂ = ; ക്യൂ.പുഷ്(1); // queue.push(2); // ആദ്യം അനുവദിക്കുക = queue.shift();// console.log(first); // 1

ഫംഗ്‌ഷനുകൾ JavaScript-ലെ പ്രവർത്തനങ്ങൾ ഒബ്‌ജക്‌റ്റുകളാണ്. ഫംഗ്ഷനുകൾ വേരിയബിളുകൾക്ക് നൽകാം, ഒബ്‌ജക്റ്റുകളിലോ അറേകളിലോ സംഭരിക്കുകയും മറ്റ് ഫംഗ്ഷനുകളിലേക്ക് ആർഗ്യുമെന്റുകളായി കൈമാറുകയും മറ്റ് ഫംഗ്ഷനുകളിൽ നിന്ന് തിരികെ നൽകുകയും ചെയ്യാം.

പ്രവർത്തനങ്ങൾ പ്രഖ്യാപിക്കാൻ മൂന്ന് വഴികളുണ്ട്:

• ക്ലാസിക് ഫംഗ്ഷൻ ഡിക്ലറേഷൻ (ഫംഗ്ഷൻ ഡിക്ലറേഷൻ അല്ലെങ്കിൽ ഫംഗ്ഷൻ സ്റ്റേറ്റ്മെന്റ്).
• ഫംഗ്ഷൻ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുന്നത്, ഫംഗ്ഷൻ ലിറ്ററൽസ് എന്നും അറിയപ്പെടുന്നു.
• ആരോ ഫംഗ്ഷൻ വാക്യഘടന ഉപയോഗിക്കുന്നു.

▍ക്ലാസിക് ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ ഫംഗ്‌ഷൻ ഡിക്ലറേഷനിലേക്കുള്ള ഈ സമീപനത്തിൽ, ഇനിപ്പറയുന്ന നിയമങ്ങൾ ബാധകമാണ്:

• ഫംഗ്ഷൻ ഡിക്ലറേഷൻ ലൈനിലെ ആദ്യത്തെ കീവേഡ് ഫംഗ്ഷൻ ആണ്.
• പ്രവർത്തനത്തിന് ഒരു പേര് നൽകണം.
• ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ പ്രഖ്യാപിച്ചിരിക്കുന്ന സ്കോപ്പിന്റെ മുകളിലേക്ക് ഉയർത്തുന്നതിനുള്ള സംവിധാനം കാരണം ഒരു ഫംഗ്‌ഷൻ അതിന്റെ പ്രഖ്യാപനത്തിന് മുമ്പ് കോഡിൽ ഉപയോഗിക്കാം.

ഒരു ക്ലാസിക് ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ ഇങ്ങനെയാണ്:

ഫംഗ്‌ഷൻ doSomething()()

▍ഫംഗ്ഷൻ എക്സ്പ്രഷനുകൾ ഫംഗ്ഷൻ എക്സ്പ്രഷനുകൾ ഉപയോഗിക്കുമ്പോൾ, ഇനിപ്പറയുന്നവ പരിഗണിക്കുക:

• ഫംഗ്‌ഷൻ കീവേഡ് ഇനി ഫംഗ്‌ഷൻ ഡിക്ലറേഷൻ ലൈനിലെ ആദ്യത്തെ പദമല്ല.
• ഒരു ഫംഗ്‌ഷൻ പേര് ഓപ്‌ഷണലാണ്. അജ്ഞാതവും പേരിട്ടതുമായ ഫംഗ്‌ഷൻ എക്‌സ്‌പ്രഷനുകൾ ഉപയോഗിക്കാൻ കഴിയും.
• അത്തരം ഫംഗ്‌ഷനുകൾ വിളിക്കുന്നതിനുള്ള കമാൻഡുകൾ അവ പ്രഖ്യാപിക്കുന്നതിനുള്ള കമാൻഡുകൾ പാലിക്കണം.
• ഐഐഎഫ്ഇ (ഉടൻ ഇൻവോക്ക്ഡ് ഫംഗ്ഷൻ എക്സ്പ്രഷൻ) വാക്യഘടന ഉപയോഗിച്ച്, പ്രഖ്യാപനത്തിന് തൊട്ടുപിന്നാലെ അത്തരമൊരു ഫംഗ്ഷൻ സമാരംഭിക്കാൻ കഴിയും.

ഫംഗ്ഷൻ എക്സ്പ്രഷൻ ഇതുപോലെ കാണപ്പെടുന്നു:

എന്തെങ്കിലും ചെയ്യട്ടെ = ഫംഗ്‌ഷൻ()()

▍ആരോ ഫംഗ്‌ഷനുകൾ അജ്ഞാത ഫംഗ്‌ഷൻ എക്‌സ്‌പ്രഷനുകൾ സൃഷ്‌ടിക്കുന്നതിന് ആരോ ഫംഗ്‌ഷനുകളെ “സിന്റക്‌റ്റിക് ഷുഗർ” ആയി കണക്കാക്കാം. അത്തരം ഫംഗ്‌ഷനുകൾക്ക് അവരുടേതായ ഈ, ആർഗ്യുമെന്റ് എന്റിറ്റികൾ ഇല്ല എന്നത് ശ്രദ്ധിക്കേണ്ടതാണ്. ഒരു അമ്പ് ഫംഗ്‌ഷന്റെ പ്രഖ്യാപനം ഇതുപോലെ കാണപ്പെടുന്നു:

എന്തെങ്കിലും ചെയ്യട്ടെ = () = > ();

▍ഫംഗ്ഷനുകളെ വിളിക്കാനുള്ള വഴികൾ ഫംഗ്‌ഷനുകളെ വിവിധ രീതികളിൽ വിളിക്കാം, സാധാരണ ഫംഗ്‌ഷൻ വിളിക്കുക doSomething(വാദങ്ങൾ) ഒബ്‌ജക്റ്റിന്റെ ഒരു രീതിയായി ഒരു ഫംഗ്‌ഷനെ വിളിക്കുന്നു. പുതിയ doSomething(വാദങ്ങൾ) apply() രീതി ഉപയോഗിച്ച് ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നു doSomething.apply(theObject, ) doSomething.call(TheObject, arguments) bind() രീതി ഉപയോഗിച്ച് ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നു doSomethingWithObject = doSomething.bind(theObject); doSomethingWithObject();
ഫംഗ്‌ഷനുകൾ പ്രഖ്യാപിച്ചപ്പോൾ വ്യക്തമാക്കിയ പാരാമീറ്ററുകളുടെ എണ്ണത്തേക്കാൾ കൂടുതലോ കുറവോ ആർഗ്യുമെന്റുകൾ ഉപയോഗിച്ച് വിളിക്കാം. ഫംഗ്‌ഷൻ ഓപ്പറേഷൻ സമയത്ത്, “അധിക” ആർഗ്യുമെന്റുകൾ അവഗണിക്കപ്പെടും (ഫംഗ്‌ഷന് അവയിലേക്ക് ആക്‌സസ് ഉണ്ടായിരിക്കുമെങ്കിലും), നഷ്‌ടമായ പാരാമീറ്ററുകൾക്ക് നിർവചിക്കാത്ത മൂല്യം ലഭിക്കും .

ഫംഗ്‌ഷനുകൾക്ക് രണ്ട് കപട-പാരാമീറ്ററുകളുണ്ട്: ഇതും ആർഗ്യുമെന്റുകളും.

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

• ഒരു സാധാരണ ഫംഗ്‌ഷൻ കോൾ വിൻഡോ / നിർവചിക്കാത്തതാണ്.
• ഒരു ഒബ്ജക്റ്റിന്റെ രീതിയായി ഒരു ഫംഗ്ഷനെ വിളിക്കുന്നു - ഒബ്ജക്റ്റ്.
• ഒരു ഫംഗ്‌ഷനെ കൺസ്‌ട്രക്‌ടറായി വിളിക്കുന്നത് ഒരു പുതിയ ഒബ്‌ജക്‌റ്റാണ്.
• apply() രീതി ഉപയോഗിച്ച് ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നു - theObject .
• bind() രീതി ഉപയോഗിച്ച് ഒരു ഫംഗ്ഷൻ വിളിക്കുന്നു - theObject .

▍ആർഗ്യുമെന്റ് കീവേഡ് ഫംഗ്‌ഷൻ കോളിൽ ഉപയോഗിക്കുന്ന എല്ലാ ആർഗ്യുമെന്റുകളിലേക്കും ആക്‌സസ് നൽകുന്ന ഒരു വ്യാജ പാരാമീറ്ററാണ് ആർഗ്യുമെന്റ് കീവേഡ്. ഇത് ഒരു അറേ പോലെ തോന്നുന്നു, പക്ഷേ ഇത് ഒരു അറേ അല്ല. പ്രത്യേകിച്ചും, ഇതിന് അറേ രീതികളൊന്നുമില്ല.

ഫംഗ്‌ഷൻ കുറയ്ക്കൽToSum(മൊത്തം, മൂല്യം)( മൊത്തം + മൂല്യം; ) ഫംഗ്‌ഷൻ തുക())( args = Array.prototype.slice.call(arguments); റിട്ടേൺ args.reduce(reduceToSum, 0); ) തുക(1,2) , 3);
ആർഗ്യുമെന്റ് കീവേഡിനുള്ള ഒരു ബദൽ ശേഷിക്കുന്ന പാരാമീറ്ററുകൾക്കുള്ള ഒരു പുതിയ വാക്യഘടനയാണ്. ഇനിപ്പറയുന്ന ഉദാഹരണത്തിൽ, ഫംഗ്‌ഷൻ വിളിക്കുമ്പോൾ അതിലേക്ക് അയച്ചതെല്ലാം അടങ്ങുന്ന ഒരു അറേയാണ് args.

ഫംഗ്ഷൻ തുക(...args)( റിട്ടേൺ args.reduce(reduceToSum, 0); )

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

ഫംഗ്ഷൻ getObject() ( return ( ) ) getObject()
ഈ പ്രശ്നം ഒഴിവാക്കാൻ, റിട്ടേൺ സ്റ്റേറ്റ്‌മെന്റിന്റെ അതേ വരിയിൽ ഓപ്പണിംഗ് ചുരുണ്ട ബ്രേസ് സ്ഥാപിക്കുക:

ഫംഗ്‌ഷൻ getObject() ( മടങ്ങുക ( ) )

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

ഫംഗ്ഷൻ ലോഗ്(മൂല്യം)( console.log(value); ) ലോഗ്(1); ലോഗ് ("ടെക്സ്റ്റ്"); ലോഗ് ((സന്ദേശം: "ടെക്സ്റ്റ്"));
ഒരു വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന ഡാറ്റയുടെ തരം കണ്ടെത്താൻ, നിങ്ങൾക്ക് ടൈപ്പ്() ഓപ്പറേറ്റർ ഉപയോഗിക്കാം:

n = 1 ആകട്ടെ; typeof(n); //നമ്പർ ലെറ്റ് s = "ടെക്സ്റ്റ്"; തരം(കൾ); //സ്ട്രിംഗ് ലെറ്റ് fn = ഫംഗ്ഷൻ() (); തരം (എഫ്എൻ); //പ്രവർത്തനം

സിംഗിൾ-ത്രെഡ് എക്സിക്യൂഷൻ മോഡൽ JavaScript റൺടൈം ഒറ്റ-ത്രെഡാണ്. ഇത്, പ്രത്യേകിച്ച്, രണ്ട് ഫംഗ്ഷനുകൾ ഒരേസമയം നടപ്പിലാക്കുന്നതിനുള്ള അസാധ്യതയിൽ പ്രകടിപ്പിക്കുന്നു (അസിൻക്രണസ് കോഡ് എക്സിക്യൂഷന്റെ സാധ്യത നിങ്ങൾ കണക്കിലെടുക്കുന്നില്ലെങ്കിൽ, ഞങ്ങൾ ഇവിടെ സ്പർശിക്കുന്നില്ല). റൺടൈം പരിതസ്ഥിതിയിൽ ഇവന്റ് ക്യൂ എന്ന് വിളിക്കപ്പെടുന്ന ഒന്ന് ഉണ്ട്, അത് പ്രോസസ്സ് ചെയ്യേണ്ട ജോലികളുടെ ഒരു ലിസ്റ്റ് സംഭരിക്കുന്നു. തൽഫലമായി, സിംഗിൾ-ത്രെഡുള്ള JS എക്‌സിക്യൂഷൻ സ്കീമിന് റിസോഴ്‌സ് ഡെഡ്‌ലോക്കുകളുടെ പ്രശ്‌നമില്ല, അതിനാൽ ഒരു ലോക്കിംഗ് മെക്കാനിസത്തിന്റെ ആവശ്യമില്ല. എന്നിരുന്നാലും, ഇവന്റ് ക്യൂവിൽ പ്രവേശിക്കുന്ന കോഡ് വേഗത്തിൽ എക്സിക്യൂട്ട് ചെയ്യണം. ഭാരിച്ച ജോലിയുള്ള ബ്രൗസർ ആപ്ലിക്കേഷനിൽ നിങ്ങൾ പ്രധാന ത്രെഡ് ഓവർലോഡ് ചെയ്യുകയാണെങ്കിൽ, ആപ്ലിക്കേഷൻ പേജ് ഉപയോക്തൃ ഇൻപുട്ടിനോട് പ്രതികരിക്കില്ല, കൂടാതെ ഈ പേജ് അടയ്‌ക്കാൻ ബ്രൗസർ നിങ്ങളോട് ആവശ്യപ്പെടും. ഒഴിവാക്കലുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു സംവിധാനമുണ്ട് JavaScript കൈകാര്യം ചെയ്യുന്നത്. അത്തരം മെക്കാനിസങ്ങൾക്ക് തികച്ചും സാധാരണമായ ഒരു തത്ത്വമനുസരിച്ചാണ് ഇത് പ്രവർത്തിക്കുന്നത്: ഒരു പിശകിന് കാരണമായേക്കാവുന്ന കോഡ്, try/catch കൺസ്ട്രക്റ്റ് ഉപയോഗിച്ച് എഴുതുന്നു. കോഡ് തന്നെ ട്രൈ ബ്ലോക്കിലാണ്, പിശകുകൾ ക്യാച്ച് ബ്ലോക്കിൽ കൈകാര്യം ചെയ്യുന്നു.

ചിലപ്പോൾ ജാവാസ്ക്രിപ്റ്റ്, അടിയന്തിര സാഹചര്യങ്ങൾ ഉണ്ടാകുമ്പോൾ, പിശക് സന്ദേശങ്ങൾ സൃഷ്ടിക്കുന്നില്ല എന്നത് ശ്രദ്ധേയമാണ്. ECMAScript 3 സ്റ്റാൻഡേർഡ് സ്വീകരിക്കുന്നതുവരെ JS പിശകുകൾ വരുത്തിയില്ല എന്നതാണ് ഇതിന് കാരണം.

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

obj = Object.freeze(); obj.message = "ടെക്സ്റ്റ്";
ചില "നിശബ്ദമായ" JS പിശകുകൾ കർശനമായ മോഡിൽ ദൃശ്യമാകുന്നു, "ഉപയോഗിക്കുന്ന കർശനമായ" നിർമ്മാണം ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഇത് പ്രവർത്തനക്ഷമമാക്കാം; .

പ്രോട്ടോടൈപ്പ് സിസ്റ്റം കൺസ്ട്രക്റ്റർ ഫംഗ്ഷനുകൾ, Object.create() കമാൻഡ്, ക്ലാസ് കീവേഡ് തുടങ്ങിയ JS മെക്കാനിസങ്ങൾക്ക് പ്രോട്ടോടൈപ്പ് സിസ്റ്റം അടിവരയിടുന്നു.
ഇനിപ്പറയുന്ന ഉദാഹരണം പരിഗണിക്കുക:

സേവനം അനുവദിക്കട്ടെ = ( doSomething: function() () ) specializedService = Object.create(service); console.log(specializedService.__proto__ === സേവനം); //സത്യം
ഇവിടെ, Object.create() കമാൻഡ് ഒരു സ്പെഷ്യലൈസ്ഡ് സർവീസ് ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ ഉപയോഗിച്ചു, അതിന്റെ പ്രോട്ടോടൈപ്പ് ഒരു സർവീസ് ഒബ്ജക്റ്റ് ആയിരിക്കണം. തൽഫലമായി, ഒരു പ്രത്യേക സേവന ഒബ്‌ജക്‌റ്റ് ആക്‌സസ് ചെയ്‌ത് doSomething() രീതി വിളിക്കാൻ കഴിയുമെന്ന് ഇത് മാറുന്നു. കൂടാതെ, സ്പെഷ്യലൈസ്ഡ് സർവീസ് ഒബ്‌ജക്റ്റിന്റെ __പ്രോട്ടോ__ പ്രോപ്പർട്ടി സർവീസ് ഒബ്‌ജക്റ്റിലേക്ക് പോയിന്റ് ചെയ്യുന്നു എന്നാണ് ഇതിനർത്ഥം.

ക്ലാസ് കീവേഡ് ഉപയോഗിച്ച് സമാനമായ ഒരു ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കാം:

ക്ലാസ് സേവനം ( doSomething() ) ക്ലാസ് സ്പെഷ്യലൈസ്ഡ് സർവീസ് വിപുലീകരിക്കുന്നു സേവനം ( ) സ്പെഷ്യലൈസ്ഡ് സർവീസ് = പുതിയ സ്പെഷ്യലൈസ്ഡ് സർവീസ്(); console.log(specializedService.__proto__ === SpecializedService.prototype);
സർവീസ് ക്ലാസിൽ പ്രഖ്യാപിച്ച രീതികൾ Service.prototype ഒബ്‌ജക്റ്റിലേക്ക് ചേർക്കും. സർവീസ് ക്ലാസിന്റെ ഉദാഹരണങ്ങൾക്ക് ഒരേ പ്രോട്ടോടൈപ്പ് ഉണ്ടായിരിക്കും (Service.prototype). എല്ലാ സംഭവങ്ങളും Service.prototype ഒബ്‌ജക്‌റ്റിലേക്ക് മെത്തേഡ് കോളുകൾ നിയോഗിക്കും. തൽഫലമായി, Service.prototype-ൽ ഒരിക്കൽ മാത്രമേ രീതികൾ പ്രഖ്യാപിച്ചിട്ടുള്ളൂ, അതിനുശേഷം അവ ക്ലാസിലെ എല്ലാ സന്ദർഭങ്ങളിലും "പൈതൃകമായി" ലഭിക്കുന്നു.

▍പ്രോട്ടോടൈപ്പ് ചെയിൻ ഒബ്ജക്റ്റുകൾക്ക് മറ്റ് വസ്തുക്കളുടെ "അവകാശികൾ" ആകാം. ഓരോ വസ്തുവിനും ഒരു പ്രോട്ടോടൈപ്പ് ഉണ്ട്, അതിന്റെ രീതികൾ അതിന് ലഭ്യമാണ്. ഒബ്‌ജക്‌റ്റിൽ തന്നെ ഇല്ലാത്ത ഒരു പ്രോപ്പർട്ടി ആക്‌സസ് ചെയ്യാൻ നിങ്ങൾ ശ്രമിക്കുകയാണെങ്കിൽ, പ്രോട്ടോടൈപ്പ് ശൃംഖലയിൽ JavaScript അത് തിരയാൻ തുടങ്ങും. പ്രോപ്പർട്ടി കണ്ടെത്തുന്നത് വരെ അല്ലെങ്കിൽ തിരയൽ ശൃംഖലയുടെ അവസാനം വരെ ഈ പ്രക്രിയ തുടരും. JavaScript-ലെ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗിനെക്കുറിച്ച് JavaScript-ൽ, ഫംഗ്ഷനുകൾ ഫസ്റ്റ്-ക്ലാസ് ഒബ്ജക്റ്റുകളാണ്, ഭാഷ ഒരു ക്ലോഷർ മെക്കാനിസത്തെ പിന്തുണയ്ക്കുന്നു. ഇത് JS-ൽ ഫങ്ഷണൽ പ്രോഗ്രാമിംഗ് ടെക്നിക്കുകൾ നടപ്പിലാക്കുന്നതിനുള്ള വഴി തുറക്കുന്നു. പ്രത്യേകിച്ച്, ഉയർന്ന ഓർഡർ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിനുള്ള സാധ്യതയെക്കുറിച്ചാണ് നമ്മൾ സംസാരിക്കുന്നത്.

പാരന്റ് ഫംഗ്‌ഷൻ എക്‌സിക്യൂട്ട് ചെയ്‌തതിനു ശേഷവും, പാരന്റ് ഫംഗ്‌ഷനിൽ പ്രഖ്യാപിച്ചിരിക്കുന്ന വേരിയബിളുകളിലേക്ക് ആക്‌സസ് ഉള്ള ഒരു ആന്തരിക ഫംഗ്‌ഷനാണ് ക്ലോഷർ.

മറ്റ് ഫംഗ്‌ഷനുകൾ ആർഗ്യുമെന്റുകളായി എടുക്കുന്നതിനോ ഫംഗ്‌ഷനുകൾ തിരികെ നൽകുന്നതിനോ അല്ലെങ്കിൽ രണ്ടും ചെയ്യുന്നതിനോ കഴിവുള്ള ഒരു ഫംഗ്‌ഷനാണ് ഉയർന്ന ഓർഡർ ഫംഗ്‌ഷൻ.

JS-ലെ ഫംഗ്ഷണൽ പ്രോഗ്രാമിംഗ് പല പ്രസിദ്ധീകരണങ്ങളിലും ഉൾപ്പെടുത്തിയിട്ടുണ്ട്. നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, ഈ വിഷയത്തെക്കുറിച്ചുള്ള ചില മെറ്റീരിയലുകൾ ഇവിടെയുണ്ട്

ഞങ്ങളുടെ വെബ് പേജ് ആക്‌സസ് ചെയ്‌ത ക്ലയന്റ് ഭാഗത്ത് ചില പ്രവർത്തനങ്ങൾ നടത്തേണ്ടിവരുമ്പോൾ JavaScript പ്രവർത്തിക്കുന്നു.

സെർവറുമായി ബന്ധപ്പെടാതെ തന്നെ ഒരു വെബ് പേജ് പരിഷ്കരിക്കാനും ഉപയോക്തൃ ഇൻപുട്ടിന്റെ മൂല്യങ്ങൾ സാധൂകരിക്കാനും മറ്റേതെങ്കിലും പ്രവർത്തനങ്ങൾ നടത്താനും JavaScript-ന് കഴിയും.

നിങ്ങൾ JavaScript ഉപയോഗിക്കുന്നത് ആരംഭിക്കുന്നതിന് ഈ ലേഖനം ചില അടിസ്ഥാന വിവരങ്ങൾ നൽകുന്നു.

പേജ് കോഡിലേക്ക് നേരിട്ട് ഒരു സ്ക്രിപ്റ്റ് ചേർക്കുന്നു

നിങ്ങൾക്ക് പേജിനുള്ളിൽ നേരിട്ട് JS കോഡ് ചേർക്കാം.

മുന്നറിയിപ്പ് ("ഹായ്!"); //ചില JS കോഡ് ഇവിടെയുണ്ട്

ഒരു പ്രത്യേക ഫയലിലേക്ക് കോഡ് നീക്കുന്നു

നിങ്ങൾക്ക് JavaScript കോഡ് ഒരു ബാഹ്യ ഫയലിൽ ഇടുകയും പേജിൽ അതിലേക്കുള്ള ഒരു ലിങ്ക് ഉപയോഗിക്കുകയും ചെയ്യാം

ഈ സാഹചര്യത്തിൽ ക്ലോസിംഗ് ടാഗ് ആവശ്യമാണ്.

ക്ലോസിംഗ് ടാഗിന് മുമ്പ് സ്ക്രിപ്റ്റുകൾ തിരുകുന്നതാണ് നല്ലത്

വേരിയബിളുകൾ വേരിയബിൾ പേരുകൾ

വേരിയബിൾ പേരുകൾ ഒരു വലിയ അക്ഷരം, ഒരു ചെറിയ അക്ഷരം, ഒരു അടിവര, അല്ലെങ്കിൽ $ ചിഹ്നം എന്നിവയിൽ തുടങ്ങാം.

പേരിൽ അക്കങ്ങൾ അടങ്ങിയിരിക്കാം, എന്നാൽ വേരിയബിൾ നാമം ഒരു സംഖ്യയിൽ ആരംഭിക്കാൻ കഴിയില്ല.

JavaScript കേസ് സെൻസിറ്റീവ് ആണ്: mytext, myText എന്നിവ രണ്ട് വ്യത്യസ്ത വേരിയബിളുകളാണ്.

പേരിടാൻ CamelCase ഉപയോഗിക്കുന്നതാണ് നല്ലത്, വേരിയബിൾ നാമത്തിലെ ഓരോ വാക്കും ഒരു വലിയ അക്ഷരത്തിൽ ആരംഭിക്കുന്നു.

വേരിയബിളുകൾ പ്രഖ്യാപിക്കുന്നു

വേരിയബിളുകൾ പ്രഖ്യാപിക്കാൻ Javascript var ഉപയോഗിക്കുന്നു.

Var myText; //undefined myText = "ഹായ്!"; മുന്നറിയിപ്പ് (myText);

ഒരു വേരിയബിൾ പ്രഖ്യാപിച്ചതിന് ശേഷം, അതിന്റെ മൂല്യം നിർവചിക്കപ്പെട്ടിട്ടില്ല.

ഒരു വേരിയബിളിനെ പ്രഖ്യാപിക്കുമ്പോൾ നിങ്ങൾക്ക് ഒരു മൂല്യം നൽകാം:

Var myText = "ഹായ്!";

ഒരു var-ൽ ഒന്നിലധികം വേരിയബിളുകൾ പ്രഖ്യാപിക്കുന്നതും സാധ്യമാണ്:

വർ സം = 4 + 5, myText = "ഹായ്!";

ഒരു മൂല്യം നൽകുമ്പോൾ, var ഒഴിവാക്കാവുന്നതാണ്, എന്നാൽ അങ്ങനെ ചെയ്യാതിരിക്കുന്നതാണ് നല്ലത്.

വേരിയബിൾ തരങ്ങൾ

JavaScript-ൽ നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന സ്ട്രിംഗുകൾ ഉപയോഗിക്കാം:

Var myText = "ഹലോ!";

മുഴുവൻ സംഖ്യകൾ:

Var myNumber = 10;

ഭിന്നസംഖ്യകൾ:

var pi = 3.14;

ബൂളിയൻ മൂല്യങ്ങൾ:

Var isBoolean = false;

JavaScript സിന്റാക്സ് വിശദാംശങ്ങൾ അഭിപ്രായങ്ങൾ

ഒരേ വരിയിലെ അഭിപ്രായങ്ങൾ "//" ഉപയോഗിച്ച് ഹൈലൈറ്റ് ചെയ്തിരിക്കുന്നു. ഈ കഥാപാത്രങ്ങൾക്ക് ശേഷമുള്ള എന്തും ഒരു കമന്റായി കണക്കാക്കും.

ഒന്നിലധികം വരികൾ കമന്റ് ചെയ്യാൻ, കമന്റിന്റെ തുടക്കം സൂചിപ്പിക്കാൻ "/*" ഉം കമന്റിന്റെ അവസാനം സൂചിപ്പിക്കാൻ "*/" ഉം ഉപയോഗിക്കുക.

/* ഇവിടെ കമന്റ് ചെയ്ത കോഡ് ഉണ്ട്, അത് കമന്റും ആണ് */

ഓപ്പറേറ്റർ വേർപിരിയൽ

ഓപ്പറേറ്റർമാരെ വേർതിരിക്കാൻ നിങ്ങൾ ";" ഉപയോഗിക്കേണ്ടതുണ്ട്

ടെക്‌സ്‌റ്റിന്റെ വായനാക്ഷമത മെച്ചപ്പെടുത്തുന്നതിന് വൈറ്റ്‌സ്‌പെയ്‌സ് ഉപയോഗിക്കുന്നത് ഉചിതമാണ്, പക്ഷേ ആവശ്യമില്ല.

സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു var str = 4 + 5 + "7"

str-ൽ "97" എന്ന സ്ട്രിംഗ് മൂല്യം നൽകും

Var str2 = "7" + 4 + 5

str2-ൽ "745" എന്ന സ്ട്രിംഗ് മൂല്യം നൽകും

കൂട്ടിച്ചേർക്കലിന്റെ മൂല്യം തുടർച്ചയായി കണക്കാക്കുന്നു എന്നതാണ് വസ്തുത - ഇടത്തുനിന്ന് വലത്തോട്ട്. 2 അക്കങ്ങൾ ചേർക്കുമ്പോൾ, ഫലം ഒരു സംഖ്യയാണ്. ഒരു സ്ട്രിംഗും ഒരു സംഖ്യയും ചേർക്കുമ്പോൾ, സംഖ്യയെ ഒരു സ്ട്രിംഗായി മനസ്സിലാക്കുകയും രണ്ട് സ്ട്രിംഗുകളും കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു.

ഒരു സ്ട്രിംഗ് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു

ഒരു സ്ട്രിംഗിനെ ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാൻ, parseInt(), parseFloat() എന്നിവ ഉപയോഗിക്കുക

ഈ പ്രവർത്തനങ്ങൾക്ക് രണ്ട് ആർഗ്യുമെന്റുകൾ ലഭിക്കും. ആദ്യത്തേത് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യപ്പെടുന്ന സ്ട്രിംഗ് ആണ്, രണ്ടാമത്തേത് വിവർത്തനത്തിനായി ഉപയോഗിക്കുന്ന നമ്പർ സിസ്റ്റം ബേസ് ആണ്. ഒരു സ്ട്രിംഗിനെ ഒരു ദശാംശ സംഖ്യയായി കണക്കാക്കാൻ, നിങ്ങൾ രണ്ടാമത്തെ ആർഗ്യുമെന്റായി 10 ഉപയോഗിക്കേണ്ടതുണ്ട്

Var myNumber = parseInt("345", 10);

JavaScript പ്രവർത്തനങ്ങൾ

JavaScript-ലെ ഫംഗ്‌ഷനുകൾ ഇതുപോലെ പ്രഖ്യാപിക്കുന്നു:

ഫംഗ്ഷൻ myFunction() (ചില JS കോഡ്)

ഒരു മൂല്യം തിരികെ നൽകാൻ നിങ്ങൾ റിട്ടേൺ ഉപയോഗിക്കേണ്ടതുണ്ട്:

ഫംഗ്‌ഷൻ myMultiplication(paramOne, paramTwo) ( തിരികെ paramOne * paramTwo )

ഫംഗ്‌ഷന്റെ പേര് ഒഴിവാക്കി നിങ്ങൾക്ക് ഒരു "അജ്ഞാത" ഫംഗ്‌ഷൻ പ്രഖ്യാപിക്കാം.

ഒരു ഫംഗ്‌ഷന്റെ പേര് വ്യക്തമാക്കിയുകൊണ്ട് മറ്റൊരു ഫംഗ്‌ഷനിലേക്ക് ഒരു പാരാമീറ്ററായി കൈമാറാൻ കഴിയും.

വസ്തുക്കൾ

ജാവാസ്ക്രിപ്റ്റിലെ എല്ലാം ഒബ്ജക്റ്റിന്റെ പിൻഗാമികളാണ്.

ഒരു പുതിയ ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുന്നു var വ്യക്തി = പുതിയ ഒബ്‌ജക്റ്റ്(); // ഒരു വ്യക്തി ഒബ്ജക്റ്റ് വ്യക്തിയെ സൃഷ്ടിക്കുന്നു.firstname = "ആൻഡ്രൂ"; //ആദ്യത്തെ ആട്രിബ്യൂട്ട് ചേർക്കുക person.lastname = "Peterson";// രണ്ടാമത്തെ ആട്രിബ്യൂട്ട് ചേർക്കുക person.getFullName = function() (// രീതി ചേർക്കുക this.firstname + "" + this.lastname; )

രണ്ടാമതായി, ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കുന്നതിനുള്ള ചെറിയ ഓപ്ഷൻ

Var വ്യക്തി = ( // ഒരു വ്യക്തിയുടെ ഒബ്‌ജക്‌റ്റ് ആദ്യനാമം സൃഷ്‌ടിക്കുന്നു: "ആൻഡ്രൂ", അവസാന നാമം: "പീറ്റേഴ്‌സൺ", getFullName: ഫംഗ്‌ഷൻ() ( ഇത്.firstname + "" + this.lastname തിരികെ നൽകുക; ) )

ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നു

var me = പുതിയ ഒബ്ജക്റ്റ്();

ഞാൻ ["പേര്"] = "സെർഗ്";
me.age = 33;

ജാവാസ്ക്രിപ്റ്റിലെ അറേകൾ ഒരു അറേ സൃഷ്ടിക്കുന്നു var arr = new Array(11, "Hello!", true); // ഒരു അറേ സൃഷ്ടിക്കുക

റെക്കോർഡ് ചെയ്യാനുള്ള പുതിയ വഴി

Var arr = ; // ഒരു അറേ സൃഷ്ടിക്കുക

ജാവാസ്ക്രിപ്റ്റിലെ അറേകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നു അറേയിലെ ഘടകങ്ങളുടെ എണ്ണം var length = arr.length; // 3 അറേയിലേക്ക് ഘടകങ്ങൾ ചേർക്കുന്നു - പുഷ് arr.push("ഒരു പുതിയ മൂല്യം"); ഒരു അറേയുടെ അവസാന ഘടകം വീണ്ടെടുക്കുന്നു - pop var lastValue = arr.pop(); അറേകൾ സംയോജിപ്പിക്കുന്നു var arr2 = ; var longArray = arr.concat(arr2); // രണ്ട് അറേകൾ arr ഉം arr2 ഉം ഒരു longArray ആയി സംയോജിപ്പിക്കുന്നു - അറേയുടെ എല്ലാ ഘടകങ്ങളും ലയിപ്പിക്കുന്നു var longString = arr.join(":") // "11:Hello!:true" ജാവാസ്ക്രിപ്റ്റിലെ താരതമ്യവും ലോജിക്കൽ ഫംഗ്ഷനുകളും കൂടുതലോ കുറവോ var isTrue = 6 >= 5; // തുല്യത var isFalse = 1 == 2 എന്നതിനേക്കാൾ വലുതോ തുല്യമോ; // isTrue = 1 != 2; // തുല്യമല്ല var alsoTrue = "6" == 6; ഐഡന്റിറ്റി var notIdentical = "3" === 3 // തെറ്റ് കാരണം ഡാറ്റ തരങ്ങൾ പൊരുത്തപ്പെടുന്നില്ല notIdentical = "3" !== 3 // true കാരണം ഡാറ്റ തരങ്ങൾ IF പ്രസ്താവനയുമായി പൊരുത്തപ്പെടുന്നില്ല എങ്കിൽ (5< 6) { alert("true!"); } else { alert("false!") } Оператор SWITCH var lunch = prompt("What do you want for lunch?","Type your lunch choice here"); switch(lunch){ case "sandwich": console.log("Sure thing! One sandwich, coming up."); break; case "soup": console.log("Got it! Tomato"s my favorite."); break; case "salad": console.log("Sounds good! How about a caesar salad?"); break; case "pie": console.log("Pie"s not a meal!"); break; default: console.log("Huh! I"m not sure what " + lunch + " is. How does a sandwich sound?"); } Логическое AND — && if (1 == 1 && 2 == 2) { alert("true!"); } Логическое OR — || if (1 == 1 || 2 == 3) { alert("true!"); } Логическое NOT — ! if (!(1 == 1)) { alert("false!"); } Циклы FOR for (var i = 0; i < 10; i = i + 1) { alert(i); } var names = [ "Sergey", "Andrey", "Petr" ]; for (var i = 0, len = names.length; i < len; i = i + 1) { alert(names[i]); } WHILE while (true) { // Бесконечный цикл alert("This will never stop!"); } var names = [ "Sergey", "Andrey", "Petr" ]; while (names.length >0) (അലേർട്ട്(പേരുകൾ[i]); ) ചെയ്യുന്പോൾ ചെയ്യുക (അലേർട്ട് ("ഇത് ഒരിക്കലും നിർത്തില്ല!"); ) അതേസമയം (ശരി) (// അനന്തമായ ലൂപ്പ് ലൈനുകൾ ടെക്സ്റ്റ് = "ബ്ലാ ബ്ലാ ബ്ല ബ്ല ബ്ല ബ്ല ബ്ല ബ്ല ബ്ല ബ്ലാ ബ്ലാ എറിക് \ ബ്ലാ ബ്ലാ ബ്ലാ ബ്ലാ എറിക് ബ്ലാ ബ്ലാ

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

"some word".substring(x, y) എവിടെയാണ് x നിങ്ങൾ മുറിക്കാൻ തുടങ്ങുന്നത്, y എന്നത് യഥാർത്ഥ സ്‌ട്രിംഗ് മുറിച്ച് പൂർത്തിയാക്കുന്നിടത്താണ്.

നമ്പർ ഭാഗം അൽപ്പം വിചിത്രമാണ്. "ഹലോ" എന്നതിലെ "അവൻ" തിരഞ്ഞെടുക്കുന്നതിന്, നിങ്ങൾ ഇത് എഴുതണം: "ഹലോ". സബ്സ്ട്രിംഗ് (0, 2);

ഓരോ പ്രതീകത്തിന്റെയും ഇടതുവശത്ത് ഇതുപോലെ ഒരു മാർക്കർ ഉണ്ടെന്ന് ചിന്തിക്കുക: 0-h-1-e-2-l-3-l-4-o-5 .

നിങ്ങൾ 0-ലും വീണ്ടും 2-ലും മുറിച്ചാൽ നിങ്ങൾക്ക് അവശേഷിക്കും.

കൂടുതൽ ഉദാഹരണങ്ങൾ:

1. "ബാറ്റ്മാൻ" എന്നതിന്റെ ആദ്യ 3 അക്ഷരങ്ങൾ
"ബാറ്റ്മാൻ".സബ്‌സ്ട്രിംഗ്(0,3)

2. "ലാപ്‌ടോപ്പിന്റെ" 4 മുതൽ 6 വരെയുള്ള അക്ഷരങ്ങൾ
"ലാപ്‌ടോപ്പ്".സബ്‌സ്ട്രിംഗ്(3,6)

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

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

നിങ്ങൾക്ക് ആദ്യം മുതൽ ജാവാസ്ക്രിപ്റ്റ് പഠിക്കാനാകുമെന്ന് നിങ്ങൾക്ക് ഇപ്പോഴും ഉറപ്പില്ലെങ്കിൽ, വാക്കിലും ഉദാഹരണത്തിലും വിപരീതമായി തെളിയിക്കുന്ന ഒരു ലേഖനം ഞങ്ങൾ നിങ്ങളുടെ ശ്രദ്ധയിൽപ്പെടുത്തുന്നു.

ജാവാസ്ക്രിപ്റ്റ്: ആദ്യം മുതൽ പഠിക്കുന്നു

ആദ്യം, ജാവാസ്ക്രിപ്റ്റ് എന്താണെന്നും അത് എന്തുകൊണ്ട് ആവശ്യമാണെന്നും പറയാം.

പ്രത്യേക സോഫ്‌റ്റ്‌വെയർ ഉപയോഗിച്ച് എക്‌സിക്യൂട്ട് ചെയ്യുന്ന സ്‌ക്രിപ്റ്റുകൾ എഴുതാൻ ഉപയോഗിക്കുന്ന ഒരു പ്രോട്ടോടൈപ്പ് അധിഷ്‌ഠിത സാങ്കേതികവിദ്യയാണ് ജാവാസ്ക്രിപ്റ്റ്.

മനുഷ്യ ഭാഷയിലേക്ക് വിവർത്തനം ചെയ്യുമ്പോൾ, അത് സോഫ്റ്റ്‌വെയർ-സ്ക്രിപ്റ്റ്-എക്‌സിക്യൂഷൻ ശൃംഖലയിലെ ഒരു സഹായക ലിങ്കാണ്.

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

വഴിമധ്യേ! ഞങ്ങളുടെ വായനക്കാർക്ക് ഇപ്പോൾ 10% കിഴിവുണ്ട്

തുടക്കക്കാർക്കുള്ള ജാവാസ്ക്രിപ്റ്റ് അടിസ്ഥാനങ്ങൾ: എവിടെ പഠിക്കണം

ആദ്യം മുതൽ JavaScript എങ്ങനെ പഠിക്കാം? സ്വന്തമായി പ്രോഗ്രാം ചെയ്യാൻ എങ്ങനെ പഠിക്കാം? പല തുടക്കക്കാരായ പ്രോഗ്രാമർമാരും ഈ ചോദ്യങ്ങൾ ചോദിക്കുന്നു. ഭാഗ്യവശാൽ, ഉത്തരം നിലവിലുണ്ട്, അത് വളരെ വിശദമായതാണ്.

ഈ പ്രോഗ്രാമിംഗ് ഭാഷ പഠിക്കുന്നതിന് നിരവധി ഓപ്ഷനുകൾ ഉണ്ട്:

• പ്രത്യേക കോഴ്സുകൾ,
• സ്വതന്ത്ര പഠനം,
• യൂണിവേഴ്സിറ്റിയിൽ പഠിക്കുന്നു.

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

കോഴ്സുകൾ ദീർഘകാലമായിരിക്കണം. ഒരു മാസത്തിനുള്ളിൽ ആർക്കും നിങ്ങളെ ഒന്നും പഠിപ്പിക്കാൻ കഴിയില്ല!

സ്വന്തമായി എങ്ങനെ ജാവാസ്ക്രിപ്റ്റ് പഠിക്കാം: 4 വഴികൾ

നിങ്ങൾക്ക് സ്വന്തമായി ജാവാസ്ക്രിപ്റ്റ് പഠിക്കണമെങ്കിൽ, നിങ്ങൾ അങ്ങേയറ്റം സ്വയം അച്ചടക്കം പാലിക്കുകയും എല്ലാം ശരിയാണെന്ന് ഉറപ്പാക്കാൻ പരമാവധി പരിശ്രമിക്കുകയും വേണം. അവർ പറയുന്നതുപോലെ, ക്ഷമയും ജോലിയും എല്ലാം തകർക്കും.

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

1. ലളിതമായ കാര്യങ്ങൾ പഠിക്കാനും ഓർമ്മിക്കാനും പഠിക്കുക. സ്വയം വികസനത്തിനുള്ള കഴിവ് വികസിപ്പിക്കേണ്ടതുണ്ട്. ഫലപ്രദമായി പഠിക്കാൻ കഴിയുക എന്നത് വളരെ പ്രധാനമാണ്. ഇതിന് സ്വയം അച്ചടക്കവും ശക്തമായ ലക്ഷ്യവും ആവശ്യമാണ്, അതിനാൽ നിങ്ങൾ പഠിക്കാൻ തുടങ്ങുന്നതിനുമുമ്പ്, എങ്ങനെ പഠിക്കണമെന്ന് സ്വയം പഠിപ്പിക്കുക.

2. ജാവാസ്ക്രിപ്റ്റിന്റെ അടിസ്ഥാനകാര്യങ്ങൾ പഠിക്കുക. കോഡ്‌കാഡമി: JavaScript പഠിക്കുക, സ്‌നൂപ്‌കോഡ്: JavaScript ട്യൂട്ടോറിയലുകൾ, MDN-ന്റെ JavaScript ഗൈഡ് - ഈ ഓൺലൈൻ ഉറവിടങ്ങൾ വ്യാകരണം, തരങ്ങൾ, ലൂപ്പുകൾ, പ്രവർത്തനങ്ങൾ, പദപ്രയോഗങ്ങൾ, നമ്പറുകൾ, തീയതികൾ, ഫോർമാറ്റിംഗ് എന്നിവയും അതിലേറെയും ഉൾക്കൊള്ളുന്നു.

3. വിപുലമായ ഭാഷാ സവിശേഷതകൾ പര്യവേക്ഷണം ചെയ്യാൻ ആരംഭിക്കുക. നിങ്ങൾ അടിസ്ഥാനകാര്യങ്ങൾ പഠിച്ച ശേഷം, ലൈബ്രറികളും ചട്ടക്കൂടുകളും മാസ്റ്റേഴ്സ് ചെയ്യാൻ ആരംഭിക്കുക: JQuery, ReactJS, Angular 2, node.js, ഇത് സെർവർ ഭാഗത്തും മറ്റുള്ളവയിലും വികസനം അനുവദിക്കും.

4. നിങ്ങളുടെ സ്വന്തം പ്രോജക്ടുകൾ സൃഷ്ടിക്കുക. സൗജന്യ കോഡ് ക്യാമ്പ് എന്നത് ഡെവലപ്പർമാരുടെ ഒരു കമ്മ്യൂണിറ്റിയാണ്, അവിടെ നിങ്ങൾക്ക് കോഡ് പോസ്റ്റുചെയ്യാനും പ്രോജക്റ്റുകൾ സൃഷ്ടിക്കാനും അതിനായി സർട്ടിഫിക്കറ്റുകൾ സ്വീകരിക്കാനും കഴിയും. മറ്റ് കമ്മ്യൂണിറ്റി അംഗങ്ങളിൽ നിന്ന് ഫീഡ്‌ബാക്ക് സ്വീകരിക്കുക എന്നതാണ് പ്രധാന കാര്യം.

പ്രൊഫഷണൽ വികസനം: പരിശീലനവും കൂടുതൽ പരിശീലനവും

നിങ്ങൾക്ക് ഒരു ടൺ സാഹിത്യം പഠിക്കാൻ കഴിയും, പക്ഷേ നിരന്തരമായ പരിശീലനമില്ലാതെ നിങ്ങൾക്ക് ഒന്നും നേടാനാവില്ല.

ഒരു വ്യക്തിക്ക് എല്ലാം അറിയാമെങ്കിലും ഒന്നും ചെയ്യാൻ കഴിയുന്നില്ലെങ്കിൽ അവനെ അവന്റെ കരകൗശലത്തിന്റെ മാസ്റ്റർ എന്ന് വിളിക്കാനാവില്ല.

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

നിങ്ങളുടെ ദിവസം ആസൂത്രണം ചെയ്യുക, അങ്ങനെ നിങ്ങൾക്ക് എല്ലാ ദിവസവും രണ്ട് മണിക്കൂർ പഠന സമയം ലഭിക്കും. അധികം അധ്വാനിക്കരുത്. ഇടവേളകൾ എടുത്ത് നിങ്ങളുടെ പ്രവർത്തനം മാറ്റുക. ജാവാസ്ക്രിപ്റ്റ് പഠിക്കാൻ മികച്ചത്.

വീഡിയോ പാഠങ്ങൾ കാണുക, രസകരമായ ലേഖനങ്ങൾ വായിക്കുക, സംരക്ഷിക്കുക, സെമിനാറുകളിലും കോൺഫറൻസുകളിലും പങ്കെടുക്കുക, മറ്റ് വിദ്യാർത്ഥികളുമായി ചർച്ച ചെയ്യുകയും നിങ്ങളുടെ അഭിപ്രായങ്ങൾ പങ്കിടുകയും ചെയ്യുക.

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