റിലേഷണൽ, ലോജിക്കൽ ഓപ്പറേറ്റർമാർ. PHP-യിലെ താരതമ്യ ഓപ്പറേറ്റർമാർ

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

താരതമ്യ ഓപ്പറേറ്റർമാർ

ഉദാഹരണം	പേര്	ഫലമായി
$i == $y	തുല്യമാണ്	ഡാറ്റ തരം പരിവർത്തനത്തിന് ശേഷം $i എന്നത് $y ന് തുല്യമാണെങ്കിൽ ശരിയാണ്.
$i === $y	ഒരേപോലെ	$i എന്നത് $y ന് തുല്യവും അതേ ഡാറ്റ തരവുമാണെങ്കിൽ ശരിയാണ്.
$i != $y	തുല്യമല്ല
$i<>$y	തുല്യമല്ല	ഡാറ്റ തരം പരിവർത്തനത്തിന് ശേഷം $i എന്നത് $y എന്നതിന് തുല്യമല്ലെങ്കിൽ ശരിയാണ്.
$i !== $y	സമാനമല്ല	$i എന്നത് $y എന്നതിന് തുല്യമല്ലെങ്കിലോ അവ വ്യത്യസ്ത തരത്തിലോ ആണെങ്കിൽ ശരിയാണ്.
$i< $y	കുറവ്	$i എന്നത് $y-നേക്കാൾ കുറവാണെങ്കിൽ ശരിയാണ്.
$i > $y	കൂടുതൽ	$i എന്നത് $y നേക്കാൾ കൂടുതലാണെങ്കിൽ ശരിയാണ്.
$i<= $y	കുറവോ തുല്യമോ	$i എന്നത് $y-നേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ ശരി.
$i >= $y	കൂടുതലോ തുല്യമോ	$i എന്നത് $y എന്നതിനേക്കാൾ വലുതോ തുല്യമോ ആണെങ്കിൽ ശരിയാണ്.

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

ഇത് ശ്രദ്ധിക്കേണ്ടതാണ്: അക്കങ്ങൾ ഉൾക്കൊള്ളുന്ന ഒരു സംഖ്യയോ രണ്ട് സ്ട്രിംഗുകളോ ഉള്ള ഒരു സ്ട്രിംഗിനെ താരതമ്യം ചെയ്താൽ, ഓരോ സ്ട്രിംഗും ഒരു സംഖ്യയായി പരിവർത്തനം ചെയ്യപ്പെടും, അവ സംഖ്യകളായി താരതമ്യം ചെയ്യും.

ഓപ്പറേറ്റർ == (സമത്വങ്ങൾ)

== (സമത്വം) ഓപ്പറേറ്റർ ഏത് തരത്തിലുള്ള ഓപ്പറണ്ടുകളും സ്വീകരിക്കുന്നു; രണ്ട് ഓപ്പറണ്ടുകളും തുല്യമാണെങ്കിൽ, അത് ശരിയാണെന്ന് നൽകുന്നു, അല്ലാത്തപക്ഷം അത് തെറ്റായി നൽകുന്നു.

ഓപ്പറണ്ടുകൾ വ്യത്യസ്ത ഡാറ്റ തരങ്ങളാണെങ്കിൽ, അവയെ താരതമ്യം ചെയ്യുന്നതിനുമുമ്പ് PHP അതേ ഡാറ്റ തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കും, ഉദാഹരണത്തിന് "4" == 4 എന്ന പദപ്രയോഗം ശരിയാകും, കാരണം PHP സ്വയമേവ താരതമ്യം ചെയ്യുന്ന മൂല്യങ്ങൾ കാസ്റ്റ് ചെയ്യും. ഒരേ ഡാറ്റ തരം. അതുപോലെ, $a == 1 എന്ന പദപ്രയോഗം, $a എന്ന വേരിയബിളിൽ മൂല്യം 1 അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, true എന്ന് തിരികെ നൽകും. താരതമ്യപ്പെടുത്തുമ്പോൾ നിങ്ങൾക്ക് വ്യക്തമായ തരത്തിലുള്ള പരിവർത്തനം ഒഴിവാക്കണമെങ്കിൽ, നിങ്ങൾ ഐഡൻ്റിറ്റി ഓപ്പറേറ്റർ ഉപയോഗിക്കണം, അത് പിന്നീട് ചർച്ചചെയ്യും.

