Aritmetiske operatorer php. Operasjoner i PHP

Programmerere som trenger å utføre ansvarlig numerisk, vitenskapelig eller statistiske beregninger, vil neppe vurdere et webskriptspråk som en akseptabel kandidat for denne rollen. Men til tross for ovennevnte tilbyr PHP-språket et utmerket sett med funksjoner som fullstendig gir en løsning for de fleste matematiske problemer, som oppstår under utførelse av skript for nettet. I tillegg gir PHP noen mer avanserte funksjoner, for eksempel vilkårlig presisjonsaritmetikk, hashing-biblioteker og kryptografiske biblioteker.

Utviklerne av PHP-språket tok en velbegrunnet tilnærming og gjorde ikke noe forsøk på å finne opp hjulene designet for dette formålet på nytt. Faktum er at mange av de mest grunnleggende matematiske funksjonene som brukes i PHP er ganske enkelt omslag rundt C-motpartene.

Matematiske operasjoner

Det meste av matematikk i PHP gjøres i form av innebygde funksjoner i stedet for operasjoner. I tillegg til sammenligningsoperatorer tilbyr PHP fem enkle aritmetiske operatorer, samt noen snarveisoperatorer som lar deg konstruere kortere inkrement-, dekrement- og tilordningsuttrykk.

Aritmetiske operasjoner

De fem grunnleggende aritmetiske operasjonene inkluderer de som vanligvis implementeres i en hvilken som helst firefunksjonskalkulator, pluss modulo (%). Kort beskrivelse aritmetiske operasjoner vist i tabellen:

Aritmetiske operasjoner
Operasjon Beskrivelse
+ Returnerer summen av verdiene til de to operandene
- Hvis det er to operander, trekkes verdien av den høyre operanden fra verdien til den venstre. Hvis det bare er en høyreoperand, returnerer operasjonen verdien av den operanden med motsatt fortegn
* Returnerer produktet av verdiene til de to operandene
/ Returnerer flyttallresultatet ved å dele verdien av venstre operande med verdien av høyre operande
% Returnerer resten av et heltall delt på verdien av venstre operand med absoluttverdien av høyre operande

Når du bruker de tre første aritmetiske operasjonene beskrevet ovenfor (+, -, *) i et program, bør du ta i betraktning at når du utfører disse operasjonene, skjer typeutbredelse fra dobbelpresisjons flyttallsverdier til heltallsverdier. Hva dette betyr er at hvis begge operandene til en operasjon er heltall, så er resultatet et heltall, og hvis minst en av operandene er et flytende tall med dobbel presisjon, så er resultatet et flytende tall med dobbel presisjon Antall. Samme type forplantning forekommer når du utfører en delingsoperasjon; i tillegg er det en tilleggseffekt at resultatet blir et flyttall med dobbel presisjon dersom delingen ikke utføres uten rest (helt).

Modulo (%)-operasjonen i PHP aksepterer heltallsoperander, og når denne operasjonen brukes på flytende tall med dobbel presisjon, blir disse tallene først konvertert til heltall (ved å forkaste brøkdelen). Resultatet av en slik operasjon er alltid et heltall.

Øke og redusere operasjoner

Mye av PHPs syntaks er avledet fra C, og C-programmerere er kjent for sin kjærlighet til korthet og er stolte av det. Inkrement- og dekrementoperatorene, hentet fra C-språket, gjør det mulig å mer konsist representere uttrykk som $count = $count + 1, som vanligvis finnes ganske ofte i programmer.

Inkrementoperatoren (++) brukes til å legge til én til verdien av variabelen som påvirkes av operasjonen, og dekrementoperatoren (--) trekker én fra verdien til variabelen.

Hver av disse to operasjonene har to varianter - suffiks(i denne formen plasseres operasjonstegnet umiddelbart etter variabelen som påvirkes av operasjonen) og prefiks(i dette skjemaet er operasjonstegnet plassert rett foran variabelen som operasjonen gjelder). Begge variantene har det samme bivirkning forbundet med å endre verdien av en variabel, men suffiks- og prefiksoperasjoner returnerer forskjellige betydninger når det brukes som uttrykk. Suffiksoperasjonen fungerer slik at verdien av variabelen endres etter at verdien av uttrykket er returnert, og prefiksoperasjonen fungerer slik at verdien først endres og deretter den nye verdien returneres til variabelen. Denne forskjellen kan oppdages ved å bruke dekrementerings- og inkrementoperatorene i tildelingsoperatorer:

PHP-kode $count = 0; $result = $count++; echo "Resultat av $count++ økning: ".$result."
"; $count = 0; $result = ++$count; ekko "Resultat av ++$count-økning: ".$result."
";

Følgende utsagn produserer følgende utdata i nettleservinduet:

Øke operasjoner

I dette eksemplet er operatoren $result = $count++ fullstendig ekvivalent med operatorene:

PHP-kode $result = $count; $count = $count + 1;

Sammen med dette tilsvarer operatoren $result = ++$count følgende operatorer:

PHP-kode $count = $count +1; $result = $count;

Oppdragsoperatører

Øke (og dekrementere) operatører reduserer mengden kode som kreves for å legge en til verdien av en variabel, men reduserer ikke mengden kode som tildeler en variabel resultatet av å legge til verdien til et annet tall eller resultatet av andre aritmetiske operasjoner . Heldigvis har alle fem aritmetiske operatorer tilsvarende tilordningsoperatorer (+=, -=, *=, /= og %=), som lar deg tilordne resultatet av en aritmetisk operasjon på verdien av den variabelen til en variabel i en kort uttrykk. For eksempel operatøren

PHP-kode $count = $count * 3;

kan forkortes som

PHP-kode $count *= 3;

Enkle matematiske funksjoner

Det neste trinnet i å gjøre et program mer komplekst enn et som bare bruker aritmetiske operasjoner er å bruke alle slags funksjoner. Med funksjoner kan du utføre oppgaver som å konvertere fra én talltype til en annen (se artikkelen om datatyper) og finne minimums- eller maksimumstallet i et sett med tall. Følgende tabell viser enkle matematiske funksjoner:

Enkle PHP matematiske funksjoner
Funksjon Beskrivelse
gulv() Tar en enkelt faktisk parameter (vanligvis et flyttall med dobbel presisjon) og returnerer det største heltall som er mindre enn eller lik den faktiske parameteren (rund nedover)
tak() Navnet på denne funksjonen er en forkortelse av ordet tak. Funksjonen tar en enkelt faktisk parameter (vanligvis et flytende tall med dobbel presisjon) og returnerer det minste heltall som er større enn eller lik den faktiske parameteren (avrunding oppover)
rund() Tar en enkelt faktisk parameter (vanligvis et flyttall med dobbel presisjon) og returnerer det nærmeste heltall
abs() Den absolutte verdien av et tall. Hvis den eneste numeriske faktiske parameteren har en negativ verdi, returnerer funksjonen den tilsvarende positivt tall; hvis den faktiske parameteren er positiv, returnerer funksjonen selve parameteren
min() Godtar et hvilket som helst antall numeriske faktiske parametere (men minst én) og returnerer den minste av alle faktiske parameterverdier
maks() Godtar et hvilket som helst antall numeriske faktiske parametere (men ikke mindre enn én) og returnerer den største av alle faktiske parameterverdier

For eksempel er resultatet av det følgende uttrykket 3 fordi verdien av hvert funksjonsanropsuttrykk også er 3:

PHP-kode $result = min(3, abs(-3), max(round(2.7), ceil(2.3), floor(3.9)));

Generer tilfeldige tall

PHP-språket bruker to tilfeldige tallgeneratorer (kalles henholdsvis ved å bruke funksjonene rand() Og mt_rand()). Hver av disse generatorene er assosiert med tre funksjoner med samme formål: funksjonen for å sette startverdien ( srand() Og mt_srand()), selve funksjonen for å få et tilfeldig tall og funksjonen som sampler det største heltallet som kan returneres av generatoren (( getrandmax() Og mt_getrandmax())). Funksjonene getrandmax() og mt_getrandmax() returnerer en verdi det største antallet, som kan returneres av rand() eller mt_rand(), på Windows-plattformer denne verdien er begrenset til 32768.

Valget av den spesifikke pseudotilfeldige tallgenereringsfunksjonen som brukes i rand()-funksjonen kan avhenge av hvilke biblioteker PHP-tolken ble kompilert med. I kontrast bruker mt_rand()-generatoren alltid den samme pseudo-tilfeldige tallgenereringsfunksjonen (mt er forkortelse for Mersenne Twister), og forfatteren av operasjonsdokumentasjonen for mt_rand()-funksjonen hevder at denne funksjonen også er raskere og "mer random" (fra et kryptografisk synspunkt) enn rand(). Vi har ingen grunn til å tvile på sannheten til disse utsagnene, og det er grunnen til at vi foretrekker å bruke funksjonen mt_rand() fremfor rand().

Når du bruker noen versjoner av PHP på noen plattformer, ser det ut til at rand()- og mt_rand()-funksjonene produserer tilsynelatende rimelige tilfeldige tall, selv uten først å sette et frø. Men et slikt inntrykk bør man ikke stole på. For det første kan ikke programmer som bruker funksjoner for å generere tilfeldige tall uten å spesifisere en startverdi enkelt overføres til andre plattformer, og for det andre, pålitelig drift av de spesifiserte funksjonene uten å spesifisere en startverdi er ikke garantert.

En typisk måte å angi startverdien for en av de tilfeldige generatorene PHP tall(ved å bruke funksjonen mt_srand() eller srand()) er som følger:

PHP-kode mt_srand((dobbel)mikrotid()*1000000);

Denne operatøren setter startverdien til generatoren, lik antall mikrosekunder som har gått på dette tidspunktet siden det siste hele sekundet ble talt. (Det å doble casten i denne setningen er faktisk nødvendig fordi funksjonen microtime() returnerer en streng, som behandles som et heltall i multiplikasjonsoperasjonen, men ikke i operasjonen med å sende parametere til funksjonen.) Vi anbefaler at leseren skriver inn den spesifiserte initialiseringsoperatøren selv om formålet med denne operatøren ikke er helt klart for ham; akkurat nok til å plassere denne operatøren for hver PHP-side, bare én gang, før du bruker den tilsvarende mt_rand()- eller rand()-funksjonen, og denne operatoren vil sørge for at startpunktet endres og derfor produserer forskjellige tilfeldige sekvenser hver gang.

De spesifikk metodeå sette startverdien ble dypt gjennomtenkt av de spesialistene som fullt ut forstår alle nyansene ved å generere pseudo-tilfeldige tall, derfor vil det mest sannsynlig for alltid forbli bedre enn noen forsøk fra en individuell programmerer på å komme opp med noe mer "vanskelig" .

Åpenbart returnerer disse pseudo-tilfeldige tallgenererende funksjonene bare heltall, men et tilfeldig heltall fra et gitt område kan enkelt konverteres til et tilsvarende flyttall (f.eks. et tall fra området 0,0 til 1,0 inklusive) ved å bruke et uttrykk som rand () / getrandmax(). Det angitte området kan deretter skaleres og forskyves etter behov. Nedenfor er et eksempel:

PHP-kode // La oss si at vi må generere tilfeldig tall fra 100,0 til 120,0 $tilfeldig = 100,0 + 20,0 * mt_rand() / mt_getrandmax(); ekko $tilfeldig."
"; // Generer heltall (100 - 120); echo round($random);

Prøv å oppdatere siden med denne koden flere ganger for å sikre at tilfeldige tall genereres.

Matematiske konstanter

I PHP versjon 4.0 var det kun én matematisk konstant beskrevet i dokumentasjonen - M_PI (verdien av π, representert som et flytende tall med dobbel presisjon). Og starter fra PHP-versjoner 4.0.2 ble mange nye konstanter introdusert. De fleste av disse nye konstantene knyttet til π (eller dens multipler), e (eller dens multipler) og kvadratrøtter; i tillegg tilhørte noen konstanter andre typer. Men i påfølgende utgivelser, av en rekke årsaker, ble listen over konstanter igjen redusert til et relativt lite antall forhåndsdefinerte matematiske konstanter:

PHP matematiske konstanter
Konstant Beskrivelse
M_PI π
M_PI_2 π/2
M_PI_4 π/4
M_1_PI 1/π
M_2_PI 2/π
M_2_SQRTPI 2 / sqrt(π)
MEG e
M_SQRT2 sqrt(2)
M_SQRT1_2 1 / sqrt(2)
M_LOG2E log2(e)
M_LOG10E logg(e)
M_LN2 loge(2)
M_LN10 loge (10)

Sjekker tallformat

PHP-språket har en rekke funksjoner som lar deg sjekke riktig representasjon av tall. Selv om PHP ikke har streng typekontroll, anbefales det at du implementerer noen av disse sjekkene i koden din når det er nødvendig for å kunne forutsi egenskapene til resultatene du mottar, og også velge beste måten behandlingen deres.

Først og mest enkel sjekk er å bruke funksjonen is_numeric(). Som med de fleste andre slike tester, returnerer funksjonen is_numeric et boolsk resultat - sant hvis parameteren som sendes til den er numeriske data av en hvilken som helst type (med eller uten fortegn, heltall eller flytende komma) eller et matematisk uttrykk som returnerer en gyldig numerisk verdi.

Bruke funksjoner is_int() Og er_flyter Du kan bestemme om et tall er et heltall eller en brøk. Ytterligere to kontroller er litt mer komplekse: funksjoner er_endelig() Og er_uendelig() lar deg utføre nøyaktig de testene som navnene deres indikerer (om tallet er endelig eller uendelig). Men strengt tatt kan ikke utvalget av verdier som disse funksjonene strekker seg over inkludere faktisk uendelighet (og kan det til og med kontrolleres om tallet har uendelig? veldig viktig?). I stedet brukes grensene for rekkevidden av flytende kommaverdier som er tillatt på det bestemte systemet.

Nedenfor er et eksempel på bruk av disse funksjonene:

PHP-kode er_numerisk(4); // sant er_numerisk(25 - 6); // true is_numeric("25"); // true is_numeric("25 - 6"); // false is_int(4); // sant er_int(4.2); // false is_int("4"); // falsk - denne sjekken strengere enn is_numeric() is_float(4); // false is_float(4.0); // true is_float(M_PI); // sant

Konvertering av tallsystemer

Standard i PHP-språk for forover- og bakoverkonvertering numeriske verdier radix 10 brukes fra den eksterne representasjonen til den interne representasjonen. I tillegg kan du fortelle PHP-tolken at den eksterne representasjonen bruker oktale tall, spesifisert i grunntall 8 (for dette må du angi en innledende 0 før tallet), eller heksadesimale tall, spesifisert i base 16 (for dette må du angi prefikset 0x før tallet).

Selvfølgelig, etter å ha konvertert tall fra en ekstern representasjon til en intern, lagres de i minnet i binært format, og alle grunnleggende aritmetiske og matematiske beregninger utføres i operativsystem i base 2. I tillegg gir PHP en rekke funksjoner for å konvertere tall fra en base til en annen. Generell informasjon Disse funksjonene er vist i tabellen nedenfor:

Num
Funksjon Beskrivelse
BinDec() Tar en enkelt strengparameter som er et binært heltall (et base 2 tall) og returnerer base 10 strengrepresentasjonen av det tallet
DecBin() Ligner på BinDec(), men konverterer fra base 10 til base 2
oktdes() Ligner på BinDec(), men konverterer fra base 8 til base 10
DecOct() Ligner på BinDec(), men konverterer fra base 10 til base 8
HexDec() Ligner på BinDec(), men konverterer fra base 16 til base 10
DecHex() Ligner på BinDec(), men konverterer fra base 10 til base 16
base_convert() Godtar en strengparameter (representerer heltallet som skal konverteres) og to heltallsparametere (den opprinnelige og ønsket radiks). Returnerer en streng som representerer det konverterte tallet. På denne linjen er tall større enn 9 (10 til 35) representert symbolene a-z. Både originalen og den ønskede basen må være innenfor området 2-36

Alle ter funksjoner Spesielt formål, konvertere tall fra en bestemt base til en annen. Et unntak er base_convert()-funksjonen, som aksepterer vilkårlige parametere som indikerer de innledende og resulterende basene.

Merk at alle tgodtar strengparametere og returnerer strengverdier, men du kan bruke desimal numeriske parametere og stole på at PHP-tolken utfører typekonverteringen riktig. Med andre ord, både DecBin("1234") og DecBin(1234) gir begge det samme resultatet.

Eksponenter og logaritmer

PHP-språket inkluderer standard eksponentiell og logaritmiske funksjoner to varianter - for arbeid i base 10 og base e (som er vist i tabellen).

PHP gir en exp() funksjon for å heve e til en gitt potens, men det er ingen en-parameter funksjon for å heve 10 til en gitt potens. Du kan imidlertid bruke pow() funksjonen i stedet, som tar to parametere, og gir 10 som den første parameteren.

Du kan bekrefte at eksponentielle og logaritmiske funksjoner med samme base er invers av hverandre ved å sjekke identiteten til resultatene oppnådd på denne måten:

PHP-kode $test_449 = 449,0; $test_449 = pow(10, exp(log(log10($test_449)))); echo "test_449 = $test_449"; // test_449 = 449

Trigonometriske funksjoner

PHP-språket gir et standard sett med grunnleggende trigonometriske funksjoner, generell informasjon om hvilke er gitt i tabellen:

Trigonometriske funksjoner
Funksjon Beskrivelse
pi() Den tar ingen parametere og returnerer en omtrentlig verdi på π (3,1415926535898). Kan brukes om hverandre med M_PI-konstanten
synd() Aksepterer en numerisk parameter i radianer og returnerer sinusen til parameteren som et flyttall med dobbel presisjon
cos() Tar en numerisk parameter i radianer og returnerer cosinus til parameteren som et flyttall med dobbel presisjon
tan() Aksepterer en numerisk parameter i radianer og returnerer tangensen til parameteren som et flyttall med dobbel presisjon
som i() Tar en numerisk parameter og returnerer arcsinus til parameteren i radianer. Inndata må være mellom -1 og 1 (funksjonen som mottar innganger utenfor dette området resulterer i et NAN-resultat). Resultatene varierer fra -π/2 til π/2
acos() Tar en numerisk parameter og returnerer buecosinus til parameteren i radianer. Inndata må være i området -1 til 1 (funksjonen som mottar innganger utenfor dette området resulterer i et NAN-resultat. Resultatene er i området 0 til π
brunfarge() Tar en numerisk parameter og returnerer arctangensen til parameteren i radianer. Resultatene varierer fra -π/2 til π/2

Nedenfor er et eksempel på å kompilere en tabell for beregning av trigonometriske funksjoner for "standard" vinkler:

PHP-kode function display_trigonometry($func_array, $input_array) ( // Funksjonshodeekko " "; ) ekko ""; // Skriv ut resten av tabellen foreach($input_array som $input) ( echo " "; foreach($func_array som $func) ( echo " "; ) ekko ""; ) ekko "
Betydning/funksjon$func
".sprintf("%.4f",$input).""; printf("%4.4f", $func($input)); ekko "
"; ) display_trigonometry(array("sin", "cos", "tan"), array(0, M_PI / 6, M_PI / 3, M_PI / 2, M_PI));
Et eksempel på bruk av trigonometriske funksjoner i PHP

Å oppnå veldig store (men ikke uendelige) tangentverdier skyldes det faktum at nevnerne teoretisk skal være lik null, men er faktisk litt forskjellig fra null på grunn av avrundingsfeil.

Vilkårlig presisjonsberegning (ved hjelp av BC-funksjoner)

Heltalls- og dobbelpresisjons flyttallstyper er helt tilstrekkelige for de fleste matematiske problemer som oppstår i nettskripting, men hver forekomst av verdien representert av disse typene har en fast lagringskapasitet. datamaskinens minne, derfor er det uunngåelig pålagt begrensninger på størrelsen og nøyaktigheten av representasjonen av tall av disse typene.

Selvfølgelig kan de nøyaktige verdiområdene for disse datatypene avhenge av arkitekturen til serverdatamaskinen, men heltallsverdier kan typisk variere fra -2 31 -1 til 2 31 -1, og flytende tall med dobbel presisjon kan representerer tall med en presisjon på omtrent 13 til 14 desimaler. På den annen side for å løse problemer som krever bruk av flere bred rekkevidde representasjon eller større presisjon, gir PHP-språket vilkårlige matematiske presisjonsfunksjoner(også kalt BC-funksjoner, oppkalt etter det Unix-baserte dataverktøyet med vilkårlig presisjon).

Du kan finne at vilkårlige presisjonsfunksjoner ikke er inkludert i kompileringen PHP tolk, spesielt hvis brukeren utførte slik kompilering uavhengig, siden for dette måtte brukeren vite at det på konfigurasjonsstadiet er nødvendig å inkludere en avmerkingsboks i parameterne --enable-bcmath. For å sjekke om du har tilgang til spesifiserte funksjoner, prøv å evaluere uttrykket bcadd("1","1"). Hvis du får en feilmelding som sier udefinert funksjon, så må du konfigurere konfigurasjonen på nytt og kompilere PHP-tolken på nytt.

BC-funksjoner bruker ikke parametere eller returverdier. numeriske typer med en representasjon av fast lengde i stedet for en streng. Siden i PHP er lengden på strenger bare begrenset av størrelsen tilgjengelig minne, kan tallene som brukes i beregningene være av hvilken som helst lengde. Grunnleggende beregninger utføres i desimal og minner på mange måter om de som en person kan gjøre med blyant og papir (hvis han kan handle veldig raskt og være tålmodig). BC-heltallsfunksjoner er presise og lar deg bruke så mange sifre som nødvendig, mens flyttallfunksjoner utfører beregninger nøyaktig til et spesifisert antall desimaler. Generell informasjon om BC-funksjoner er gitt i tabellen nedenfor:

Matematiske funksjoner med vilkårlig presisjon (BC-funksjoner)
Funksjon Beskrivelse
bcadd() Tar to strengparametere, som representerer tall, og en valgfri heltallsparameter som indikerer en skaleringsfaktor. Returnerer summen av de to første parameterne som en streng, med antall desimaler i resultatet bestemt av parameteren som indikerer skaleringsfaktoren. Hvis parameteren som indikerer skaleringsfaktoren ikke er spesifisert, brukes standard skaleringsfaktor
bcsub() Ligner på bcadd(), bortsett fra at den returnerer resultatet av å trekke den andre parameteren fra den første
bcmui() Ligner på bcadd(), bortsett fra at den returnerer resultatet av å multiplisere parameterne
bcdiv() Ligner på bcadd(), bortsett fra at den returnerer resultatet av å dele den første parameteren med den andre
bcmod() Returnerer modulen (resten) for å dele den første parameteren med den andre. Fordi returverdien er et heltall, godtar ikke funksjonen en parameter som indikerer en skaleringsfaktor
bcpow() Hever den første parameteren til en potens, angitt andre parameter. Antall desimaler i resultatet bestemmes av skalafaktoren, hvis en er angitt
bcsqrt() Returnerer Kvadratrot parameter med et antall desimaler bestemt av verdien av den valgfrie skaleringsfaktoren
bcscale() Angir standard skaleringsfaktor for påfølgende anrop til BC-funksjonen

De fleste av disse funksjonene tar som siste parameter en valgfri skalafaktor (heltall) som spesifiserer hvor mange desimaler resultatet skal ha. Hvis denne parameteren ikke er spesifisert, brukes standard skaleringsfaktor som skaleringsfaktor, som igjen kan settes ved å kalle funksjonen bcscale(). Standardverdien for denne standardverdien (det vil si verdien som brukes hvis skriptet ikke kaller bcscale()) kan også angis i initialiseringsfilen php.ini.

Nedenfor er et eksempel på bruk av en vilkårlig presisjonsfunksjon for å utføre heltallsaritmetiske operasjoner nøyaktig. Utfører følgende kode:

PHP-kode for ($x = 1; $x< 25; $x++) { echo "$x$x= ".bcpow($x, $x)."
"; } Nøyaktig beregning av astronomiske størrelser ved hjelp av BC-funksjoner

Hvis for disse beregningene den vanlige heltallstype PHP, så ville heltallsoverløpet skje lenge før slutten av beregningen, så resten av løkken ville utføre beregninger for å få et omtrentlig flyttall.

Matriser Skjemabehandling 1 2 3 4 5 6 7 8 9 10

Operasjoner med PHP-variabler (operatører)

Det er ulike grupper for gjennomføring.

En operator er noe som består av en eller flere verdier (uttrykk i programmeringssjargong) som kan evalueres som en ny verdi (dermed kan hele konstruksjonen betraktes som et uttrykk). Det følger at funksjoner eller andre konstruksjoner som returnerer en verdi (f.eks. skrive ut()) er operatorer, i motsetning til alle andre språkkonstruksjoner (f.eks. ekko()), som ikke returnerer noe.

Aritmetiske operasjoner i PHP

Husker du skolens grunnleggende aritmetikk? Utsagnene nedenfor fungerer på samme måte.

Divisjonsoperatøren ("/") returnerer alltid ekte type, selv om begge verdiene var heltall (eller strenger som konverteres til heltall). Ellers vil resultatet være brøkdel.

Operasjonen med å beregne resten av divisjonen " % " fungerer bare med hele tall, så å bruke det på brøker kan gi uønskede resultater.

Det er mulig å bruke parenteser. Prioriteten til noen matematiske operasjoner fremfor andre og endringen i prioriteringer ved bruk av parenteser i aritmetiske uttrykk samsvarer med vanlige matematiske regler.

Øke og redusere operasjoner

PHP, som C, støtter prefiks- og postfix-operatorer for inkrement og dekrementering.

Postfix-operatorer for økning og reduksjon

Som i C, øker eller reduserer disse operatorene verdien til en variabel, og i et uttrykk returnerer verdien til variabelen $a før endringen. For eksempel:

$a=10;
$b=$a++;
ekko "a=$a, b=$b"; // Skriver ut a=11, b=10

Som du kan se, først variabelen $b verdi tilordnet variabel $a, og først da ble den siste økt. Imidlertid uttrykket hvis verdi er tilordnet til variabelen $b, kan være vanskeligere - i alle fall øke $a vil skje først etter at det er beregnet.

Operatorer for prefiks for økning og reduksjon

Det finnes også inkrement- og dekrementoperatorer, som er spesifisert i stedet for etter variabelnavnet. Følgelig returnerer de verdien av variabelen etter endringen. Eksempel:

$a=10;
$b=--$a;
ekko "a=$a, b=$b"; // Skriver ut a=9, b=9

Inkrement- og dekrementoperasjoner brukes svært ofte i praksis. For eksempel forekommer de i nesten hvilken som helst syklus til .

ekko "

Postfix-økning

" ;
$a = 5 ;
ekko "Bør være 5: " . $a++ . "
\n" ;

\n" ;

Ekko "

Prefiks økning

" ;
$a = 5 ;
ekko "Bør være 6: " . ++ $a . "
\n" ;
ekko "Bør være 6: " . $a . "
\n" ;

Ekko "

Postfix-reduksjon

" ;
$a = 5 ;
ekko "Bør være 5: " . $a -- . "
\n" ;

\n" ;

Ekko "

Prefiksreduksjon

" ;
$a = 5 ;
ekko "Må være 4: " . --$a. "
\n" ;
ekko "Må være 4: " . $a . "
\n" ;
?>

Strengeoperasjoner

PHP har to operatører for å jobbe med strenger. Den første er sammenkoblingsoperatoren ("."), som returnerer sammenkoblingen av venstre og høyre argumenter. Den andre er en tilordningsoperator med sammenkobling, som legger til det høyre argumentet til det venstre. La oss gi et spesifikt eksempel:

$a = "Hei" ;
$b = $a . "Verden!" ; // $b inneholder strengen "Hello World!"

$a = "Hei" ;
$a .= "Verden!" ; // $a inneholder strengen "Hello World!"
?>

Bitvise operasjoner

Disse operasjonene er utformet for å betjene (sette/deaktivere/sjekke) grupper av biter i en hel variabel. Bitene i et heltall er ikke mer enn individuelle sifre med samme tall, skrevet inn binært system Regning. For eksempel, i binær vil tallet 12 se ut som 1100 og 2 vil se ut som 10, så uttrykket 12|2 vil returnere oss nummeret 14 (1110 in binær notasjon). Hvis en variabel ikke er et heltall, så er den det
først avrundet, og deretter blir følgende operatorer brukt på den.

For å representere ett tall, brukes 32 biter:

  • 0000 0000 0000 0000 0000 0000 0000 0000 er null;
  • 0000 0000 0000 0000 0000 0000 0000 0001 er 1;
  • 0000 0000 0000 0000 0000 0000 0000 0010 er 2;
  • 0000 0000 0000 0000 0000 0000 0000 0011 er 3;
  • 0000 0000 0000 0000 0000 0000 0000 0100 er 4;
  • 0000 0000 0000 0000 0000 0000 0000 0101 er 5;
  • 0000 0000 0000 0000 0000 0000 0000 1111 er 15;

Bitvise operatører:

Eksempel Navn Resultat
$a & $b Bitvis "og" Bare de bitene som er satt i både $a og $b er satt.
$a | $b Bitvis "eller" De bitene som er satt i enten $a eller $b er satt.
$a^$b Eksklusiv eller Bare de bitene som er satt i enten bare $a eller bare $b er satt
~$a Negasjon De bitene som ikke er satt i $a er satt, og omvendt.
$a<< $b Skift til venstre Alle biter av variabel $a forskyves $b-posisjoner til venstre (hver posisjon innebærer en "multipliser med 2")
$a >> $b Skift til høyre Alle biter av variabel $a forskyves $b-posisjoner til høyre (hver posisjon innebærer "divisjon med 2")

Sammenligningsoperasjoner

Sammenligningsoperatorer, som navnet antyder, lar deg sammenligne to verdier.

Dette er unike operasjoner på hver sin måte fordi, uavhengig av typen argumentasjon, de alltid returnerer en av to ting: falsk eller ekte. Sammenligningsoperasjoner sammenligner to verdier med hverandre og returnerer hvis betingelsen er sann ekte, Og hvis ikke - falsk.

PHP lar bare skalarvariabler sammenlignes. Matriser og objekter kan ikke sammenlignes i PHP. De kan ikke engang sammenlignes for likestilling (ved å bruke ==-operatoren), men PHP gir ingen advarsel når en slik operasjon utføres. Så, etter å ha lurt på hvorfor to helt forskjellige arrays når du sammenligner dem med == plutselig viser seg å være det samme, husk at før sammenligning blir begge operandene konvertert til et ord array, som deretter sammenlignes.

Se Array-sammenligning for detaljer.

Sammenligningsoperatører:

Eksempel Navn Resultat
$a == $b Er lik EKTE hvis $a er lik $b.
$a === $b Identisk like EKTE hvis $a er lik $b og har samme type. (Lagt til i PHP 4)
$a != $b Ikke lik EKTE hvis $a ikke er lik $b.
$a<>$b Ikke lik EKTE hvis $a ikke er lik $b.
$a !== $b Identisk er ikke lik EKTE hvis $a ikke er lik $b eller om de er det forskjellige typer(Lagt til i PHP 4)
$a< $b Mindre EKTE hvis $a er strengt tatt mindre enn $b.
$a > $b Mer EKTE hvis $a er strengt tatt større enn $b.
$a<= $b Mindre eller lik EKTE hvis $a er mindre enn eller lik $b.
$a >= $b Mer eller lik EKTE hvis $a er større enn eller lik $b.

Logiske operasjoner

Logiske operatorer er designet eksklusivt for å jobbe med boolske uttrykk og også returnere falsk eller ekte.

Her er en tabell over logiske PHP-operatorer:

Det skal bemerkes at beregningen logiske uttrykk, som inneholder slike operatorer, går alltid fra venstre til høyre, og hvis resultatet allerede er åpenbart (f.eks. usant&&noe gir alltid falsk), så avsluttes beregningene, selv om uttrykket inneholder funksjonskall. For eksempel, i operatoren $logic = 0&&(tid()>100); standard funksjon tid() vil aldri bli kalt.

Vær forsiktig med logiske operasjoner- Ikke glem å doble symbolet. Vær oppmerksom på at f.eks. | Og || – absolutt to forskjellige operatører, hvorav den ene potensielt kan returnere et hvilket som helst tall, og den andre - bare falsk Og ekte.

Operatorene inkrement (++) og dekrement (--) fungerer ikke med boolske variabler.

Ekvivalensoperatører

I PHP, fra og med PHP4, er det en identisk sammenligningsoperatør - et trippel likhetstegn === ,
eller sjekkeoperatøren. PHP er ganske tolerant for at strenger implisitt konverteres til tall, og omvendt.
For eksempel vil følgende kode skrive ut at verdiene til variablene er like:

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

Og dette til tross for at variabelen $a representerer et tall og $b- linje. La oss nå se på et litt annet eksempel:

$a=0; // null
$b=""; // tom linje
if($a==$b) ekko "a og b er like"; // Skriver ut "a og b er like"

Selv om $a Og $b er tydeligvis ikke like selv i den vanlige betydningen av ordet, vil manuset erklære at de er like. Hvorfor skjer dette? Poenget er at hvis en av operandene logisk operatør kan behandles som et tall, så behandles begge operandene som tall. I dette tilfellet blir den tomme linjen til 0 , som så sammenlignes med null. Det er ikke overraskende at operatøren ekko virker.
Problemet løses av ekvivalensoperatøren === (trippel likestilling). Den sammenligner ikke bare to uttrykk, men også typene deres. La oss omskrive eksemplet vårt ved å bruke denne operatoren.

Sist oppdatert: 1.11.2015

I PHP kan vi bruke ulike operatører: aritmetisk, logisk, etc. La oss se på hver type operasjon.

Aritmetiske operasjoner

    + (tilleggsoperasjon)

    For eksempel $a + 5

    - (subtraksjonsoperasjon)

    For eksempel $a - 5

    * (multiplikasjon)

    For eksempel $a * 5

    / (divisjon)

    For eksempel $a / 5

    % (oppnå resten av divisjonen)

    For eksempel: $a=12; ekko $a % 5; // er lik 2

    ++ (øk/øk verdi med én)

    For eksempel ++$a

    Det er viktig å forstå forskjellen mellom uttrykkene ++$a og $a++ . For eksempel:

    $a=12; $b=++$a; // $b er lik 13 ekko $b;

    Her legges man først til verdien av variabelen $a, og deretter blir verdien likestilt med variabelen $b. Det ville vært annerledes hvis uttrykket så slik ut: $b=$a++; . Her var først verdien av variabelen $a lik variabelen $b, og deretter ble verdien av variabelen $a økt.

    -- (reduser/reduser verdien med én)

    For eksempel --$a . Og også, som i tilfellet med inkrement, er det to typer opptak: --$a og $a--

Oppdragsoperatører

    Tilsvarer en variabel med en bestemt verdi: $a = 5

    Tillegg etterfulgt av tildeling av resultatet. For eksempel: $a=12; $a += 5; ekko $a; // lik 17

    Subtraksjon etterfulgt av tildeling av resultatet. For eksempel: $a=12; $a -= 5; ekko $a; // er lik 7

    Multiplikasjon etterfulgt av tildeling av resultatet: $a=12; $a *= 5; ekko $a; // er lik 60

    Divisjon etterfulgt av tildeling av resultatet: $a=12; $a /= 5; ekko $a; // lik 2,4

    Slå sammen rader og tilordne resultatet. Gjelder to linjer. Hvis variablene ikke lagrer strenger, men for eksempel tall, konverteres verdiene deres til strenger og deretter utføres operasjonen: $a=12; $a .= 5; ekko $a; // lik 125 // identisk med $b="12"; $b .="5"; // lik 125

    Innhente resten av divisjonen og deretter tildele resultatet: $a=12; $a %= 5; ekko $a; // er lik 2

Sammenligningsoperasjoner

Sammenligningsoperasjoner brukes vanligvis i betingede konstruksjoner, når du trenger å sammenligne to verdier, og avhengig av resultatet av sammenligningen, utføre noen handlinger. Følgende sammenligningsoperasjoner er tilgjengelige.

    Likhetsoperatoren sammenligner to verdier, og hvis de er like, returnerer sann, ellers returnerer falsk: $a == 5

    Identitetsoperatoren sammenligner også to verdier, og hvis de er like, returnerer true, ellers returnerer false: $a === 5

    Sammenligner to verdier, og hvis de ikke er like, returnerer sann, ellers returnerer falsk: $a != 5

    Sammenligner to verdier, og hvis de ikke er like, returnerer sann, ellers returnerer falsk: $a !== 5

    Sammenligner to verdier, og hvis den første er større enn den andre, returnerer den sann, ellers returnerer falsk: $a > 5

    Sammenligner to verdier, og hvis den første er mindre enn den andre, returnerer den sann, ellers returnerer falsk: $a< 5

    Sammenligner to verdier, og hvis den første er større enn eller lik den andre, returnerer den sann, ellers returnerer falsk: $a >= 5

    Sammenligner to verdier, og hvis den første er mindre enn eller lik den andre, returnerer den sann, ellers returnerer falsk: $a<= 5

Likestillings- og identitetsoperatør

Begge operatorene sammenligner to uttrykk og returnerer sann hvis uttrykkene er like. Men det er forskjeller mellom dem. Hvis likestillingsoperasjonen tar to verdier av forskjellige typer, reduseres de til én - den som tolken finner optimal. For eksempel:

Selvfølgelig lagrer variabler forskjellige verdier av forskjellige typer. Men når de sammenlignes, vil de bli redusert til samme type - numerisk. Og variabelen $a vil reduseres til tallet 22. Og til slutt vil begge variablene være like.

Eller, for eksempel, vil følgende variabler også være like:

$a = usann; $b = 0;

For å unngå slike situasjoner brukes ekvivalensoperasjonen, som ikke bare tar hensyn til verdien, men også typen av variabelen:

$a = "22a"; $b = 22; if($a===$b) ekko "lik"; annet ekko "ikke like";

Nå vil ikke variablene være like.

Ulikhetsoperatørene != og !== fungerer på samme måte.

Logiske operasjoner

Logiske operasjoner brukes vanligvis til å kombinere resultatene av to sammenligningsoperasjoner. For eksempel må vi utføre en bestemt handling hvis flere forhold er sanne. Følgende logiske operasjoner er tilgjengelige:

    Returnerer true hvis begge sammenligningsoperasjonene returnerer true, ellers returnerer false: $a == 5 && $b = 6

    I likhet med &&-operasjonen: $a == 5 og $b > 6

    Returnerer true hvis minst én sammenligningsoperasjon returnerer true, ellers returnerer false: $a == 5 || $b = 6

    Ligner på operasjonen || : $a< 5 or $b > 6

    Returnerer sann hvis sammenligningsoperasjonen returnerer usann: !($a >= 5)

    Returnerer sann hvis bare én av verdiene er sann. Hvis begge er sanne eller ingen av dem er sanne, returneres usant. For eksempel: $a=12; $b=6; if($a xor $b) ekko "true"; annet ekko "false";

    Her vil resultatet av den logiske operasjonen være usann siden begge variablene har en bestemt verdi. La oss endre koden:

    $a=12; $b=NULL; if($a xor $b) ekko "true"; annet ekko "false";

    Her vil resultatet allerede være sant, siden verdien av én variabel ikke er satt. Hvis en variabel har verdien NULL, vil verdien i logiske operasjoner bli behandlet som usann

Bitoperasjoner

Bitoperasjoner utføres på individuelle biter av et tall. Tall betraktes i binær representasjon, for eksempel er 2 i binær representasjon 010, tallet 7 er 111.

    & (logisk multiplikasjon)

    Multiplikasjon utføres bitvis, og hvis begge operandene har bitverdier lik 1, returnerer operasjonen 1, ellers returneres tallet 0. For eksempel: $a1 = 4; //100 $b1 = 5; //101 ekko $a1 & $b1; // er lik 4

    Her er tallet 4 i det binære systemet 100, og tallet 5 er 101. Multipliser tallene bitvis og få (1*1, 0*0, 0 *1) = 100, det vil si tallet 4 i desimalformat.

    | (logisk tillegg)

    I likhet med logisk multiplikasjon utføres operasjonen også på binære sifre, men nå returneres ett hvis minst ett tall i et gitt siffer har en ener. For eksempel: $a1 = 4; //100 $b1 = 5; //101 echo $a1 | $b1; // er lik 5

    ~ (logisk negasjon)

    inverterer alle biter: hvis bitverdien er 1, blir den null, og omvendt. $b = 5; ekko ~$b;

    x<

    x>>y - flytter tallet x til høyre med y sifre. For eksempel, 16>>1 skifter 16 (som er 10000 i binær) ett sted til høyre, noe som resulterer i 1000 eller 8 i desimal

Sammenknytte strenger

Punktoperatoren brukes til å sette sammen strenger. La oss for eksempel koble sammen flere linjer:

$a="Hei,"; $b=" verden"; ekko $a. $b . "!";

Hvis variablene representerer andre typer enn strenger, for eksempel tall, blir verdiene deres konvertert til strenger, og deretter skjer også strengsammenkoblingsoperasjonen.

Logiske operasjoner finnes i alle programmeringsspråk og PHP ikke et unntak. I tillegg til enkel divisjon, multiplikasjon, addisjon eller subtraksjon, er det også heltalls- og restdivisjoner, som vi nå skal snakke om og også analysere dem ved hjelp av detaljerte eksempler.

Heltallsdivisjon er utgangen av heltallsdelen fra divisjonen. For eksempel, hvis vi deler 5 på 2, får vi 2, ikke 2,5.

Med restdeling er alt annerledes. Dette er utgangen av resten når de er delt på et heltall. For eksempel, hvis du deler de samme fem, får du ikke 2, men 1, fordi å dele 5 med 2, får vi 2, og resten er 1.

Hvordan gjøre heltallsdeling i PHP

For eksempel, i Python gjøres denne divisjonen ved å bruke en enkel operator: "//".

Og i PHP dette vil ikke være så lett å gjøre, men likevel krever ikke prosessen superkunnskaper i språket.

La oss gi et eksempel på hvordan dette kan implementeres.

I PHP Den syvende versjonen av funksjonen ser slik ut:

Intdiv();

I en eldre versjon ser den samme funksjonen slik ut:

Det er også en metode for alle versjoner:

Gulv();

Hvordan søke?

La oss for eksempel ta den første funksjonen, alle de andre utføres på omtrent samme måte.

$resultat = intdiv(10, 3); ekko $resultat;

Resten inndeling i PHP

For å vise hele tallet resten av divisjon i PHP Det er nok å bare bruke "%"-operatoren.

$i = 10 % 3; ekko $i;

Som vi kan se, er alt ganske enkelt og krever ikke lange forklaringer.

Hvor kan det brukes?

Kunnskap om heltallsdivisjon PHP vil være veldig nyttig hvis du trenger å sammenligne to tall, lage et invertert tall (en populær øvelse), eller for eksempel et program som heter FizzBuzz. Essensen er at du må skrive en syklus fra 1 til 100, som deler hvert tall med 3 og 5. Hvis tallet delt på 3 har en rest på 0, skriver vi Fizz, hvis de er delt på 5, så Buzz, og hvis , deler både 5 og 3, resten er 0, så skriver vi FizzBuzz. Dette er en veldig populær intervjuoppgave. Hvis du har fullført det selv, kan du være stolt av deg selv.

Eller, for eksempel, må vi utlede alle tallene (4, 5, 2) fra tallet 452.

Konklusjon

Selvfølgelig er heltalls- og restdivisjoner nyttige og ganske vanlige; de ​​er ikke like praktiske å bruke som i Python, men de er fortsatt viktige.

Nå er du et skritt nærmere å lære et programmeringsspråk PHP og i fremtiden vil du bli enda nærmere hvis du overvinner vanskeligheter like flittig.