Programmerere som trenger å utføre ansvarlige numeriske, vitenskapelige eller statistiske beregninger vil neppe vurdere et webskriptspråk som en akseptabel kandidat for denne rollen. Men når det er sagt, tilbyr PHP-språket et flott sett med funksjoner som gir en komplett løsning på de fleste matematikkproblemene som dukker opp i nettskripting. I tillegg gir PHP-språket noen mer avanserte funksjoner, for eksempel aritmetikk med vilkårlig presisjon, samt fasiliteter for hashing av biblioteker og kryptografiske biblioteker.
Utviklerne av PHP-språket har tatt en velbegrunnet tilnærming og har ikke gjort noe forsøk på å finne opp hjul designet for dette formålet på nytt. Faktum er at mange av de mest grunnleggende matematiske funksjonene som brukes i PHP-språket, bare er omslag rundt ekvivalentene til disse funksjonene i C-språket.
Matematiske operasjoner
De fleste matematiske operasjoner i PHP-språket utføres i form av innebygde funksjoner, ikke i form av operasjoner. I tillegg til sammenligningsoperasjoner, gir PHP fem enkle aritmetiske operasjoner, samt noen stenografioperasjoner som lar deg skrive kortere inkrement- og dekrementeringsuttrykk, samt oppgaver.
Aritmetiske operasjoner
De fem grunnleggende aritmetiske operasjonene inkluderer de operasjonene som vanligvis implementeres i en hvilken som helst firefunksjonskalkulator, så vel som modulo (%) operasjonen. Kort beskrivelse aritmetiske operasjoner er gitt i tabellen:
| 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 den riktige operanden, returnerer operasjonen verdien av denne 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 heltallsdivisjonen av verdien til venstre operand med absoluttverdien til høyre operande |
Når du bruker de tre første aritmetiske operasjonene beskrevet ovenfor (+, -, *) i programmet, bør det tas i betraktning at når disse operasjonene utføres, forplanter typen seg fra dobbelpresisjons flyttallsverdier til heltallsverdier. Dette betyr at hvis begge operandene til operasjonen 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. Den samme typen forplantning forekommer når du utfører en divisjonsoperasjon; i tillegg er det en slik tilleggseffekt at resultatet blir et flyttall med dobbel presisjon dersom delingen ikke utføres uten en rest (heltall).
Operatoren modulo (%) i PHP tar heltallsoperander, og hvis 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 arvet fra C, og C-programmerere har et rykte for kortfattethet og stolthet over det. Inkrement- og dekrementoperatorene, hentet fra C-språket, lar oss mer konsist representere uttrykk som $count = $count + 1 , som vanligvis er ganske vanlige i programmer.
Inkrementoperatoren (++) brukes til å legge til én til verdien av variabelen som denne operasjonen gjelder, og dekrementoperatoren (--) trekker én fra verdien til en slik variabel.
Hver av disse to operasjonene har to varianter - suffiks(i denne formen plasseres operasjonstegnet umiddelbart etter variabelen som operasjonen gjelder) og prefiks(i dette skjemaet er operasjonstegnet plassert rett foran variabelen som operasjonen gjelder). Begge variantene har det samme bivirkning forbundet med å endre verdien til en variabel, men suffiks- og prefiksoperatorer returnerer forskjellige verdier når de brukes som uttrykk. Suffiksoperatoren fungerer på en slik måte at verdien av variabelen endres etter at verdien av uttrykket er returnert, og prefiksoperatoren fungerer på en slik måte at verdien først endres, og deretter returneres den nye verdien til variabelen . Denne forskjellen kan finnes 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."
";
Utsagnene ovenfor genererer følgende utdata i nettleservinduet:
Øke operasjoner
I dette eksemplet er setningen $result = $count++ fullstendig ekvivalent med setningene:
PHP-kode $result = $count; $count = $count + 1;Sammen med dette tilsvarer operatoren $result = ++$count følgende operatorer:
PHP-kode $count = $count +1; $result = $count;Oppdragsdrift
Operasjonene for å øke (og redusere) reduserer mengden kode som kreves for å legge til én til verdien av en variabel, men reduserer ikke mengden kode som tildeler variabelens verdi til et annet tall eller andre aritmetiske operasjoner. Heldigvis har alle fem aritmetiske operatorer tilsvarende tilordningsoperatorer (+=, -=, *=, /= og %=) som lar deg tilordne en variabel i ett kort uttrykk resultatet av å utføre en aritmetisk operasjon på verdien av denne variabelen. For eksempel operatøren
PHP-kode $count = $count * 3;kan forkortes som
PHP-kode $count *= 3;Enkle matematiske funksjoner
Det neste trinnet i programmets kompleksitet sammenlignet med det der kun aritmetiske operasjoner brukes, er å bruke alle slags funksjoner. Funksjoner lar deg utføre oppgaver som å konvertere fra en numerisk type til en annen (se Datatyper) og finne minimums- eller maksimumstallet i et sett med tall. Følgende tabell gir enkle matematiske funksjoner:
| Funksjon | Beskrivelse |
|---|---|
| gulv() | Tar en enkelt faktisk parameter (vanligvis et flyttall med dobbel presisjon) og returnerer det største heltall mindre enn eller lik den faktiske parameteren (avrunding nedover) |
| tak() | Navnet på denne funksjonen er en forkortelse for tak. Funksjonen tar en enkelt faktisk parameter (vanligvis et flyttall med dobbel presisjon) og returnerer det minste heltall større enn eller lik den faktiske parameteren (rundet opp) |
| 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 enkelte numeriske faktiske parameteren har en negativ verdi, returnerer funksjonen det tilsvarende positive tallet; 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 minst én) og returnerer den største av alle faktiske parameterverdier |
For eksempel er resultatet av følgende uttrykk 3 fordi verdien av hvert uttrykk med et funksjonskall også er 3:
PHP-kode $result = min(3, abs(-3), max(round(2.7), ceil(2.3), floor(3.9)));Generering av tilfeldig tall
PHP bruker to tilfeldige tallgeneratorer (henholdsvis kalt av funksjonene rand() og mt_rand()). Tre funksjoner med samme formål er knyttet til hver av disse generatorene: funksjonen for å sette startverdien ( srand() og mt_srand()), selve tilfeldige tallfunksjonen, og funksjonen som velger det største heltallet som kan returneres av generatoren (( getrandmax() og mt_getrandmax())). Funksjonene getrandmax() og mt_getrandmax() returnerer det største tallet som kan returneres av rand()- eller mt_rand()-funksjonen, på Windows-plattformer er denne verdien begrenset til 32768.
Valget av en bestemt pseudo-tilfeldig tallgenereringsfunksjon, 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 nettdokumentasjonen for mt_rand()-funksjonen hevder at denne funksjonen også er raskere og "mer random" (når det gjelder kryptografi) enn rand(). Vi har ingen grunn til å tvile på sannheten til disse utsagnene, så vi foretrekker å bruke funksjonen mt_rand() fremfor rand().
Når du bruker noen versjoner av PHP for noen plattformer, ser det ut til at rand()- og mt_rand()-funksjonene genererer tilsynelatende helt akseptable tilfeldige tall, selv uten først å spesifisere en startverdi. Men et slikt inntrykk bør man ikke stole på. For det første kan ikke programmer som bruker funksjoner for generering av tilfeldige tall uten å spesifisere en startverdi enkelt porteres til andre plattformer, og for det andre er pålitelig drift av disse funksjonene uten å spesifisere en startverdi garantert.
En typisk måte å sette et frø for en av PHPs tilfeldige tallgeneratorer (ved å bruke funksjonen mt_srand() eller srand() er som følger:
PHP-kode mt_srand((dobbel)mikrotid()*1000000);Denne setningen setter startverdien til generatoren til antall mikrosekunder som har gått så langt siden siste hele sekund. (Det er nødvendig å doble casten i denne setningen, fordi microtime()-funksjonen returnerer en streng, som behandles som et heltall i multiplikasjonsoperasjonen, men ikke i parameteroverføringsoperasjonen.) Leseren oppfordres til å legge inn spesifisert initialiseringsoperatør, selv om han ikke helt forstår formålet med denne operatøren; det er nok å bare legge denne setningen på hver PHP-side, bare én gang, før du bruker den tilsvarende mt_rand()- eller rand()-funksjonen, og denne setningen vil sikre at startpunktet endres og derfor genereres en annen tilfeldig sekvens hver gang.
De spesifikk metode frøverdien har blitt dypt gjennomtenkt av de som fullt ut forstår alle nyansene ved å generere pseudo-tilfeldige tall, så den vil mest sannsynlig for alltid forbli den beste sammenlignet med alle forsøk fra en individuell programmerer på å komme opp med noe mer "vanskelig".
Åpenbart returnerer disse pseudo-tilfeldige tallgenereringsfunksjonene bare heltall, men et tilfeldig heltall fra et gitt område kan enkelt konverteres til et tilsvarende flyttall (f.eks. et tall mellom 0.0 og 1.0 inklusive) ved å bruke et uttrykk som rand() / getrandmax(). Etter det kan det angitte området skaleres og forskyves etter behov. Et eksempel er vist nedenfor:
PHP-kode // Anta 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 de tilfeldige tallene genereres.
Matematiske konstanter
I PHP versjon 4.0 var det bare én matematisk konstant, beskrevet i dokumentasjonen - M_PI (verdien av tallet pi, representert som et flyttall med dobbel presisjon). Og siden PHP 4.0.2 har mange nye konstanter blitt introdusert. De fleste av disse nye konstantene knyttet til tallet pi (eller multipler av det), tallet e (eller multipler av det) og kvadratrøtter; i tillegg var noen konstanter av 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:
| 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 | kvadrat (2) |
| M_SQRT1_2 | 1 / kvadrat(2) |
| M_LOG2E | log2(e) |
| M_LOG10E | logg(e) |
| M_LN2 | loge(2) |
| M_LN10 | loge (10) |
Nummerformatsjekk
PHP-språket har en rekke funksjoner som lar deg sjekke riktig representasjon av tall. Selv om PHP ikke har sterk skriving, anbefales det at du bruker noen av disse sjekkene i koden din om nødvendig, for å kunne forutsi egenskapene til resultatene som oppnås, og også for å velge den beste måten behandlingen deres.
Den første og enkleste testen er å bruke funksjonen is_numeric(). Som med de fleste andre slike sjekker, returnerer funksjonen is_numeric et boolsk resultat, sant, hvis argumentet som sendes til det 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 .
Med 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 kompliserte: funksjonene er_endelig() og er_uendelig() lar deg utføre nøyaktig de kontrollene som navnene deres indikerer (om tallet er endelig eller uendelig). Men strengt tatt kan ikke området av verdier som dekkes av disse funksjonene 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.
Følgende 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"); // false - denne kontrollen er strengere enn kontrollen med is_numeric() funksjonen is_float(4); // false is_float(4.0); // true is_float(M_PI); // santTallsystemkonvertering
Som standard bruker PHP base 10 for å konvertere eksterne til interne numeriske verdier fremover og bakover. Du kan også fortelle PHP-tolken at den eksterne representasjonen bruker grunntallet 8 oktale tall ved å prefiksere tallet med innledende 0), eller heksadesimale tall spesifisert i base 16 (for å gjøre dette må du prefiksere tallet 0x).
Selvfølgelig, etter å ha konvertert tall fra ekstern til intern representasjon, lagres de i minnet i binært format, og alle grunnleggende aritmetiske og matematiske beregninger utføres i operativsystem base 2. I tillegg gir PHP-språket en rekke funksjoner for å konvertere tall fra en base til en annen. Generell informasjon Disse funksjonene er oppført i tabellen nedenfor:
| Funksjon | Beskrivelse |
|---|---|
| BinDec() | Tar et enkelt strengargument som er et binært heltall (tall i grunntall 2) og returnerer strengrepresentasjonen av det tallet i grunntall 10 |
| 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() | Det krever en strengparameter (som representerer heltallet som skal konverteres) og to heltallsparametere (basen og ønsket base). Returnerer en streng som representerer det konverterte tallet. På denne linjen er sifre eldre enn 9 (fra 10 til 35) representert med tegn a-z. Både den originale og den ønskede basen må være i området 2-36 |
Alle tallkonverteringsfunksjoner er spesialfunksjoner som konverterer tall fra en bestemt base til en annen. Unntaket er base_convert()-funksjonen, som aksepterer vilkårlige parametere med betegnelsen på den opprinnelige og resulterende basen.
Merk at alle tallkonverteringsfunksjoner tar strengparametere og returnerer strengverdier, men du kan bruke desimal numeriske parametere og stole på at PHP-tolken gjør typekonverteringen riktig. Med andre ord gir både DecBin("1234") og DecBin(1234) kallene det samme resultatet.
Eksponenter og logaritmer
PHP-språket inkluderer standard eksponentielle og logaritmiske funksjoner av to varianter - å arbeide i base 10 og base e (som er vist i tabellen).
PHP gir exp()-funksjonen for å heve tallet e til den angitte potensen, men det er ingen funksjon med én parameter som kan øke potensen 10 til den spesifiserte potensen. Du kan imidlertid bruke pow()-funksjonen med to parametere i stedet gir 10 som den første parameteren.
Du kan verifisere 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 = 449Trigonometriske funksjoner
PHP-språket gir et standardsett med grunnleggende trigonometriske funksjoner, generell informasjon om dette er gitt i tabellen:
| Funksjon | Beskrivelse |
|---|---|
| pi() | Den tar ingen parametere og returnerer en omtrentlig verdi på π (3,1415926535898). Kan brukes om hverandre med M_PI konstant |
| 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. Inngangen må være mellom -1 og 1 (hvis funksjonen mottar input utenfor dette området, vil det gi 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 mellom -1 og 1 (hvis funksjonen mottar input utenfor dette området, vil det gi et NAN-resultat. Resultatene er mellom 0 og π |
| brunfarge() | Aksepterer en numerisk parameter og returnerer buetangensen 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 "| Betydning/funksjon | $func | "; ) ekko "
|---|---|
| ".sprintf("%.4f",$input)." | "; foreach($func_array som $func) ( echo ""; printf("%4.4f", $func($input)); ekko " | "; ) ekko "
Et eksempel på bruk av trigonometriske funksjoner i PHP Å få veldig store (men ikke uendelige) tangentverdier skyldes at nevnerne teoretisk skal være lik null, men i virkeligheten skiller de seg litt fra null på grunn av avrundingsfeil.
Vilkårlig presisjonsberegning (ved hjelp av BC-funksjoner)
Heltalls- og flyttallstyper med dobbel presisjon er fine for de fleste matematiske problemer som dukker opp i nettskripting, men det er en fast mengde dataminne for å lagre hver forekomst av en verdi representert med disse typene, så størrelsen og presisjonen til tallrepresentasjon disse typene pålegger uunngåelig restriksjoner.
Selvfølgelig kan de nøyaktige områ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 representere tall med en presisjon på omtrent 13 til 14 desimaler. På den annen side, for oppgaver som krever et bredere representasjonsområde eller større presisjon, gir PHP matematiske funksjoner med vilkårlig presisjon(også kalt BC-funksjoner, etter et beregningsverktøy med vilkårlig presisjon basert på fasilitetene til Unix-systemet).
Funksjoner med vilkårlig presisjon kan ikke inkluderes i kompileringen av PHP-tolken, spesielt hvis brukeren har gjort slik kompilering selv, fordi for dette burde brukeren ha visst at på konfigurasjonsstadiet må flagget inkluderes i parameterne --enable-bcmath. For å sjekke om du har tilgang til de angitte funksjonene, prøv å evaluere uttrykket bcadd("1","1"). Hvis du mottar en feilmelding som sier en udefinert funksjon, må du justere konfigurasjonen på nytt og kompilere PHP-tolken på nytt.
BC-funksjoner bruker ikke-numeriske typer med representasjon som parametere og returverdier fast lengde, og linjer. Siden i PHP er lengden på strenger bare begrenset av tilgjengelig minne, tallene som brukes i beregninger kan være av hvilken som helst lengde. De grunnleggende beregningene er gjort i desimalform, og ligner på mange måter de som en person kan utføre med blyant og papir (hvis han kan handle veldig raskt og være tålmodig). BC-funksjoner som opererer på heltall er presise og lar deg bruke så mange sifre du trenger, mens funksjoner som opererer på flyttall utfører beregninger til det angitte antall desimaler. En oversikt over BC-funksjoner er gitt i tabellen nedenfor:
| Funksjon | Beskrivelse |
|---|---|
| bcadd() | Tar to strengparametere som representerer tall og en valgfri heltallsparameter med en skalafaktorbetegnelse. Returnerer summen av de to første parameterne som en streng, med antall desimaler i resultatet spesifisert av skalafaktorparameteren. Hvis parameteren med skaleringsfaktorbetegnelsen ikke er spesifisert, brukes standardskalafaktoren. |
| 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 det første argumentet med det andre. |
| bcmod() | Returnerer modulen (resten) fra å dele den første parameteren med den andre. Siden returverdien er av heltallstype, godtar ikke funksjonen en parameter med skalafaktornotasjon |
| bcpow() | Hever den første parameteren til effekten spesifisert av den andre parameteren. Antall desimaler i resultatet bestemmes av skalafaktoren, hvis en er gitt. |
| bcsqrt() | returnerer Kvadratrot parameter med antall desimaler, som bestemmes av verdien av den valgfrie skalafaktoren |
| 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 desimalplasseringer resultatet skal ha. Hvis ingen slik parameter er spesifisert, brukes standard skaleringsfaktor som skaleringsfaktor, som igjen kan settes ved å kalle opp bcscale()-funksjonen. Standardverdien for denne standardverdien (dvs. verdien som brukes hvis skriptet ikke bruker funksjonskallet bcscale()) kan også settes i initialiseringsfilen php.ini.
Følgende er et eksempel på bruk av en vilkårlig presisjonsfunksjon for å utføre heltalls aritmetiske operasjoner nøyaktig. Kjø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 den vanlige PHP-heltallstypen hadde blitt brukt for disse beregningene, ville heltallsoverløpet ha skjedd lenge før slutten av beregningen, så resten av løkken måtte gjøre beregningene for å få et omtrentlig flyttall.
Matriser Formbehandling 1 2 3 4 5 6 7 8 9 10PHP-variable operasjoner (utsagn)
Det er ulike grupper for implementering.
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 behandles 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? Operatørene beskrevet nedenfor fungerer på samme måte.
Divisjonsoperatoren ("/") returnerer alltid en reell 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øktall kan føre til uønskede resultater.
Du kan bruke parenteser. Forrangen til noen matematiske operasjoner fremfor andre og endringen av prioriteter ved bruk av parentes i aritmetiske uttrykk samsvarer med de vanlige matematiske reglene.
Ø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 returnerer verdien til variabelen i et uttrykk. $a før endringen. For eksempel:
$a=10;
$b=$a++;
ekko "a=$a, b=$b"; // Utganger a=11, b=10
Som du kan se, først variabelen $b tildelt en verdi til en variabel $a, og først da ble sistnevnte økt. Imidlertid et uttrykk hvis verdi er tilordnet en variabel $b, kan være vanskeligere - i alle fall økningen $a skjer først etter at det er beregnet.
Operatorer for inkrementering og dekrementering av prefiks
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"; // Utganger 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 "Bør være 4: " . --$a. "
\n" ;
ekko "Bør 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 sammenkoblingstildelingsoperatøren, som legger til høyre argument til venstre argument. La oss ta et konkret 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 for å betjene (sette/tømme/kontrollere) grupper av biter i en heltallsvariabel. Bitene i et heltall er ikke mer enn individuelle sifre med samme tall skrevet i binærtall. 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 tallet 14 (1110 i binær notasjon). Hvis variabelen ikke er et heltall, så er den
neste runde rundes opp, og deretter brukes følgende operatorer på den.
32 biter brukes til å representere et enkelt tall:
- 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 biter satt i enten $a eller $b er satt. |
| ~$a | Negasjon | Bits som ikke er satt i $a settes, og omvendt. |
| $a<< $b | Skift til venstre | Alle biter i $a er forskjøvet $b-posisjoner til venstre (hver posisjon betyr "multipliser med 2") |
| $a >> $b | skift til høyre | Alle biter av variabel $a er forskjøvet $b-posisjoner til høyre (hver posisjon innebærer "divide med 2") |
Sammenligningsoperasjoner
Sammenligningsoperatører, som navnet tilsier, lar deg sammenligne to verdier med hverandre.
Dette er unike operasjoner på hver sin måte, fordi uavhengig av typen argumentasjon, returnerer de alltid en av to ting: falsk eller ekte. Sammenligningsoperasjoner lar deg sammenligne to verdier med hverandre og, hvis betingelsen er oppfylt, returnere ekte, Og hvis ikke - falsk.
I PHP er det kun tillatt å sammenligne skalarvariabler. 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 du gjør dette. Så en gang lurte på hvorfor to helt forskjellige arrays når man sammenligner dem med == er plutselig det samme, husk at før du sammenligner begge operandene konverteres 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 | Like 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 ikke like | 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. |
boolske operasjoner
Logiske operatorer er designet utelukkende for å jobbe med logiske uttrykk og også retur falsk eller ekte.
Her er en tabell over logiske PHP-operatorer:
Det skal bemerkes at evalueringen av logiske uttrykk som inneholder slike operatører alltid går fra venstre til høyre, og hvis resultatet allerede er åpenbart (f.eks. usant&&noe gir alltid falsk), så avsluttes beregningene, selv om det er funksjonskall i uttrykket. For eksempel, i setningen $logic = 0&&(tid()>100); standard funksjon tid() vil aldri bli kalt.
Vær forsiktig med logiske operasjoner - ikke glem å doble karakteren. Merk at f.eks. | og || - to helt forskjellige operatører, hvorav den ene potensielt kan returnere et hvilket som helst nummer, og den andre - bare falsk og ekte.
Operatorene inkrement (++) og dekrement (--) fungerer ikke på boolske variabler.
Ekvivalensoperatører
I PHP, siden PHP4 er det en identisk sammenligningsoperatør - et trippel likhetstegn ===
,
eller innsjekkingsoperatøren. PHP er ganske tolerant for at strenger implisitt konverteres til tall, og omvendt.
For eksempel vil følgende kode gi ut at verdiene til variablene er like:
$a=10;
$b="10";
Og dette til tross for at variabelen $a er 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? Faktum er at hvis en av operandene til en logisk operator kan behandles som et tall, så behandles begge operandene som tall. Dette gjør den tomme strengen 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 operatorer: aritmetiske, logiske, 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
% (resten av divisjonen)
For eksempel: $a=12; ekko $a % 5; // er lik 2
++ (øk/øk verdien 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 utjevnes verdien til variabelen $b. Ellers ville det vært 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 akkurat som i tilfellet med inkrement, er det to typer notasjon: --$a og $a--
Oppdragsdrift
Setter en variabel til en bestemt verdi: $a = 5
Tillegg etterfulgt av tildeling av resultatet. For eksempel: $a=12; $a += 5; ekko $a; // er 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; // er lik 2,4
Sammenkobling av strenger med tilordning av resultatet. Gjelder to linjer. Hvis variablene ikke lagrer strenger, men for eksempel tall, blir verdiene deres konvertert til strenger og deretter utføres operasjonen: $a=12; $a .= 5; ekko $a; // er lik 125 // identisk med $b="12"; $b .="5"; // er lik 125
Hente resten av en divisjon og deretter tildele resultatet: $a=12; $a %= 5; ekko $a; // er lik 2
Sammenligningsoperasjoner
Sammenligningsoperasjoner brukes som regel i betingede konstruksjoner, når det er nødvendig å 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 den sann, ellers returnerer den falsk: $a == 5
Identitetsoperatoren sammenligner også to verdier, og hvis de er like returnerer den sann, ellers returnerer den falsk: $a === 5
Sammenligner to verdier og returnerer sann hvis de ikke er like, 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 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 to verdier av forskjellige typer tas i likestillingsoperasjonen, 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 bli kastet til tallet 22. Og som et resultat 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.
boolske operasjoner
Boolske 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
Ligner på && : $a == 5 og $b > 6
Returnerer sann hvis minst én sammenligningsoperasjon evalueres til sann, ellers returnerer falsk: $a == 5 || $b = 6
På samme måte som 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 viss verdi. La oss endre koden:
$a=12; $b=NULL; if($a xor $b) ekko "true"; annet ekko "false";
Allerede her vil resultatet være sant , siden verdien av én variabel ikke er satt. Hvis variabelen er NULL, vil verdien i logiske operasjoner anses 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.
& (boolsk multiplikasjon)
Multiplikasjonen 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 binær 100, og tallet 5 er 101. Multipliser tallene bit for bit og få (1*1, 0*0, 0*1) = 100, det vil si tallet 4 i desimal.
| (logisk tillegg)
I likhet med logisk multiplikasjon utføres operasjonen også på binære sifre, men nå returneres en ener hvis minst ett tall i denne biten har en. For eksempel: $a1 = 4; //100 $b1 = 5; //101 echo $a1 | $b1; // er lik 5
~ (logisk negasjon)
inverterer alle sifre: hvis verdien av et siffer er 1, blir det null, og omvendt. $b = 5; ekko ~$b;
x< x>>y - flytter tallet x til høyre med y sifre. For eksempel, 16>>1 skifter tallet 16 (som er 10 000 i binær) ett siffer til høyre, noe som resulterer i 1000 eller 8 i desimal
Sammenknytting av strenger
Punktoperatoren brukes til å sette sammen strenger. La oss for eksempel slå sammen flere linjer:
$a="Hei,"; $b="verden"; ekko $a. $ b . "!";
Hvis variablene ikke representerer strenger, men andre typer, for eksempel tall, blir verdiene deres konvertert til strenger, og deretter skjer også strengsammenkoblingsoperasjonen.