ഓപ്പറേറ്റർ === (ഐഡൻ്റിറ്റികൾ)

=== (ഐഡൻ്റിറ്റി) ഓപ്പറേറ്റർ ഏത് തരത്തിലുമുള്ള ഓപ്പറണ്ടുകൾ സ്വീകരിക്കുകയും അവയുടെ മൂല്യങ്ങൾ ഒരേ (തുല്യം) ആണെങ്കിൽ ശരിയും വ്യത്യസ്തമാണെങ്കിൽ തെറ്റും നൽകുകയും ചെയ്യുന്നു. സമത്വ ഓപ്പറേറ്ററിൽ നിന്ന് ഇത് എങ്ങനെ വ്യത്യാസപ്പെട്ടിരിക്കുന്നു? ഐഡൻ്റിറ്റി ഓപ്പറേറ്റർ ഒരു പൊരുത്തത്തിൻ്റെ കർശനമായ നിർവചനത്തെ അടിസ്ഥാനമാക്കി "ഐഡൻ്റിറ്റി" എന്നതിനായി രണ്ട് ഓപ്പറണ്ടുകൾ പരിശോധിക്കുന്നു, അതായത് ഓപ്പറണ്ടുകളുടെ മൂല്യങ്ങൾ തുല്യമായിരിക്കുന്നതിന് പുറമേ, അവയും ഒരേ ഡാറ്റ തരത്തിലായിരിക്കണം. ഒരു ഉദാഹരണമായി, 5 === "5" പോലെയുള്ള ഒരു പദപ്രയോഗം പരിഗണിക്കുക, ഈ പദപ്രയോഗത്തിൻ്റെ ഫലം തെറ്റായിരിക്കും, കാരണം ഇടതുവശത്തുള്ള മൂല്യം ഒരു സംഖ്യയും വലതുവശത്തുള്ള മൂല്യം ഒരു സ്ട്രിംഗുമാണ്, അതായത് ഈ മൂല്യങ്ങൾ വ്യത്യസ്ത ഡാറ്റ തരങ്ങൾ ഉണ്ട്. ഓപ്പറേറ്റർമാർ == കൂടാതെ === അർത്ഥമാക്കുന്നത് “തുല്യമായത്”, “സമാനം/സമാനമായത്” എന്നിങ്ങനെയാണ്.

ഓപ്പറേറ്റർ != അല്ലെങ്കിൽ<>(അസമത്വങ്ങൾ)

അസമത്വ ഓപ്പറേറ്റർരണ്ട് തരമുണ്ട്: != ഒപ്പം<>. ഇത് == ഓപ്പറേറ്ററിൻ്റെ വിപരീതമാണ് കൂടാതെ ഓപ്പറണ്ടുകൾ തുല്യമല്ലെങ്കിൽ ശരിയായി നൽകുന്നു. അസമത്വ ഓപ്പറേറ്റർ അതിൻ്റെ ഇരുവശത്തുമുള്ള മൂല്യങ്ങൾ പരസ്പരം തുല്യമാണെങ്കിൽ മാത്രമേ തെറ്റായി നൽകൂ.

$var2); // തെറ്റായ var_dump ("ഹോം" തിരികെ നൽകുക<>"വീട്"); // സത്യമായിരിക്കുമോ ?>

ഓപ്പറേറ്റർ !== (ഐഡൻ്റിറ്റി അല്ലാത്തത്)

