ഓപ്പറേറ്റർ സീനിയോറിറ്റി

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

ഓപ്പറേറ്റർമാരുടെ സീനിയോറിറ്റി, താഴ്ന്നത് മുതൽ ഉയർന്നത് വരെ, ഇനിപ്പറയുന്നതായിരിക്കും:

അസൈൻമെൻ്റ് =+=-=*=/=%==>>=&=^=|=

വ്യവസ്ഥ പ്രകാരം തിരഞ്ഞെടുക്കണോ? :

ലോജിക്കൽ അല്ലെങ്കിൽ ||

ലോജിക്കൽ കൂടാതെ&&

ബിറ്റ്വൈസ് അല്ലെങ്കിൽ |

ബിറ്റ്വൈസ് എക്സ്ക്ലൂസീവ്^

ബിറ്റ്‌വൈസ് ആൻഡ്&

അസമത്വം!=

സമത്വം/അസമത്വം == !=

താരതമ്യം =

ബിറ്റ് ഷിഫ്റ്റ് >>>

കൂട്ടിച്ചേർക്കൽ/കുറക്കൽ + -

ഗുണിക്കുക/വിഭജിക്കുക * / %

നിഷേധം/പൂരകം/അനറി മൈനസ്/ഇൻക്രിമെൻ്റ്/കുറവ്! ~ - ++ --

വിളിക്കുക, പാരാമീറ്ററുകൾ കൈമാറുക () .

JavaScript-ൽ റിസർവ് ചെയ്‌ത കീവേഡുകൾ.

ജാവാസ്ക്രിപ്റ്റിന് നിരവധി റിസർവ്ഡ് കീവേഡുകൾ ഉണ്ട്. ഈ വാക്കുകൾ മൂന്ന് തരത്തിലാണ്: JavaScript റിസർവ്ഡ് പദങ്ങൾ, ഭാവിയിലേക്കുള്ള റിസർവ്ഡ് വാക്കുകൾ, ഉപയോഗത്തിനായി ഒഴിവാക്കേണ്ട വാക്കുകൾ. JavaScript കീവേഡുകൾ

ഈ ശൂന്യതയിൽ തെറ്റായി തകർക്കുക

പുതിയ യഥാർത്ഥ സമയത്തേക്ക് തുടരുക

ഫംഗ്‌ഷൻ null typeof ഉപയോഗിച്ച് ഇല്ലാതാക്കുക

മറ്റുള്ളവ തിരികെ വരുകയാണെങ്കിൽ

ഭാവിയിലെ ഉപയോഗത്തിനുള്ള JavaScript കീവേഡുകൾ

കേസ് ഡീബഗ്ഗർ കയറ്റുമതി സൂപ്പർ

ക്യാച്ച് ഡിഫോൾട്ട് വിപുലീകരിക്കുന്ന സ്വിച്ച്

ക്ലാസ് അവസാനം എറിയുന്നു

const enum ഇറക്കുമതി ശ്രമിക്കൂ

ഇൻ്റേണൽ JavaScript ഒബ്‌ജക്‌റ്റുകളുടെയോ പ്രവർത്തനങ്ങളുടെയോ പേരുകൾ ഇതിനകം ഉള്ളവയാണ് ഉപയോഗിക്കുന്നത് ഒഴിവാക്കേണ്ട വാക്കുകൾ. ഇതിൽ String അല്ലെങ്കിൽ parseInt പോലുള്ള വാക്കുകൾ ഉൾപ്പെടുന്നു.

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

var ടെക്സ്റ്റ് = പുതിയ സ്ട്രിംഗ് ("ഇതൊരു സ്ട്രിംഗ് ഒബ്ജക്റ്റ് ആണ്");

ഈ സാഹചര്യത്തിൽ, സ്ട്രിംഗ് ഒരു വസ്തുവല്ലെന്ന് പ്രസ്താവിക്കുന്ന ഒരു പിശക് നിങ്ങൾക്ക് ലഭിക്കും. മുമ്പേ നിലവിലുള്ള ഒരു ഐഡൻ്റിഫയറിനായി ഉപയോഗിക്കുന്ന പല കേസുകളും അത്ര വ്യക്തമല്ല.

സ്ക്രിപ്റ്റുകൾ. സാഹചര്യങ്ങൾ സൃഷ്ടിക്കുന്നു.

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

നിലവിൽ എല്ലാ പ്രധാന വെബ് ബ്രൗസറുകളും (ഇൻ്റർനെറ്റ് എക്സ്പ്ലോറർ, ഫയർഫോക്സ്, നെറ്റ്‌സ്‌കേപ്പ്, സഫാരി, ഓപ്പറ, കാമിനോ മുതലായവ) പിന്തുണയ്ക്കുന്ന ഒരേയൊരു സ്‌ക്രിപ്റ്റിംഗ് ഭാഷ ജാവാസ്ക്രിപ്റ്റ് ആയതിനാൽ, ഇത് വളരെ വ്യാപകമായി ഉപയോഗിക്കുന്നു.

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

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

ടെക്സ്റ്റ് എഡിറ്ററിനെ സംബന്ധിച്ചിടത്തോളം, വിൻഡോസിന് നോട്ട്പാഡ് എഡിറ്റർ ഉണ്ട്. JavaScript, HTML, CSS എന്നിവ എഡിറ്റുചെയ്യുന്നതിന് ഇത് മതിയാകുമെങ്കിലും, EditPlus അല്ലെങ്കിൽ മറ്റൊന്ന് പോലെയുള്ള കൂടുതൽ ശക്തമായ എഡിറ്റർ കൂടുതൽ സൗകര്യപ്രദമായിരിക്കും.

ശരി, ഇപ്പോൾ നമുക്ക് JavaScript സ്ക്രിപ്റ്റ് സൃഷ്ടിക്കുന്നതിലേക്ക് പോകാം!

ആദ്യം, ഒരു HTML പേജിലേക്ക് JavaScript എങ്ങനെ ചേർക്കാമെന്ന് നിങ്ങൾ പഠിക്കേണ്ടതുണ്ട്. ഇത് രണ്ട് വഴികളിൽ ഒന്നിൽ ചെയ്യാം: വെബ് പേജിൽ സ്‌ക്രിപ്റ്റ് ടാഗുകൾ സ്ഥാപിച്ച് ആ ടാഗുകൾക്കുള്ളിൽ JavaScript കോഡ് സ്ഥാപിക്കുക, അല്ലെങ്കിൽ എല്ലാ JavaScript കോഡും ഒരു പ്രത്യേക ഫയലിൽ സ്ഥാപിച്ച് ഒരു സ്‌ക്രിപ്റ്റ് ടാഗ് ഉപയോഗിച്ച് ലിങ്ക് ചെയ്യുക.

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

JavaScript കോഡ് ഉൾപ്പെടുത്തുന്നതിനുള്ള രണ്ട് വഴികളുടെ ഉദാഹരണങ്ങൾ ചുവടെയുണ്ട്:

സ്ക്രിപ്റ്റ് പ്രവർത്തനങ്ങൾ.

നിങ്ങളുടെ JavaScript സ്‌ക്രിപ്റ്റിലെ വിവിധ സ്ഥലങ്ങളിൽ നിന്ന് ആവശ്യാനുസരണം ഫംഗ്‌ഷനെ വിളിച്ച് നിങ്ങൾക്ക് സോഴ്‌സ് കോഡിൻ്റെ ഭാഗങ്ങൾ ഒരു ഫംഗ്‌ഷനായി പാക്കേജുചെയ്യാനാകും.

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

ഫംഗ്‌ഷൻ നിർവചനത്തിൻ്റെ പൊതുവായ കാഴ്ച ചുവടെ അവതരിപ്പിച്ചിരിക്കുന്നു:

ഫംഗ്‌ഷൻ നാമം([പാരാമീറ്റർ 1] [,പാരാമീറ്റർ 2] [...,പാരാമീറ്റർ N])

ഫംഗ്ഷൻ ബോഡി ലൈനുകൾ

മൂല്യമനുസരിച്ച് എല്ലാ പാരാമീറ്ററുകളും ഫംഗ്ഷനിലേക്ക് കൈമാറുന്നു. അതിനാൽ, ഫംഗ്ഷനിലേക്ക് പാരാമീറ്ററുകളായി കൈമാറിയ വേരിയബിളുകളുടെ ഉള്ളടക്കം മാറ്റാൻ കഴിയില്ല.

റിട്ടേൺ കീവേഡ് ഉപയോഗിച്ച്, ഒരു ഫംഗ്‌ഷന് ഒരു മൂല്യം തിരികെ നൽകാനാകും.

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

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

ഓപ്പറേറ്റർ മുൻഗണന

