Ang mga programmer na kailangang magsagawa ng mga sensitibong numerical, scientific, o statistical calculations ay malabong isaalang-alang ang isang web scripting language bilang isang katanggap-tanggap na kandidato para sa tungkuling ito. Ngunit, sa kabila ng nasa itaas, ang wikang PHP ay nag-aalok ng isang mahusay na hanay ng mga function na ganap na nagbibigay ng solusyon sa karamihan sa mga problema sa matematika na lumitaw sa proseso ng pagpapatupad ng mga script para sa web. Bilang karagdagan, ang PHP ay nagbibigay ng ilang mas advanced na mga kakayahan, tulad ng arbitrary precision arithmetic, hashing library, at cryptographic library.
Ang mga nag-develop ng wikang PHP ay kumuha ng isang mahusay na itinatag na diskarte at hindi gumawa ng anumang pagtatangka na muling likhain ang mga gulong na idinisenyo para sa layuning ito. Ang katotohanan ay marami sa mga pinakapangunahing mathematical function na ginagamit sa PHP ay simpleng mga wrapper sa paligid ng kanilang mga katapat na C.
Mga operasyon sa matematika
Karamihan sa matematika sa PHP ay ginagawa sa anyo ng mga built-in na function sa halip na mga operasyon. Bilang karagdagan sa mga operator ng paghahambing, nag-aalok ang PHP ng limang simpleng operator ng arithmetic, pati na rin ang ilang mga operator ng shortcut na nagbibigay-daan sa iyong bumuo ng mas maikling increment, decrement, at mga expression ng pagtatalaga.
Mga operasyon sa aritmetika
Kasama sa limang pangunahing pagpapatakbo ng arithmetic ang mga karaniwang ipinapatupad sa anumang calculator na may apat na function, kasama ang modulo (%). Maikling Paglalarawan Ang mga operasyon sa aritmetika ay ibinibigay sa talahanayan:
| Operasyon | Paglalarawan |
|---|---|
| + | Ibinabalik ang kabuuan ng mga halaga ng dalawang operand nito |
| - | Kung mayroong dalawang operand, ang halaga ng kanang operand ay ibabawas mula sa halaga ng kaliwa. Kung mayroon lamang kanang operand, ibinabalik ng operasyon ang halaga ng operand na iyon na may kabaligtaran na tanda |
| * | Ibinabalik ang produkto ng mga halaga ng dalawang operand nito |
| / | Ibinabalik ang resulta ng floating point ng paghahati ng halaga ng kaliwang operand sa halaga ng kanang operand |
| % | Ibinabalik ang natitira sa isang integer na hinati sa halaga ng kaliwang operand sa ganap na halaga ng tamang operand |
Kapag ginagamit ang unang tatlong pagpapatakbo ng aritmetika na inilarawan sa itaas (+, -, *) sa isang programa, dapat mong isaalang-alang na kapag isinasagawa ang mga operasyong ito, ang pagpapalaganap ng uri ay nangyayari mula sa dobleng katumpakan na mga floating-point na halaga hanggang sa mga halaga ng integer. Ang ibig sabihin nito ay kung ang parehong mga operand ng isang operasyon ay mga integer, kung gayon ang resulta ay isang integer, at kung hindi bababa sa isa sa mga operand ay isang double-precision na floating-point na numero, ang resulta ay isang double-precision na floating-point. numero. Ang parehong uri ng pagpapalaganap ay nangyayari kapag nagsasagawa ng operasyon ng dibisyon; bilang karagdagan, mayroong karagdagang epekto na ang resulta ay nagiging isang double-precision na floating-point na numero kung ang paghahati ay hindi isinasagawa nang walang natitira (ganap).
Ang modulo (%) na operasyon sa PHP ay tumatanggap ng mga integer operand, at kapag ang operasyong ito ay inilapat sa double-precision floating-point na mga numero, ang mga numerong ito ay unang mako-convert sa mga integer (sa pamamagitan ng pagtatapon ng fractional na bahagi). Ang resulta ng naturang operasyon ay palaging isang integer.
Mga pagpapatakbo ng pagtaas at pagbaba
Karamihan sa syntax ng PHP ay nagmula sa C, at ang mga C programmer ay kilala sa kanilang pagmamahal sa kaiklian at ipinagmamalaki ito. Ang mga increment at decrement operator, na kinuha mula sa wikang C, ay ginagawang posible na mas maigsi na kumatawan sa mga expression tulad ng $count = $count + 1, na kadalasang matatagpuan sa mga programa.
Ang increment operator (++) ay ginagamit upang magdagdag ng isa sa value ng variable na apektado ng operasyon, at ang decrement operator (--) ay nagbabawas ng isa mula sa value ng variable.
Ang bawat isa sa dalawang operasyong ito ay may dalawang uri - panlapi(sa form na ito ang operation sign ay inilalagay kaagad pagkatapos ng variable na apektado ng operasyon) at unlapi(sa form na ito, ang operation sign ay inilalagay kaagad bago ang variable kung saan nalalapat ang operasyon). Ang parehong mga varieties ay may pareho by-effect nauugnay sa pagbabago ng halaga ng isang variable, ngunit ang mga operator ng suffix at prefix ay nagbabalik ng iba't ibang mga halaga kapag ginamit bilang mga expression. Gumagana ang operasyon ng suffix upang ang halaga ng variable ay mabago pagkatapos maibalik ang halaga ng expression, at ang prefix na operasyon ay gumagana upang ang halaga ay unang mabago at pagkatapos ay ang bagong halaga ay ibabalik sa variable. Maaaring matukoy ang pagkakaibang ito sa pamamagitan ng paggamit ng mga operator ng pagbabawas at pagtaas sa mga operator ng pagtatalaga:
PHP code $bilang = 0; $result = $count++; echo "Resulta ng $count++ increment: ".$result.""; $count = 0; $result = ++$count; echo "Resulta ng ++$count increment: ".$result."
";
Ang mga sumusunod na pahayag ay gumagawa ng sumusunod na output sa window ng browser:
Mga pagpapatakbo ng pagtaas
Sa halimbawang ito, ang operator na $result = $count++ ay ganap na katumbas ng mga operator:
PHP code $result = $count; $count = $count + 1;Kasama nito, ang operator na $result = ++$count ay katumbas ng mga sumusunod na operator:
PHP code $count = $count +1; $result = $count;Mga Operator ng Pagtatalaga
Binabawasan ng mga operator ng pagtaas (at pagbabawas) ang halaga ng code na kinakailangan upang magdagdag ng isa sa halaga ng isang variable, ngunit hindi binabawasan ang halaga ng code na nagtatalaga sa isang variable ng resulta ng pagdaragdag ng halaga nito sa isa pang numero o ang resulta ng iba pang mga operasyon sa aritmetika . Sa kabutihang palad, lahat ng limang operator ng aritmetika ay may kaukulang mga operator ng pagtatalaga (+=, -=, *=, /=, at %=), na nagbibigay-daan sa iyong italaga ang resulta ng isang operasyon ng aritmetika sa halaga ng variable na iyon sa isang variable sa isa maikling ekspresyon. Halimbawa, ang operator
PHP code $count = $count * 3;maaaring paikliin bilang
PHP code $count *= 3;Simpleng Math Function
Ang susunod na hakbang sa paggawa ng isang programa na mas kumplikado kaysa sa isa na gumagamit lamang ng mga pagpapatakbo ng arithmetic ay ang paggamit ng lahat ng uri ng mga function. Binibigyang-daan ka ng mga function na magsagawa ng mga gawain tulad ng pag-convert mula sa isang uri ng numero patungo sa isa pa (tingnan ang artikulo ng Mga Uri ng Data) at paghahanap ng minimum o maximum na numero sa isang hanay ng mga numero. Ang sumusunod na talahanayan ay nagpapakita ng mga simpleng mathematical function:
| Function | Paglalarawan |
|---|---|
| sahig() | Kumuha ng isang aktwal na parameter (karaniwang isang double-precision na floating-point na numero) at ibinabalik ang pinakamalaking integer na mas mababa sa o katumbas ng aktwal na parameter na iyon (round down) |
| kisame() | Ang pangalan ng function na ito ay isang abbreviation ng salitang ceiling. Ang function ay tumatagal ng isang aktwal na parameter (karaniwan ay isang double-precision na floating-point na numero) at ibinabalik ang pinakamaliit na integer na mas malaki sa o katumbas ng aktwal na parameter na iyon (pag-round up) |
| bilog() | Kumukuha ng isang aktwal na parameter (karaniwang isang double-precision na floating-point na numero) at ibinabalik ang pinakamalapit na integer |
| abs() | Ang ganap na halaga ng isang numero. Kung ang tanging numerong aktwal na parameter ay may negatibong halaga, ibabalik ng function ang katumbas na positibong numero; kung ang aktwal na parameter ay positibo, pagkatapos ay ibabalik ng function ang aktwal na parameter mismo |
| min() | Tumatanggap ng anumang bilang ng mga aktwal na parameter ng numero (ngunit hindi bababa sa isa) at ibinabalik ang pinakamaliit sa lahat ng aktwal na mga halaga ng parameter |
| max() | Tumatanggap ng anumang bilang ng mga numerong aktwal na parameter (ngunit hindi bababa sa isa) at ibinabalik ang pinakamalaki sa lahat ng aktwal na halaga ng parameter |
Halimbawa, ang resulta ng sumusunod na expression ay 3 dahil ang halaga ng bawat function call expression ay 3 din:
PHP code $result = min(3, abs(-3), max(round(2.7), ceil(2.3), floor(3.9)));Pagbuo ng mga random na numero
Gumagamit ang wika ng PHP ng dalawang random na generator ng numero (tinatawag ayon sa pagkakabanggit gamit ang mga function rand() At mt_rand()). Ang bawat isa sa mga generator na ito ay nauugnay sa tatlong mga pag-andar ng parehong layunin: ang pag-andar ng pagtatakda ng paunang halaga ( srand() At mt_srand()), ang function mismo para sa pagkuha ng random na numero at ang function na nagsa-sample ng pinakamalaking integer na maaaring ibalik ng generator (( getrandmax() At mt_getrandmax())). Ang getrandmax() at mt_getrandmax() function ay nagbabalik ng pinakamalaking bilang na maaaring ibalik ng rand() o mt_rand(), na limitado sa 32768 sa mga Windows platform.
Ang pagpili ng partikular na pseudorandom number generation function na ginamit sa rand() function ay maaaring depende sa kung aling mga aklatan ang PHP interpreter ay pinagsama-sama. Sa kabaligtaran, ang generator ng mt_rand() ay palaging gumagamit ng parehong pseudo-random number generation function (ang mt ay maikli para sa Mersenne Twister), at ang may-akda ng operational documentation para sa mt_rand() function ay sinasabing ang function na ito ay mas mabilis din at " more random" (mula sa cryptographic point of view) kaysa sa rand(). Wala kaming dahilan upang pagdudahan ang katotohanan ng mga pahayag na ito, kaya naman mas gusto naming gamitin ang function na mt_rand() kaysa rand().
Kapag gumagamit ng ilang bersyon ng PHP sa ilang platform, lumilitaw na ang rand() at mt_rand() na mga function ay gumagawa ng tila makatwirang mga random na numero, kahit na hindi muna nagtatakda ng binhi. Ngunit ang gayong impresyon ay hindi dapat pagkatiwalaan. Una, ang mga program na gumagamit ng mga function para sa pagbuo ng mga random na numero nang hindi tinukoy ang isang paunang halaga ay hindi madaling ilipat sa iba pang mga platform, at, pangalawa, ang maaasahang operasyon ng mga function na ito nang hindi tinukoy ang isang paunang halaga ay hindi ginagarantiyahan.
Ang karaniwang paraan upang itakda ang seed value para sa alinman sa mga random number generator ng PHP (gamit ang mt_srand() o srand() function) ay ang mga sumusunod:
PHP code mt_srand((double)microtime()*1000000);Itinatakda ng operator na ito ang paunang halaga ng generator, katumbas ng bilang ng mga microsecond na lumipas sa oras na ito mula noong pagbibilang ng huling buong segundo. (Ang cast na magdoble sa pahayag na ito ay talagang kinakailangan dahil ang microtime() function ay nagbabalik ng isang string, na itinuturing bilang isang integer sa multiplication operation ngunit hindi sa pagpapatakbo ng pagpasa ng mga parameter sa function.) Inirerekomenda namin na ang mambabasa ay pumasok ang tinukoy na operator ng paunang halaga kahit na hindi niya lubos na nauunawaan ang layunin ng operator na ito; Ang paglalagay lamang ng pahayag na ito sa bawat pahina ng PHP, isang beses lang, bago gamitin ang kaukulang mt_rand() o rand() function, ay titiyakin na ang panimulang punto ay nagbabago at samakatuwid ay gumagawa ng ibang random na pagkakasunud-sunod sa bawat pagkakataon.
Ang tiyak na pamamaraan Ang pagtatakda ng paunang halaga ay malalim na pinag-isipan ng mga espesyalistang iyon na lubos na nauunawaan ang lahat ng mga nuances ng pagbuo ng mga pseudo-random na numero, samakatuwid, malamang, ito ay magpakailanman ay mananatiling mas mahusay kaysa sa anumang mga pagtatangka ng sinumang indibidwal na programmer na makabuo ng isang bagay na mas "mapanlinlang" .
Malinaw, ang mga pseudo-random na function na bumubuo ng numero ay nagbabalik lamang ng mga integer, ngunit ang isang random na integer mula sa isang ibinigay na hanay ay madaling ma-convert sa isang katumbas na floating-point na numero (sabihin, isang numero mula sa saklaw na 0.0 hanggang 1.0 kasama) gamit ang isang expression tulad ng rand () / getrandmax(). Ang tinukoy na hanay ay maaaring i-scale at ilipat kung kinakailangan. Nasa ibaba ang isang halimbawa:
PHP code // Sabihin nating kailangan nating bumuo random na numero mula 100.0 hanggang 120.0 $random = 100.0 + 20.0 * mt_rand() / mt_getrandmax(); echo $random.""; // Bumuo ng mga integer (100 - 120); echo round($random);
Subukang i-refresh ang page gamit ang code na ito nang maraming beses upang matiyak na ang mga random na numero ay nabuo.
Mga pare-parehong matematika
Sa bersyon ng PHP 4.0, mayroon lamang isang mathematical constant na inilarawan sa dokumentasyon - M_PI (ang halaga ng π, na kinakatawan bilang isang double-precision na floating-point na numero). At simula sa PHP 4.0.2, maraming mga bagong constant ang ipinakilala. Karamihan sa mga bagong constant na ito ay nauugnay sa π (o mga multiple nito), e (o mga multiple nito), at square roots; bilang karagdagan, ang ilang mga constant ay kabilang sa iba pang mga uri. Ngunit sa mga kasunod na paglabas, para sa maraming mga kadahilanan, ang listahan ng mga constant ay muling nabawasan sa isang medyo maliit na bilang ng mga paunang natukoy na mathematical constants:
| pare-pareho | Paglalarawan |
|---|---|
| M_PI | π |
| M_PI_2 | π/2 |
| M_PI_4 | π/4 |
| M_1_PI | 1/π |
| M_2_PI | 2/π |
| M_2_SQRTPI | 2 / sqrt(π) |
| M_E | e |
| M_SQRT2 | sqrt(2) |
| M_SQRT1_2 | 1 / sqrt(2) |
| M_LOG2E | log2(e) |
| M_LOG10E | log(e) |
| M_LN2 | loge(2) |
| M_LN10 | loge(10) |
Sinusuri ang format ng numero
Ang wikang PHP ay nagbibigay ng ilang function na nagbibigay-daan sa iyong suriin ang tamang representasyon ng mga numero. Bagama't walang mahigpit na pagsusuri sa uri ang PHP, inirerekumenda na ipatupad mo ang ilan sa mga pagsusuring ito sa iyong code kung kinakailangan upang mahulaan ang mga katangian ng mga resulta na iyong natatanggap, at upang piliin din pinakamahusay na paraan kanilang pagproseso.
Ang una at pinakasimpleng pagsusuri ay ang paggamit ng function is_numeric(). Tulad ng karamihan sa iba pang mga pagsubok, ang is_numeric function ay nagbabalik ng Boolean na resulta - true kung ang parameter na ipinasa dito ay numeric data ng anumang uri (lagdaan o hindi nilagdaan, integer o floating point) o isang mathematical expression na nagbabalik ng wastong numerong halaga.
Paggamit ng mga function is_int() At is_float Maaari mong matukoy kung ang isang numero ay isang integer o isang fraction. Ang dalawa pang tseke ay medyo mas kumplikado: mga function is_finite() At is_infinite() nagbibigay-daan sa iyo na gawin ang eksaktong mga pagsubok na ipinahiwatig ng kanilang mga pangalan (kung ang numero ay may hangganan o walang katapusan). Ngunit, sa mahigpit na pagsasalita, ang hanay ng mga halaga kung saan pinalawak ng mga pagpapaandar na ito ay hindi maaaring magsama ng aktwal na infinity (at maaari ba itong suriin kung ang numero ay may infinity? pinakamahalaga?). Sa halip, ang mga limitasyon ng saklaw ng mga halaga ng lumulutang na punto na pinapayagan sa partikular na sistema ay ginagamit.
Nasa ibaba ang isang halimbawa ng paggamit ng mga function na ito:
PHP code is_numeric(4); // true is_numeric(25 - 6); // true is_numeric("25"); // true is_numeric("25 - 6"); // false is_int(4); // true is_int(4.2); // false is_int("4"); // false - ang tseke na ito ay mas mahigpit kaysa sa tseke gamit ang is_numeric() function is_float(4); // false is_float(4.0); // true is_float(M_PI); // totooPagbabago ng mga sistema ng numero
Bilang default, ginagamit ng PHP ang base 10 upang i-convert ang mga numeric na halaga mula sa panlabas patungo sa panloob na representasyon pasulong at paatras. Maaari mo ring sabihin sa PHP interpreter na ang panlabas na representasyon ay gumagamit ng mga batayang 8 octal na numero (upang magawa ito, kailangan mong ilagay ang nangungunang 0 ), o mga numerong hexadecimal na tinukoy sa base 16 (upang gawin ito, dapat mong prefix ang numero na may 0x).
Siyempre, pagkatapos ma-convert ang mga numero mula sa isang panlabas na representasyon sa isang panloob, sila ay naka-imbak sa memorya sa binary na format, at ang lahat ng mga pangunahing aritmetika at matematikal na pagkalkula ay isinasagawa sa operating system sa base 2. Bilang karagdagan, ang PHP ay nagbibigay ng ilang mga function para sa pag-convert ng mga numero mula sa isang base patungo sa isa pa. Pangkalahatang Impormasyon Ang mga function na ito ay ipinapakita sa talahanayan sa ibaba:
| Function | Paglalarawan |
|---|---|
| BinDec() | Kinukuha ang isang parameter ng string na isang binary integer (isang base 2 na numero) at ibinabalik ang base 10 string na representasyon ng numerong iyon |
| DecBin() | Katulad ng BinDec(), ngunit nagko-convert mula sa base 10 hanggang sa base 2 |
| OctDec() | Katulad ng BinDec(), ngunit nagko-convert mula sa base 8 hanggang sa base 10 |
| DecOct() | Katulad ng BinDec(), ngunit nagko-convert mula sa base 10 hanggang sa base 8 |
| HexDec() | Katulad ng BinDec(), ngunit nagko-convert mula sa base 16 hanggang sa base 10 |
| DecHex() | Katulad ng BinDec(), ngunit nagko-convert mula sa base 10 hanggang sa base 16 |
| base_convert() | Tumatanggap ng string parameter (kumakatawan sa integer na iko-convert) at dalawang integer parameter (ang orihinal at ang gustong radix). Nagbabalik ng string na kumakatawan sa na-convert na numero. Sa linyang ito, kinakatawan ang mga numerong higit sa 9 (10 hanggang 35). mga simbolo a-z. Parehong ang orihinal at ninanais na mga base ay dapat nasa hanay ng 2-36 |
Ang lahat ng function ng conversion ng system ng numero ay mga function na may espesyal na layunin na nagko-convert ng mga numero mula sa isang partikular na base patungo sa isa pa. Ang isang exception ay ang base_convert() function, na tumatanggap ng mga di-makatwirang parameter na nagsasaad ng inisyal at nagreresultang mga base.
Tandaan na ang lahat ng function ng conversion ng system ng numero ay tumatanggap ng mga parameter ng string at nagbabalik ng mga halaga ng string, ngunit maaari kang gumamit ng mga decimal na numeric na parameter at umasa sa PHP interpreter upang maisagawa nang tama ang uri ng conversion. Sa madaling salita, parehong DecBin("1234") at DecBin(1234) ay parehong gumagawa ng parehong resulta.
Exponent at logarithms
Kasama sa wikang PHP ang karaniwang exponential at logarithmic function sa dalawang uri - para sa pagtatrabaho sa base 10 at base e (na ipinapakita sa talahanayan).
Nagbibigay ang PHP ng exp() function upang itaas ang e sa isang ibinigay na kapangyarihan, ngunit walang isang parameter na function upang itaas ang 10 sa isang ibinigay na kapangyarihan. Gayunpaman, maaari mong gamitin ang pow() function sa halip, na tumatagal ng dalawang parameter, na nagbibigay ng 10 bilang unang parameter.
Maaari mong i-verify na ang mga exponential at logarithmic function na may parehong base ay magkabaligtaran sa bawat isa sa pamamagitan ng pagsuri sa pagkakakilanlan ng mga resultang nakuha sa ganitong paraan:
PHP code $test_449 = 449.0; $test_449 = pow(10, exp(log(log10($test_449)))); echo "test_449 = $test_449"; // pagsubok_449 = 449Trigonometric function
Ang wikang PHP ay nagbibigay ng isang karaniwang hanay ng mga pangunahing trigonometriko function, pangkalahatang impormasyon tungkol sa kung saan ay ibinigay sa talahanayan:
| Function | Paglalarawan |
|---|---|
| pi() | Hindi ito tumatagal ng mga parameter at nagbabalik ng tinatayang halaga ng π (3.1415926535898). Maaaring gamitin nang palitan sa M_PI constant |
| kasalanan() | Tumatanggap ng numeric parameter sa radians at ibinabalik ang sine ng parameter bilang double precision floating point number |
| cos() | Kumuha ng numeric na parameter sa radians at ibinabalik ang cosine ng parameter bilang double precision floating point number |
| kulay-balat() | Tumatanggap ng numeric na parameter sa radians at ibinabalik ang tangent ng parameter bilang double precision floating point number |
| tulad ng sa() | Kumuha ng numeric na parameter at ibinabalik ang arcsine ng parameter sa radians. Ang mga input ay dapat nasa pagitan ng -1 at 1 (ang function na tumatanggap ng mga input sa labas ng hanay na ito ay nagreresulta sa isang resulta ng NAN). Ang mga resulta ay mula sa -π/2 hanggang π/2 |
| acos() | Kumuha ng numeric na parameter at ibinabalik ang arc cosine ng parameter sa radians. Ang mga input ay dapat nasa hanay na -1 hanggang 1 (ang function na tumatanggap ng mga input sa labas ng hanay na ito ay nagreresulta sa isang resulta ng NAN. Ang mga resulta ay nasa hanay na 0 hanggang π |
| atan() | Kumuha ng numeric na parameter at ibinabalik ang arctangent ng parameter sa radians. Ang mga resulta ay mula sa -π/2 hanggang π/2 |
Nasa ibaba ang isang halimbawa ng pag-compile ng isang talahanayan para sa pagkalkula ng mga function ng trigonometriko para sa mga "standard" na anggulo:
PHP code function display_trigonometry($func_array, $input_array) ( // Function header echo "| Kahulugan/function | $func | "; ) echo "
|---|---|
| ".sprintf("%.4f",$input)." | "; foreach($func_array bilang $func) ( echo ""; printf("%4.4f", $func($input)); echo " | "; ) echo "
Isang halimbawa ng paggamit ng trigonometriko function sa PHP Ang dahilan para sa pagkuha ng napakalaking (ngunit hindi walang katapusan) tangent na mga halaga ay ang mga denominator ay dapat na theoretically ay zero, ngunit sa katotohanan ay bahagyang naiiba mula sa zero dahil sa mga error sa rounding.
Di-makatwirang pagkalkula ng katumpakan (gamit ang mga function ng BC)
Ang mga uri ng integer at double-precision na floating-point ay ganap na sapat para sa karamihan ng mga problema sa matematika na nararanasan sa web scripting, ngunit ang bawat instance ng value na kinakatawan ng mga ganitong uri ay nangangailangan ng isang nakapirming dami ng memorya ng computer, kaya ang laki at katumpakan ng representasyon ng numero sa mga ganitong uri hindi maiiwasang magpataw ng mga limitasyon.
Siyempre, ang eksaktong mga hanay ng halaga ng mga uri ng data na ito ay maaaring depende sa arkitektura ng server computer, ngunit ang mga halaga ng integer ay karaniwang maaaring mula sa -2 31 -1 hanggang 2 31 -1, at ang mga double-precision na floating-point na numero ay maaaring kumakatawan sa mga numero na may katumpakan na humigit-kumulang 13 hanggang 14 na decimal na digit. Sa kabilang banda, upang malutas ang mga problema na nangangailangan ng paggamit ng mas malawak na hanay ng representasyon o mas katumpakan, nagbibigay ang PHP di-makatwirang katumpakan ng mga function ng matematika(tinatawag din na mga function ng BC, pinangalanan sa Unix-based na arbitrary-precision computing utility).
Maaaring hindi kasama sa compilation ng PHP interpreter ang mga arbitrary precision function, lalo na kung mismong ang user ang gumawa ng compilation, dahil para dito kailangang malaman ng user na sa yugto ng pagsasaayos ay kinakailangang magsama ng checkbox sa mga parameter --enable-bcmath. Upang tingnan kung available ang mga tinukoy na function, subukang suriin ang expression na bcadd("1","1"). Kung nakatanggap ka ng mensahe ng error na nagsasaad ng hindi natukoy na function, kakailanganin mong i-configure muli ang PHP interpreter at muling i-compile ito.
Ang mga function ng BC ay gumagamit ng mga hindi numeric na uri na may representasyon bilang mga parameter at mga return value nakapirming haba, at ang mga linya. Dahil sa PHP ang haba ng mga string ay limitado lamang sa laki magagamit na memorya, ang mga numerong ginamit sa mga kalkulasyon ay maaaring maging anumang haba. Ang mga pangunahing kalkulasyon ay ginagawa sa desimal na anyo at katulad ng nagagawa ng isang tao gamit ang lapis at papel (kung kaya niyang magtrabaho nang napakabilis at matiyaga). Ang mga function ng BC integer ay tumpak at nagbibigay-daan sa iyong gumamit ng maraming digit kung kinakailangan, habang ang mga function ng floating-point ay nagsasagawa ng mga kalkulasyon na tumpak sa isang tinukoy na bilang ng mga decimal na lugar. Ang pangkalahatang impormasyon tungkol sa mga function ng BC ay ibinibigay sa talahanayan sa ibaba:
| Function | Paglalarawan |
|---|---|
| bcadd() | Tumatanggap ng dalawang string na parameter na kumakatawan sa mga numero at isang opsyonal na parameter ng integer na nagsasaad ng scale factor. Ibinabalik ang kabuuan ng unang dalawang parameter bilang isang string, na may bilang ng mga decimal na lugar sa resulta na tinutukoy ng parameter na nagsasaad ng scale factor. Kung hindi tinukoy ang parameter na nagsasaad ng scale factor, gagamitin ang default na scale factor |
| bcsub() | Katulad ng bcadd(), maliban na ibinabalik nito ang resulta ng pagbabawas ng pangalawang parameter mula sa una |
| bcmui() | Katulad ng bcadd(), maliban na ibinabalik nito ang resulta ng pagpaparami ng mga parameter nito |
| bcdiv() | Katulad ng bcadd(), maliban na ibinabalik nito ang resulta ng paghahati ng unang parameter sa pangalawa |
| bcmod() | Ibinabalik ang modulus (natitira) ng paghahati ng unang parameter sa pangalawa. Dahil ang return value ay isang integer, ang function ay hindi tumatanggap ng parameter na nagsasaad ng scale factor |
| bcpow() | Itinataas ang unang parameter sa kapangyarihan na tinukoy ng pangalawang parameter. Ang bilang ng mga decimal na lugar sa resulta ay tinutukoy ng scale factor, kung ang isa ay tinukoy |
| bcsqrt() | Nagbabalik Kuwadrado na ugat parameter na may bilang ng mga decimal na lugar na tinutukoy ng halaga ng opsyonal na scale factor |
| bcscale() | Itinatakda ang default na scale factor para sa mga kasunod na tawag sa BC function |
Karamihan sa mga function na ito ay tumatagal bilang huling parameter ng isang opsyonal na scale factor (isang integer), na tumutukoy kung gaano karaming mga decimal na lugar ang dapat magkaroon ng resulta. Kung hindi tinukoy ang parameter na ito, gagamitin ang default na scale factor bilang scale factor, na maaaring itakda sa pamamagitan ng pagtawag sa bcscale() function. Ang default na value para sa default na value na ito (iyon ay, ang value na ginagamit kung ang script ay hindi tumatawag sa bcscale()) ay maaari ding itakda sa php.ini initialization file.
Nasa ibaba ang isang halimbawa ng paggamit ng arbitrary precision function upang maisagawa ang integer arithmetic operations nang tumpak. Isinasagawa ang sumusunod na code:
PHP code para sa ($x = 1; $x< 25; $x++) { echo "$x$x= ".bcpow($x, $x).""; }
Tumpak na pagkalkula ng astronomical na dami gamit ang BC functions Kung ang isang regular na uri ng PHP integer ay ginamit para sa mga kalkulasyong ito, kung gayon ang integer overflow ay magaganap bago matapos ang pagkalkula, kaya ang natitirang bahagi ng loop ay magsasagawa ng mga kalkulasyon upang makakuha ng tinatayang numero ng floating point.
Arrays Form processing 1 2 3 4 5 6 7 8 9 10Mga operasyon na may mga variable ng PHP (mga operator)
Mayroong iba't ibang mga grupo para sa pagpapatupad.
Ang operator ay isang bagay na binubuo ng isa o higit pang mga halaga (mga expression sa programming jargon) na maaaring masuri bilang isang bagong halaga (kaya, ang buong construct ay maaaring ituring na isang expression). Sinusundan nito ang mga function o anumang iba pang mga konstruksyon na nagbabalik ng isang halaga (halimbawa, print()) ay mga operator, hindi katulad ng lahat ng iba pang mga konstruksyon ng wika (halimbawa, echo()), na walang ibinabalik.
Mga pagpapatakbo ng aritmetika sa PHP
Tandaan ang mga pangunahing kaalaman sa paaralan ng aritmetika? Ang mga pahayag sa ibaba ay gumagana sa parehong paraan.
Ang division operator ("/") ay palaging nagbabalik ng isang tunay na uri, kahit na ang parehong mga halaga ay mga integer (o mga string na nagko-convert sa mga integer). Kung hindi, magiging fractional ang resulta.
Ang pagpapatakbo ng pagkalkula ng natitira sa dibisyon " % " Gumagana lamang sa mga buong numero, kaya ang paglalapat nito sa mga fraction ay maaaring magbunga ng hindi kanais-nais na mga resulta.
Posibleng gumamit ng mga panaklong. Ang precedence ng ilang mga mathematical operations sa iba at ang pagbabago sa mga priority kapag gumagamit ng parentheses sa mga arithmetic expression ay sumusunod sa mga karaniwang tuntunin ng matematika.
Mga pagpapatakbo ng pagtaas at pagbaba
Ang PHP, tulad ng C, ay sumusuporta sa prefix at postfix increment at decrement operator.
Mga operator ng pagtaas at pagbaba ng postfix
Tulad ng sa C, ang mga operator na ito ay nagdaragdag o nagpapababa ng halaga ng isang variable, at sa isang expression ay ibinabalik ang halaga ng variable. $a bago ang pagbabago. Halimbawa:
$a=10;
$b=$a++;
echo "a=$a, b=$b"; // Nagpi-print ng a=11, b=10
Tulad ng nakikita mo, una ang variable $b halaga na itinalaga sa variable $a, at saka lang nadagdagan ang huli. Gayunpaman, ang expression na ang halaga ay itinalaga sa variable $b, ay maaaring mas mahirap - sa anumang kaso, pagtaas $a mangyayari lamang pagkatapos itong makalkula.
Prefix increment at decrement operator
Mayroon ding mga increment at decrement operator, na tinukoy sa halip na pagkatapos ng variable na pangalan. Alinsunod dito, ibinabalik nila ang halaga ng variable pagkatapos ng pagbabago. Halimbawa:
$a=10;
$b=--$a;
echo "a=$a, b=$b"; // Nagpi-print ng a=9, b=9
Ang mga pagpapatakbo ng pagtaas at pagbabawas ay madalas na ginagamit sa pagsasanay. Halimbawa, nangyayari ang mga ito sa halos anumang cycle para sa .
echo "Pagdagdag ng postfix
"
;
$a = 5 ;
echo "Dapat ay 5: " . $a++ . "
\n" ;
\n" ;
Echo "Pagdaragdag ng prefix
"
;
$a = 5 ;
echo "Dapat ay 6: " . ++ $a . "
\n" ;
echo "Dapat ay 6: " . $a . "
\n" ;
Echo "Pagbawas ng postfix
"
;
$a = 5 ;
echo "Dapat ay 5: " . $a -- . "
\n" ;
\n" ;
Echo "Pagbaba ng prefix
"
;
$a = 5 ;
echo "Dapat ay 4: " . -- $a . "
\n" ;
echo "Dapat ay 4: " . $a . "
\n" ;
?>
Mga pagpapatakbo ng string
Ang PHP ay may dalawang operator para sa pagtatrabaho sa mga string. Ang una ay ang concatenation operator ("."), na nagbabalik ng concatenation ng kaliwa at kanang argumento. Ang pangalawa ay isang assignment operator na may concatenation, na nagdaragdag ng tamang argumento sa kaliwa. Magbigay tayo ng isang tiyak na halimbawa:
$a = "Kumusta" ;
$b = $a . "Mundo!" ; // $b ay naglalaman ng string na "Hello World!"
$a = "Kumusta" ;
$a .= "Mundo!" ; // $a ay naglalaman ng string na "Hello World!"
?>
Mga pagpapatakbo ng bitwise
Ang mga operasyong ito ay idinisenyo upang patakbuhin (itakda/i-unset/suriin) ang mga pangkat ng mga bit sa isang buong variable. Ang mga bit ng isang integer ay hindi hihigit sa mga indibidwal na digit ng parehong numero na nakasulat sa binary number system. Halimbawa, sa binary ang numero 12 ay magmumukhang 1100 at 2 ay magiging 10, kaya ang expression 12|2
ibabalik sa amin ang numero 14 (1110 sa binary notation). Kung ang isang variable ay hindi isang integer, kung gayon ito ay
unang bilugan, at pagkatapos ay ilalapat dito ang mga sumusunod na operator.
Upang kumatawan sa isang numero, ginagamit ang 32 bits:
- 0000 0000 0000 0000 0000 0000 0000 0000 ay zero;
- 0000 0000 0000 0000 0000 0000 0000 0001 ay 1;
- 0000 0000 0000 0000 0000 0000 0000 0010 ay 2;
- 0000 0000 0000 0000 0000 0000 0000 0011 ay 3;
- 0000 0000 0000 0000 0000 0000 0000 0100 ay 4;
- 0000 0000 0000 0000 0000 0000 0000 0101 ay 5;
- 0000 0000 0000 0000 0000 0000 0000 1111 ay 15;
Mga operator ng bitwise:
| Halimbawa | Pangalan | Resulta |
|---|---|---|
| $a at $b | Bitwise "at" | Tanging ang mga bit na nakatakda sa parehong $a at $b ang nakatakda. |
| $a | $b | Bitwise "o" | Ang mga bit na iyon na nakatakda sa alinman sa $a o $b ay nakatakda. |
| $a^$b | Eksklusibo o | Tanging ang mga bit na nakatakda sa $a lamang o $b lamang ang nakatakda |
| ~$a | Negasyon | Ang mga bit na hindi nakatakda sa $a ay nakatakda, at vice versa. |
| $a<< $b | Lumipat pakaliwa | Ang lahat ng mga bit ng variable na $a ay inililipat ng $b na mga posisyon sa kaliwa (bawat posisyon ay nagpapahiwatig ng "multiply ng 2") |
| $a >> $b | Lumipat pakanan | Ang lahat ng mga bit ng variable na $a ay inilipat sa $b na mga posisyon sa kanan (bawat posisyon ay nagpapahiwatig ng "division by 2") |
Mga Operasyon sa Paghahambing
Ang mga operator ng paghahambing, gaya ng iminumungkahi ng kanilang pangalan, ay nagbibigay-daan sa iyong paghambingin ang dalawang halaga.
Ito ay mga natatanging operasyon sa kanilang sariling paraan dahil, anuman ang mga uri ng kanilang mga argumento, palagi nilang ibinabalik ang isa sa dalawang bagay: mali o totoo. Ang mga operasyon sa paghahambing ay naghahambing ng dalawang halaga sa isa't isa at, kung totoo ang kundisyon, bumalik totoo, At kung hindi - mali.
Pinapayagan lamang ng PHP na maihambing ang mga scalar variable. Ang mga array at object ay hindi maihahambing sa PHP. Hindi man sila maihahambing para sa pagkakapantay-pantay (gamit ang == operator), ngunit ang PHP ay hindi nagbibigay ng babala kapag nagsasagawa ng naturang operasyon. Kaya, minsan ay nagtaka kung bakit dalawang ganap na magkaibang mga array kapag inihambing ang mga ito gamit == biglang naging pareho, tandaan na bago ang paghahambing, ang parehong mga operand ay na-convert sa isang salita array, na pagkatapos ay inihambing.
Tingnan ang paghahambing ng array para sa mga detalye.
Mga operator ng paghahambing:
| Halimbawa | Pangalan | Resulta |
|---|---|---|
| $a == $b | katumbas | TOTOO kung ang $a ay katumbas ng $b. |
| $a === $b | Magkaparehong pantay | TOTOO kung ang $a ay katumbas ng $b at may parehong uri. (Idinagdag sa PHP 4) |
| $a != $b | Hindi pantay | TOTOO kung ang $a ay hindi katumbas ng $b. |
| $a<>$b | Hindi pantay | TOTOO kung ang $a ay hindi katumbas ng $b. |
| $a !== $b | Ang magkapareho ay hindi pantay | TOTOO kung ang $a ay hindi katumbas ng $b o kung sila ay iba't ibang uri(Idinagdag sa PHP 4) |
| $a< $b | Mas kaunti | TOTOO kung ang $a ay mahigpit na mas mababa sa $b. |
| $a > $b | Higit pa | TOTOO kung ang $a ay mahigpit na mas malaki kaysa sa $b. |
| $a<= $b | Mas kaunti o katumbas | TOTOO kung ang $a ay mas mababa sa o katumbas ng $b. |
| $a >= $b | Higit pa o katumbas | TOTOO kung ang $a ay mas malaki sa o katumbas ng $b. |
Mga lohikal na operasyon
Ang mga lohikal na operator ay eksklusibong idinisenyo para sa pagtatrabaho sa mga Boolean na expression at bumalik din mali o totoo.
Narito ang isang talahanayan ng mga lohikal na operator ng PHP:
Dapat tandaan na ang pagsusuri ng mga lohikal na expression na naglalaman ng mga naturang operator ay palaging nagpapatuloy mula kaliwa hanggang kanan, at kung ang resulta ay halata na (halimbawa, huwad&&isang bagay laging nagbibigay mali), pagkatapos ay ang mga kalkulasyon ay wawakasan, kahit na ang expression ay naglalaman ng mga function na tawag. Halimbawa, sa operator $logic = 0&&(time()>100); karaniwang pag-andar oras() hindi na tatawagin.
Mag-ingat sa mga lohikal na operasyon - huwag kalimutan ang tungkol sa pagdodoble ng character. Pakitandaan na, halimbawa, | At || - dalawang ganap na magkaibang mga operator, ang isa ay maaaring magbalik ng anumang numero, at ang pangalawa - lamang mali At totoo.
Ang increment (++) at decrement (--) operator ay hindi gumagana sa boolean variable.
Mga operator ng equivalence
Sa PHP, simula sa PHP4 ay mayroong magkaparehong operator ng paghahambing - isang triple equal sign ===
,
o ang check operator. Ang PHP ay medyo mapagparaya sa mga string na tahasang na-convert sa mga numero, at vice versa.
Halimbawa, ang sumusunod na code ay magpi-print na ang mga halaga ng mga variable ay pantay:
$a=10;
$b="10";
At ito sa kabila ng katotohanan na ang variable $a kumakatawan sa isang numero at $b- linya. Ngayon tingnan natin ang isang bahagyang naiibang halimbawa:
$a=0; // sero
$b=""; // walang laman na linya
if($a==$b) echo "ang a at b ay pantay"; // Nagpi-print ng "a at b ay pantay"
Bagaman $a At $b ay malinaw na hindi pantay kahit sa karaniwang kahulugan ng salita, ang script ay magdedeklara na sila ay pareho. Bakit ito nangyayari? Ang punto ay kung ang isa sa mga operand ng isang lohikal na operator ay maaaring bigyang-kahulugan bilang isang numero, kung gayon ang parehong mga operand ay itinuturing bilang mga numero. Sa kasong ito, ang walang laman na linya ay nagiging 0
, na pagkatapos ay inihambing sa zero. Ito ay hindi nakakagulat na ang operator echo gumagana.
Ang problema ay nalulutas ng equivalence operator ===
(triple equality). Hindi lamang ito naghahambing ng dalawang expression, kundi pati na rin ang kanilang mga uri. Isulat muli natin ang ating halimbawa gamit ang operator na ito.
Huling na-update: 11/1/2015
Sa PHP maaari tayong gumamit ng iba't ibang mga operator: aritmetika, lohikal, atbp. Tingnan natin ang bawat uri ng operasyon.
Mga operasyon sa aritmetika
+ (pagdaragdag ng operasyon)
Halimbawa, $a + 5
- (pagpapatakbo ng pagbabawas)
Halimbawa, $a - 5
* (pagpaparami)
Halimbawa, $a * 5
/ (dibisyon)
Halimbawa, $a / 5
% (pagkuha ng natitirang bahagi)
Halimbawa: $a=12; echo $a % 5; // katumbas ng 2
++ (pagtaas/pagtaas ng halaga ng isa)
Halimbawa, ++$a
Mahalagang maunawaan ang pagkakaiba sa pagitan ng mga expression na ++$a at $a++ . Halimbawa:
$a=12; $b=++$a; // $b ay katumbas ng 13 echo $b;
Dito, una, ang isa ay idinagdag sa halaga ng variable na $a, at pagkatapos ay itinutumbas ang halaga nito sa variable na $b. Magiging iba kung ganito ang ekspresyon: $b=$a++; . Dito, una ang halaga ng variable na $a ay katumbas ng variable na $b, at pagkatapos ay ang halaga ng variable na $a ay nadagdagan.
-- (bawas/bawas halaga ng isa)
Halimbawa, --$a . At gayundin, tulad ng sa kaso ng pagtaas, mayroong dalawang uri ng pag-record: --$a at $a--
Mga Operator ng Pagtatalaga
Tinutumbas ang isang variable sa isang partikular na halaga: $a = 5
Pagdaragdag na sinusundan ng pagtatalaga ng resulta. Halimbawa: $a=12; $a += 5; echo $a; // katumbas ng 17
Pagbabawas na sinusundan ng pagtatalaga ng resulta. Halimbawa: $a=12; $a -= 5; echo $a; // katumbas ng 7
Pagpaparami na sinusundan ng pagtatalaga ng resulta: $a=12; $a *= 5; echo $a; // katumbas ng 60
Dibisyon na sinusundan ng pagtatalaga ng resulta: $a=12; $a /= 5; echo $a; // katumbas ng 2.4
Pagsamahin ang mga hilera at italaga ang resulta. Nalalapat sa dalawang linya. Kung ang mga variable ay hindi nag-iimbak ng mga string, ngunit, halimbawa, mga numero, ang kanilang mga halaga ay na-convert sa mga string at pagkatapos ay ang operasyon ay ginanap: $a=12; $a .= 5; echo $a; // katumbas ng 125 // kapareho ng $b="12"; $b .="5"; // katumbas ng 125
Pagkuha ng natitirang bahagi at pagkatapos ay italaga ang resulta: $a=12; $a %= 5; echo $a; // katumbas ng 2
Mga Operasyon sa Paghahambing
Ang mga pagpapatakbo ng paghahambing ay kadalasang ginagamit sa mga kondisyong konstruksyon kapag kinakailangan upang ihambing ang dalawang halaga at, depende sa resulta ng paghahambing, magsagawa ng ilang mga aksyon. Ang mga sumusunod na operasyon sa paghahambing ay magagamit.
Ang operator ng pagkakapantay-pantay ay naghahambing ng dalawang halaga, at kung magkapareho ang mga ito, magbabalik ng true, kung hindi ay magbabalik ng false: $a == 5
Ang operator ng pagkakakilanlan ay naghahambing din ng dalawang halaga, at kung magkapareho ang mga ito, magbabalik ng true, kung hindi, magbabalik ng false: $a === 5
Naghahambing ng dalawang value, at kung hindi magkapantay ang mga ito, nagbabalik ng true, kung hindi, nagbabalik ng false: $a != 5
Naghahambing ng dalawang value, at kung hindi sila magkapantay, nagbabalik ng true, kung hindi ay nagbabalik ng false: $a !== 5
Naghahambing ng dalawang halaga, at kung ang una ay mas malaki kaysa sa pangalawa, pagkatapos ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a > 5
Naghahambing ng dalawang halaga, at kung ang una ay mas mababa sa pangalawa, pagkatapos ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a< 5
Naghahambing ng dalawang halaga, at kung ang una ay mas malaki kaysa o katumbas ng pangalawa, pagkatapos ay ibabalik ang true, kung hindi, ibabalik ang false: $a >= 5
Naghahambing ng dalawang halaga, at kung ang una ay mas mababa sa o katumbas ng pangalawa, pagkatapos ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a<= 5
Operator ng pagkakapantay-pantay at pagkakakilanlan
Ang parehong operator ay naghahambing ng dalawang expression at nagbabalik ng true kung ang mga expression ay pantay. Ngunit may mga pagkakaiba sa pagitan nila. Kung ang pagpapatakbo ng pagkakapantay-pantay ay tumatagal ng dalawang halaga ng iba't ibang uri, kung gayon ang mga ito ay nabawasan sa isa - ang isa na nahanap ng interpreter na pinakamainam. Halimbawa:
Malinaw, ang mga variable ay nag-iimbak ng iba't ibang mga halaga ng iba't ibang uri. Ngunit kapag inihambing, sila ay mababawasan sa parehong uri - numeric. At ang variable na $a ay mababawasan sa bilang na 22. At sa huli, ang parehong mga variable ay magiging pantay.
O, halimbawa, ang mga sumusunod na variable ay magiging pantay din:
$a = mali; $b = 0;
Upang maiwasan ang mga ganitong sitwasyon, ginagamit ang equivalence operation, na isinasaalang-alang hindi lamang ang halaga, kundi pati na rin ang uri ng variable:
$a = "22a"; $b = 22; if($a===$b) echo "equal"; iba echo "hindi katumbas";
Ngayon ang mga variable ay hindi magiging pantay.
Ang mga operator ng hindi pagkakapantay-pantay != at !== ay gumagana nang katulad.
Mga lohikal na operasyon
Ang mga lohikal na operasyon ay karaniwang ginagamit upang pagsamahin ang mga resulta ng dalawang paghahambing na operasyon. Halimbawa, kailangan nating magsagawa ng isang partikular na pagkilos kung totoo ang ilang kundisyon. Ang mga sumusunod na lohikal na operasyon ay magagamit:
Nagbabalik ng true kung ang parehong paghahambing ay nagbabalik ng true, kung hindi ay nagbabalik ng false: $a == 5 && $b = 6
Katulad ng && operation: $a == 5 at $b > 6
Nagbabalik ng true kung magbabalik ng true ang kahit isang operasyon ng paghahambing, kung hindi, magbabalik ng false: $a == 5 || $b = 6
Katulad ng operasyon || : $a< 5 or $b > 6
Nagbabalik ng true kung ang operasyon ng paghahambing ay nagbabalik ng false: !($a >= 5)
Nagbabalik ng true kung isa lang sa mga value ang totoo. Kung pareho ang totoo o alinman ay hindi totoo, nagbabalik ng mali. Halimbawa: $a=12; $b=6; if($a xor $b) echo "totoo"; iba pa echo "false";
Dito ang resulta ng lohikal na operasyon ay magiging mali dahil ang parehong mga variable ay may isang tiyak na halaga. Baguhin natin ang code:
$a=12; $b=NULL; if($a xor $b) echo "totoo"; iba pa echo "false";
Dito magiging totoo na ang resulta, dahil hindi nakatakda ang halaga ng isang variable. Kung ang isang variable ay may halagang NULL, kung gayon sa mga lohikal na operasyon ang halaga nito ay ituturing na hindi totoo
Mga pagpapatakbo ng bit
Ang mga bit operation ay ginagawa sa mga indibidwal na bit ng isang numero. Ang mga numero ay isinasaalang-alang sa binary na representasyon, halimbawa, 2 sa binary na representasyon ay 010, ang numero 7 ay 111.
& (lohikal na pagpaparami)
Ang multiplikasyon ay ginaganap nang bitwise, at kung ang parehong mga operand ay may mga bit na halaga na katumbas ng 1, ang operasyon ay nagbabalik ng 1, kung hindi, ang numerong 0 ay ibinalik. Halimbawa: $a1 = 4; //100 $b1 = 5; //101 echo $a1 & $b1; // katumbas ng 4
Narito ang numero 4 sa binary system ay 100, at ang numero 5 ay 101. I-multiply ang mga numero nang bitwise at makakuha ng (1*1, 0*0, 0 *1) = 100, iyon ay, ang numero 4 sa decimal na format.
| (lohikal na karagdagan)
Katulad ng logical multiplication, ang operasyon ay ginagawa din sa binary digits, ngunit ngayon ay ibinabalik ang isa kung kahit isang numero sa isang naibigay na digit ay may isa. Halimbawa: $a1 = 4; //100 $b1 = 5; //101 echo $a1 | $b1; // katumbas ng 5
~ (lohikal na pagtanggi)
binabaligtad ang lahat ng mga bit: kung ang halaga ng bit ay 1, ito ay magiging zero, at kabaliktaran. $b = 5; echo ~$b;
x< x>>y - inililipat ang numerong x sa kanan sa pamamagitan ng y digit. Halimbawa, ang 16>>1 ay naglilipat ng 16 (na 10000 sa binary) isang lugar sa kanan, na nagreresulta sa 1000 o 8 sa decimal
Pinagsasama-samang Strings
Ang dot operator ay ginagamit upang pagdugtungin ang mga string. Halimbawa, ikonekta natin ang ilang linya:
$a="Hello,"; $b=" mundo"; echo $a . $b . "!";
Kung ang mga variable ay kumakatawan sa iba pang mga uri kaysa sa mga string, tulad ng mga numero, ang kanilang mga halaga ay na-convert sa mga string at pagkatapos ay ang string concatenation operasyon ay nangyayari din.