!== (നോൺ-ഐഡൻ്റിറ്റി) ഓപ്പറേറ്റർ === ഓപ്പറേറ്ററിന് നേരെ വിപരീതമാണ് പ്രവർത്തിക്കുന്നത്. ഓപ്പറാൻറ് മൂല്യങ്ങൾ പരസ്പരം തുല്യമല്ലെങ്കിലോ ഒരേ ഡാറ്റ തരത്തിലല്ലെങ്കിലോ അത് ശരിയാണെന്ന് നൽകുന്നു. ഒരു ഉദാഹരണമായി, ഇനിപ്പറയുന്ന പദപ്രയോഗം പരിഗണിക്കുക: 7 !== "7" , ഇടതുവശത്തുള്ള മൂല്യം ഒരു സംഖ്യയും വലതുവശത്തുള്ള മൂല്യം ഒരു സ്‌ട്രിംഗും ആയതിനാൽ, "നോൺ-ഐഡൻ്റിറ്റി" ഓപ്പറേറ്റർ സത്യമായി തിരികെ നൽകും, അതായത് അവർ സൂചിപ്പിക്കുന്നത് വത്യസ്ത ഇനങ്ങൾഡാറ്റ. ഇവിടെ നിന്ന്, ഓപ്പറേറ്റർമാർ != ഒപ്പം !== അർത്ഥമാക്കുന്നത് "തുല്യമല്ല" എന്നും "സമാനമല്ല / സമാനമല്ല തുല്യമല്ല" എന്നും ഓർക്കുന്നത് എളുപ്പമായിരിക്കും.

ഓപ്പറേറ്റർ > (കൂടുതൽ)

> (കൂടുതൽ) ഓപ്പറേറ്റർ ഉപയോഗിക്കുമ്പോൾ, ഓപ്പറേറ്ററുടെ ഇടതുവശത്തുള്ള മൂല്യം അതിൻ്റെ വലതുവശത്തുള്ള മൂല്യത്തേക്കാൾ വലുതാണെങ്കിൽ മാത്രമേ താരതമ്യം ശരിയാണെന്ന് നൽകൂ. മറ്റ് ഓപ്പറേറ്റർമാരെപ്പോലെ, > ഓപ്പറേറ്ററും പ്രവർത്തിക്കുന്നത് കൂടെ മാത്രമല്ല സംഖ്യാ മൂല്യങ്ങൾ, മാത്രമല്ല ചരടുകൾക്കൊപ്പം. എന്നാൽ ഒരു വരി മറ്റൊന്നിനേക്കാൾ വലുതാകുന്നത് എങ്ങനെ?

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

3); // യഥാർത്ഥ var_dump ("ഹായ്" > "ഹായ്") തിരികെ നൽകുക; // തെറ്റായ var_dump (1 > 1) തിരികെ നൽകുക; // തെറ്റ് തിരിച്ചു കൊടുക്കുക ?>

ഓപ്പറേറ്റർ< (меньше)

ഓപ്പറേറ്റർ< (меньше ) является функциональной противоположностью оператора «больше». Он возвращает true , когда значение слева от него മൂല്യത്തേക്കാൾ കുറവാണ്, അത് വലതുവശത്താണ്, ഇടത് ഓപ്പറണ്ടിൻ്റെ മൂല്യം വലത്തേതിനേക്കാൾ വലുതാണെങ്കിൽ അല്ലെങ്കിൽ മൂല്യങ്ങൾ തുല്യമാണെങ്കിൽ തെറ്റ്.

ഓപ്പറേറ്റർ >= (അതിനേക്കാൾ വലുതോ തുല്യമോ)

ഓപ്പറേറ്റർ >= ( കൂടുതലോ തുല്യമോ) മുമ്പ് ചർച്ച ചെയ്ത താരതമ്യ ഓപ്പറേറ്റർമാരിൽ നിന്ന് അല്പം വ്യത്യസ്തമാണ്. അതിൻ്റെ ഇരുവശത്തുമുള്ള രണ്ട് മൂല്യങ്ങൾ തുല്യമാകാനുള്ള കഴിവ് ഇത് ചേർക്കുന്നു, അതായത്, ശരി തിരികെ ലഭിക്കുന്നതിന്, ഓപ്പറേറ്ററുടെ ഇടതുവശത്തുള്ള മൂല്യം അതിൻ്റെ വലതുവശത്തുള്ള മൂല്യത്തേക്കാൾ വലുതോ തുല്യമോ ആയിരിക്കണം. ഓപ്പറേറ്ററേക്കാൾ വലുതോ തുല്യമോ ആയത് അതിൻ്റെ ഇടതുവശത്തുള്ള മൂല്യം വലതുവശത്തുള്ള മൂല്യത്തേക്കാൾ കുറവാണെങ്കിൽ മാത്രമേ തെറ്റായി നൽകൂ.

= 5); // true var_dump ("hi" >= "hi") തിരികെ നൽകുക; // യഥാർത്ഥ var_dump (1 >= 2) തിരികെ നൽകുക; //തെറ്റായി തിരികെ നൽകുക ?>

ഓപ്പറേറ്റർ<= (കുറവ് അല്ലെങ്കിൽ തുല്യം)

ഓപ്പറേറ്റർ<= (меньше или равно) похож на оператор «больше или равно». Чтобы оператор <= вернул true , значение слева от оператора должно быть меньше или равно значению справа от него. Он возвращает false , только если значение слева от него больше, чем значение справа.

മുമ്പത്തെ ലേഖനത്തിൽ ഞാൻ ആദ്യമായി ഒരു ലോജിക്കൽ ഓപ്പറേഷൻ ഉപയോഗിച്ചതിനാൽ, അവ എന്താണെന്നും എത്ര എണ്ണം ഉണ്ട്, അവ എങ്ങനെ ഉപയോഗിക്കാമെന്നും ഞാൻ നിങ്ങളോട് പറയും.

C++ ൽ മൂന്ന് ലോജിക്കൽ ഓപ്പറേഷനുകളുണ്ട്:

ലോജിക്കൽ പ്രവർത്തനം AND && ഇതിനകം ഞങ്ങൾക്ക് അറിയാം;
ലോജിക്കൽ അല്ലെങ്കിൽ പ്രവർത്തനം || ;
ലോജിക്കൽ ഓപ്പറേഷൻ അല്ല ! അല്ലെങ്കിൽ ലോജിക്കൽ നിഷേധം.

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

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

// or_and_not.cpp: കൺസോൾ ആപ്ലിക്കേഷൻ്റെ എൻട്രി പോയിൻ്റ് നിർവചിക്കുന്നു. #ഉൾപ്പെടുത്തുക "stdafx.h" #ഉൾപ്പെടുത്തുക നെയിംസ്പേസ് എസ്ടിഡി ഉപയോഗിക്കുന്നു; int main(int argc, char* argv) ( bool a1 = true, a2 = false; // ബൂളിയൻ വേരിയബിളുകളുടെ പ്രഖ്യാപനം bool a3 = true, a4 = false; cout<< "Tablica istinnosti log operacii &&" << endl; cout << "true && false: " << (a1 && a2) << endl // логическое И << "false && true: " << (a2 && a1) << endl << "true && true: " << (a1 && a3) << endl << "false && false: " << (a2 && a4) << endl; cout << "Tablica istinnosti log operacii ||" << endl; cout << "true || false: " << (a1 || a2) << endl // логическое ИЛИ << "false || true: " << (a2 || a1) << endl << "true || true: " << (a1 || a3) << endl << "false || false: " << (a2 || a4) << endl; cout << "Tablica istinnosti log operacii !" << endl; cout << "!true: " << (! a1) << endl // логическое НЕ << "!false: "<< (! a2) << endl; system("pause"); return 0; }

9, 10 വരികൾതരത്തിൻ്റെ വേരിയബിളുകൾ ഇവിടെ ആരംഭിച്ചിരിക്കുന്നതിനാൽ നിങ്ങൾക്ക് വ്യക്തമായിരിക്കണംബൂൾ . മാത്രമല്ല, ഓരോ വേരിയബിളിനും ഒരു മൂല്യം നൽകിയിരിക്കുന്നുശരിയോ തെറ്റോ . തുടങ്ങി 9-ാമത്തെ വരിഅവസാനിക്കുന്നതും 20-ാം തീയതി, ലോജിക്കൽ പ്രവർത്തനങ്ങളുടെ ഉപയോഗം കാണിക്കുന്നു. പ്രോഗ്രാമിൻ്റെ ഫലം (ചിത്രം 1 കാണുക).

Tablica istinnosti log operacii && true && false: 0 false && true: 0 true && true: 1 false && false: 0 Tablica istinnosti log operacii || സത്യം || തെറ്റ്: 1 തെറ്റ് || സത്യം: 1 സത്യം || ശരി: 1 തെറ്റ് || തെറ്റ്: 0 ടാബ്ലിക്ക ഇസ്തിൻനോസ്റ്റി ലോഗ് ഓപ്പറസി ! !true: 0 !false: 1 തുടരാൻ, ഏതെങ്കിലും കീ അമർത്തുക. . .

ചിത്രം 1 - C++ ലോജിക്കൽ പ്രവർത്തനങ്ങൾ

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

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

എങ്കിൽ (അവസ്ഥ)
വ്യവസ്ഥ പാലിച്ചു, ഇത് ചെയ്യുക
}
വേറെ
{
വ്യവസ്ഥ പാലിച്ചിട്ടില്ല, വ്യത്യസ്തമായി ചെയ്യുക
}
സോപാധിക പ്രവർത്തനത്തിൻ്റെ യുക്തി വ്യക്തമാണെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. ഇനി നമുക്ക് ഒരു ഉദാഹരണം നോക്കാം.

$a = 5;
$b = 25;

// ഇനി ശ്രദ്ധിക്കൂ! വ്യവസ്ഥ: $b എന്നത് $a-നേക്കാൾ വലുതാണെങ്കിൽ
// അടയാളങ്ങൾ > ഒപ്പം< , как и в математике, обозначают больше и меньше
എങ്കിൽ ($b > $a)
{
// വ്യവസ്ഥ പാലിക്കുകയാണെങ്കിൽ, ഈ പ്രവർത്തനം നടത്തുക
പ്രതിധ്വനി "$b $a നേക്കാൾ വലുതാണ്";
}
വേറെ
{
// എക്സിക്യൂട്ട് ചെയ്തില്ലെങ്കിൽ, ഇത്
പ്രതിധ്വനി "$a $b-നേക്കാൾ വലുതോ തുല്യമോ ആണ്";
}
?>
പ്രകടനം ഉറവിടങ്ങൾ ഡൗൺലോഡ് ചെയ്യുക
തൽഫലമായി, സ്ക്രിപ്റ്റ് ഔട്ട്പുട്ട് ചെയ്യും 5 നേക്കാൾ 25 കൂടുതൽ. ഉദാഹരണം വളരെ ലളിതമാണ്. എല്ലാം വ്യക്തമാണെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. ഇപ്പോൾ കൂടുതൽ സങ്കീർണ്ണമായ ഒരു സാഹചര്യം പരിഗണിക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു, അവിടെ നിരവധി വ്യവസ്ഥകൾ പാലിക്കേണ്ടതുണ്ട്. ഓരോ പുതിയ വ്യവസ്ഥയും പ്രധാന വ്യവസ്ഥയ്ക്ക് ശേഷം അടങ്ങിയിരിക്കും എങ്കിൽ ()- ഓക്സിലറി, എന്ന് എഴുതിയിരിക്കുന്നു ഇല്ലെങ്കിൽ (). അവസാനം അത് പതിവുപോലെ ആയിരിക്കും വേറെ.

ചുമതല:സ്‌കൂളിലാണ് പരിശോധന നടത്തുന്നത്. ഓരോ ഗ്രേഡും നേടുന്നതിനുള്ള വ്യവസ്ഥകളും വിദ്യാർത്ഥിയുടെ സ്‌കോറും അറിഞ്ഞുകൊണ്ട് സ്‌ക്രിപ്റ്റ് സ്‌കോർ കണക്കാക്കേണ്ടതുണ്ട്. ഇത് എങ്ങനെ എഴുതാമെന്ന് നോക്കാം, കമൻ്ററി വായിക്കാൻ മറക്കരുത്.

$ ടെസ്റ്റ് = 82; // ഒരു വിദ്യാർത്ഥി 82 പോയിൻ്റുമായി ഒരു പരീക്ഷ എഴുതി എന്ന് പറയാം