ഓപ്പറേറ്റർ മുൻഗണന എന്നത് ഒരു ഓപ്പറേറ്ററുടെ ഒരു പ്രോപ്പർട്ടിയാണ്, അത് അവ മൂല്യനിർണ്ണയം ചെയ്യുന്ന ക്രമം വ്യക്തമായി വ്യക്തമാക്കാതെ നിരവധി വ്യത്യസ്ത ഓപ്പറേറ്റർമാരുമൊത്തുള്ള ഒരു എക്‌സ്‌പ്രഷനിൽ അത് എക്‌സിക്യൂട്ട് ചെയ്യുന്ന ക്രമത്തെ ബാധിക്കുന്നു. കുറഞ്ഞ മുൻഗണനയുള്ള പ്രസ്താവനകൾക്ക് മുമ്പ് ഉയർന്ന മുൻഗണനയുള്ള പ്രസ്താവനകൾ നടപ്പിലാക്കുന്നു.

ഓപ്പറേറ്റർ നിരയിൽ, ഒരു എലിപ്സിസ് ഓപ്പറേറ്ററുമായി ബന്ധപ്പെട്ട ഓപ്പറണ്ടുകളുടെ സ്ഥാനം കാണിക്കുന്നു.

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

X - y - z (x - y) - z

അസൈൻമെൻ്റ് ഓപ്പറേറ്റർക്ക് വലത്തുനിന്നും ഇടത്തേക്കുള്ള അസോസിയേറ്റിവിറ്റി ഉണ്ട്, അതിനാൽ ഇനിപ്പറയുന്ന രണ്ട് പദപ്രയോഗങ്ങൾ തുല്യമാണ്:

W = x = y = z w = (x = (y = z))

കോളം O ഓപ്പറണ്ടുകളുടെ എണ്ണം സൂചിപ്പിക്കുന്നു.

മൂല്യ തരങ്ങൾ കോളത്തിൽ, പ്രതീക്ഷിക്കുന്ന ഓപ്പറാൻറ് തരങ്ങൾ അമ്പടയാളത്തിന് മുമ്പായി സൂചിപ്പിച്ചിരിക്കുന്നു, കൂടാതെ അമ്പടയാളത്തിന് ശേഷം റിട്ടേൺ മൂല്യ തരവും സൂചിപ്പിച്ചിരിക്കുന്നു.

lval (ഇടത് മൂല്യത്തിൻ്റെ ചുരുക്കം) ഒരു ഇടത് കൈ പ്രയോഗമാണ്. ഒരു അസൈൻമെൻ്റ് ഓപ്പറേറ്ററുടെ ഇടതുവശത്ത് ദൃശ്യമാകുന്ന ഒരു പദപ്രയോഗത്തിൻ്റെ ചരിത്രപരമായ പദമാണിത്. ഇടത് കൈ എക്സ്പ്രഷനുകൾ ഇവയാണ്: വേരിയബിളുകൾ, ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടികൾ, അറേ ഘടകങ്ങൾ.

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

ഓപ്പറേറ്റർ ഓപ്പറേറ്റർ തരം A O മൂല്യ തരങ്ങൾ

(…)	ഗ്രൂപ്പിംഗ്	ഇല്ല	1	ഏതെങ്കിലും→ ഏതെങ്കിലും
… . … … […] പുതിയ...()	ആക്സസ് ഓപ്പറേറ്റർ ആക്സസ് ഓപ്പറേറ്റർ പുതിയത് (വാദങ്ങളുടെ ലിസ്റ്റിനൊപ്പം)	ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇല്ല	2 2 1	lval, lval → ഏതെങ്കിലും lval, സ്ട്രിംഗ് അല്ലെങ്കിൽ നമ്പർ → ഏതെങ്കിലും കൺസ്ട്രക്റ്റർ -> ഒബ്ജക്റ്റ്
… () പുതിയ...	ഒരു ഫംഗ്‌ഷൻ വിളിക്കുന്നു പുതിയത് (വാദങ്ങളൊന്നുമില്ല)	ഇടത്തുനിന്ന് വലത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട്	1 1	ഫംഗ്ഷൻ → ഏതെങ്കിലും കൺസ്ട്രക്റ്റർ -> ഒബ്ജക്റ്റ്
… ++ … --	പോസ്റ്റ്ഫിക്സ് ഇൻക്രിമെൻ്റ് പോസ്റ്റ്ഫിക്സ് ഡിക്രിമെൻ്റ്	ഇല്ല ഇല്ല	1 1	lval → നമ്പർ lval → നമ്പർ
! … ~ … + … - … ++ … -- … ഇല്ലാതാക്കുക... തരം... ശൂന്യമായ...	ലോജിക്കൽ അല്ല (വിപരീതം) ബിറ്റ്‌വൈസ് അല്ല (വിപരീതം) യൂണറി പ്ലസ് യുണറി മൈനസ് പ്രിഫിക്സ് ഇൻക്രിമെൻ്റ് പ്രിഫിക്സ് ഡിക്രിമെൻ്റ് നീക്കം ഡാറ്റ തരം നിർവചിക്കുന്നു നിർവചിക്കാത്ത മൂല്യം നൽകുന്നു	വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട്	1 1 1 1 1 1 1 1 1	ഏതെങ്കിലും → ബൂളിയൻ മുഴുവൻ → മുഴുവൻ നമ്പർ → നമ്പർ നമ്പർ → നമ്പർ lval → നമ്പർ lval → നമ്പർ lval → ബൂളിയൻ ഏതെങ്കിലും → സ്ട്രിംഗ് ഏതെങ്കിലും → നിർവചിച്ചിട്ടില്ല
… ** … … * … … / … … % …	എക്സ്പോണൻഷ്യേഷൻ ഗുണനം ഡിവിഷൻ ബാക്കിയുള്ള വിഭജനം	വലത്തുനിന്ന് ഇടത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട്	2 2 2 2	നമ്പർ, നമ്പർ → നമ്പർ നമ്പർ, നമ്പർ → നമ്പർ നമ്പർ, നമ്പർ → നമ്പർ നമ്പർ, നമ്പർ → നമ്പർ
… + … … - … … + …	കൂട്ടിച്ചേർക്കൽ കുറയ്ക്കൽ സംയോജനം	ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട്	2 2 2	നമ്പർ, നമ്പർ → നമ്പർ നമ്പർ, നമ്പർ → നമ്പർ സ്ട്രിംഗ്, സ്ട്രിംഗ് → സ്ട്രിംഗ്
… > … … >>> …	ഷിഫ്റ്റ് ബിറ്റുകൾ അവശേഷിക്കുന്നു അടയാളം സംരക്ഷിക്കുമ്പോൾ ബിറ്റുകൾ വലത്തേക്ക് മാറ്റുക സീറോ പാഡിംഗ് ഉപയോഗിച്ച് ബിറ്റുകൾ വലത്തേക്ക് മാറ്റുക	ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട്	2 2 2	മുഴുവനും, മുഴുവനും → മുഴുവനും മുഴുവനും, മുഴുവനും → മുഴുവനും മുഴുവനും, മുഴുവനും → മുഴുവനും
… < … … … … >= … ... ൽ ... ... ഉദാഹരണം ...	അതിൽ കുറവ് കുറവോ തുല്യമോ അതിലും കൂടുതൽ കൂടുതലോ തുല്യമോ ഒരു വസ്തുവിൻ്റെ സാന്നിധ്യം പരിശോധിക്കുന്നു ഈ തരത്തിൽ പെട്ടതാണോയെന്ന് പരിശോധിക്കുന്നു	ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട്	2 2 2 2 2 2	നമ്പർ, നമ്പർ → ബൂളിയൻ നമ്പർ, നമ്പർ → ബൂളിയൻ നമ്പർ, നമ്പർ → ബൂളിയൻ നമ്പർ, നമ്പർ → ബൂളിയൻ സ്ട്രിംഗ്, ഒബ്ജക്റ്റ് → ബൂളിയൻ ഒബ്ജക്റ്റ്, കൺസ്ട്രക്റ്റർ → ബൂളിയൻ
… == … … != … … === … … !== …	തുല്യമാണ് തുല്യമല്ല കർശനമായി തുല്യമാണ് കർശനമായി തുല്യമല്ല	ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട് ഇടത്തുനിന്ന് വലത്തോട്ട്	2 2 2 2	ഏതെങ്കിലും, ഏതെങ്കിലും → ബൂളിയൻ ഏതെങ്കിലും, ഏതെങ്കിലും → ബൂളിയൻ ഏതെങ്കിലും, ഏതെങ്കിലും → ബൂളിയൻ ഏതെങ്കിലും, ഏതെങ്കിലും → ബൂളിയൻ
… & …	ബിറ്റ്വൈസ് AND	ഇടത്തുനിന്ന് വലത്തോട്ട്	2	മുഴുവനും, മുഴുവനും → മുഴുവനും
… ^ …	ബിറ്റ്‌വൈസ് എക്സ്ക്ലൂസീവ് അല്ലെങ്കിൽ	ഇടത്തുനിന്ന് വലത്തോട്ട്	2	മുഴുവനും, മുഴുവനും → മുഴുവനും
… | …	അസൈൻമെൻ്റ് പ്രവർത്തനം അസൈൻമെൻ്റ് പ്രവർത്തനം അസൈൻമെൻ്റ് പ്രവർത്തനം	വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട്	2 2 2 2 2 2 2 2 2 2 2 2 2	lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും lval, ഏതെങ്കിലും → ഏതെങ്കിലും
വരുമാനം... വരുമാനം* ...	വരുമാനം വരുമാനം*	വലത്തുനിന്ന് ഇടത്തോട്ട് വലത്തുനിന്ന് ഇടത്തോട്ട്	1 1
... …	വിപുലീകരണം	ഇല്ല	1
… , …	കോമ	ഇടത്തുനിന്ന് വലത്തോട്ട്	2	ഏതെങ്കിലും, ഏതെങ്കിലും → ഏതെങ്കിലും

ജാവാസ്ക്രിപ്റ്റിലെ എക്സ്പ്രഷനുകൾ കോമ്പിനേഷനുകളാണ് പ്രവർത്തനങ്ങൾഒപ്പം ഓപ്പറേറ്റർമാർ.

പ്രവർത്തനങ്ങൾഎക്സ്പ്രഷനുകളിൽ മുൻഗണനാ മൂല്യത്തിന് അനുസൃതമായി തുടർച്ചയായി നടപ്പിലാക്കുന്നു (മുൻഗണന മൂല്യം ഉയർന്നത്, അത് ഉയർന്നതാണ്). നൽകിയ ഫലം എല്ലായ്‌പ്പോഴും പ്രോസസ്സ് ചെയ്യുന്ന ഡാറ്റയുടെ തരത്തിന് സമാനമല്ല. ഉദാഹരണത്തിന്, താരതമ്യ പ്രവർത്തനങ്ങളിൽ വ്യത്യസ്ത തരം ഓപ്പറണ്ടുകൾ ഉൾപ്പെടുന്നു, എന്നാൽ റിട്ടേൺ ഫലം എല്ലായ്പ്പോഴും ഒരു ബൂളിയൻ തരമായിരിക്കും.

അരി. 1. ജാവാസ്ക്രിപ്റ്റിലെ എക്സ്പ്രഷൻ ഘടന

JavaScript സ്ക്രിപ്റ്റ് പ്രോസസ്സ് ചെയ്യുന്ന ഡാറ്റയാണ് ഓപ്പറാൻഡുകൾ. ഓപ്പറണ്ടുകൾ ലളിതമോ സങ്കീർണ്ണമോ ആയ ഡാറ്റ തരങ്ങളും മറ്റ് എക്സ്പ്രഷനുകളും ആകാം.

ഡാറ്റയിൽ വിവിധ പ്രവർത്തനങ്ങൾ നടത്തുന്ന ഭാഷാ ചിഹ്നങ്ങളാണ് ഓപ്പറേറ്റർമാർ. വിരാമചിഹ്ന പ്രതീകങ്ങളോ കീവേഡുകളോ ഉപയോഗിച്ച് ഓപ്പറേറ്റർമാരെ എഴുതാം.

പ്രവർത്തനങ്ങളുടെ എണ്ണത്തെ ആശ്രയിച്ച്, ഇനിപ്പറയുന്ന തരത്തിലുള്ള ഓപ്പറേറ്റർമാരെ വേർതിരിച്ചിരിക്കുന്നു:
unary - ഒരു ഓപ്പറാൻറ് ഓപ്പറേഷനിൽ ഉൾപ്പെടുന്നു;
ബൈനറി - പ്രവർത്തനത്തിൽ രണ്ട് ഓപ്പറണ്ടുകൾ ഉൾപ്പെടുന്നു;
ത്രിതീയ - മൂന്ന് ഓപ്പറണ്ടുകൾ സംയോജിപ്പിക്കുന്നു.

ഒരു പദപ്രയോഗത്തിൻ്റെ ഏറ്റവും ലളിതമായ രൂപം അക്ഷരാർത്ഥമാണ് - സ്വയം വിലയിരുത്തുന്ന ഒന്ന്, ഉദാഹരണത്തിന്, നമ്പർ 100, സ്ട്രിംഗ് "ഹലോ വേൾഡ്". ഒരു വേരിയബിളും ഒരു എക്സ്പ്രഷൻ ആകാം, കാരണം അത് അതിന് നിയുക്തമാക്കിയ മൂല്യത്തെ വിലയിരുത്തുന്നു.

JavaScript-ലെ എക്സ്പ്രഷനുകളും ഓപ്പറേറ്റർമാരും 1. അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാർ

ഗണിതശാസ്ത്രപരമായ പ്രവർത്തനങ്ങൾ നടത്താൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ് ഗണിത ഓപ്പറേറ്റർമാർ; അവ സംഖ്യാ ഓപ്പറണ്ടുകളിൽ പ്രവർത്തിക്കുന്നു (അല്ലെങ്കിൽ സംഖ്യാ മൂല്യങ്ങൾ സംഭരിക്കുന്ന വേരിയബിളുകൾ), ഫലമായി ഒരു സംഖ്യാ മൂല്യം നൽകുന്നു.

ഓപ്പറൻഡുകളിലൊന്ന് ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ, JavaScript വ്യാഖ്യാതാവ് അതിനെ ഒരു സംഖ്യാ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കും, തുടർന്ന് ഉചിതമായ പ്രവർത്തനം നടത്തുകയും ചെയ്യും. തരം പരിവർത്തനം സാധ്യമല്ലെങ്കിൽ, ഫലം NaN ആയിരിക്കും (ഒരു സംഖ്യയല്ല).

പട്ടിക 1. അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാർ ഓപ്പറേറ്റർ/ഓപ്പറേഷൻ വിവരണം മുൻഗണന

+ കൂട്ടിച്ചേർക്കൽ	സംഖ്യാ ഓപ്പറണ്ടുകൾ ചേർക്കുന്നു. ഓപ്പറൻഡുകളിലൊന്ന് ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ, പദപ്രയോഗത്തിൻ്റെ ഫലം ഒരു സ്ട്രിംഗാണ്.	12
- കുറയ്ക്കൽ	ആദ്യത്തേതിൽ നിന്ന് രണ്ടാമത്തെ ഓപ്പറാൻറ് കുറയ്ക്കുന്നു.	12
- യുണറി മൈനസ്	ഒരു പോസിറ്റീവ് സംഖ്യയെ നെഗറ്റീവ് സംഖ്യയായും തിരിച്ചും പരിവർത്തനം ചെയ്യുന്നു.	14
* ഗുണനം	രണ്ട് ഓപ്പറണ്ടുകളെ ഗുണിക്കുന്നു.	13
/ ഡിവിഷൻ	ആദ്യ ഓപ്പറണ്ടിനെ രണ്ടാമത്തേത് കൊണ്ട് ഹരിക്കുന്നു. വിഭജനത്തിൻ്റെ ഫലം ഒന്നുകിൽ ഒരു പൂർണ്ണസംഖ്യയോ ഫ്ലോട്ടിംഗ് പോയിൻ്റ് സംഖ്യയോ ആകാം.	13
% മൊഡ്യൂളോ ഡിവിഷൻ (ഡിവിഷൻ ബാക്കി)	ആദ്യ ഓപ്പറണ്ടിനെ രണ്ടാമത്തേത് കൊണ്ട് ഒരു പൂർണ്ണസംഖ്യ വിഭജിച്ചതിൻ്റെ ഫലമായി ബാക്കിയുള്ളത് കണക്കാക്കുന്നു. പൂർണ്ണസംഖ്യകൾക്കും ഫ്ലോട്ടിംഗ് പോയിൻ്റ് നമ്പറുകൾക്കും ബാധകമാണ്.	13

var x = 5, y = 8, z; z = x + y; // റിട്ടേൺ 13 z = x - y; // മടങ്ങുക -3 z = - y; // റിട്ടേൺ -8 z = x * y; // റിട്ടേൺ 40 z = x / y; // റിട്ടേൺ 0.625 z = y % x; // റിട്ടേൺ 3 2. അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ

വേരിയബിളുകൾക്ക് മൂല്യങ്ങൾ നൽകുന്നതിന് അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ ഉപയോഗിക്കുന്നു. ഒറിജിനൽ, തുടർന്നുള്ള മൂല്യങ്ങൾ ഒരൊറ്റ വേരിയബിളിൽ സംഭരിക്കുന്നതിന് സംയോജിത ഓപ്പറേറ്റർമാർ നിങ്ങളെ അനുവദിക്കുന്നു.

var a = 5; // a var b = "ഹലോ" എന്ന വേരിയബിളിന് സംഖ്യാ മൂല്യം 5 നൽകുക; // b var m = n = z = 10 എന്ന വേരിയബിളിൽ സ്ട്രിംഗ് ഹെല്ലോ സംഭരിക്കുക; // m, n, z എന്നീ വേരിയബിളുകൾ അസൈൻ ചെയ്യുക സംഖ്യാ മൂല്യമായ 10 x += 10; // x = x + 10 ന് തുല്യം; x -= 10; // x = x - 10 ന് തുല്യം; x *= 10; // x = x * 10 ന് തുല്യം; x /= 10; // x = x / 10 ന് തുല്യം; x %= 10; // x = x % 10 ന് തുല്യം; 3. ഇൻക്രിമെൻ്റ് ആൻഡ് ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർമാർ

ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് പ്രവർത്തനങ്ങൾ ഏകീകൃതവും ഓപ്പറണ്ടിൻ്റെ മൂല്യം ഒന്നായി വർദ്ധിപ്പിക്കുകയും കുറയ്ക്കുകയും ചെയ്യുന്നു. ഓപ്പറാൻറ് ഒരു വേരിയബിൾ, ഒരു അറേ ഘടകം അല്ലെങ്കിൽ ഒരു ഒബ്ജക്റ്റ് പ്രോപ്പർട്ടി ആകാം. മിക്കപ്പോഴും, അത്തരം പ്രവർത്തനങ്ങൾ ഒരു ലൂപ്പിൽ ഒരു കൌണ്ടർ വർദ്ധിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു.

var x = y = m = n = 5, z, s, k, l; z = ++x * 2; /* കണക്കുകൂട്ടലുകളുടെ ഫലമായി z = 12, x = 6, അതായത് മൂല്യം തിരികെ നൽകും. x ൻ്റെ മൂല്യം ആദ്യം 1 കൊണ്ട് വർദ്ധിപ്പിക്കുന്നു, തുടർന്ന് ഗുണന പ്രവർത്തനം നടത്തുന്നു */ s = y++ * 2; /* കണക്കുകൂട്ടലുകളുടെ ഫലമായി മൂല്യം s = 10, y = 6, അതായത് തിരികെ നൽകും. ആദ്യം, ഗുണന പ്രവർത്തനം നടത്തുന്നു, തുടർന്ന് 1 വർദ്ധിച്ച മൂല്യം y */ k = --m * 2 എന്ന വേരിയബിളിൽ സംഭരിക്കുന്നു; // മൂല്യം തിരികെ നൽകുക k = 8, m = 4 l = n-- * 2; // മൂല്യം തിരികെ നൽകുക l = 10, n = 4 4. താരതമ്യ ഓപ്പറേറ്റർമാർ

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

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

രണ്ട് ഓപ്പറണ്ടുകളും സ്ട്രിംഗുകൾ/നമ്പറുകൾ ആണെങ്കിൽ അല്ലെങ്കിൽ സ്ട്രിംഗുകൾ/നമ്പറുകൾ ആയി പരിവർത്തനം ചെയ്യാൻ കഴിയുമെങ്കിൽ, അവയെ സ്ട്രിംഗുകൾ/നമ്പറുകൾ ആയി താരതമ്യം ചെയ്യും.

ഒരു ഓപ്പറാൻറ് ഒരു സ്ട്രിംഗ് ആണെങ്കിൽ/ഒരു സ്ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്യുന്നു, മറ്റൊന്ന് ഒരു സംഖ്യയാണെങ്കിൽ/ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യുന്നുവെങ്കിൽ, ഓപ്പറേറ്റർ സ്ട്രിംഗ് ഒരു സംഖ്യയിലേക്ക് പരിവർത്തനം ചെയ്യാനും ഒരു സംഖ്യ താരതമ്യം ചെയ്യാനും ശ്രമിക്കും. സ്ട്രിംഗ് ഒരു സംഖ്യയല്ലെങ്കിൽ, അത് NaN ആയി പരിവർത്തനം ചെയ്യപ്പെടുകയും താരതമ്യത്തിൻ്റെ ഫലം തെറ്റാണ് .

മിക്കപ്പോഴും, പ്രോഗ്രാമുകളിൽ ശാഖകൾ സംഘടിപ്പിക്കുമ്പോൾ താരതമ്യ പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു.

പട്ടിക 4. താരതമ്യ ഓപ്പറേറ്റർമാർ ഓപ്പറേറ്റർ/ഓപ്പറേഷൻ വിവരണം മുൻഗണന

== സമത്വം	ഒരേ മൂല്യത്തിനായി രണ്ട് മൂല്യങ്ങൾ പരിശോധിക്കുന്നു, ഇത് തരം പരിവർത്തനം അനുവദിക്കുന്നു. ഓപ്പറണ്ടുകൾ ഒന്നുതന്നെയാണെങ്കിൽ ശരിയും വ്യത്യസ്തമാണെങ്കിൽ തെറ്റും നൽകുന്നു.	9
!= അസമത്വം	ഓപ്പറണ്ടുകൾ തുല്യമല്ലെങ്കിൽ ശരിയാണെന്ന് നൽകുന്നു	9
=== ഐഡൻ്റിറ്റി	ഒരു പൊരുത്തത്തിൻ്റെ കർശനമായ നിർവചനം ഉപയോഗിച്ച് "ഐഡൻ്റിറ്റി"ക്കായി രണ്ട് ഓപ്പറണ്ടുകൾ പരിശോധിക്കുന്നു. തരം പരിവർത്തനം കൂടാതെ ഓപ്പറണ്ടുകൾ തുല്യമാണെങ്കിൽ ശരി എന്ന് നൽകുന്നു.	9
!== ഐഡൻ്റിറ്റി അല്ലാത്തത്	ഐഡൻ്റിറ്റി വെരിഫിക്കേഷൻ നടത്തുന്നു. തരം പരിവർത്തനം കൂടാതെ ഓപ്പറണ്ടുകൾ തുല്യമല്ലെങ്കിൽ ശരി എന്ന് നൽകുന്നു.	9
> കൂടുതൽ	ആദ്യ ഓപ്പറാൻറ് രണ്ടാമത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ ശരി നൽകുന്നു, അല്ലാത്തപക്ഷം തെറ്റ് നൽകുന്നു.	10
>= ഇതിലും വലുത് അല്ലെങ്കിൽ തുല്യം	ആദ്യ ഓപ്പറാൻറ് രണ്ടാമത്തേതിനേക്കാൾ കുറവല്ലെങ്കിൽ ശരി നൽകുന്നു, അല്ലാത്തപക്ഷം തെറ്റ് നൽകുന്നു.	10
	ആദ്യ ഓപ്പറാൻറ് രണ്ടാമത്തേതിനേക്കാൾ കുറവാണെങ്കിൽ ശരി നൽകുന്നു, അല്ലാത്തപക്ഷം തെറ്റ് നൽകുന്നു.	10
	ആദ്യത്തെ ഓപ്പറാൻറ് രണ്ടാമത്തേതിനേക്കാൾ വലുതല്ലെങ്കിൽ ശരി നൽകുന്നു, അല്ലാത്തപക്ഷം തെറ്റ് നൽകുന്നു.	10

5 == "5"; // യഥാർത്ഥ 5 തിരികെ നൽകുക != -5.0; // ശരി 5 തിരികെ നൽകുക === "5"; // തെറ്റ് തെറ്റ് തിരികെ === തെറ്റ്; // സത്യ 1 തിരികെ നൽകുക !== true; // സത്യ 1 തിരികെ നൽകുക != true; true എന്നത് 1 3 > -3 ആയി പരിവർത്തനം ചെയ്യപ്പെടുന്നതിനാൽ // false തിരികെ നൽകും; // ശരി 3 മടങ്ങുക >= "4"; // തെറ്റായി തിരികെ നൽകുക 5. ലോജിക്കൽ ഓപ്പറേറ്റർമാർ

ബൂളിയൻ മൂല്യങ്ങൾ നൽകുന്ന വ്യവസ്ഥകൾ സംയോജിപ്പിക്കാൻ ലോജിക്കൽ ഓപ്പറേറ്റർമാർ നിങ്ങളെ അനുവദിക്കുന്നു. ഒരു if സോപാധിക പ്രസ്താവനയിലാണ് മിക്കപ്പോഴും ഉപയോഗിക്കുന്നത്.

(2 < 3) && (3===3); // вернет true, так как выражения в обеих скобках дают true (x < 10 && x >0); x 0 മുതൽ 10 വരെയുള്ള റേഞ്ചിൽ ആണെങ്കിൽ // true തിരികെ നൽകും !false; // ശരി തിരികെ നൽകുക 6. ബിറ്റ്‌വൈസ് ഓപ്പറേറ്റർമാർ

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

പട്ടിക 6. ബിറ്റ്വൈസ് ഓപ്പറേറ്റർമാർ ഓപ്പറേറ്റർ/ഓപ്പറേഷൻ വിവരണം മുൻഗണന

& ബിറ്റ്‌വൈസ് AND	രണ്ട് ബിറ്റുകളും 1 ആണെങ്കിൽ, ഫലമായുണ്ടാകുന്ന ബിറ്റ് 1 ആയിരിക്കും. അല്ലെങ്കിൽ ഫലം 0 ആണ്.	8
| ബിറ്റ്വൈസ് അല്ലെങ്കിൽ	ഓപ്പറണ്ടുകളിൽ ഒന്നിൽ 1 സ്ഥാനത്തുണ്ടെങ്കിൽ, ഫലത്തിൽ ആ സ്ഥാനത്ത് 1 ഉണ്ടായിരിക്കും, അല്ലാത്തപക്ഷം ആ സ്ഥാനത്തെ ഫലം 0 ആയിരിക്കും.	6
^ എക്സ്ക്ലൂസീവ് അല്ലെങ്കിൽ	ഒരേ ഒരു മൂല്യത്തിൽ ഏതെങ്കിലും സ്ഥാനത്ത് 1 അടങ്ങിയിരിക്കുന്നുവെങ്കിൽ, ഫലത്തിൽ ആ സ്ഥാനത്ത് 1 ഉണ്ടായിരിക്കും, അല്ലാത്തപക്ഷം ആ സ്ഥാനത്തെ ഫലം 0 ആയിരിക്കും.	7
~ നിഷേധം	ഒരു പദപ്രയോഗത്തിൻ്റെ മൂല്യത്തിൻ്റെ ബൈനറി പ്രാതിനിധ്യത്തിൽ ഒരു ബിറ്റ്‌വൈസ് നിഷേധ പ്രവർത്തനം നടത്തുന്നു. ഒറിജിനൽ എക്‌സ്‌പ്രഷനിൽ 1 അടങ്ങിയ ഏത് സ്ഥാനവും 0 ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഒറിജിനൽ എക്സ്പ്രഷനിൽ 0 അടങ്ങിയ ഏത് സ്ഥാനവും 0 ആയി മാറുന്നു. പോസിറ്റീവ് സംഖ്യകൾ 0-ൽ ആരംഭിക്കുന്നു, നെഗറ്റീവ് സംഖ്യകൾ -1-ൽ ആരംഭിക്കുന്നു, അതിനാൽ ~ n == -(n+1) .	14
	രണ്ടാമത്തെ ഓപ്പറാൻറ് സജ്ജമാക്കിയ ബിറ്റ് സ്ഥാനങ്ങളുടെ എണ്ണം ഉപയോഗിച്ച് ഓപ്പറേറ്റർ ആദ്യത്തെ ഓപ്പറണ്ടിൻ്റെ ബിറ്റുകൾ ഇടത്തേക്ക് മാറ്റുന്നു. വലതുവശത്തുള്ള സ്ഥാനങ്ങൾ പൂരിപ്പിക്കാൻ പൂജ്യങ്ങൾ ഉപയോഗിക്കുന്നു. ഇടത് ഓപ്പറണ്ടിൻ്റെ അതേ തരത്തിലുള്ള ഫലം നൽകുക.	11
>> ബിറ്റ്വൈസ് വലത്തേക്ക് മാറ്റുക	രണ്ടാമത്തെ ഓപ്പറാൻറ് സജ്ജീകരിച്ചിരിക്കുന്ന ബിറ്റ് സ്ഥാനങ്ങളുടെ എണ്ണം അനുസരിച്ച് ഓപ്പറേറ്റർ ആദ്യത്തെ ഓപ്പറണ്ടിൻ്റെ ബിറ്റുകൾ വലത്തേക്ക് മാറ്റുന്നു. പരിധിക്ക് പുറത്ത് മാറ്റിയ അക്കങ്ങൾ നീക്കം ചെയ്യപ്പെടും. ഫലത്തിൻ്റെ അടയാളം സംരക്ഷിക്കാൻ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റ് (32-ാമത്തെ) മാറ്റമില്ലാതെ അവശേഷിക്കുന്നു. ആദ്യ ഓപ്പറാൻറ് പോസിറ്റീവ് ആണെങ്കിൽ, ഫലത്തിൻ്റെ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റുകൾ പൂജ്യങ്ങൾ കൊണ്ട് നിറഞ്ഞിരിക്കുന്നു; ആദ്യ ഓപ്പറാൻറ് നെഗറ്റീവ് ആണെങ്കിൽ, ഫലത്തിൻ്റെ ഏറ്റവും പ്രധാനപ്പെട്ട ബിറ്റുകൾ നിറയുന്നു. ഒരു മൂല്യം വലത്തേക്ക് മാറ്റുന്നത് 2 കൊണ്ട് ഹരിക്കുന്നതിന് തുല്യമാണ് (ബാക്കിയുള്ളത് ഉപേക്ഷിക്കുക), രണ്ട് സ്ഥാനങ്ങൾ ഉപയോഗിച്ച് വലത്തേക്ക് മാറ്റുന്നത് 4 കൊണ്ട് ഹരിക്കുന്നതിന് തുല്യമാണ്.	11
>>> അടയാളമില്ലാതെ ബിറ്റ്‌വൈസ് വലത് ഷിഫ്റ്റ്	രണ്ടാമത്തെ ഓപ്പറാൻറ് സജ്ജീകരിച്ചിരിക്കുന്ന ബിറ്റ് സ്ഥാനങ്ങളുടെ എണ്ണം അനുസരിച്ച് ഓപ്പറേറ്റർ ആദ്യത്തെ ഓപ്പറണ്ടിൻ്റെ ബിറ്റുകൾ വലത്തേക്ക് മാറ്റുന്നു. ആദ്യ ഓപ്പറണ്ടിൻ്റെ അടയാളം പരിഗണിക്കാതെ ഇടതുവശത്ത് പൂജ്യങ്ങൾ ചേർക്കുന്നു. പരിധിക്ക് പുറത്ത് മാറ്റിയ അക്കങ്ങൾ നീക്കം ചെയ്യപ്പെടും.	11

var x = 9, y = 5, z = 2, s = -5, ഫലം; // 9 എന്നത് 1001 ന് തുല്യമാണ്, 5 എന്നത് 0101 ഫലത്തിന് തുല്യമാണ് = x & y; // 1 (0001 ന് തുല്യം) ഫലം = x | y; // 13 (1101 ന് തുല്യം) ഫലം = x ^ y; // 12 (1100 ന് തുല്യം) ഫലം = ~ y; // തിരികെ നൽകും -6 (1100 ന് തുല്യം) ഫലം = x > z; // റിട്ടേൺ 2 (10 ന് തുല്യം) ഫലം = s >>> z; // 1073741822 (111111111111111111111111111110 എന്നതിന് തുല്യം) 7. സ്ട്രിംഗ് ഓപ്പറേറ്റർമാർ

പ്രത്യേക രീതികളിൽ സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്ന നിരവധി ഓപ്പറേറ്റർമാർ ഉണ്ട്.

"1" + "10"; // തിരികെ "110" "1" + 10; // "110" 2 + 5 + "നിറമുള്ള പെൻസിലുകൾ" നൽകുന്നു; // "7 നിറമുള്ള പെൻസിലുകൾ" "നിറമുള്ള പെൻസിലുകൾ" + 2 + 5 നൽകുന്നു; // "25 നിറമുള്ള പെൻസിലുകൾ" "1" > "10" നൽകുന്നു; // തെറ്റായ "10" 10 തിരികെ നൽകണോ? x * 2: x / 2; // x > 10 ആണെങ്കിൽ x * 2 നൽകുന്നു, അല്ലാത്തപക്ഷം x / 2 9. JavaScript-ലെ അഭിപ്രായങ്ങൾ

സിംഗിൾ-ലൈൻ കമൻ്റ്: നിങ്ങൾ കമൻ്റ് ടെക്‌സ്‌റ്റിന് മുമ്പായി ചിഹ്നങ്ങൾ ഉപയോഗിച്ച് വേണം // .

ജാവാസ്ക്രിപ്റ്റ് ഭാഷ ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗിൻ്റെ തത്വങ്ങളെ പിന്തുണയ്ക്കുന്നു. നിങ്ങളുടെ ജോലിയിൽ നിങ്ങൾ നേരിട്ടേക്കാവുന്ന എല്ലാ വസ്തുക്കളെയും മൂന്ന് വലിയ ഗ്രൂപ്പുകളായി തിരിക്കാം:

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

2. ബാഹ്യ നിലവാരമുള്ള വസ്തുക്കൾ. സാധാരണ ഇൻ്റർഫേസ് ഘടകങ്ങളുമായും ബ്രൗസർ പ്രവർത്തനങ്ങളുമായും സംവദിക്കാൻ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. വിൻഡോ, ഡോക്യുമെൻ്റ്, ഇവൻ്റ് തുടങ്ങിയ ഒബ്ജക്റ്റുകൾ ഇവയാണ്. എല്ലാ ബാഹ്യ വസ്തുക്കളും സ്ക്രിപ്റ്റിൽ എവിടെയും ലഭ്യമാണ്, തൽക്ഷണം ആവശ്യമില്ല.

3. ഇഷ്ടാനുസൃത വസ്തുക്കൾ. ചില പ്രത്യേക ആവശ്യങ്ങൾക്കായി അവ ഡെവലപ്പർ സൃഷ്ടിച്ചതാണ്. നിങ്ങളുടെ സ്വന്തം വസ്തുക്കൾ സൃഷ്ടിക്കുന്നതിന് ചില കഴിവുകളും വികസന അനുഭവവും ആവശ്യമാണ്.

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

ഒരു പ്രോപ്പർട്ടി അല്ലെങ്കിൽ രീതി അതിൻ്റെ പേരും ഒബ്ജക്റ്റ് ഉദാഹരണവും വ്യക്തമാക്കിക്കൊണ്ട് നിങ്ങൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയും:

വസ്തു.സ്വത്ത്

object.method()

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

// വ്യാഖ്യാതാവ് ഓപ്പൺ() രീതിയെ വിളിക്കും

// വ്യാഖ്യാതാവ് തുറന്ന പ്രോപ്പർട്ടിക്കായി നോക്കും,

// അത് കണ്ടെത്തില്ല, ഒരു പിശക് എറിയുകയും ചെയ്യും

8. JavaScript-ലെ പ്രത്യേക ഓപ്പറേറ്റർമാർ.

?: "എങ്കിൽ...പിന്നെ...മറ്റൊരു" ലളിതമായ ഒരു ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു

രണ്ട് പദപ്രയോഗങ്ങൾ വിലയിരുത്തുകയും രണ്ടാമത്തെ പദപ്രയോഗത്തിൻ്റെ ഫലം നൽകുകയും ചെയ്യുന്നു.

ഇല്ലാതാക്കുക ഒരു അറേയിലെ ഒരു നിർദ്ദിഷ്ട സൂചികയിലെ ഒരു വസ്തുവിൻ്റെ അല്ലെങ്കിൽ ഒരു ഘടകത്തിൻ്റെ ഒരു പ്രോപ്പർട്ടി ഇല്ലാതാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

പുതിയ ഒരു ഉപയോക്തൃ നിർവചിച്ച ഒബ്‌ജക്റ്റ് തരത്തിൻ്റെ അല്ലെങ്കിൽ അന്തർനിർമ്മിത ഒബ്‌ജക്റ്റ് തരങ്ങളിൽ ഒന്നിൻ്റെ ഒരു ഉദാഹരണം സൃഷ്‌ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

നിലവിലെ ഒബ്‌ജക്‌റ്റിനെ സൂചിപ്പിക്കാൻ നിങ്ങൾക്ക് ഈ കീവേഡ് ഉപയോഗിക്കാം.

typeof മൂല്യനിർണ്ണയം ചെയ്യാത്ത ഓപ്പറണ്ടിൻ്റെ തരം സൂചിപ്പിക്കുന്ന ഒരു സ്ട്രിംഗ് നൽകുന്നു.

void ഒരു മൂല്യം നൽകാതെ തന്നെ മൂല്യനിർണ്ണയം ചെയ്യപ്പെടുന്ന ഒരു പദപ്രയോഗം void ഓപ്പറേറ്റർ നിർവചിക്കുന്നു.

9. JavaScript-ൽ ഓപ്പറേറ്റർ മുൻഗണന.

ഓപ്പറേറ്റർ സീനിയോറിറ്റി

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

ഓപ്പറേറ്റർമാരുടെ സീനിയോറിറ്റി, താഴ്ന്നത് മുതൽ ഉയർന്നത് വരെ, ഇനിപ്പറയുന്നതായിരിക്കും:

അസൈൻമെൻ്റ് =+=-=*=/=%==>>=&=^=|=

വ്യവസ്ഥ പ്രകാരം തിരഞ്ഞെടുക്കണോ? :

ലോജിക്കൽ അല്ലെങ്കിൽ ||

ലോജിക്കൽ കൂടാതെ &&

ബിറ്റ്വൈസ് അല്ലെങ്കിൽ |

ബിറ്റ്വൈസ് എക്സ്ക്ലൂസീവ്^

ബിറ്റ്‌വൈസ് ആൻഡ് &

അസമത്വം!=

സമത്വം/അസമത്വം == !=

താരതമ്യം =

ബിറ്റ് ഷിഫ്റ്റ് > >>>

കൂട്ടിച്ചേർക്കൽ/കുറക്കൽ + -

ഗുണിക്കുക/വിഭജിക്കുക * / %

നിഷേധം/പൂരകം/അനറി മൈനസ്/ഇൻക്രിമെൻ്റ്/കുറവ്! ~ - ++ --

വിളിക്കുക, പാരാമീറ്ററുകൾ കൈമാറുക () .

ഏതൊരു പ്രോഗ്രാമിംഗ് ഭാഷയുടെയും ഏറ്റവും അടിസ്ഥാനപരവും സാർവത്രികവുമായ പ്രവർത്തനങ്ങളിൽ ഒന്നാണ് ഗണിത പ്രവർത്തനങ്ങൾ. JavaScript-ൽ, ഒരു ബ്രൗസർ വിൻഡോയുടെ വലുപ്പം നിർണ്ണയിക്കുക, പണമിടപാടിൻ്റെ അന്തിമ വില കണക്കാക്കുക, അല്ലെങ്കിൽ ഒരു വെബ്‌സൈറ്റ് ഡോക്യുമെൻ്റിലെ ഘടകങ്ങൾ തമ്മിലുള്ള ദൂരം എന്നിവ പോലുള്ള പൊതുവായ ജോലികളിൽ നമ്പറുകൾ ഉപയോഗിക്കാറുണ്ട്.

ഒരു നല്ല ഡെവലപ്പർ ആകാൻ നിങ്ങൾ ഗണിതത്തിൽ മികച്ച ആളായിരിക്കണമെന്നില്ല, എന്നാൽ JavaScript-ൽ ഏത് തരത്തിലുള്ള പ്രവർത്തനങ്ങളാണ് ലഭ്യമെന്നും പ്രായോഗിക ജോലികൾ ചെയ്യാൻ അവ എങ്ങനെ ഉപയോഗിക്കാമെന്നും അറിയേണ്ടത് പ്രധാനമാണ്.

മറ്റ് പ്രോഗ്രാമിംഗ് ഭാഷകളിൽ നിന്ന് വ്യത്യസ്തമായി, ജാവാസ്ക്രിപ്റ്റിന് ഒരു സംഖ്യാ ഡാറ്റാ തരം മാത്രമേയുള്ളൂ; ഇത് പൂർണ്ണസംഖ്യകളും ഫ്ലോട്ടുകളും തമ്മിൽ വേർതിരിക്കുന്നില്ല.

ഈ ട്യൂട്ടോറിയൽ ജാവാസ്ക്രിപ്റ്റ് ന്യൂമറിക് ഡാറ്റ ഉപയോഗിച്ച് ഗണിത ഓപ്പറേറ്റർമാർ, അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ, പ്രവർത്തനങ്ങളുടെ ക്രമം എന്നിവ ഉൾക്കൊള്ളും.

അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാർ

ഗണിത പ്രവർത്തനങ്ങളെ നിർവചിക്കുകയും ഫലം നൽകുകയും ചെയ്യുന്ന ചിഹ്നങ്ങളാണ് അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാർ. ഉദാഹരണത്തിന്, 3 + 7 = 10 ൽ, ചിഹ്നം + കൂട്ടിച്ചേർക്കൽ പ്രവർത്തനത്തിനുള്ള വാക്യഘടനയെ നിർവചിക്കുന്നു.

പല JavaScript ഓപ്പറേറ്റർമാരും അടിസ്ഥാന ഗണിതത്തിൽ നിന്ന് നിങ്ങൾക്ക് പരിചിതമാണ്, എന്നാൽ നിരവധി അധിക ഓപ്പറേറ്റർമാരുമുണ്ട്.

എല്ലാ JavaScript അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാരും ഇനിപ്പറയുന്ന പട്ടികയിൽ അവതരിപ്പിച്ചിരിക്കുന്നു.

ഓപ്പറേറ്റർ	വാക്യഘടന	ഉദാഹരണം	നിർവ്വചനം
കൂട്ടിച്ചേർക്കൽ	+	x+y	x, y എന്നിവയുടെ ആകെത്തുക
കുറയ്ക്കൽ	—	x - y	x ഉം y ഉം തമ്മിലുള്ള വ്യത്യാസം
ഗുണനം	*	x*y	x, y എന്നിവയുടെ ഡെറിവേറ്റീവ്
ഡിവിഷൻ	/	x/y	x, y എന്നിവയുടെ ക്വോട്ട്
മൊഡ്യൂൾ	%	x % y	ശേഷിക്കുന്ന x/y
എക്സ്പോണൻഷ്യേഷൻ	**	x**y	y യുടെ ശക്തിയിലേക്ക് x
ഇൻക്രിമെന്റും	++	x++	x പ്ലസ് വൺ
കുറയ്ക്കൽ	—	x-	x മൈനസ് ഒന്ന്

കൂട്ടലും കുറയ്ക്കലും

സങ്കലനവും കുറയ്ക്കലും ഓപ്പറേറ്റർമാർ JavaScript-ൽ ലഭ്യമാണ്, കൂടാതെ സംഖ്യാ മൂല്യങ്ങളുടെ ആകെത്തുകയും വ്യത്യാസവും കണ്ടെത്താൻ ഇത് ഉപയോഗിക്കാം. JavaScript-ന് ഒരു ബിൽറ്റ്-ഇൻ കാൽക്കുലേറ്റർ ഉണ്ട്, കൂടാതെ ഗണിത പ്രവർത്തനങ്ങൾ കൺസോളിൽ നേരിട്ട് നടത്താവുന്നതാണ്.

സംഖ്യകൾ ചേർക്കാൻ പ്ലസ് ചിഹ്നം നിങ്ങളെ അനുവദിക്കുന്നു, ഉദാഹരണത്തിന്:

പ്രൈം നമ്പറുകളുള്ള പ്രവർത്തനങ്ങൾക്ക് പുറമേ, വേരിയബിളുകൾക്ക് നമ്പറുകൾ നൽകാനും അവയിൽ കണക്കുകൂട്ടലുകൾ നടത്താനും JavaScript നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് x, y എന്നീ വേരിയബിളുകൾക്ക് സംഖ്യാ മൂല്യങ്ങൾ നൽകുകയും ഫലം z-ൽ നൽകുകയും ചെയ്യാം.

// x, y എന്നിവയ്ക്ക് മൂല്യങ്ങൾ നൽകുക
x = 10 ആകട്ടെ;
y = 20 ആകട്ടെ;
//x, y എന്നിവ ചേർത്ത് തുക z-ലേക്ക് അസൈൻ ചെയ്യുക
z = x + y എന്ന് അനുവദിക്കുക;
console.log(z);
30

// x, y എന്നിവയ്ക്ക് മൂല്യങ്ങൾ നൽകുക
x = 10 ആകട്ടെ;
y = 20 ആകട്ടെ;
// y-ൽ നിന്ന് x കുറയ്ക്കുക, വ്യത്യാസം z-ലേക്ക് നൽകുക
z = y - x എന്ന് അനുവദിക്കുക;
console.log(z);
10

// x, y എന്നിവയ്ക്ക് മൂല്യങ്ങൾ നൽകുക
x = -5.2 അനുവദിക്കുക;
y = 2.5 ആകട്ടെ;
// x-ൽ നിന്ന് y കുറയ്ക്കുക, വ്യത്യാസം z-ലേക്ക് നൽകുക
z = x - y എന്ന് അനുവദിക്കുക;
console.log(z);
-7.7

നിങ്ങൾ പരിഗണിക്കേണ്ടതും അറിയേണ്ടതുമായ JavaScript-ലെ രസകരമായ ഒരു സവിശേഷത ഒരു സംഖ്യയും ഒരു സ്ട്രിംഗും ചേർക്കുന്നതിൻ്റെ ഫലമാണ്. 1 + 1 2 ന് തുല്യമാകണമെന്ന് നമുക്കറിയാം, എന്നാൽ ഈ സമവാക്യം ഒരു അപ്രതീക്ഷിത ഫലം നൽകും.

x = 1 + "1" അനുവദിക്കുക;
console.log(x);
x തരം;
11
"സ്ട്രിംഗ്"

സംഖ്യകൾ ചേർക്കുന്നതിനുപകരം, JavaScript മുഴുവൻ എക്സ്പ്രഷനും സ്ട്രിംഗുകളാക്കി മാറ്റുകയും അവയെ കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു. JavaScript-ൽ ഡൈനാമിക് ടൈപ്പിംഗ് ശ്രദ്ധിക്കേണ്ടത് പ്രധാനമാണ്, കാരണം അത് അഭികാമ്യമല്ലാത്ത ഫലങ്ങൾ ഉണ്ടാക്കും.

നാവിഗേഷൻ ബാർ സ്ക്രോൾ ചെയ്യാൻ ജാവാസ്ക്രിപ്റ്റിലെ കൂട്ടിച്ചേർക്കലും കുറയ്ക്കലും ഉപയോഗിക്കാറുണ്ട്.

ഫംഗ്‌ഷൻ scrollToId() (
const navHeight = 60;
window.scrollTo(0, window.pageYOffset - navHeight);
}
window.addEventListener("hashchange", scrollToId);

ഈ സാഹചര്യത്തിൽ, പാനൽ ഐഡിയിൽ നിന്ന് 60 പിക്സലുകൾ സ്ക്രോൾ ചെയ്യും.

ഗുണനവും വിഭജനവും

സംഖ്യാ മൂല്യങ്ങളുടെ ഡെറിവേറ്റീവും ഘടകവും കണ്ടെത്താൻ JavaScript ഗുണനവും ഡിവിഷൻ ഓപ്പറേറ്ററുകളും ഉപയോഗിക്കുന്നു.

നക്ഷത്രചിഹ്നം ഗുണന ഓപ്പറേറ്ററാണ്.

// x, y എന്നിവയ്ക്ക് മൂല്യങ്ങൾ നൽകുക
x = 20 ആകട്ടെ;
y = 5 ആകട്ടെ;
// ഉൽപ്പന്നം ലഭിക്കാൻ x നെ y കൊണ്ട് ഗുണിക്കുക
z = x * y എന്ന് അനുവദിക്കുക;
console.log(z);
100

വിൽപ്പന നികുതി ചുമത്തിയതിന് ശേഷം ഒരു വസ്തുവിൻ്റെ വില കണക്കാക്കാൻ ഗുണനം ഉപയോഗിക്കാം.

കോൺസ്റ്റ് വില = 26.5; // നികുതിക്ക് മുമ്പുള്ള ഇനത്തിൻ്റെ വില
const taxRate = 0.082; // 8.2% നികുതി നിരക്ക്
// നികുതിക്ക് ശേഷമുള്ള ആകെ തുക രണ്ട് ദശാംശ സ്ഥാനങ്ങളിലേക്ക് കണക്കാക്കുക
മൊത്തം വില = വില + (വില * നികുതി നിരക്ക്);
totalPrice.toFixed(2);
console.log("മൊത്തം:", മൊത്തം വില);
ആകെ: 28.67

സ്ലാഷ് ആണ് ഡിവിഷൻ ഓപ്പറേറ്റർ.

// x, y എന്നിവയ്ക്ക് മൂല്യങ്ങൾ നൽകുക
x = 20 ആകട്ടെ;
y = 5 ആകട്ടെ;
// ഉദ്ധരണി ലഭിക്കാൻ y-യെ x ആയി ഹരിക്കുക
z = x / y എന്ന് അനുവദിക്കുക;
console.log(z);
4

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

ഒരു സംഖ്യയുടെ കേവല മൂല്യം

മോഡുലസ് മറ്റൊരു ഗണിത ഓപ്പറേറ്ററാണ്, മുമ്പത്തേതിനേക്കാൾ ജനപ്രിയമല്ല. % ചിഹ്നത്താൽ പ്രതിനിധീകരിക്കുന്നു. ആദ്യത്തെ സംഖ്യയെ രണ്ടാമത്തേത് കൊണ്ട് ഹരിക്കുമ്പോൾ അത് ബാക്കിയുള്ളത് നൽകുന്നു.

ഉദാഹരണത്തിന്, 9 എന്നത് ബാക്കിയില്ലാതെ 3 കൊണ്ട് ഹരിക്കാമെന്ന് നമുക്കറിയാം:

ഒരു സംഖ്യ ഇരട്ടയാണോ അതോ ഒറ്റയാണോ എന്ന് നിർണ്ണയിക്കാൻ നമ്പർ മോഡുലസ് നിങ്ങളെ അനുവദിക്കുന്നു, ഉദാഹരണത്തിന്:

// ഒരു സംഖ്യ ഇരട്ടയാണോ എന്ന് പരിശോധിക്കാൻ ഫംഗ്‌ഷൻ ആരംഭിക്കുക
const isEven = x => (
// രണ്ടായി ഹരിച്ചതിന് ശേഷമുള്ള ശേഷിക്കുന്നത് 0 ആണെങ്കിൽ, ശരി തിരികെ നൽകുക
എങ്കിൽ (x % 2 === 0) (
സത്യമായി മടങ്ങുക;
}
// ഒറ്റസംഖ്യ ആണെങ്കിൽ, തെറ്റ് തിരികെ നൽകുക
തെറ്റായി മടങ്ങുക;
}
// നമ്പർ പരീക്ഷിക്കുക
isEven(12);
സത്യം

ഈ ഉദാഹരണത്തിൽ, 12 നെ 2 കൊണ്ട് ഹരിക്കുന്നു, അതിനാൽ ഇത് ഇരട്ട സംഖ്യയാണ്.

പ്രോഗ്രാമിംഗിൽ, സോപാധിക പ്രസ്താവനകളുമായി സംയോജിപ്പിച്ച് നമ്പർ മോഡുലസ് പലപ്പോഴും ഉപയോഗിക്കുന്നു.

എക്സ്പോണൻഷ്യേഷൻ

JavaScript-ലെ ഏറ്റവും പുതിയ ഓപ്പറേറ്റർമാരിൽ ഒന്നാണ് എക്സ്പോണൻഷ്യേഷൻ. എക്‌സ്‌പോണൻഷ്യേഷൻ്റെ വാക്യഘടന ഒരു വരിയിലെ രണ്ട് നക്ഷത്രചിഹ്നങ്ങളാണ് (**).

ഉദാഹരണത്തിന്, 10 മുതൽ അഞ്ചാമത്തെ ശക്തി (10^5) ഇതുപോലെ എഴുതിയിരിക്കുന്നു:

10 ** 5;
100000

10**5 എന്ന ഓപ്പറേഷന് 10*10 5 തവണ ആവർത്തിച്ചതിന് സമാനമായ ഫലമുണ്ട്.

10 * 10 * 10 * 10 * 10;

Math.pow() രീതി ഉപയോഗിച്ചും ഈ പ്രവർത്തനം എഴുതാം.

Math.pow(10, 5);
100000

എക്‌സ്‌പോണൻഷ്യേഷൻ ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നത് ഒരു നിശ്ചിത സംഖ്യയുടെ ശക്തി നിർണ്ണയിക്കുന്നതിനുള്ള ഒരു ദ്രുത മാർഗമാണ്, എന്നാൽ എല്ലായ്പ്പോഴും എന്നപോലെ, ഒരു രീതിയും ഓപ്പറേറ്ററും തമ്മിൽ തിരഞ്ഞെടുക്കുമ്പോൾ, ഒരേ ശൈലിയിൽ സ്ഥിരത പുലർത്തുകയും കോഡ് ചെയ്യുകയും ചെയ്യേണ്ടത് പ്രധാനമാണ്.

വർദ്ധനവും കുറവും

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

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

7++
പിടിക്കപ്പെടാത്ത റഫറൻസ് പിശക്: പോസ്റ്റ്ഫിക്സ് ഓപ്പറേഷനിൽ അസാധുവായ ഇടതുവശത്തുള്ള എക്സ്പ്രഷൻ

വേരിയബിളുമായി ബന്ധപ്പെട്ട് ഓപ്പറേറ്ററെ എവിടെയാണ് സ്ഥാപിച്ചിരിക്കുന്നത് എന്നതിനെ ആശ്രയിച്ച് ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർമാരെ പ്രിഫിക്സ്, പോസ്റ്റ്ഫിക്സ് ഓപ്പറേറ്റർമാരായി തരംതിരിക്കാം.

പ്രിഫിക്‌സ് ഇൻക്രിമെൻ്റ് ++x എന്ന് എഴുതിയിരിക്കുന്നു.

//ഒരു വേരിയബിൾ സജ്ജമാക്കുക
x = 7 ആകട്ടെ;

പ്രിഫിക്സ് = ++x;
console.log(പ്രിഫിക്സ്);
8

x ൻ്റെ മൂല്യം 1 വർദ്ധിച്ചു. പോസ്റ്റ്ഫിക്സ് ഇൻക്രിമെൻ്റ് y++ എന്ന് എഴുതിയിരിക്കുന്നു.

//ഒരു വേരിയബിൾ സജ്ജമാക്കുക
y = 7 ആകട്ടെ;
// പ്രിഫിക്സ് ഇൻക്രിമെൻ്റ് ഓപ്പറേഷൻ ഉപയോഗിക്കുക
പോസ്റ്റ്ഫിക്സ് = y++;
console.log(postfix);
7

പോസ്റ്റ്ഫിക്സ് പ്രവർത്തനം മൂല്യം വർദ്ധിപ്പിച്ചില്ല. എക്സ്പ്രഷൻ വിലയിരുത്തുന്നത് വരെ ഈ മൂല്യം വർദ്ധിപ്പിക്കില്ല. ഇത് ചെയ്യുന്നതിന്, നിങ്ങൾ രണ്ടുതവണ പ്രവർത്തനം നടത്തേണ്ടതുണ്ട്:

y = 7 ആകട്ടെ;
y++;
y++;
console.log(y);
8

മിക്കപ്പോഴും ഈ ഓപ്പറേറ്റർമാർ ലൂപ്പുകളിൽ കാണപ്പെടുന്നു. ഇതിൽ ഫോർ ലൂപ്പിൽ, ഫോർ സ്റ്റേറ്റ്മെൻ്റ് 0 മുതൽ 10 തവണ എക്സിക്യൂട്ട് ചെയ്യുന്നു.

// ഒരു ലൂപ്പ് പത്ത് തവണ പ്രവർത്തിപ്പിക്കുക
വേണ്ടി (ഞാൻ = 0; i< 10; i++) {
console.log(i);
}
0
1
2
3
4
5
6
7
8
9

ഈ ഉദാഹരണത്തിൽ, ഇൻക്രിമെൻ്റ് ഓപ്പറേറ്റർ ഉപയോഗിച്ച് ലൂപ്പ് ആവർത്തിക്കുന്നു.

ലളിതമായി പറഞ്ഞാൽ, x ++ എന്നത് x = x + 1 എന്നതിൻ്റെ ചുരുക്കമായും x എന്നത് x = x - 1 ൻ്റെ ഹ്രസ്വമായും കണക്കാക്കാം.

അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ

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

// വയസ്സ് വേരിയബിളിലേക്ക് 27 അസൈൻ ചെയ്യുക
പ്രായം = 27 ആകട്ടെ;

സ്റ്റാൻഡേർഡ് അസൈൻമെൻ്റ് ഓപ്പറേറ്റർ കൂടാതെ, JavaScript-ന് കോമ്പൗണ്ട് അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാരുണ്ട്, അത് = ഓപ്പറേറ്ററുമായി ഗണിത ഓപ്പറേറ്ററെ സംയോജിപ്പിക്കുന്നു.

ഉദാഹരണത്തിന്, ആഡ് ഓപ്പറേറ്റർ യഥാർത്ഥ മൂല്യത്തിൽ നിന്ന് ആരംഭിക്കുകയും അതിലേക്ക് ഒരു പുതിയ മൂല്യം ചേർക്കുകയും ചെയ്യും.

// വയസ്സ് വേരിയബിളിലേക്ക് 27 അസൈൻ ചെയ്യുക
പ്രായം = 27 ആകട്ടെ;
പ്രായം += 3;
console.log(പ്രായം);
30

അടിസ്ഥാനപരമായി, പ്രായം += 3 എന്നത് പ്രായം = വയസ്സ് + 3 എന്നതിന് തുല്യമാണ്.

എല്ലാ ഗണിത ഓപ്പറേറ്റർമാരെയും ഒരു അസൈൻമെൻ്റ് ഓപ്പറേറ്ററുമായി സംയോജിപ്പിക്കാൻ കഴിയും. JavaScript-ലെ അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാരുടെ ഒരു റഫറൻസ് പട്ടിക ചുവടെയുണ്ട്.

കോമ്പൗണ്ട് അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർ പലപ്പോഴും ഇൻക്രിമെൻ്റുകളും ഡിക്രിമെൻ്റുകളും പോലെയുള്ള ലൂപ്പുകളിൽ ഉപയോഗിക്കുന്നു.

ഓപ്പറേറ്റർ മുൻഗണന

സാധാരണ ഗണിതത്തിലെന്നപോലെ മുൻഗണനാക്രമത്തിലാണ് ഓപ്പറേറ്റർമാരെ നിർവ്വഹിക്കുന്നത്.

ഉദാഹരണത്തിന്, ഗുണനത്തിന് സങ്കലനത്തേക്കാൾ ഉയർന്ന മുൻഗണനയുണ്ട്.

// ആദ്യം 3 നെ 5 കൊണ്ട് ഗുണിക്കുക, തുടർന്ന് 10 ചേർക്കുക
10 + 3 * 5;
25

നിങ്ങൾ ആദ്യം ഒരു കൂട്ടിച്ചേർക്കൽ പ്രവർത്തനം നടത്തണമെങ്കിൽ, അത് പരാൻതീസിസിൽ ഇടുക - അത്തരം പ്രവർത്തനങ്ങൾക്ക് എല്ലായ്പ്പോഴും ഉയർന്ന മുൻഗണനയുണ്ട്.

// ആദ്യം 10 ​​ഉം 3 ഉം ചേർക്കുക, തുടർന്ന് 5 കൊണ്ട് ഗുണിക്കുക
(10 + 3) * 5;
65

ജാവാസ്ക്രിപ്റ്റിലെ ഗണിത ഓപ്പറേറ്റർമാരുടെ മുൻഗണനാ പട്ടിക നിങ്ങൾ ചുവടെ കണ്ടെത്തും. ഇൻക്രിമെൻ്റിനും ഡിക്രിമെൻ്റിനും, പോസ്റ്റ്ഫിക്സിന് പ്രിഫിക്സിനേക്കാൾ ഉയർന്ന മുൻഗണനയുണ്ട്.

വർദ്ധനവ്/കുറവ്, ഗുണനം/വിഭജനം, സങ്കലനം/കുറക്കൽ എന്നിവയ്ക്ക് ഒരേ മുൻഗണനാ തലമുണ്ട്.

അരിത്മെറ്റിക് ഓപ്പറേറ്റർമാർക്ക് മാത്രമല്ല, അസൈൻമെൻ്റ് ഓപ്പറേറ്റർമാർക്കും ലോജിക്കൽ ഓപ്പറേറ്റർമാർക്കും സോപാധിക ഓപ്പറേറ്റർമാർക്കും മുൻഗണനയുണ്ട്. നിങ്ങൾക്ക് മുഴുവൻ പട്ടികയും കാണാം.

ടാഗുകൾ: