PHP വേരിയബിളുകളുമായുള്ള പ്രവർത്തനങ്ങൾ (ഓപ്പറേറ്റർമാർ)

നടപ്പാക്കുന്നതിന് വിവിധ ഗ്രൂപ്പുകളുണ്ട്.

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

PHP-യിലെ ഗണിത പ്രവർത്തനങ്ങൾ

ഗണിതത്തിൻ്റെ സ്കൂൾ അടിസ്ഥാനകാര്യങ്ങൾ ഓർക്കുന്നുണ്ടോ? താഴെ വിവരിച്ചിരിക്കുന്ന ഓപ്പറേറ്റർമാർ ഒരേ രീതിയിൽ പ്രവർത്തിക്കുന്നു.

രണ്ട് മൂല്യങ്ങളും പൂർണ്ണസംഖ്യകളാണെങ്കിലും (അല്ലെങ്കിൽ പൂർണ്ണസംഖ്യകളിലേക്ക് പരിവർത്തനം ചെയ്യുന്ന സ്ട്രിംഗുകൾ) ഡിവിഷൻ ഓപ്പറേറ്റർ ("/") എല്ലായ്പ്പോഴും ഒരു യഥാർത്ഥ തരം നൽകുന്നു. അല്ലെങ്കിൽ, ഫലം ഫ്രാക്ഷണൽ ആയിരിക്കും.

ഡിവിഷൻ്റെ ശേഷിക്കുന്ന ഭാഗം കണക്കാക്കുന്നതിനുള്ള പ്രവർത്തനം " % പൂർണ്ണ സംഖ്യകളിൽ മാത്രമേ പ്രവർത്തിക്കൂ, അതിനാൽ ഭിന്നസംഖ്യകളിൽ ഇത് പ്രയോഗിക്കുന്നത് അഭികാമ്യമല്ലാത്ത ഫലങ്ങൾ ഉണ്ടാക്കിയേക്കാം.

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

ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് പ്രവർത്തനങ്ങൾ

PHP, C പോലെ, പ്രിഫിക്സ്, പോസ്റ്റ്ഫിക്സ് ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർമാരെ പിന്തുണയ്ക്കുന്നു.

പോസ്റ്റ്ഫിക്സ് ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർമാർ

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

$a=10;
$b=$a++;
പ്രതിധ്വനി "a=$a, b=$b"; // പ്രിൻ്റുകൾ a=11, b=10

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, ആദ്യം വേരിയബിൾ $bമൂല്യം വേരിയബിളിന് നൽകിയിരിക്കുന്നു $a, അതിനുശേഷം മാത്രമാണ് അവസാനത്തേത് വർദ്ധിപ്പിച്ചത്. എന്നിരുന്നാലും, വേരിയബിളിന് മൂല്യം നൽകിയിരിക്കുന്ന എക്സ്പ്രഷൻ $b, കൂടുതൽ ബുദ്ധിമുട്ടായിരിക്കാം - ഏത് സാഹചര്യത്തിലും, വർദ്ധനവ് $aഅത് കണക്കാക്കിയതിനുശേഷം മാത്രമേ സംഭവിക്കുകയുള്ളൂ.

പ്രിഫിക്സ് ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർമാർ

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

$a=10;
$b=--$a;
പ്രതിധ്വനി "a=$a, b=$b"; // പ്രിൻ്റുകൾ a=9, b=9

ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് പ്രവർത്തനങ്ങൾ പ്രായോഗികമായി പലപ്പോഴും ഉപയോഗിക്കുന്നു. ഉദാഹരണത്തിന്, അവ മിക്കവാറും ഏത് ചക്രത്തിലും സംഭവിക്കുന്നു വേണ്ടി .

പ്രതിധ്വനി "

പോസ്റ്റ്ഫിക്സ് ഇൻക്രിമെൻ്റ്

" ;
$a = 5 ;
echo "5 ആയിരിക്കണം:" . $a++ . "
\n" ;

\n" ;

എക്കോ "

പ്രിഫിക്സ് ഇൻക്രിമെൻ്റ്

" ;
$a = 5 ;
echo "6 ആയിരിക്കണം:" . ++ $a . "
\n" ;
echo "6 ആയിരിക്കണം:" . $എ. "
\n" ;

എക്കോ "

പോസ്റ്റ്ഫിക്സ് ഡിക്രിമെൻ്റ്

" ;
$a = 5 ;
echo "5 ആയിരിക്കണം:" . $a -- . "
\n" ;

\n" ;

എക്കോ "

പ്രിഫിക്സ് ഡിക്രിമെൻ്റ്

" ;
$a = 5 ;
echo "4 ആയിരിക്കണം:" . -- $a . "
\n" ;
echo "4 ആയിരിക്കണം:" . $എ. "
\n" ;
?>

സ്ട്രിംഗ് പ്രവർത്തനങ്ങൾ

സ്ട്രിംഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ PHP-ക്ക് രണ്ട് ഓപ്പറേറ്റർമാരുണ്ട്. ആദ്യത്തേത് ഇടത് വലത് ആർഗ്യുമെൻ്റുകളുടെ സംയോജനം നൽകുന്ന കോൺകാറ്റനേഷൻ ഓപ്പറേറ്ററാണ് ("."). രണ്ടാമത്തേത് സംയോജിപ്പിക്കുന്ന ഒരു അസൈൻമെൻ്റ് ഓപ്പറേറ്ററാണ്, അത് ഇടതുവശത്ത് ശരിയായ ആർഗ്യുമെൻ്റ് കൂട്ടിച്ചേർക്കുന്നു. നമുക്ക് ഒരു പ്രത്യേക ഉദാഹരണം നൽകാം:

$a = "ഹലോ" ;
$b = $a. "ലോകം!" ; // $b-ൽ "ഹലോ വേൾഡ്!" എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു.

$a = "ഹലോ" ;
$a .= "ലോകം!" ; // $a-ൽ "ഹലോ വേൾഡ്!" എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കുന്നു.
?>

ബിറ്റ്വൈസ് പ്രവർത്തനങ്ങൾ

ഈ പ്രവർത്തനങ്ങൾ ഒരു മുഴുവൻ വേരിയബിളിലെ ബിറ്റുകളുടെ ഗ്രൂപ്പുകൾ പ്രവർത്തിപ്പിക്കുന്നതിന് (സജ്ജീകരിക്കുക/അൺസെറ്റ് ചെയ്യുക/ചെക്ക് ചെയ്യുക) രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. ഒരു പൂർണ്ണസംഖ്യയുടെ ബിറ്റുകൾ ബൈനറി നമ്പർ സിസ്റ്റത്തിൽ എഴുതിയ അതേ സംഖ്യയുടെ വ്യക്തിഗത അക്കങ്ങളല്ലാതെ മറ്റൊന്നുമല്ല. ഉദാഹരണത്തിന്, ബൈനറിയിൽ 12 എന്ന സംഖ്യ 1100 പോലെയും 2 10 ആയി കാണപ്പെടും, അതിനാൽ എക്സ്പ്രഷൻ 12|2 14 (ബൈനറി നൊട്ടേഷനിൽ 1110) എന്ന സംഖ്യ തിരികെ നൽകും. ഒരു വേരിയബിൾ ഒരു പൂർണ്ണസംഖ്യയല്ലെങ്കിൽ, അത്
ആദ്യം വൃത്താകൃതിയിലുള്ളത്, തുടർന്ന് ഇനിപ്പറയുന്ന ഓപ്പറേറ്റർമാർ അതിൽ പ്രയോഗിക്കുന്നു.

ഒരു സംഖ്യയെ പ്രതിനിധീകരിക്കാൻ, 32 ബിറ്റുകൾ ഉപയോഗിക്കുന്നു:

• 0000 0000 0000 0000 0000 0000 0000 0000 പൂജ്യമാണ്;
• 0000 0000 0000 0000 0000 0000 0000 0001 എന്നത് 1 ആണ്;
• 0000 0000 0000 0000 0000 0000 0000 0010 എന്നത് 2 ആണ്;
• 0000 0000 0000 0000 0000 0000 0000 0011 എന്നത് 3 ആണ്;
• 0000 0000 0000 0000 0000 0000 0000 0100 എന്നത് 4 ആണ്;
• 0000 0000 0000 0000 0000 0000 0000 0101 എന്നത് 5 ആണ്;
• 0000 0000 0000 0000 0000 0000 0000 1111 എന്നത് 15 ആണ്;

ബിറ്റ്വൈസ് ഓപ്പറേറ്റർമാർ:

ഉദാഹരണം	പേര്	ഫലമായി
$a & $b	ബിറ്റ്വൈസ് "ഒപ്പം"	$a, $b എന്നിവയിൽ സജ്ജീകരിച്ചിരിക്കുന്ന ബിറ്റുകൾ മാത്രമേ സജ്ജീകരിച്ചിട്ടുള്ളൂ.
$a | $b	ബിറ്റ്വൈസ് "അല്ലെങ്കിൽ"	$a അല്ലെങ്കിൽ $b എന്നിവയിൽ സജ്ജീകരിച്ചിരിക്കുന്ന ബിറ്റുകൾ സജ്ജീകരിച്ചിരിക്കുന്നു.
$a^$b	എക്സ്ക്ലൂസീവ് അല്ലെങ്കിൽ	$a മാത്രം അല്ലെങ്കിൽ $b മാത്രം സജ്ജീകരിച്ചിരിക്കുന്ന ബിറ്റുകൾ മാത്രമേ സജ്ജീകരിച്ചിട്ടുള്ളൂ
~$എ	നിഷേധം	$a-ൽ സജ്ജീകരിക്കാത്ത ആ ബിറ്റുകൾ സജ്ജീകരിച്ചിരിക്കുന്നു, തിരിച്ചും.
$a<< $b	ഷിഫ്റ്റ് വിട്ടു	$a എന്ന വേരിയബിളിൻ്റെ എല്ലാ ബിറ്റുകളും $b സ്ഥാനങ്ങൾ ഇടത്തേക്ക് മാറ്റുന്നു (ഓരോ സ്ഥാനവും "2 കൊണ്ട് ഗുണിക്കുക" എന്ന് സൂചിപ്പിക്കുന്നു)
$a >> $b	വലത്തേക്ക് മാറുക	$a എന്ന വേരിയബിളിൻ്റെ എല്ലാ ബിറ്റുകളും $b സ്ഥാനങ്ങൾ വലത്തേക്ക് മാറ്റുന്നു (ഓരോ സ്ഥാനവും "2 കൊണ്ട് വിഭജനം" എന്ന് സൂചിപ്പിക്കുന്നു)

താരതമ്യ പ്രവർത്തനങ്ങൾ

താരതമ്യ ഓപ്പറേറ്റർമാർ, അവരുടെ പേര് സൂചിപ്പിക്കുന്നത് പോലെ, രണ്ട് മൂല്യങ്ങൾ താരതമ്യം ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

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

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

വിശദാംശങ്ങൾക്ക് അറേ താരതമ്യം കാണുക.

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

ഉദാഹരണം	പേര്	ഫലമായി
$a == $b	തുല്യമാണ്	സത്യം$a എന്നത് $b ന് തുല്യമാണെങ്കിൽ.
$a === $b	ഒരേപോലെ തുല്യം	സത്യം$a എന്നത് $b ന് തുല്യവും അതേ തരവും ആണെങ്കിൽ. (PHP 4 ൽ ചേർത്തു)
$a != $b	തുല്യമല്ല	സത്യം$a എന്നത് $b എന്നതിന് തുല്യമല്ലെങ്കിൽ.
$a<>$b	തുല്യമല്ല	സത്യം$a എന്നത് $b എന്നതിന് തുല്യമല്ലെങ്കിൽ.
$a !== $b	സമാനത തുല്യമല്ല	സത്യം$a എന്നത് $b ന് തുല്യമല്ലെങ്കിലോ അവ വ്യത്യസ്ത തരത്തിലാണെങ്കിൽ (PHP 4-ൽ ചേർത്തിരിക്കുന്നു)
$a< $b	കുറവ്	സത്യം$a കർശനമായി $b-യിൽ കുറവാണെങ്കിൽ.
$a > $b	കൂടുതൽ	സത്യം$a കർശനമായി $b-നേക്കാൾ കൂടുതലാണെങ്കിൽ.
$a<= $b	കുറവോ തുല്യമോ	സത്യം$a $b-നേക്കാൾ കുറവോ തുല്യമോ ആണെങ്കിൽ.
$a >= $b	കൂടുതലോ തുല്യമോ	സത്യം$a $b-നേക്കാൾ വലുതോ തുല്യമോ ആണെങ്കിൽ.

ലോജിക്കൽ പ്രവർത്തനങ്ങൾ

ബൂളിയൻ എക്‌സ്‌പ്രഷനുകൾക്കൊപ്പം പ്രവർത്തിക്കുന്നതിനും റിട്ടേൺ ചെയ്യുന്നതിനും മാത്രമായി ലോജിക്കൽ ഓപ്പറേറ്റർമാർ രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു തെറ്റായഅഥവാ സത്യം.

PHP ലോജിക്കൽ ഓപ്പറേറ്റർമാരുടെ ഒരു പട്ടിക ഇതാ:

അത്തരം ഓപ്പറേറ്റർമാർ അടങ്ങുന്ന ലോജിക്കൽ എക്സ്പ്രഷനുകളുടെ മൂല്യനിർണ്ണയം എല്ലായ്പ്പോഴും ഇടത്തുനിന്ന് വലത്തോട്ട് തുടരുന്നുവെന്നതും ഫലം ഇതിനകം വ്യക്തമാണെങ്കിൽ (ഉദാഹരണത്തിന്, തെറ്റായ&&എന്തോഎപ്പോഴും നൽകുന്നു തെറ്റായ), എക്‌സ്‌പ്രഷനിൽ ഫംഗ്‌ഷൻ കോളുകൾ അടങ്ങിയിട്ടുണ്ടെങ്കിലും കണക്കുകൂട്ടലുകൾ അവസാനിപ്പിക്കും. ഉദാഹരണത്തിന്, ഓപ്പറേറ്ററിൽ $logic = 0&&(time()>100); സ്റ്റാൻഡേർഡ് ഫംഗ്ഷൻ സമയം()ഒരിക്കലും വിളിക്കില്ല.

ലോജിക്കൽ പ്രവർത്തനങ്ങളിൽ ശ്രദ്ധാലുവായിരിക്കുക - പ്രതീകം ഇരട്ടിപ്പിക്കുന്നതിനെക്കുറിച്ച് മറക്കരുത്. ദയവായി ശ്രദ്ധിക്കുക, ഉദാഹരണത്തിന്, | ഒപ്പം || - തികച്ചും വ്യത്യസ്തമായ രണ്ട് ഓപ്പറേറ്റർമാർ, അവയിലൊന്ന് ഏത് നമ്പറും തിരികെ നൽകാം, രണ്ടാമത്തേത് - മാത്രം തെറ്റായഒപ്പം സത്യം.

ഇൻക്രിമെൻ്റ് (++), ഡിക്രിമെൻ്റ് (--) ഓപ്പറേറ്റർമാർ ബൂളിയൻ വേരിയബിളുകളിൽ പ്രവർത്തിക്കില്ല.

തുല്യത ഓപ്പറേറ്റർമാർ

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

$a=10;
$b="10";

വേരിയബിൾ എന്ന വസ്തുത ഉണ്ടായിരുന്നിട്ടും ഇത് $aഒരു സംഖ്യയെ പ്രതിനിധീകരിക്കുന്നു $b- ലൈൻ. ഇനി അല്പം വ്യത്യസ്തമായ ഒരു ഉദാഹരണം നോക്കാം:

$a=0; // പൂജ്യം
$b=""; // ശൂന്യമായ വരി
if($a==$b) "a, b എന്നിവ തുല്യമാണ്"; // പ്രിൻ്റുകൾ "എയും ബിയും തുല്യമാണ്"

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

എല്ലാ അടിസ്ഥാന ഗണിത പ്രവർത്തനങ്ങളും PHP-യിൽ ലഭ്യമാണ്. പൂർണ്ണസംഖ്യകളും യഥാർത്ഥ സംഖ്യകളും ഓപ്പറണ്ടുകളായി ഉപയോഗിക്കാം.

ഗണിത ഓപ്പറേറ്റർമാരുടെ ഒരു ലിസ്റ്റ് പട്ടിക കാണിക്കുന്നു:

ഓപ്പറേറ്റർ	അടയാളം	വിവരണം
കൂട്ടിച്ചേർക്കൽ	+	രണ്ട് മൂല്യങ്ങളുടെ കൂട്ടിച്ചേർക്കൽ
കുറയ്ക്കൽ	-	ഒരു മൂല്യം മറ്റൊന്നിൽ നിന്ന് കുറയ്ക്കുന്നു
ഗുണനം	*	രണ്ട് മൂല്യങ്ങൾ ഗുണിക്കുന്നു
ഡിവിഷൻ	/	ഒരു മൂല്യം മറ്റൊന്ന് കൊണ്ട് ഹരിക്കുന്നു
ഒരു ഡിവിഷൻ്റെ ബാക്കി ഭാഗം ലഭിക്കുന്നു	%	ഒരു മൂല്യം മറ്റൊന്ന് കൊണ്ട് ഹരിച്ച് ബാക്കിയുള്ളത് തിരികെ നൽകുന്നു (മോഡ്യൂളോ ഡിവിഷൻ)
ഇൻക്രിമെന്റും	++	ഒരു സംഖ്യയെ ഒന്നായി വർദ്ധിപ്പിക്കുന്നതിനുള്ള ചുരുക്കെഴുത്ത്
കുറയ്ക്കൽ	--	ഒരു സംഖ്യയെ ഒന്നായി കുറയ്ക്കുന്നതിനുള്ള ചുരുക്കെഴുത്ത്
ഏകീകൃത നിഷേധം	-	പോസിറ്റീവ് സംഖ്യയെ നെഗറ്റീവ് ആക്കി അല്ലെങ്കിൽ നെഗറ്റീവ് സംഖ്യയെ പോസിറ്റീവ് ആക്കി മാറ്റുന്നു

കുറയ്ക്കൽ, ഗുണനം, വിഭജനം, മൊഡ്യൂളോ, കൂട്ടിച്ചേർക്കൽ ഓപ്പറേറ്റർമാർ

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

ഡിവിഷൻ ഓപ്പറേറ്റർ (" / ") ഒരു ഫ്ലോട്ടിംഗ് പോയിൻ്റ് നമ്പർ നൽകുന്നു, രണ്ട് മൂല്യങ്ങളും ഒരു പൂർണ്ണസംഖ്യ കൊണ്ട് ഹരിച്ചിരിക്കുന്ന പൂർണ്ണസംഖ്യകൾ (അല്ലെങ്കിൽ പൂർണ്ണസംഖ്യകളായി പരിവർത്തനം ചെയ്യപ്പെടുന്ന സ്ട്രിംഗുകൾ) അല്ലാത്തപക്ഷം, അത് ഒരു പൂർണ്ണസംഖ്യ മൂല്യം നൽകുന്നു.

ഫലം2 = $ഫലം2
"; എക്കോ "ഫലം3 = $ഫലം3
result4 = $result4"; ?>

മോഡുലോ ഡിവിഷനിൽ, പ്രവർത്തനം ആരംഭിക്കുന്നതിന് മുമ്പ് ഓപ്പറണ്ടുകൾ പൂർണ്ണസംഖ്യകളാക്കി (ഫ്രാക്ഷണൽ ഭാഗം നീക്കംചെയ്ത്) പരിവർത്തനം ചെയ്യുന്നു. ഡിവിഷൻ ശേഷിക്കുന്ന പ്രവർത്തനത്തിൻ്റെ % ഫലത്തിന് ലാഭവിഹിതത്തിൻ്റെ അതേ ചിഹ്നം ഉണ്ടായിരിക്കും:

ഏകീകൃത നിഷേധം

ഏകീകൃത നിഷേധ ഓപ്പറേറ്ററെ "-" എന്ന ചിഹ്നത്താൽ സൂചിപ്പിക്കുന്നു, മാത്രമല്ല ഇത് അതിൻ്റെ ഒരേയൊരു പ്രവർത്തനത്തിൻ്റെ അർത്ഥത്തെ വിപരീതമാക്കുന്നു:

ഈ സാഹചര്യത്തിൽ, പരാൻതീസിസുകൾ ആവശ്യമില്ല, കാരണം ഏകീകൃതമായ നിഷേധത്തിന് ഏറ്റവും മുൻഗണനയുണ്ട്, പക്ഷേ അവ കോഡ് ക്രമീകരിക്കാൻ സഹായിക്കുന്നു, അങ്ങനെ അക്കങ്ങൾ -5 ഉം 4 ഉം ചേർക്കുന്നത് വ്യക്തമാണ്.

ഇൻക്രിമെന്റും

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

ഇൻക്രിമെൻ്റിൻ്റെ പ്രിഫിക്സ് ഫോം

പ്രിഫിക്സ് ഫോം- ഇതാണ് ഇൻക്രിമെൻ്റ് ഓപ്പറേറ്ററെ ഓപ്പറണ്ടിന് മുമ്പായി സ്ഥാപിക്കുന്നത്, ഈ രീതിയിലുള്ള നൊട്ടേഷൻ അർത്ഥമാക്കുന്നത് ഇൻക്രിമെൻ്റ് ആദ്യം എക്സിക്യൂട്ട് ചെയ്യുമെന്നാണ്: ഇത് ഓപ്പറണ്ടിൻ്റെ മൂല്യം ഒന്നായി വർദ്ധിപ്പിക്കുന്നു, അതിനുശേഷം മാത്രമേ ബാക്കി നിർദ്ദേശങ്ങൾ നടപ്പിലാക്കുകയുള്ളൂ:

ഇൻക്രിമെൻ്റിൻ്റെ പോസ്റ്റ്ഫിക്സ് ഫോം

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

കുറയ്ക്കൽ

ഡിക്രിമെൻ്റ് ഓപ്പറേറ്ററെ സൂചിപ്പിക്കുന്നത് -- ചിഹ്നത്താൽ, ഇൻക്രിമെൻ്റ് ഓപ്പറേറ്ററിൽ നിന്ന് വ്യത്യസ്തമായി, അതിൻ്റെ ഓപ്പറണ്ടിൻ്റെ മൂല്യം ഒന്നായി വർദ്ധിപ്പിക്കുന്നതിന് പകരം കുറയുന്നു. ഡിക്രിമെൻ്റ് പ്രിഫിക്സും പോസ്റ്റ്ഫിക്സ് നൊട്ടേഷനും അനുവദിക്കുന്നു:

ഞാൻ മനസ്സിലാക്കിയിടത്തോളം, കുറച്ച് പാഠങ്ങൾക്ക് മുമ്പ് ഞാൻ ഞങ്ങളുടെ കോഴ്സിനെ ചെറുതായി തടസ്സപ്പെടുത്തിയ SQL- ൻ്റെ അടിസ്ഥാന കഴിവുകളുടെ വിവരണം അതിരുകടന്നതല്ല.

ഇന്ന് ഞാൻ വീണ്ടും "പാർട്ടി കോഴ്സിൽ" നിന്ന് അല്പം വ്യതിചലിച്ച് ഘടനകളെക്കുറിച്ച് സംസാരിക്കാൻ ആഗ്രഹിക്കുന്നു. എന്നാൽ SQL അല്ല, PHP തന്നെ. പ്രോഗ്രാം ലിസ്റ്റിംഗുകൾ എളുപ്പത്തിൽ വായിക്കാൻ ഇത് നിങ്ങളെ സഹായിക്കും, നിങ്ങൾക്ക് എന്നെ മനസ്സിലാകില്ല എന്ന ഭയമില്ലാതെ തുടർന്നുള്ള പ്രവർത്തനങ്ങൾ കൂടുതൽ സംക്ഷിപ്തമായി എഴുതാൻ എനിക്ക് കഴിയും.

പരിഭ്രാന്തരാകരുത്, സങ്കീർണ്ണവും അവ്യക്തവുമായ എല്ലാം ഞാൻ എഴുതുന്നത് തുടരുമെന്ന് ഇതിനർത്ഥമില്ല. ഇല്ല, അങ്ങനെയൊന്നുമില്ല. PHP ബേസിക് അല്ലെന്ന് നിങ്ങൾ മനസ്സിലാക്കണമെന്ന് ഞാൻ ആഗ്രഹിക്കുന്നു, അവിടെ നിങ്ങൾക്ക് എഴുതാൻ കഴിയുന്നതുപോലെ മാത്രമേ എഴുതാൻ കഴിയൂ. പിന്നെ മറ്റൊന്നുമല്ല. നന്നായി പറഞ്ഞു, നിങ്ങൾ എഴുതിയത് മനസ്സിലായോ കുറെപിൻ?! കിട്ടി, കിട്ടി...

മീറ്റ് - കാലഘട്ടം.

ഡോട്ട് "." നിങ്ങൾക്ക് ഇതിനകം അറിയാം, അത് സ്ട്രിംഗുകളെ സംയോജിപ്പിക്കുന്നു. കൂടാതെ "+" അക്കങ്ങൾ ചേർക്കുന്നു, ഒരു ഡോട്ട് വരികൾ സംയോജിപ്പിക്കുന്നു.
$a1="100";
$a2="200"
മടക്കിയാൽ എന്ത് സംഭവിക്കും $a1ഒപ്പം $a2? ഇതെങ്ങനെ ഇടാം...
$a1+$a2=300
$a1.$a2="100200"
...ഒരിക്കലും മറക്കരുത്.

കൂട്ടിച്ചേർക്കൽ എഴുതാനുള്ള മറ്റൊരു വഴി ഇതാ.

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

$this->string_about_letters = $this->string_about_letters."കുറച്ച് അക്ഷരങ്ങൾ..."; $this->string_about_letters = $this->string_about_letters." കുറച്ച് അക്ഷരങ്ങൾ കൂടി..."; $this->string_about_letters = $this->string_about_letters." കൂടാതെ കുറച്ച് അക്ഷരങ്ങൾ കൂടി..."; $this->string_about_letters = $this->string_about_letters." വീണ്ടും കുറച്ച് അക്ഷരങ്ങൾ...";

കുറച്ച് നീളമുണ്ട്, അല്ലേ? ഒരു നീണ്ട വേരിയബിൾ ആവർത്തിക്കുന്നത് വഴിയിൽ ലഭിക്കുന്നു $this->string_about_letters. അതിനാൽ, ഞങ്ങൾ ഇത് വ്യത്യസ്തമായി രേഖപ്പെടുത്തും:

$this->string_about_letters .= "നിരവധി അക്ഷരങ്ങൾ..."; $this->string_about_letters .= "കുറച്ച് അക്ഷരങ്ങൾ കൂടി..."; $this->string_about_letters .= "കൂടാതെ കുറച്ച് അക്ഷരങ്ങൾ കൂടി..."; $this->string_about_letters .= "കുറച്ച് അക്ഷരങ്ങൾ വീണ്ടും...";

കൂടുതൽ സൗകര്യപ്രദമാണ്, അല്ലേ?

ഗണിതശാസ്ത്ര കൂട്ടിച്ചേർക്കലിനും ഇത് ബാധകമാണ്:
$abc+=1;
ഒരു വേരിയബിളിൻ്റെ ഉള്ളടക്കത്തിലേക്ക് 1 ചേർക്കുക $abc.

നിങ്ങൾക്ക് മറ്റൊന്ന് എങ്ങനെ ചേർക്കാനാകും? സാധാരണയായി, S-shno അനുസരിച്ച്:

$abc++;അഥവാ +$abc;

ഈ രണ്ട് പദപ്രയോഗങ്ങളും സാധാരണയായി ചാക്രിക നിർമ്മാണങ്ങളിൽ ഉപയോഗിക്കുന്നു. സ്വയം അല്ല, കൂടുതൽ സങ്കീർണ്ണമായ പ്രയോഗത്തിൽ.
ഈ രണ്ട് എക്സ്പ്രഷനുകളും തമ്മിലുള്ള വ്യത്യാസം, ആദ്യ സന്ദർഭത്തിൽ, എക്സ്പ്രഷനിൽ വേരിയബിളിൻ്റെ മൂല്യം കണക്കിലെടുക്കുന്നു, തുടർന്ന് ഒന്ന് ചേർക്കുന്നു, രണ്ടാമത്തേതിൽ വിപരീതം ശരിയാണ് - ആദ്യം വേരിയബിളിൻ്റെ മൂല്യം വർദ്ധിക്കുന്നു. , തുടർന്ന് ഫലമായുണ്ടാകുന്ന മൂല്യം എക്സ്പ്രഷനിൽ ഉപയോഗിക്കുന്നു. ഒരു ഉദാഹരണം വ്യക്തമാക്കും:
$a=1;
പ്രതിധ്വനി $a++;
എക്കോ +$a;
ആദ്യം പ്രതിധ്വനിഞങ്ങൾക്കായി "1" പ്രിൻ്റ് ചെയ്യുമോ, രണ്ടാമത്തേത് പ്രിൻ്റ് ചെയ്യുമോ?.. എന്നാൽ അത് ശരിയല്ല! അല്ല 2 അത് പ്രിൻ്റ് ഔട്ട് ചെയ്യും, കൂടാതെ "3". എന്തുകൊണ്ട്? സ്വയം ഊഹിക്കുക.

ഇന്ന് ഞങ്ങളുടെ പ്രോഗ്രാമിൽ ഞങ്ങൾ പലപ്പോഴും ഉപയോഗിക്കുന്ന ഒരു കോഡ് നിങ്ങൾക്കായി തകർക്കാൻ ഞാൻ ആഗ്രഹിക്കുന്നു. പൊതുവേ, ഒരു SQL ഡാറ്റാബേസിൽ നിന്ന് ഡാറ്റ എടുക്കുന്ന ഏതൊരു പ്രോഗ്രാമിലും.

തീർച്ചയായും, ഡാറ്റ നേടുന്നതിനെക്കുറിച്ചാണ് ഞങ്ങൾ സംസാരിക്കുന്നത് തിരഞ്ഞെടുക്കുക-എ.

ഡാറ്റാബേസ് എങ്ങനെ അന്വേഷിക്കണമെന്ന് നിങ്ങൾക്ക് ഇതിനകം അറിയാം, എന്നാൽ ലഭിച്ച ഡാറ്റ എങ്ങനെ പാഴ്‌സ് ചെയ്യാം എന്നതിനെക്കുറിച്ച് ഞങ്ങൾ സംസാരിച്ചിട്ടില്ല. അതേസമയം, ഇത് വിവിധ രീതികളിൽ ചെയ്യാം.

നമുക്ക് ഒരു ഉദാഹരണത്തിൽ നിന്ന് ആരംഭിക്കാം. വീഡിയോ കാസറ്റ് ഡാറ്റാബേസിൽ നിന്ന് 2000-ൽ പുറത്തിറങ്ങിയ വീഡിയോ ഫിലിമുകളുടെ ശീർഷകങ്ങൾ ഞങ്ങൾ തിരഞ്ഞെടുത്ത് ഒരു പട്ടികയുടെ രൂപത്തിൽ (കാസറ്റ് ഐഡിയോടെ, തീർച്ചയായും) പ്രിൻ്റ് ചെയ്യാൻ ആഗ്രഹിക്കുന്നുവെന്ന് കരുതുക.

അതിനാൽ, നിങ്ങൾക്ക് ഈ നടപടിക്രമം ക്രമീകരിക്കാം (പല പാഠപുസ്തകങ്ങളിലും സമാനമായ എന്തെങ്കിലും നിങ്ങൾ കണ്ടെത്തും):

$this->sql_query="2000-01-01 00:00:00" നും "2000-12-31 23:59:59 ഓർഡർ പ്രകാരം f_id" എന്നതിനുമിടയിൽ f_date ചെയ്യുന്ന ഫിലിമിൽ നിന്ന് * തിരഞ്ഞെടുക്കുക; $this->sql_execute(); $str=" "; $row_count=mysql_num_rows($this->sql_res); ($i=0;$isql_res); $str=$str." \n"; ) $str=$str."

".$film["f_id"]."

".$film["f_name"]."

";

എന്നെ വിശദമാക്കാൻ അനുവദിക്കൂ.

ഞങ്ങൾ ഡാറ്റാബേസിലേക്ക് ഒരു അഭ്യർത്ഥന നടത്തുന്നു (വഴി, അഭ്യർത്ഥനയിലെ പുതിയ അവസ്ഥ ശ്രദ്ധിക്കുക: തീയതിക്കും തീയതിക്കും ഇടയിൽ, ഈ ഫോം പലപ്പോഴും ഒരു തീയതി പരിധി സൂചിപ്പിക്കാൻ ഉപയോഗിക്കുന്നു).

വാചകത്തിൻ്റെ ആദ്യ ശകലം - പട്ടികയുടെ ആരംഭം ചേർത്തുകൊണ്ട് HTML കോഡ് നൽകുന്നതിന് ഞങ്ങൾ ഒരു ടെക്സ്റ്റ് വേരിയബിൾ ആരംഭിക്കുന്നു.

അന്വേഷണത്തിൽ നിന്ന് വീണ്ടെടുത്ത വരികളുടെ എണ്ണത്തിന് തുല്യമായ നിരവധി ആവർത്തനങ്ങളുള്ള ഒരു ലൂപ്പ് ഞങ്ങൾ തുറക്കുന്നു.

ലൂപ്പിൻ്റെ ബോഡിയിൽ, ഞങ്ങളുടെ അഭ്യർത്ഥനയിൽ നിന്ന് അടുത്ത വരി ഒരു അറേ വേരിയബിളിലേക്ക് ഞങ്ങൾ എക്‌സ്‌ട്രാക്റ്റുചെയ്യുന്നു $ഫിലിം. ഫംഗ്ഷൻ mysql_fetch_arrayഡാറ്റ ക്രമീകരിക്കുന്നു അസോസിയേറ്റീവ് അറേ, പട്ടികയിൽ നിന്നുള്ള ഫീൽഡ് നാമങ്ങൾ കീകളായി ഉപയോഗിക്കുന്നു.

ഒരു അസോസിയേറ്റീവ് അറേ ഒരു സാധാരണ (നമ്പർ ചെയ്ത) അറേയ്ക്ക് സമാനമാണ്, സെല്ലുകളുടെ പേരുകളായി നമ്പറുകൾക്ക് പകരം പ്രതീകങ്ങളുടെ സ്ട്രിംഗുകൾ മാത്രമേ ഉപയോഗിക്കൂ. അതനുസരിച്ച് നിങ്ങൾ അത്തരം ഒരു ശ്രേണിയുടെ സെല്ലുകൾ ആക്‌സസ് ചെയ്യണം: $abc["ആദ്യം"], $abc["mama"]...

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

ദയവായി പ്രത്യേകം ശ്രദ്ധിക്കുക: ടെക്സ്റ്റ് സ്ട്രിംഗുകളിലെ അസോസിയേറ്റീവ് അറേകളുടെ സെല്ലുകൾ നിങ്ങൾക്ക് ആക്സസ് ചെയ്യാൻ കഴിയില്ല! കാണിച്ചിരിക്കുന്നതുപോലെ ലൈൻ തകർത്ത് ഡോട്ടുകൾ (.) ഉപയോഗിച്ച് മൂല്യങ്ങൾ “ഒട്ടിക്കുക” ആവശ്യമാണ്.

സൈക്കിൾ ആവശ്യമുള്ള തവണ ആവർത്തിക്കുന്നു, അതിനുശേഷം ഞങ്ങൾ അടയ്ക്കുന്നു $strഅവസാന html ടാഗ്. തയ്യാറാണ്.

എന്നാൽ ഇതെല്ലാം വളരെ ബുദ്ധിമുട്ടുള്ള കാര്യമല്ലേ? എൻ്റെ അഭിപ്രായത്തിൽ, വളരെ. ഇതെല്ലാം വ്യത്യസ്തമായി എഴുതാൻ ഞാൻ നിർദ്ദേശിക്കുന്നു: എല്ലാം ഒന്നുതന്നെയാണ്, പക്ഷേ ചെറുതാണ്.