// അഞ്ചിനുള്ള ആദ്യ വ്യവസ്ഥ എഴുതുക
എങ്കിൽ ($ടെസ്റ്റ് > 90)
{
// വ്യവസ്ഥ പാലിക്കുകയാണെങ്കിൽ, ഈ പ്രവർത്തനം നടത്തുക.
എക്കോ "റേറ്റിംഗ് 5";
}
// && ചിഹ്നത്തിൻ്റെ അർത്ഥം "ഒപ്പം, യൂണിയൻ", രണ്ടും ശരിയാണെങ്കിൽ വ്യവസ്ഥ പാലിക്കപ്പെടുമെന്നാണ്
// അതായത്, സ്കോർ 91-ൽ കുറവും 80-ൽ കൂടുതലുമാണ്, തുടർന്ന് 4. അല്ലെങ്കിൽ, വ്യവസ്ഥകൾ കൂടുതൽ വായിക്കും
അല്ലെങ്കിൽ ($ടെസ്റ്റ്< 91 && $test > 80)
{
എക്കോ "റേറ്റിംഗ് 4";
}
അല്ലെങ്കിൽ ($ടെസ്റ്റ്< 81 && $test > 70)
{
എക്കോ "റേറ്റിംഗ് 3";
}
വേറെ
{
പ്രതിധ്വനി "നമുക്ക് വീണ്ടും പരീക്ഷ എഴുതണം...";
}
?>
പ്രകടനം ഉറവിടങ്ങൾ ഡൗൺലോഡ് ചെയ്യുക
വിശ്രമിക്കാനും സാധാരണ പരീക്ഷ എഴുതാനും സമയമുള്ള ഞങ്ങളുടെ വിദ്യാർത്ഥിക്ക് ലഭിക്കുന്നു റേറ്റിംഗ് 4! പ്രവർത്തനത്തിൻ്റെ തത്വം വ്യക്തമാണെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു.

വ്യവസ്ഥ പാലിക്കുകയാണെങ്കിൽ മാത്രം നിങ്ങൾക്ക് ഒരു പ്രവർത്തനം ആവശ്യമുള്ളപ്പോൾ, ഒരു സോപാധിക പ്രവർത്തനത്തിൻ്റെ പ്രവർത്തനം ഹ്രസ്വമായി രേഖപ്പെടുത്താനും കഴിയും.

$പ്രായം = 19; // പ്രായത്തിനനുസരിച്ച് വേരിയബിൾ

എങ്കിൽ ($വയസ്സ് > 17)(
പ്രതിധ്വനി "അത് തന്നെ! എനിക്ക് എന്ത് വേണമെങ്കിലും ചെയ്യാം! എനിക്ക് ഇതിനകം തന്നെ $പ്രായമായി!";
}
വളരെ നല്ല ഉദാഹരണം ചെറിയ കുറിപ്പ്സോപാധിക പ്രവർത്തനം. വേറെഎഴുതേണ്ട ആവശ്യമില്ല.

PHP-യിലെ താരതമ്യ ഓപ്പറേറ്റർമാർ

ഒരു സോപാധിക പ്രവർത്തനത്തിൻ്റെ പ്രവർത്തന തത്വം വ്യക്തമാണ്. പക്ഷേ, നിങ്ങൾ മനസ്സിലാക്കുന്നതുപോലെ, താരതമ്യം ചെയ്യാൻ ഇനിയും നിരവധി മാർഗങ്ങളുണ്ട്. താരതമ്യ ഓപ്പറേറ്റർമാരുമായി ചുവടെയുള്ള പട്ടിക നോക്കാം.

ഉദാഹരണം പേര് ഫലം
$a == $b എന്നത് $b-ന് തുല്യമാണെങ്കിൽ ശരിയാണ്
$a === $b എന്നത് True എന്നതിന് തുല്യമാണ്, $a എന്നത് $b ന് തുല്യമാണെങ്കിൽ രണ്ട് വേരിയബിളുകളും ഒരേ തരത്തിലാണെങ്കിൽ
$a != $b എന്നത് True എന്നതിന് തുല്യമല്ലെങ്കിൽ $a എന്നത് $b ന് തുല്യമല്ല
$a === $b എന്നത് True എന്നതിന് സമാനമല്ല, $a എന്നത് $b ന് തുല്യമല്ലെങ്കിൽ രണ്ട് തരങ്ങളും ഒരുപോലെയല്ല
$a $b-നേക്കാൾ വലുതാണെങ്കിൽ $a > $b ശരിയേക്കാൾ വലുതാണ്
$a< $b Меньше чем True, если $a меньше, чем $b
$a $b എന്നതിനേക്കാൾ വലുതോ തുല്യമോ ആണെങ്കിൽ $a >= $b ശരിയേക്കാൾ വലുതോ തുല്യമോ ആണ്
$a<= $b Меньше или равно True, если $a меньше или равно $b
ഇനി ഓപ്പറേറ്റർമാരെ നോക്കാം ഉദാഹരണങ്ങൾ സഹിതം:

// ശീലത്തിന് വിരുദ്ധമായി = ഒരു വേരിയബിളിന് ഒരു മൂല്യം നൽകുന്നത് അർത്ഥമാക്കുന്നു, == തുല്യമാണ്
എങ്കിൽ ($a == 5)(
പ്രതിധ്വനി "$a 5 ആണ്"; // "5 സമം 5" എന്ന് അച്ചടിക്കും
) വേറെ (
പ്രതിധ്വനി "$a 5 ന് തുല്യമല്ല";
}

എങ്കിൽ ($a != 6)(
പ്രതിധ്വനി "$a 6 ന് തുല്യമല്ല"; // "5 is not equal to 6" എന്ന് പ്രിൻ്റ് ചെയ്യും. നിരസിച്ചാൽ അത്യാവശ്യമാണ്
) വേറെ (
പ്രതിധ്വനി "$a എങ്ങനെയെങ്കിലും 6 ന് തുല്യമാണ്";
}

//കൂടുതലും കുറവും എല്ലാം വ്യക്തമാണെന്ന് ഞാൻ കരുതുന്നു. അതിനാൽ, ഉദാഹരണം കൂടുതൽ സങ്കീർണ്ണമാണ്
എങ്കിൽ ($a<= 6){
പ്രതിധ്വനി "$a 6-നേക്കാൾ കുറവാണ് അല്ലെങ്കിൽ തുല്യമാണ്"; // "5 എന്നത് 6-നേക്കാൾ കുറവോ തുല്യമോ" എന്ന് അച്ചടിക്കും
) വേറെ (
പ്രതിധ്വനി "$a 6 നേക്കാൾ വലുതാണ്";
}

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

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

ഉദാഹരണം പേര് ഫലം
$a, $b എന്നിവ ശരിയാണെങ്കിൽ $a, $b ലോജിക്കൽ "ഒപ്പം" TRUE.
$a അല്ലെങ്കിൽ $b എന്നത് ശരിയാണെങ്കിൽ $a അല്ലെങ്കിൽ $b ലോജിക്കൽ "അല്ലെങ്കിൽ" TRUE.
$a അല്ലെങ്കിൽ $b ശരിയാണെങ്കിൽ $a xor $b എക്സ്ക്ലൂസീവ് "അല്ലെങ്കിൽ" TRUE, എന്നാൽ രണ്ടും അല്ല.
! $a ശരിയല്ലെങ്കിൽ, $a TRUE എന്നതിൻ്റെ നിഷേധം.
$a, $b എന്നിവ ശരിയാണെങ്കിൽ $a && $b ലോജിക്കൽ "ഒപ്പം" TRUE.
$a || $b ബൂളിയൻ "അല്ലെങ്കിൽ" $a അല്ലെങ്കിൽ $b ശരിയാണെങ്കിൽ TRUE.
പ്രവർത്തനങ്ങൾക്കായി ഞങ്ങൾ ഇതിനകം ശ്രദ്ധിച്ചു ഒപ്പംഒപ്പം അഥവാഅധിക ഓപ്പറേറ്റർമാരുണ്ടോ? സങ്കീർണ്ണമായ താരതമ്യ പ്രവർത്തനങ്ങൾക്ക് മുൻഗണന നൽകുന്നതിനാണ് ഇത് ചെയ്യുന്നത്. പട്ടികയിൽ, ലോജിക്കൽ ഓപ്പറേറ്റർമാരെ മുൻഗണനാ ക്രമത്തിൽ പട്ടികപ്പെടുത്തിയിരിക്കുന്നു: ഏറ്റവും കുറഞ്ഞത് മുതൽ ഏറ്റവും വലുത് വരെ, അതായത്, ഉദാഹരണത്തിന്, || അല്ലെങ്കിൽ എന്നതിനേക്കാൾ ഉയർന്ന മുൻഗണനയുണ്ട്.

നമുക്ക് നീങ്ങാം ഉദാഹരണങ്ങളിലേക്ക്

$a = 5;
$b = 6;
$c = 7;

// വ്യവസ്ഥ: 5 എന്നത് 6 ന് തുല്യമല്ല (ശരി) കൂടാതെ 6 എന്നത് 7 ന് തുല്യമല്ല (ശരി)
എങ്കിൽ ($a< 6 && $b != $c){
പ്രതിധ്വനി "തീർച്ചയായും അങ്ങനെ!"; // "തീർച്ചയായും അങ്ങനെ തന്നെ!" എന്ന് അച്ചടിക്കും. കാരണം രണ്ട് വ്യവസ്ഥകളും ശരിയാണ്
) വേറെ (
പ്രതിധ്വനി "ഒരു വ്യവസ്ഥ ശരിയല്ല";
}

// വ്യവസ്ഥ: 6 എന്നത് 6 ന് തുല്യമല്ലെങ്കിൽ (തെറ്റ്) അല്ലെങ്കിൽ 6 എന്നത് 7 ന് തുല്യമല്ല (ശരി)
എങ്കിൽ ($b != 6 || $b != $c)(
പ്രതിധ്വനി "അതാണ്!"; // "അത് തന്നെ!" പ്രദർശിപ്പിക്കും, കാരണം വ്യവസ്ഥകളിൽ ഒരെണ്ണമെങ്കിലും ശരിയാണ്
) വേറെ (
പ്രതിധ്വനി "രണ്ട് വ്യവസ്ഥകളും തെറ്റാണ്";
}

ടെർനറി ഓപ്പറേറ്റർ

ത്രിതല കോഡിൻ്റെ പ്രശ്നത്തിലേക്ക് പിന്നീട് മടങ്ങാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു. കോഡ് വലുപ്പം ഗണ്യമായി കുറയ്ക്കുന്ന ഒരു പ്രധാന രൂപകൽപ്പനയായതിനാൽ എനിക്ക് അത് പരാമർശിക്കാതിരിക്കാൻ കഴിഞ്ഞില്ല. ഉടൻ തന്നെ കോഡ് നോക്കാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു.

കോഡിൻ്റെ സാരം:(അവസ്ഥ) ? ശരിയാണെങ്കിൽ a യുടെ മൂല്യം: തെറ്റാണെങ്കിൽ a യുടെ മൂല്യം

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

// ടെർനറി ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നതിൻ്റെ ഉദാഹരണം
$settings = (ശൂന്യമായ($_POST["ക്രമീകരണങ്ങൾ"])) ? "Default" : $_POST["ക്രമീകരണങ്ങൾ"];

// മുകളിലെ കോഡ് if/else ഉപയോഗിക്കുന്ന ഇനിപ്പറയുന്ന ബ്ലോക്കിന് സമാനമാണ്
(ശൂന്യമാണെങ്കിൽ($_POST["ക്രമീകരണങ്ങൾ"])) (
$ക്രമീകരണങ്ങൾ = "സ്ഥിരസ്ഥിതി"; // ഒന്നും കൈമാറ്റം ചെയ്തില്ലെങ്കിൽ, അത് "Default" ആയി വിടുക
) വേറെ (
$ക്രമീകരണങ്ങൾ = $_POST["ക്രമീകരണങ്ങൾ"]; // പാസ്സായാൽ, $ക്രമീകരണങ്ങൾ പാസ്സായ മൂല്യം നൽകും.
}
?>
കോഡിലേക്കുള്ള അഭിപ്രായങ്ങൾ വായിക്കുക, എല്ലാം വ്യക്തമായിരിക്കണം.

നിങ്ങളുടെ ശ്രദ്ധയ്ക്ക് നന്ദി!