പ്രോഗ്രാമിന്റെ നിർവ്വഹണത്തെ ബാധിക്കുന്ന ഒരു സോപാധിക നിർമ്മാണം JavaScript-നുണ്ട്. (ഇംഗ്ലീഷിൽ) എന്തെങ്കിലും നിലവിലുണ്ടെങ്കിൽ, എന്തെങ്കിലും ശരിയാണെങ്കിൽ, ഒരു കാര്യം ചെയ്യുക, അല്ലെങ്കിൽ (ഇംഗ്ലീഷിൽ വേറെ) - മറ്റെന്തെങ്കിലും ചെയ്യുക.

പ്രസ്താവന എങ്കിൽ

if സ്റ്റേറ്റ്‌മെന്റ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നമുക്ക് ഉടൻ നോക്കാം; ഇത് ലളിതവും കൂടുതൽ വിശദീകരണം ആവശ്യമില്ല.

എങ്കിൽ (അവസ്ഥ) (വ്യവസ്ഥ ശരിയാണെങ്കിൽ എക്സിക്യൂട്ട് ചെയ്യാനുള്ള കോഡ്)

ഇത് ലളിതമാണ്: വ്യവസ്ഥ ശരിയാണെങ്കിൽ, (...) ബ്ലോക്കിലെ കോഡ് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും.

വർ അക്കം = 4; എങ്കിൽ (അക്കം == 4) (document.write("വേരിയബിൾ അക്കത്തിന്റെ മൂല്യം 4 ആണ്."); )

നിങ്ങൾക്ക് ഒരു ചെറിയ വിചിത്രമായ കോഡ് ഉണ്ടാക്കാം:

വർ അക്കം = 4; (ശരി) ആണെങ്കിൽ (document.write ("അവസ്ഥ ശരിയാണ്."); )

മറ്റൊരു പ്രസ്താവന

if സ്റ്റേറ്റ്മെന്റുമായി ചേർന്ന് else സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കാം. ഇത് "അല്ലെങ്കിൽ" എന്ന് വിവർത്തനം ചെയ്യുകയും ഒരു ഇതര കോഡ് വ്യക്തമാക്കുകയും ചെയ്യുന്നു.

വർ അക്കം = 4; എങ്കിൽ (അക്ക

if, else എന്നീ പ്രസ്താവനകൾക്കായി ഈ ഉദാഹരണത്തിലെ ചുരുണ്ട ബ്രേസുകളുടെ വ്യത്യസ്ത അക്ഷരവിന്യാസം ശ്രദ്ധിക്കുക. ഇത് ഇങ്ങനെ എഴുതേണ്ട ആവശ്യമില്ല; രണ്ട് വാക്യഘടനകളും ശരിയാണ്.

else പ്രസ്താവനയ്ക്ക് ശേഷം ഒരു പുതിയ if സ്റ്റേറ്റ്മെന്റ് ഉണ്ടാകാം. ഇത് ഒന്നിലധികം വ്യവസ്ഥകൾ പരിശോധിക്കും.

വർ അക്കം = 4; എങ്കിൽ (അക്ക

ജാവാസ്ക്രിപ്റ്റിന് PHP പോലെ ഒരു elseif സ്റ്റേറ്റ്മെന്റ് (ഒറ്റവാക്കിൽ) ഇല്ല.

നിങ്ങൾക്ക് ഒരു പ്രസ്താവന മാത്രം നടപ്പിലാക്കണമെങ്കിൽ, ചുരുണ്ട ബ്രേസുകൾ തടയുക (...) ആവശ്യമില്ല. ഞങ്ങളുടെ ഉദാഹരണത്തിൽ, നിങ്ങൾ അവ എഴുതേണ്ടതില്ല:

വർ അക്കം = 4; എങ്കിൽ (അക്ക

JavaScript-ൽ തെറ്റ്

if (condition) പ്രസ്താവന പരാന്തീസിസിലെ അവസ്ഥയെ (എക്സ്പ്രഷൻ) ഒരു ബൂളിയൻ തരത്തിലേക്ക് (ശരിയോ തെറ്റോ) വിലയിരുത്തുകയും പരിവർത്തനം ചെയ്യുകയും ചെയ്യുന്നു.

ജാവാസ്ക്രിപ്റ്റിൽ ഒരു നുണ ഉണ്ടെന്ന് നമുക്ക് ആവർത്തിക്കാം.

• നമ്പർ 0 (പൂജ്യം).
• ശൂന്യമായ വരി "".
• ബൂളിയൻ മൂല്യം തെറ്റാണ് :)
• മൂല്യം ശൂന്യമാണ്.
• മൂല്യം നിർവചിക്കപ്പെട്ടിട്ടില്ല.
• മൂല്യം NaN ആണ് (ഒരു സംഖ്യയല്ല).

ബാക്കിയെല്ലാം സത്യമാണ്.

സാധ്യമായ രണ്ട് പിശകുകൾ:

("false") document.write ("ഇത് ശരിയാണ്.
"); (തെറ്റായ) പ്രമാണം.write("ഇത് ശരിയാണ്.

");

ഇവിടെ നിങ്ങൾ "false" എന്ന സ്ട്രിംഗ് (ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്നു) ബൂളിയൻ മൂല്യം തെറ്റിൽ നിന്ന് വേർതിരിച്ചറിയേണ്ടതുണ്ട്.

എങ്കിൽ (" ") document.write("ഇത് ശരിയാണ്.
"); else document.write("ഇത് തെറ്റാണ്.
");

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

JavaScript-ലെ മറ്റ് നിബന്ധനകൾ

• JavaScript സ്വിച്ച് നിർമ്മാണം.
• ഓപ്പറേറ്റർ ചോദ്യചിഹ്നം

ഈ ലേഖനത്തിൽ നമ്മൾ ജാവാസ്ക്രിപ്റ്റ് ഭാഷയുടെ സോപാധികവും ലോജിക്കൽ ഓപ്പറേറ്റർമാരെയും നോക്കും.

ജാവാസ്ക്രിപ്റ്റ് സോപാധിക പ്രസ്താവനകൾ

സോപാധിക ഓപ്പറേറ്റർമാർ JavaScript (ECMAScript) ഓപ്പറേറ്റർമാരാണ്, അത് ചില വ്യവസ്ഥകളെ ആശ്രയിച്ച്, ഒന്നോ അതിലധികമോ നിർദ്ദിഷ്ട നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കാൻ അനുവദിക്കുന്നു.

ജാവാസ്ക്രിപ്റ്റിലെ സോപാധിക പ്രസ്താവനകളുടെ രൂപങ്ങൾ:

• സോപാധിക എങ്കിൽ പ്രസ്താവന (ഒരു ശാഖയിൽ);
• സോപാധിക പ്രസ്‌താവന... അല്ലെങ്കിൽ (രണ്ട് ശാഖകളോടെ);
• സോപാധിക പ്രസ്താവന മറ്റെന്തെങ്കിലും... (നിരവധി ശാഖകളോടെ);
• ടെർനറി ഓപ്പറേറ്റർ (?: );
• തിരഞ്ഞെടുക്കൽ പ്രസ്താവന മാറ്റുക.

സോപാധിക എങ്കിൽ പ്രസ്താവന

if പ്രസ്താവനയുടെ വാക്യഘടന ഇതാണ്:

എങ്കിൽ (അവസ്ഥ) പ്രസ്താവന

സോപാധിക if പ്രസ്താവനയിൽ ഇവ ഉൾപ്പെടുന്നു:

• എങ്കിൽ കീവേഡ്;
• നിബന്ധനകൾ (പരാന്തീസിസിലെ പദപ്രയോഗങ്ങൾ) ശരിയോ തെറ്റോ (അല്ലെങ്കിൽ ഈ മൂല്യങ്ങളിൽ ഒന്നിലേക്ക് കാസ്റ്റ് ചെയ്യണം);
• വ്യവസ്ഥ ശരിയാണെങ്കിൽ അല്ലെങ്കിൽ ശരിയാണെന്ന് വിലയിരുത്തുകയാണെങ്കിൽ നടപ്പിലാക്കേണ്ട നിർദ്ദേശങ്ങൾ.

ഉദാഹരണത്തിന്:

എങ്കിൽ (ശരി) എണ്ണം = 4;

ഈ ഉദാഹരണം ശരിയാണ് വ്യവസ്ഥയായി ഉപയോഗിക്കുന്നത്. ഇതിനർത്ഥം നിർദ്ദേശങ്ങളുടെ എണ്ണം = 4 എല്ലായ്പ്പോഴും എക്സിക്യൂട്ട് ചെയ്യപ്പെടും എന്നാണ്. if സ്റ്റേറ്റ്മെന്റ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് വിശദീകരിക്കാൻ ഈ ഉദാഹരണം നൽകിയിരിക്കുന്നു, കാരണം അതിന് യാതൊരു അർത്ഥവുമില്ല.

ഉദാഹരണത്തിന്, അത് (അതിന്റെ തരം) ഒരു സംഖ്യയാണെങ്കിൽ, വോട്ട് വേരിയബിളിന്റെ മൂല്യം 1 കൊണ്ട് വർദ്ധിപ്പിക്കാം:

എങ്കിൽ (തരം വോട്ടുകൾ === "നമ്പർ") വോട്ടുകൾ++;

ഒന്നിലധികം നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കണമെങ്കിൽ, അവ ചുരുണ്ട ബ്രേസുകളിൽ സ്ഥാപിക്കണം:

എങ്കിൽ (വോട്ടുകളുടെ തരം === "നമ്പർ") (വോട്ടുകൾ++; console.log("വോട്ടുകളുടെ എണ്ണം: " + വോട്ടുകൾ); )

എങ്കിൽ (തരം വോട്ടുകൾ === "നമ്പർ") (വോട്ടുകൾ++; )

എങ്കിൽ...മറ്റൊരു പ്രസ്താവന

ഒരു വ്യവസ്ഥ ശരിയാണെങ്കിൽ ചില നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കേണ്ടിവരുമ്പോൾ if...else പ്രസ്താവന ഉപയോഗിക്കുന്നു, മറ്റുള്ളവ തെറ്റാണെങ്കിൽ.

വാക്യഘടന:

(അവസ്ഥ) (ഒന്നോ അതിലധികമോ പ്രസ്താവനകൾ (കണ്ടീഷൻ ശരിയാകുമ്പോൾ അല്ലെങ്കിൽ ശരിയായി കുറയ്ക്കുമ്പോൾ) ) അല്ലെങ്കിൽ (ഒന്നോ അതിലധികമോ പ്രസ്താവനകൾ (കണ്ടീഷൻ തെറ്റാകുമ്പോൾ അല്ലെങ്കിൽ തെറ്റ് ആയി കുറയുമ്പോൾ നടപ്പിലാക്കും) )

ഉദാഹരണത്തിന്, നമ്പർ തുല്യമാണോ അല്ലയോ എന്നതിനെക്കുറിച്ചുള്ള ഒരു സന്ദേശം കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യാം:

എങ്കിൽ (നമ്പർ% 2) (console.log("സംഖ്യ വിചിത്രമാണ്!"); ) മറ്റുള്ളവ (console.log("സംഖ്യ ഇരട്ടയാണ്!"); )

ഒരു അവസ്ഥ ശരിയോ തെറ്റോ കൊണ്ടുവരുന്നതിനുള്ള നിയമം

if സ്റ്റേറ്റ്‌മെന്റിന്റെ അവസ്ഥയിലുള്ള പദപ്രയോഗം ശരിയോ തെറ്റോ അല്ലെങ്കിൽ, JavaScript അതിനെ ആ മൂല്യങ്ങളിലൊന്നിലേക്ക് കാസ്‌റ്റ് ചെയ്യും. "നുണകളുടെ ഭരണം" എന്ന് വിളിക്കപ്പെടുന്നവ ഉപയോഗിച്ചാണ് അദ്ദേഹം ഈ പ്രവർത്തനം നടത്തുന്നത്.

ഈ നിയമത്തിന്റെ അർത്ഥം: ഇനിപ്പറയുന്ന മൂല്യങ്ങൾ ഒഴികെ ഏത് പദപ്രയോഗവും ശരിയാണ്:

• തെറ്റായ (തെറ്റായ);
• "" അല്ലെങ്കിൽ "" (ശൂന്യമായ സ്ട്രിംഗ്);
• NaN (പ്രത്യേക സംഖ്യാ ഡാറ്റ തരം "ഒരു സംഖ്യയല്ല");
• 0 (സംഖ്യ "പൂജ്യം");
• null ("ശൂന്യമായ" മൂല്യം);
• നിർവചിക്കാത്ത ("നിർവചിക്കാത്ത" മൂല്യം).

ഉദാഹരണത്തിന്, നെയിം യൂസർ വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന മൂല്യത്തെ ആശ്രയിച്ച്, ബ്രൗസർ കൺസോളിൽ ഒരു സ്വാഗത സന്ദേശം പ്രദർശിപ്പിക്കാം:

എങ്കിൽ (nameUser) ( console.log("ഹലോ, " + പേര് + "!"); ) വേറെ (console.log("ഹലോ, അതിഥി!"); )

നെയിം യൂസർ വേരിയബിളിൽ ഒരു ശൂന്യമായ സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, നുണ നിയമം അനുസരിച്ച്, അത് തെറ്റായ മൂല്യത്തിലേക്ക് കാസ്‌റ്റ് ചെയ്യും. തൽഫലമായി, “ഹലോ, അതിഥി!” എന്ന സന്ദേശം കൺസോളിലേക്ക് പ്രിന്റ് ചെയ്യും. .

ഉദാഹരണത്തിന്, നെയിം യൂസർ വേരിയബിളിൽ "തിമൂർ" ​​എന്ന സ്ട്രിംഗ് അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, കണ്ടീഷനിലെ എക്സ്പ്രഷൻ യഥാർത്ഥ മൂല്യത്തിലേക്ക് ചുരുക്കും. തൽഫലമായി, കൺസോൾ "ഹലോ, തിമൂർ!" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കും. .

അല്ലെങ്കിൽ... പ്രസ്താവന (ഒന്നിലധികം വ്യവസ്ഥകൾ)

വാക്യഘടന:

(condition1) (നിർദ്ദേശങ്ങൾ 1) വേറെയാണെങ്കിൽ (condition2) (നിർദ്ദേശങ്ങൾ 2) വേറെയാണെങ്കിൽ (condition3) (നിർദ്ദേശങ്ങൾ 3 //...) അല്ലെങ്കിൽ (conditionN) (നിർദ്ദേശങ്ങൾ N) മറ്റെന്തെങ്കിലും (ഒന്നല്ലെങ്കിൽ നടപ്പിലാക്കുന്ന നിർദ്ദേശങ്ങൾ വ്യവസ്ഥകൾ ശരിയല്ല അല്ലെങ്കിൽ ഈ മൂല്യത്തിലേക്ക് ചുരുക്കിയിട്ടില്ല)

സോപാധിക (ത്രിമാന) ഓപ്പറേറ്റർ (? :)

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

വാക്യഘടന:

അവസ്ഥ? എക്സ്പ്രഷൻ1: എക്സ്പ്രഷൻ2

ചിഹ്നങ്ങൾ ഉപയോഗിച്ച് വേർതിരിക്കുന്ന മൂന്ന് ഓപ്പറണ്ടുകൾ അടങ്ങുന്നതാണ് ടെർനറി ഓപ്പറേറ്റർ? ഒപ്പം: . ടെർനറി ഓപ്പറേറ്ററുടെ അവസ്ഥ ആദ്യ ഓപ്പറണ്ടിൽ വ്യക്തമാക്കിയിട്ടുണ്ട്. ഇത് പരാൻതീസിസിലും ഉൾപ്പെടുത്താം. കണ്ടീഷൻ ശരിയാണെങ്കിൽ അല്ലെങ്കിൽ ഈ മൂല്യത്തിലേക്ക് കുറയ്ക്കുകയാണെങ്കിൽ, എക്സ്പ്രഷൻ1 എക്സിക്യൂട്ട് ചെയ്യും, അല്ലാത്തപക്ഷം എക്സ്പ്രഷൻ 2 എക്സിക്യൂട്ട് ചെയ്യും.

ഉദാഹരണത്തിന്:

(നമ്പർ > 10) ? console.log("സംഖ്യ 10 നേക്കാൾ വലുതാണ്!") : console.log("സംഖ്യ 10-നേക്കാൾ കുറവോ തുല്യമോ ആണ്");

ഒന്നിലധികം ടെർനറി ഓപ്പറേറ്റർമാരെ JavaScript അനുവദിക്കുന്നു (?:):

Var dayNumber = പുതിയ തീയതി().getDay(); ദിവസം = (dayNumber === 0) ? "ഞായറാഴ്ച": (ദിവസനമ്പർ === 1) ? "തിങ്കളാഴ്‌ച" : (ദിവസനമ്പർ === 2) ? "ചൊവ്വ" : (ദിവസനമ്പർ === 3) ? "ബുധൻ" : (ദിവസനമ്പർ === 4) ? "വ്യാഴം" : (ദിവസനമ്പർ === 5) ? "വെള്ളിയാഴ്ച": (dayNumber === 6) ? "ശനി" : "ആഴ്ചയിലെ അറിയപ്പെടാത്ത ദിവസം"; console.log("ഇന്ന് " + ദിവസം. toLowerCase() + ".");

മുകളിലെ ഉദാഹരണം, എന്നാൽ if...else പ്രസ്താവനയുടെ ഒന്നിലധികം നൊട്ടേഷൻ ഉപയോഗിക്കുന്നു:

Var dayNumber = പുതിയ തീയതി().getDay(); എങ്കിൽ (dayNumber === 0) ( day = "ഞായറാഴ്ച"; ) else if (dayNumber === 1) ( day = "തിങ്കൾ"; ) else if (dayNumber === 2) ( day = "ചൊവ്വ"; ​​) അല്ലെങ്കിൽ (dayNumber === 3) (ദിവസം = "ബുധൻ"; ) else if (dayNumber === 4) ( day = "വ്യാഴം"; ) else if (dayNumber === 5) ( day = "വെള്ളി"; ) else if (dayNumber === 6) (ദിവസം = "ശനി"; ) else (ദിവസം = "ആഴ്ചയിലെ അറിയപ്പെടാത്ത ദിവസം"; ) console.log("ഇന്ന് " + day.toLowerCase() + ".");

സ്വിച്ച് സ്റ്റേറ്റ്മെന്റ്

എക്സ്പ്രഷന്റെ മൂല്യത്തെ ആശ്രയിച്ച് നിരവധി നിർദ്ദേശങ്ങളിൽ ഒന്ന് നടപ്പിലാക്കുന്നതിനാണ് സ്വിച്ച് സ്റ്റേറ്റ്മെന്റ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. ഒന്നോ അല്ലെങ്കിൽ മറ്റൊരു ഓപ്ഷന്റെ തിരഞ്ഞെടുപ്പ് നിർണ്ണയിക്കുന്നത് കേസിന്റെ (കേസ്) മൂല്യത്തിലേക്കുള്ള എക്സ്പ്രഷന്റെ ഫലത്തിന്റെ കർശനമായ തുല്യതയാണ്.

പ്രസ്താവന വാക്യഘടന മാറ്റുക:

സ്വിച്ച് (എക്‌സ്‌പ്രഷൻ) ( കേസ് മൂല്യം1: // ... എക്‌സ്‌പ്രഷൻ വിലയിരുത്തുന്നതിന്റെ ഫലം “മൂല്യം1” ബ്രേക്ക് ആണെങ്കിൽ നടപ്പിലാക്കുന്ന നിർദ്ദേശങ്ങൾ; // ഓപ്‌ഷണൽ നിർദ്ദേശം (ഉപയോഗിച്ചില്ലെങ്കിൽ, സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിന്റെ അടുത്ത കമാൻഡ് എക്‌സിക്യൂട്ട് ചെയ്യും ) case value2: // ... എക്‌സ്‌പ്രഷൻ മൂല്യനിർണ്ണയത്തിന്റെ ഫലം “മൂല്യം2” ബ്രേക്ക് ആണെങ്കിൽ നടപ്പിലാക്കുന്ന നിർദ്ദേശങ്ങൾ; // ഓപ്‌ഷണൽ നിർദ്ദേശം (ഉപയോഗിച്ചില്ലെങ്കിൽ, സ്വിച്ച് ഓപ്പറേറ്ററിന്റെ അടുത്ത കമാൻഡ് എക്‌സിക്യൂട്ട് ചെയ്യും) // . .. case valueN: // .. പദപ്രയോഗം വിലയിരുത്തുന്നതിന്റെ ഫലം “valueN” ബ്രേക്ക് ആണെങ്കിൽ നടപ്പിലാക്കുന്ന നിർദ്ദേശങ്ങൾ; // ഓപ്‌ഷണൽ നിർദ്ദേശം (ഉപയോഗിച്ചില്ലെങ്കിൽ, സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിന്റെ അടുത്ത കമാൻഡ് എക്‌സിക്യൂട്ട് ചെയ്യും) ഡിഫോൾട്ട്: // പദപ്രയോഗത്തിന്റെ ഫലം ഒന്നിൽ കൂടുതൽ മൂല്യങ്ങൾക്ക് തുല്യമല്ലെങ്കിൽ നടപ്പിലാക്കുന്ന നിർദ്ദേശങ്ങൾ)

ഡിഫോൾട്ട് കീവേഡ് ഓപ്ഷണലാണ്. ഒരു പദപ്രയോഗത്തിന്റെ ഫലം കേസിന്റെ (കേസ്) ഏതെങ്കിലും മൂല്യത്തിന് തുല്യമല്ലെങ്കിൽ, നിങ്ങൾ നടപ്പിലാക്കേണ്ട നിർദ്ദേശങ്ങൾ വ്യക്തമാക്കേണ്ടിവരുമ്പോൾ ഇത് ഉപയോഗിക്കുന്നു.

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

ഉദാഹരണത്തിന്, മിഠായികളുടെ എണ്ണത്തെക്കുറിച്ചുള്ള ഒരു സന്ദേശം ബ്രൗസർ കൺസോളിൽ പ്രദർശിപ്പിക്കാം:

Var countCandyBoys = 1, countCandyGirls = 2, സന്ദേശം; മാറുക (countCandyBoys + countCandyGirls) (കേസ് 1: സന്ദേശം = "ഒരു മിഠായി"; ബ്രേക്ക്; കേസ് 2: കേസ് 3: സന്ദേശം = "രണ്ടോ മൂന്നോ മിഠായികൾ"; ബ്രേക്ക്; കേസ് 4: സന്ദേശം = "നാല് മിഠായികൾ"; ബ്രേക്ക്; ഡിഫോൾട്ട്: സന്ദേശം = "ഒന്നല്ല, രണ്ടല്ല, മൂന്നോ നാലോ മിഠായികളല്ല"; ) // കൺസോളിലേക്ക് ഒരു സന്ദേശം അച്ചടിക്കുക.log(message);

മുകളിലെ ഉദാഹരണത്തിൽ, മൂല്യനിർണ്ണയ പദപ്രയോഗം 3 ആണ്. അതിനാൽ, സന്ദേശം = "രണ്ടോ മൂന്നോ മിഠായികൾ", ബ്രേക്ക് നിർദ്ദേശങ്ങൾ എന്നിവ നടപ്പിലാക്കും. ബ്രേക്ക് നിർദ്ദേശം സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിന്റെ കൂടുതൽ നിർവ്വഹണത്തെ തടസ്സപ്പെടുത്തുകയും അതിന് ശേഷം വരുന്ന നിർദ്ദേശത്തിലേക്ക് നിയന്ത്രണം കൈമാറുകയും ചെയ്യും, അതായത്. console.log(സന്ദേശം) . ഇത് കൺസോളിൽ "രണ്ടോ മൂന്നോ മിഠായികൾ" എന്ന സന്ദേശം പ്രദർശിപ്പിക്കും.

ഉദാഹരണത്തിന്, കൺസോളിൽ ആഴ്ചയിലെ നിലവിലെ ദിവസം പ്രദർശിപ്പിക്കാം:

വാർ ദിവസം = ""; സ്വിച്ച്(പുതിയ തീയതി().getDay()) (കേസ് 0: ദിവസം = "ഞായർ"; ഇടവേള; കേസ് 1: ദിവസം = "തിങ്കൾ"; ഇടവേള; കേസ് 2: ദിവസം = "ചൊവ്വ"; ​​ഇടവേള; കേസ് 3: ദിവസം = "ബുധൻ"; ഇടവേള; കേസ് 4: ദിവസം = "വ്യാഴം"; ഇടവേള; കേസ് 5: ദിവസം = "വെള്ളിയാഴ്ച"; ഇടവേള; കേസ് 6: ദിവസം = "ശനി"; ഇടവേള; ഡിഫോൾട്ട്: ദിവസം = "ആഴ്ചയിലെ അജ്ഞാത ദിവസം" ; ) console.log("ഇന്ന് " + ദിവസം. toLowerCase() + ".");

ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കാത്ത ഒരു ഉദാഹരണം:

Var ഫലം = "വിജയം"; സ്വിച്ച് (ഫലം) (കേസ് "വിജയം": console.log("വിജയം!"); കേസ് "invalidCaptcha": console.log("അസാധുവായ ക്യാപ്‌ച!"); സ്ഥിരസ്ഥിതി: console.log("പിശക്!"); )

ഈ ഉദാഹരണത്തിൽ, സ്വിച്ച് സ്റ്റേറ്റ്മെന്റ് എക്സ്പ്രഷൻ വിജയമാണ്. അതിനാൽ, console.log("വിജയം!") എന്ന പ്രസ്താവന നടപ്പിലാക്കും, അത് "വിജയം!" എന്ന സന്ദേശം അച്ചടിക്കും. കൺസോളിലേക്ക്. എന്നാൽ അതിനു ശേഷം ബ്രേക്ക് സ്റ്റേറ്റ്മെന്റ് ഇല്ലാത്തതിനാൽ, സ്ക്രിപ്റ്റിന്റെ എക്സിക്യൂഷൻ അടുത്ത പതിപ്പിൽ തുടരും. അങ്ങനെ, പാതയിൽ ഒരു ഇടവേള ഉണ്ടാകുന്നതുവരെ അല്ലെങ്കിൽ സ്വിച്ച് സ്റ്റേറ്റ്‌മെന്റിന്റെ അവസാനം എത്തുന്നതുവരെ നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കും. ഈ ഉദാഹരണം പ്രവർത്തിപ്പിക്കുന്നതിന്റെ ഫലമായി, കൺസോളിലേക്ക് 3 സന്ദേശങ്ങൾ ഔട്ട്പുട്ട് ചെയ്യും: "വിജയം!" , "അസാധുവായ കാപ്ച!" കൂടാതെ "പിശക്!" .

ചില സന്ദർഭങ്ങളിൽ ഈ സ്വഭാവം ആവശ്യമായി വന്നേക്കാം, എന്നാൽ ഈ സാഹചര്യത്തിൽ അല്ല. ഇവിടെ കേവലം ഒരു തെറ്റ് സംഭവിച്ചു.

തിരുത്തിയ ഉദാഹരണം:

Var ഫലം = "വിജയം"; സ്വിച്ച് (ഫലം) (കേസ് "വിജയം": console.log("വിജയം!"); ബ്രേക്ക്; കേസ് "അസാധുവായ ക്യാപ്‌ച": console.log("അസാധുവായ ക്യാപ്‌ച!"); ബ്രേക്ക്; ഡിഫോൾട്ട്: console.log("പിശക്!" );)

ലോജിക്കൽ ഓപ്പറേറ്റർമാർ

ജാവാസ്ക്രിപ്റ്റ് ഇനിപ്പറയുന്ന ലോജിക്കൽ ഓപ്പറേറ്റർമാരെ വേർതിരിക്കുന്നു:

• && - ലോജിക്കൽ "AND";
• || - ലോജിക്കൽ "OR";
• ! -ലോജിക്കൽ "അല്ല".

Boolean പദപ്രയോഗം operand1 && operand2 ബൂളിയൻ മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നുവെങ്കിൽ, ഓരോന്നും ശരിയാണെങ്കിൽ പദപ്രയോഗം true ആയി വിലയിരുത്തുന്നു ; അല്ലെങ്കിൽ ഈ പദപ്രയോഗത്തിന്റെ മൂല്യം തെറ്റായിരിക്കും.

തെറ്റ് && തെറ്റ് // തെറ്റ് ശരി && തെറ്റ് // തെറ്റ് തെറ്റ് && ശരി // തെറ്റ് ശരി && ശരി // ശരി

Boolean പദപ്രയോഗം operand1 && operand2 ബൂളിയൻ ഇതര മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നുവെങ്കിൽ, അത് തെറ്റായി കാസ്‌റ്റ് ചെയ്യാൻ കഴിയുമെങ്കിൽ അതിന്റെ ഫലം operand1 ആയിരിക്കും. അല്ലെങ്കിൽ ഈ പദപ്രയോഗത്തിന്റെ ഫലം operand2 ആയിരിക്കും.

5 && 0 // 0 1 && 5 // 5 "ലൈൻ" && നിർവചിക്കാത്തത് // നിർവചിക്കാത്ത "ലൈൻ1" && "ലൈൻ2" // "ലൈൻ2"

ഒരു ലോജിക്കൽ എക്സ്പ്രഷനിൽ ആണെങ്കിൽ operand1 || operand2 ബൂളിയൻ മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു, അവയിലൊന്നെങ്കിലും ശരിയാണെങ്കിൽ ഈ പദപ്രയോഗത്തിന്റെ ഫലം ശരിയാകും; അല്ലെങ്കിൽ ഈ പദപ്രയോഗത്തിന്റെ മൂല്യം തെറ്റായിരിക്കും.

തെറ്റ് || തെറ്റ് // തെറ്റ് സത്യം || തെറ്റ് // സത്യം തെറ്റ് || സത്യം // സത്യം സത്യം || സത്യം // സത്യം

ഒരു ലോജിക്കൽ എക്സ്പ്രഷനിൽ ആണെങ്കിൽ operand1 || operand2 ബൂളിയൻ ഇതര മൂല്യങ്ങൾ ഉപയോഗിക്കുന്നു, ഈ പദപ്രയോഗത്തിന്റെ ഫലം operand1 ആയിരിക്കും, അത് true ആയി കാസ്‌റ്റ് ചെയ്യാൻ കഴിയുമെങ്കിൽ; അല്ലെങ്കിൽ ഈ പദപ്രയോഗത്തിന്റെ ഫലം operand2 ആയിരിക്കും.

5 || 0 // 5 1 || 5 // 1 "ലൈൻ" || undefined // "string" "string1" || "ലൈൻ2" // "ലൈൻ1"

operand1 തെറ്റാണെങ്കിൽ അല്ലെങ്കിൽ ആ മൂല്യത്തിലേക്ക് കാസ്‌റ്റ് ചെയ്യാൻ കഴിയുമെങ്കിൽ Boolean പദപ്രയോഗം!operand1 true ആയി വിലയിരുത്തും; അല്ലെങ്കിൽ ഈ പദപ്രയോഗത്തിന്റെ ഫലം തെറ്റായിരിക്കും.

തെറ്റ് // സത്യം !സത്യം // തെറ്റ് !"സ്ട്രിംഗ്" // തെറ്റ്

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

ലോജിക്കൽ ഓപ്പറേറ്റർമാർ

വ്യവസ്ഥകൾ പരിശോധിക്കുമ്പോൾ ലോജിക്കൽ ഓപ്പറേറ്റർമാരെ ഉപയോഗിക്കുന്നു, അതിനാൽ സ്വയം ആവർത്തിക്കാതിരിക്കാൻ, ഞാൻ ഒരു ചുരുക്കെഴുതും: ഇടത് ഓപ്പറാൻറ് എൽ.ഒ., വലത് ഓപ്പറാൻറ് പി.ഒ.

• && - ലോജിക്കൽ "AND"
• || - "അഥവാ"
• ! - "അല്ല"
• > - എൽ.ഒ. കൂടുതൽ പി.ഒ.
• >= - എൽ.ഒ. P.O-നേക്കാൾ വലുതോ തുല്യമോ
• < - Л.О. меньше П.О.
• = 5 && a= 5 || b== 100 ) //true msg2 = "TRUE" ; else msg2 = "FALSE" ; പോപ്പ്അപ്പ് (msg2, 5 , ശീർഷകം, vbInformation) ; //സോപാധിക പ്രസ്താവന js if else if (! a) //false msg3 = "TRUE" ; else msg3 = "FALSE" ; പോപ്പ്അപ്പ് (msg3, 5 , ശീർഷകം, vbInformation) ; if (a&= 100 ) //false msg4 = "TRUE" ; else msg4 = "FALSE" ; പോപ്പ്അപ്പ് (msg4, 5 , ശീർഷകം, vbInformation) ; )

  മുമ്പത്തെ സ്ക്രിപ്റ്റിലെന്നപോലെ, ഇവിടെയും ഞാൻ പ്രോഗ്രാം കോഡ് ചെറുതാക്കാൻ വിത്ത് കൺസ്ട്രക്റ്റ് ഉപയോഗിച്ചു. എന്നിരുന്നാലും, വിവരങ്ങൾ പ്രദർശിപ്പിക്കുന്നതിന് ഞങ്ങൾ പോപ്പ്അപ്പ് ഫംഗ്ഷൻ ഉപയോഗിച്ചു (ലേഖനം "" കാണുക). തൽഫലമായി, കുറച്ച് നിമിഷങ്ങൾക്ക് ശേഷം ഡയലോഗ് ബോക്സുകൾ സ്വയം അടയ്ക്കും. ഈ ഉദാഹരണത്തിൽ ഞങ്ങൾ സോപാധികമായ js if സ്റ്റേറ്റ്മെന്റിൽ ചുരുണ്ട ബ്രേസുകൾ ഉപയോഗിച്ചിട്ടില്ല എന്നത് ശ്രദ്ധിക്കുക; നിങ്ങൾക്ക് ഒരു വരി കോഡല്ല, നിരവധി കോഡ് എക്സിക്യൂട്ട് ചെയ്യേണ്ടി വരുമ്പോൾ മാത്രമേ അവ പ്രസക്തമാകൂ.

  

  അവസാനമായി, ഒരു ക്വാഡ്രാറ്റിക് സമവാക്യം പരിഹരിക്കുന്നത് പോലെയുള്ള ഒരു പ്രായോഗിക ഉദാഹരണം നോക്കാം:

  // ഒരു ക്വാഡ്രാറ്റിക് സമവാക്യം പരിഹരിക്കുന്നു // uravnenije_if_else.js // ************************************* ************* ******************************** var a, b, c, d, x, x1, x2; //ഡിക്ലേർ വേരിയബിളുകൾ a=- 2 ; b= 6 ; c= 20 ; //വിവേചനത്തിനായി തിരയുന്നു d= Math .pow (b, 2 ) - 4 * a* c; if (d== 0 ) ( x= b/ (2 * a) ; msg= "സമവാക്യത്തിന് ഒരു പരിഹാരമുണ്ട്, x എന്നത് കൃത്യമായി " + x ) അല്ലെങ്കിൽ (d> 0 ) (x1= (- b+ ഗണിതം) ആണെങ്കിൽ. sqrt (d) ) / (2 * a) ; x2= (- b- Math .sqrt (d) ) / (2 * a) ; msg= "സമവാക്യത്തിന് രണ്ട് പരിഹാരങ്ങളുണ്ട് \n x1 കൃത്യമായി " + x1 + "\ n x2 കൃത്യമായി " + x2; // സോപാധിക പ്രസ്താവന if else js ) else msg= "ഒരു പരിഹാരവുമില്ല" ; ) WScript.Echo (msg) ;

  Reg.ru: ഡൊമെയ്‌നുകളും ഹോസ്റ്റിംഗും

  റഷ്യയിലെ ഏറ്റവും വലിയ രജിസ്ട്രാറും ഹോസ്റ്റിംഗ് ദാതാവും.

  2 ദശലക്ഷത്തിലധികം ഡൊമെയ്ൻ നാമങ്ങൾ സേവനത്തിലുണ്ട്.

  പ്രമോഷൻ, ഡൊമെയ്ൻ മെയിൽ, ബിസിനസ്സ് സൊല്യൂഷനുകൾ.

  ലോകമെമ്പാടുമുള്ള 700 ആയിരത്തിലധികം ഉപഭോക്താക്കൾ ഇതിനകം അവരുടെ തിരഞ്ഞെടുപ്പ് നടത്തി.

  ബൂട്ട്സ്ട്രാപ്പ് ചട്ടക്കൂട്: വേഗത്തിലുള്ള അഡാപ്റ്റീവ് ലേഔട്ട്

  ബൂട്ട്‌സ്‌ട്രാപ്പ് ചട്ടക്കൂടിലെ അഡാപ്റ്റീവ് ലേഔട്ടിന്റെ അടിസ്ഥാനങ്ങളെക്കുറിച്ചുള്ള ഘട്ടം ഘട്ടമായുള്ള വീഡിയോ കോഴ്‌സ്.

  ശക്തവും പ്രായോഗികവുമായ ഉപകരണം ഉപയോഗിച്ച് ലളിതമായും വേഗത്തിലും കാര്യക്ഷമമായും ടൈപ്പ് സെറ്റിംഗ് പഠിക്കുക.

  ഓർഡർ ചെയ്യാനും പണം നേടാനുമുള്ള ലേഔട്ട്.

  *സ്ക്രോളിംഗ് താൽക്കാലികമായി നിർത്താൻ മൗസ് ഓവർ ചെയ്യുക.

  തിരികെ മുന്നോട്ട്

  JavaScript-ലെ പ്രവർത്തനങ്ങളും if-else വ്യവസ്ഥകളും

  പലപ്പോഴും JavaScript ഉപയോഗിക്കുമ്പോൾ, വ്യത്യസ്ത വ്യവസ്ഥകൾ പാലിക്കുമ്പോൾ നിങ്ങൾ വ്യത്യസ്ത പ്രവർത്തനങ്ങൾ ചെയ്യേണ്ടതുണ്ട്.

  ഉദാഹരണത്തിന്, നിങ്ങളുടെ സൈറ്റ് സന്ദർശിക്കുമ്പോൾ ഒരു സന്ദർശകൻ ഉപയോഗിക്കുന്ന ബ്രൗസർ പരിശോധിക്കുന്ന ഒരു സ്ക്രിപ്റ്റ് നിങ്ങൾ എഴുതി. ഇത് Internet Explorer ആണെങ്കിൽ, IE-യ്‌ക്കായി പ്രത്യേകം രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്ന ഒരു പേജ് ലോഡ് ചെയ്യണം; മറ്റേതെങ്കിലും ബ്രൗസറാണെങ്കിൽ, ഈ പേജിന്റെ മറ്റൊരു പതിപ്പ് ലോഡ് ചെയ്യണം.

  if-else നിർമ്മിതിയുടെ പൊതുവായ വാക്യഘടന ഇപ്രകാരമാണ്:

  എങ്കിൽ (അവസ്ഥ) (പ്രവർത്തനം) മറ്റെന്തെങ്കിലും (പ്രവർത്തനം2);

  ഒരു ഉദാഹരണമായി, ഇനിപ്പറയുന്ന കോഡ് പരിഗണിക്കുക:

  എങ്കിൽ (ബ്രൗസർ=="MSIE") (അലേർട്ട്("നിങ്ങൾ IE ഉപയോഗിക്കുന്നു") ) അല്ലെങ്കിൽ ("നിങ്ങൾ IE ഉപയോഗിക്കുന്നില്ല") );

  എല്ലാ ചെറിയ അക്ഷരങ്ങളും ഉപയോഗിച്ചിട്ടുണ്ടെന്ന കാര്യം ശ്രദ്ധിക്കുക. നിങ്ങൾ "IF" എന്ന് എഴുതുകയാണെങ്കിൽ, ഒരു പിശക് സംഭവിക്കും.

  താരതമ്യത്തിനായി ഇരട്ട തുല്യ ചിഹ്നം (==) ഉപയോഗിക്കുന്നു എന്നതും ശ്രദ്ധിക്കുക.

  നമ്മൾ എഴുതിയാൽ ബ്രൗസർ="MSIE", അപ്പോൾ ഞങ്ങൾ കേവലം മൂല്യം നിയോഗിക്കും എം.എസ്.ഐ.ഇഎന്ന വേരിയബിൾ ബ്രൗസർ.

  നമ്മൾ എഴുതുമ്പോൾ ബ്രൗസർ=="MSIE", അപ്പോൾ JavaScript "മനസ്സിലാക്കുന്നു" നമ്മൾ ഒരു താരതമ്യം നടത്തണമെന്നും മൂല്യം നൽകേണ്ടതില്ലെന്നും.

  കൂടുതൽ ബുദ്ധിമുട്ടുള്ള സാഹചര്യങ്ങൾ എങ്കിൽഅവയെ ചേർത്തുകൊണ്ട് നിങ്ങൾക്ക് സൃഷ്ടിക്കാൻ കഴിയും, ഉദാഹരണത്തിന്, ഒരു ഭാഗത്തേക്ക് വേറെഇതിനകം നിലവിലുള്ള ഘടന എങ്കിൽ-ഇല്ലെങ്കിൽ:

  എങ്കിൽ (അവസ്ഥ) (പ്രവർത്തനം1) വേറെ (മറ്റ് വ്യവസ്ഥ) (പ്രവർത്തനം2) വേറെ (പ്രവർത്തനം3); );

  ഉദാഹരണത്തിന്:

  (browser=="MSIE") (അലേർട്ട്("നിങ്ങൾ IE ഉപയോഗിക്കുന്നു") ) വേറെയാണെങ്കിൽ ( (ബ്രൗസർ=="നെറ്റ്‌സ്‌കേപ്പ്") (അലേർട്ട്("നിങ്ങൾ ഫയർഫോക്സ് ഉപയോഗിക്കുന്നു") ) മറ്റെന്തെങ്കിലും (അലേർട്ട്("നിങ്ങൾ ഉപയോഗിക്കുന്നു). ഒരു തിരിച്ചറിയപ്പെടാത്ത ബ്രൗസർ: )")); );

  ലോജിക്കൽ ഓപ്പറേറ്റർമാർ AND, OR, NOT

  ഡിസൈനിന്റെ കൂടുതൽ വഴക്കമുള്ള ഉപയോഗത്തിന് എങ്കിൽ-ഇല്ലെങ്കിൽനിങ്ങൾക്ക് ലോജിക്കൽ ഓപ്പറേറ്റർമാർ എന്ന് വിളിക്കപ്പെടുന്നവ ഉപയോഗിക്കാം.

  കൂടാതെ && എന്ന് എഴുതുകയും ഒന്നിലധികം വ്യവസ്ഥകൾ സത്യത്തിനായി പരിശോധിക്കേണ്ടിവരുമ്പോൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നു.

  ഉദാഹരണത്തിന്: റഫ്രിജറേറ്ററിൽ മുട്ടകൾ ഉണ്ടെങ്കിൽ, റഫ്രിജറേറ്ററിൽ ബേക്കൺ ഉണ്ടെങ്കിൽ, നമുക്ക് മുട്ടയും ബേക്കണും കഴിക്കാം.

  വാക്യഘടന ഇപ്രകാരമാണ്:

  എങ്കിൽ (condition1 && condition2) ( പ്രവർത്തനം ) എങ്കിൽ (മണിക്കൂർ==12 && മിനിറ്റ്==0) (അലേർട്ട്("ഉച്ച!") );

  അല്ലെങ്കിൽ || എന്നാണ് എഴുതിയിരിക്കുന്നത് രണ്ടോ അതിലധികമോ വ്യവസ്ഥകളിൽ ഒന്നിന്റെയെങ്കിലും സത്യാവസ്ഥ പരിശോധിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുമ്പോൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നു. (ഷിഫ്റ്റ് കീയും \ കീയും അമർത്തിപ്പിടിച്ച് നിങ്ങൾക്ക് || ലഭിക്കും)

  ഉദാഹരണത്തിന്: റഫ്രിജറേറ്ററിൽ പാൽ ഉണ്ടെങ്കിൽ, അല്ലെങ്കിൽ റഫ്രിജറേറ്ററിൽ വെള്ളമുണ്ടെങ്കിൽ, നമുക്ക് കുടിക്കാൻ എന്തെങ്കിലും ഉണ്ട്.

  വാക്യഘടന ഇപ്രകാരമാണ്:

  എങ്കിൽ (condition1 || വ്യവസ്ഥ2) ( പ്രവർത്തനം ) എങ്കിൽ (മണിക്കൂർ==11 || മണിക്കൂർ==10) (അലേർട്ട്("ഇത് ഇതുവരെ ഉച്ചയായിട്ടില്ല!") );

  എന്ന് എഴുതിയിട്ടില്ല! കൂടാതെ നിഷേധത്തിനായി ഉപയോഗിക്കുന്നു.

  ഉദാഹരണത്തിന്: റഫ്രിജറേറ്ററിൽ മുട്ടയോ ബേക്കണോ ഇല്ലെങ്കിൽ, നമുക്ക് മുട്ടയോ ബേക്കണോ കഴിക്കാൻ കഴിയില്ല.

  വാക്യഘടന ഇതാണ്:

  എങ്കിൽ (!(അവസ്ഥ)) ( പ്രവർത്തനം ) എങ്കിൽ (!(മണിക്കൂർ==11)) (അലേർട്ട് ("ഇത് 11 മണി അല്ല") );

  ജാവാസ്ക്രിപ്റ്റിലെ പ്രവർത്തനങ്ങൾ

  പേജിലേക്ക് ജാവാസ്ക്രിപ്റ്റ് ചേർക്കുകയും ബ്രൗസർ കോഡ് വരുമ്പോൾ അത് നടപ്പിലാക്കുകയും ചെയ്യുന്നതിനുപകരം, ഒരു ഇവന്റ് സംഭവിക്കുമ്പോൾ മാത്രമേ നിങ്ങൾക്ക് സ്ക്രിപ്റ്റ് എക്സിക്യൂട്ട് ചെയ്യാൻ കഴിയൂ.

  ഉദാഹരണത്തിന്, നിങ്ങൾ ഒരു പ്രത്യേക ബട്ടണിൽ ക്ലിക്കുചെയ്യുമ്പോൾ പേജിന്റെ പശ്ചാത്തല നിറം മാറ്റുക എന്നതാണ് നിങ്ങൾ JavaScript സൃഷ്ടിച്ചത്. ഈ സാഹചര്യത്തിൽ, ഈ സ്ക്രിപ്റ്റ് അതിന്റെ ഊഴമായതിനാൽ അത് എക്സിക്യൂട്ട് ചെയ്യരുതെന്ന് നിങ്ങൾ ബ്രൗസറിനോട് "പറയേണ്ടതുണ്ട്".

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

  ഈ സാഹചര്യത്തിൽ, ജാവാസ്ക്രിപ്റ്റ് കോഡ് ഒരു പ്രത്യേക രീതിയിൽ ചെയ്യാൻ "ചോദിക്കുന്നത്" വരെ അത് എക്സിക്യൂട്ട് ചെയ്യില്ല.

  ഒരു ഫംഗ്‌ഷനായി എഴുതിയ സ്‌ക്രിപ്റ്റിന്റെ ഈ ഉദാഹരണം നോക്കുക:

  ഫംഗ്ഷൻ myfunction() (അലേർട്ട്("സ്വാഗതം!"); )

  ഈ സ്ക്രിപ്റ്റ് എന്താണ് ചെയ്യുന്നതെന്ന് കാണാൻ ബട്ടൺ ക്ലിക്ക് ചെയ്യുക:

  വരി എങ്കിൽ മുന്നറിയിപ്പ് ("സ്വാഗതം!");ഇത് ഒരു ഫംഗ്ഷനിൽ എഴുതിയിട്ടില്ലെങ്കിൽ, ബ്രൗസർ ആ ലൈനിൽ എത്തുമ്പോഴെല്ലാം അത് എക്സിക്യൂട്ട് ചെയ്യപ്പെടും. എന്നാൽ ഞങ്ങൾ ഇത് ഒരു ഫംഗ്ഷനിൽ എഴുതിയതിനാൽ, ഞങ്ങൾ ബട്ടണിൽ ക്ലിക്കുചെയ്യുന്നത് വരെ ഈ ലൈൻ എക്സിക്യൂട്ട് ചെയ്യപ്പെടുന്നില്ല.

  ഫംഗ്ഷൻ കോൾ (അതായത് അതിലേക്കുള്ള ആക്സസ്) ഈ വരിയിൽ സംഭവിക്കുന്നു:

  നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ഞങ്ങൾ ഫോമിൽ ഒരു ബട്ടൺ സ്ഥാപിച്ച് ഒരു ഇവന്റ് ചേർത്തു onClick="myfunction()"ബട്ടണിനായി.

  ഭാവി പാഠങ്ങളിൽ ഫംഗ്‌ഷനുകൾ ട്രിഗർ ചെയ്യുന്ന മറ്റ് തരത്തിലുള്ള ഇവന്റുകൾ ഞങ്ങൾ നോക്കും.

  ഫംഗ്ഷനുകളുടെ പൊതുവായ വാക്യഘടന ഇപ്രകാരമാണ്:

  ഫംഗ്‌ഷൻ ഫംഗ്‌ഷൻ നാമം(variable1, variable2,..., variableN) (// ഇവിടെ ഫംഗ്‌ഷന്റെ ബോഡി, അത് ചെയ്യുന്ന പ്രവർത്തനങ്ങൾ)

  ചുരുണ്ട ബ്രേസുകൾ: ( ഒപ്പം ) ഒരു ഫംഗ്‌ഷന്റെ തുടക്കവും അവസാനവും സൂചിപ്പിക്കുന്നു.

  ഫംഗ്‌ഷനുകൾ സൃഷ്‌ടിക്കുമ്പോൾ ഉണ്ടാകുന്ന ഒരു സാധാരണ തെറ്റ് ശ്രദ്ധക്കുറവും പ്രതീക കേസിന്റെ പ്രാധാന്യം അവഗണിക്കുന്നതുമാണ്. വാക്കിന്റെ ഫംഗ്ഷൻ കൃത്യമായി ഫംഗ്ഷൻ ആയിരിക്കണം. Function അല്ലെങ്കിൽ FUNCTION ഓപ്ഷൻ ഒരു പിശക് ഉണ്ടാക്കും.

  കൂടാതെ, വേരിയബിൾ പേരുകൾ വ്യക്തമാക്കുമ്പോൾ വലിയ അക്ഷരങ്ങളുടെ ഉപയോഗം ഒരു പങ്ക് വഹിക്കുന്നു. നിങ്ങൾക്ക് പേരുള്ള ഒരു ഫംഗ്ഷൻ ഉണ്ടെങ്കിൽ myfunction(), പിന്നെ അവളെ എന്ന് അഭിസംബോധന ചെയ്യാനുള്ള ഒരു ശ്രമം Myfunction(), MYFUNCTION()അഥവാ MyFunction()ഒരു പിശക് ഉണ്ടാക്കും.

  നിങ്ങൾക്ക് മെറ്റീരിയൽ ഇഷ്ടപ്പെട്ടോ, എന്നോട് നന്ദി പറയണോ?
  നിങ്ങളുടെ സുഹൃത്തുക്കളുമായും സഹപ്രവർത്തകരുമായും പങ്കിടുക!

  
  

  ഇതും കാണുക:

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

  പ്രസ്താവന എങ്കിൽ

  ബ്രാഞ്ച് പ്രസ്താവനകളിൽ ഏറ്റവും ലളിതമാണ് if സ്റ്റേറ്റ്മെന്റ്.

  if പ്രസ്താവനയുടെ വാക്യഘടന ഇതാണ്:

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

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

  ഇനിപ്പറയുന്ന കോഡ് if സ്റ്റേറ്റ്‌മെന്റിന്റെ ഉപയോഗം കാണിക്കുന്നു:

  പ്രസ്‌താവനകൾ മറ്റ് ഇഫ് പ്രസ്‌താവനകൾക്കുള്ളിൽ ഉൾപ്പെടുത്താൻ കഴിയുമെങ്കിൽ:

  അവസാനത്തെ ഉദാഹരണം ശ്രദ്ധിക്കുക: if സ്റ്റേറ്റ്‌മെന്റിന് കീഴിൽ നിർദ്ദേശം കൃത്യമായി എഴുതേണ്ടതില്ല; നിർദ്ദേശം വലുപ്പത്തിൽ വലുതല്ലെങ്കിൽ, അത് ഒരു വരിയിൽ എഴുതാം.

  അല്ലെങ്കിൽ പ്രസ്താവന

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

  if else എന്നതിന്റെ വാക്യഘടന ഇതാണ്:

  

  മറ്റൊരു പ്രസ്താവന ഓപ്ഷണലാണ്. മറ്റ് നിർദ്ദേശങ്ങളുടെ ബ്ലോക്ക് സ്ഥിരസ്ഥിതിയായി നടപ്പിലാക്കുന്നു, അതായത്. if ലെ സോപാധിക പദപ്രയോഗം തെറ്റായി നൽകുമ്പോൾ. if സ്റ്റേറ്റ്‌മെന്റിൽ നിന്ന് വേറെ സ്റ്റേറ്റ്‌മെന്റ് ഉപയോഗിക്കാനാവില്ല. if സ്റ്റേറ്റ്‌മെന്റിന് ശേഷം മാത്രമേ else ബ്ലോക്ക് ദൃശ്യമാകൂ; ഇത് സ്ഥിരസ്ഥിതി പ്രവർത്തനമായി കണക്കാക്കാം.

  ഞങ്ങളുടെ മുൻ ഉദാഹരണം ചെറുതായി പരിഷ്‌ക്കരിച്ചുകൊണ്ട്, കൺഡിഷൻ തെറ്റായി നൽകുകയാണെങ്കിൽ if else സ്റ്റേറ്റ്‌മെന്റ് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് നമുക്ക് കാണാൻ കഴിയും:

  if else എന്ന പ്രസ്താവന നെസ്റ്റ് ചെയ്യാവുന്നതാണ്. അത്തരം നെസ്റ്റഡ് സോപാധിക പ്രസ്താവനകൾ പ്രായോഗികമായി പലപ്പോഴും സംഭവിക്കാറുണ്ട്. ഒരു if സ്റ്റേറ്റ്‌മെന്റ് നെസ്റ്റഡ് ചെയ്യപ്പെടുന്നു, അത് മറ്റൊന്നിനുള്ളിൽ നെസ്റ്റഡ് ആണെങ്കിൽ അല്ലെങ്കിൽ തടയുന്നു. നിങ്ങളുടെ കോഡ് ഒരു വരിയിൽ ഒന്നിലധികം if പ്രസ്‌താവനകൾ ഉപയോഗിക്കുന്നുവെങ്കിൽ, മറ്റേത് എല്ലായ്‌പ്പോഴും ഏറ്റവും അടുത്തുള്ളവയെ സൂചിപ്പിക്കുന്നു:

  അവസാനത്തേത് if($a) ന് ബാധകമല്ല, കാരണം അത് അകത്തെ ബ്ലോക്കിലല്ല, അതിനാൽ അതിനോട് ഏറ്റവും അടുത്തുള്ളത് if($i) ആണ്. ബ്ലോക്കിനുള്ളിലെ else സ്റ്റേറ്റ്‌മെന്റ് if($b) എന്നതുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, കാരണം ഈ if അതിനോട് ഏറ്റവും അടുത്തുള്ളതാണ്.

  നിർമ്മാണം ആണെങ്കിൽ elseif/alse

  if/else സ്റ്റേറ്റ്മെന്റ് ഒരു സോപാധിക എക്സ്പ്രഷന്റെ മൂല്യം വിലയിരുത്തുകയും ഒരു പ്രത്യേക പ്രോഗ്രാം കോഡ് നടപ്പിലാക്കുകയും ചെയ്യുന്നു. എന്നാൽ നിങ്ങൾക്ക് നിരവധി ശകലങ്ങളിൽ ഒന്ന് എക്സിക്യൂട്ട് ചെയ്യണമെങ്കിൽ എന്തുചെയ്യും? നിങ്ങൾക്ക് തുടർച്ചയായി നിരവധി വ്യവസ്ഥകൾ പരിശോധിക്കണമെങ്കിൽ, elseif അല്ലെങ്കിൽ നിർമ്മാണം ഇതിന് അനുയോജ്യമാണെങ്കിൽ (ഇത് ഒരേ നിർമ്മാണമാണ്, വ്യത്യസ്തമായി എഴുതിയിരിക്കുന്നു). ഔപചാരികമായി, ഇത് ഒരു സ്വതന്ത്ര PHP നിർമ്മിതി അല്ല - ഇത് ആവർത്തിച്ചുള്ള if/else പ്രസ്താവനകൾ ഉപയോഗിക്കുന്ന ഒരു സാധാരണ പ്രോഗ്രാമിംഗ് ശൈലി മാത്രമാണ്. ശരി കണ്ടെത്തുന്നത് വരെ അധിക വ്യവസ്ഥകൾ പരീക്ഷിക്കാൻ ഇത് അനുവദിക്കുന്നു അല്ലെങ്കിൽ മറ്റേത് ബ്ലോക്ക് എത്തും. elseif/else if സ്റ്റേറ്റ്‌മെന്റ് if സ്റ്റേറ്റ്‌മെന്റിന് ശേഷവും മറ്റേ സ്റ്റേറ്റ്‌മെന്റിന് മുമ്പും പ്രത്യക്ഷപ്പെടണം, ഒന്ന് ഉണ്ടെങ്കിൽ.

  ഇവിടെ മൂന്ന് നിബന്ധനകൾ പരിശോധിച്ചു, $username വേരിയബിളിന്റെ മൂല്യം അനുസരിച്ച്, വ്യത്യസ്ത പ്രവർത്തനങ്ങൾ നടത്തുന്നു.

  ഈ ഭാഗത്തിന് ശരിക്കും പ്രത്യേകിച്ചൊന്നുമില്ല. ഇത് if സ്റ്റേറ്റ്‌മെന്റുകളുടെ ഒരു ക്രമമാണ്, ഇവിടെ ഓരോ if സ്റ്റേറ്റ്‌മെന്റും മുമ്പത്തെ if സ്റ്റേറ്റ്‌മെന്റിന്റെ else ക്ലോസിന്റെ ഭാഗമാണ്. ആദ്യമായി ഈ രൂപത്തിലുള്ള നൊട്ടേഷൻ അഭിമുഖീകരിക്കുകയും ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ശരിക്കും മനസ്സിലാക്കാതിരിക്കുകയും ചെയ്യുന്നവർക്കായി, ഞങ്ങൾ അതേ ഉദാഹരണം വീണ്ടും എഴുതും, ഘടനകളുടെ നെസ്റ്റിംഗ് പൂർണ്ണമായി കാണിക്കുന്ന തുല്യമായ വാക്യഘടനയിൽ മാത്രം: