PHP matematiska operationer. Operationer på PHP-nummer

Programmerare som behöver utföra ansvarsfulla numeriska, vetenskapliga eller statistiska beräkningar, är osannolikt att överväga skriptspråket för webb som en acceptabel kandidat för denna roll. Men trots ovanstående erbjuder PHP-språket en magnifik uppsättning funktioner som fullt ut säkerställer lösningen av de flesta matematiska uppgifter som uppstår vid utförandet av scenarier för webben. Dessutom tillhandahåller PHP-språk några mer avancerade funktioner som aritmetik av godtyckliga noggrannhetsnummer, samt hashbibliotek och kryptografiska bibliotek.

Utvecklarna av PHP-språket accepterade ett välgrundat tillvägagångssätt och tog inga försök att återuppfinna hjulen för det angivna målet. Faktum är att många av de mest grundläggande matematiska funktionerna som används i pHP-språkär bara skal runt analogerna av dessa egenskaper i C.

Matematiska operationer

De flesta matematiska åtgärder på PHP-språket utförs i form av inbyggda funktioner och inte i form av operationer. Förutom jämförelseverksamheten erbjuder PHP-språket fem operationer av enkla aritmetiska åtgärder, liksom vissa förkortade operationer, vilket möjliggör mer korta inkrement- och minskningsuttryck, samt uppdrag.

Aritmetiska operationer

De fem huvudsakliga aritmetiska operationerna inkluderar de operationer som vanligtvis implementeras i någon fyrfunktionell räknare, liksom divisionen av modulen (%). Kort beskrivning De aritmetiska operationerna visas i tabellen:

Aritmetiska operationer

Drift	Beskrivning
+	Returnerar summan av värdena för de två operandernas två
-	Om det finns två operander dras värdet av rätt operand från det vänstra värdet. Om det bara finns rätt operand, returnerar operationen värdet av denna operand med motsatt tecken
*	Returnerar produkten av värdena för de två operandens två
/	Returnerar resultatet av att dividera det vänstra operandens flytande punktvärde på värdet av rätt operand
%	Returnerar resten från heltal av det vänstra operandvärdet på absolutvärde Rätt operanda

När den används i de tre första aritmetiska operationerna som beskrivs ovan (+, - *), bör man komma ihåg att när de utför dessa operationer, typen av typ från värdena med en flytande punkt av dubbel noggrannhet till heltalsvärden inträffar. Enligt detta innebär följande: Om båda operativsoperationerna är heltal blir resultatet ett heltal, och om åtminstone en av operanderna är ett dubbelpassningsflödepunkt, blir resultatet en flytande punkt av dubbel noggrannhet. Samma typ av typfördelning uppstår och när divisionsoperationen utförs Dessutom uppstår en sådan ytterligare effekt att resultatet blir ett tal med en flytande punkt av dubbel noggrannhet, om divisionen inte utförs utan återstod (riktad).

Divisionen av modulen (%) i PHP-språket accepterar heltalsoperanderna, och om denna operation appliceras på siffrorna med en flytande punkt av dubbel noggrannhet, omvandlas dessa siffror tidigare till heltal (genom att kassera fraktionerna). Resultatet av en sådan operation är alltid ett heltal.

Inkrement och minskningsoperationer

En betydande del av PHP-språksyntaxen är ärvt från C-språket, och programmerare C är kända för kärlek till korthet och är stolta över det. Inkrement och minskningsoperationer som tagits från C-språket tillåter dig att mer kort representera uttrycken av typen $ count \u003d $ count + 1, som vanligtvis finns i programmen ganska ofta.

Inkrementoperationen (++) används för att lägga till en enhet till värdet av variabeln till vilken denna operation sträcker sig och minskningsoperationen (-) subtraherar enheten från värdet av en sådan variabel.

Var och en av dessa två operationer har två sorter - ändelse (I det här formen placeras operationsskylten direkt efter variabeln till vilken operationen distribueras) och prefix (I det här formuläret placeras operationsskylten omedelbart före variabeln till vilken operationen distribueras). Båda sorterna har samma bieffekt som är förknippad med att ändra värdet på variabeln, men suffix och prefix-operationer returneras olika värden När de används som uttryck. Suffixoperationen verkar på ett sådant sätt att värdet av variabeln ändras efter att ha returnerat värdet av uttrycket och prefixoperationen fungerar på ett sådant sätt att värdet först ändras, och sedan returnerar variabeln ett nytt värde. Den angivna skillnaden kan detekteras med hjälp av minsknings- och inkrementoperationer i uppdragsoperatörer:

PHP-kod $ Räkna \u003d 0; $ resultat \u003d $ count ++; Echo "Inkrement Resultat $ Count ++:". $ Resultat. "
"; $ Count \u003d 0; $ resultat \u003d ++ $ räkna; echo" inkrement resultat ++ $ räkna: "$ resultat"
";

Ovanstående operatörer utgör följande utgång i webbläsarfönstret:

Ökningsoperationer

I det här exemplet är operatören $ resultat \u003d $ count ++ helt ekvivalent med operatörer:

PHP-kod $ resultat \u003d $ räkna; $ Count \u003d $ count + 1;

Tillsammans med detta motsvarar operatören $ resultat \u003d ++ $ räkenskap motsvarande sådana operatörer:

PHP-kod $ Count \u003d $ count +1; $ resultat \u003d $ räkna;

Uppdragsverksamhet

Verksamheten av ökningen (och minskningen) gör det möjligt att minska den mängd kod som är nödvändig för att lägga till en enhet till värdet av variabeln, men tillåter inte att minska mängden kod i vilken variabeln tilldelas resultatet av tillsatsen av tillsatsen av dess värde med ett annat tal eller resultatet av utförandet av annan aritmetisk verkan. Lyckligtvis har alla fem aritmetiska operationer lämpliga uppdragsoperationer (+ \u003d, - \u003d, * \u003d, / \u003d och% \u003d), så att du kan tilldela en variabel i ett kort uttryck resultatet av en aritmetisk operation på värdet av denna variabel. Till exempel operatören

PHP $ count \u003d $ räkna * 3 kod;

kan förkortas

PHP $ Count * \u003d 3 kod;

Enkla matematiska funktioner

Nästa steg i programmets komplikation jämfört med den där endast aritmetiska operationer gäller är att använda alla möjliga funktioner. Funktioner gör det möjligt att utföra sådana uppgifter som att konvertera från en enda numerisk typ till en annan (se artikeln "datatyper") och söka efter ett minimum eller maximalt antal i ett flertal siffror. Följande tabell presenterar enkla matematiska funktioner:

Enkla matematiska funktioner php

Fungera	Beskrivning
golv ()	Accepterar den enda faktiska parametern (som regel, ett nummer med en flytande punkt av dubbel noggrannhet) och returnerar det största heltalet som är mindre än eller lika med den här faktiska parametern (avrundning till en mindre sida)
tak ()	Namnet på denna funktion är en minskning från ordet tak (tak). Funktionen tar en enda verklig parameter (som regel, ett nummer med en flytande punkt av dubbel noggrannhet) och returnerar det minsta heltalet som är större än eller lika med den här faktiska parametern (avrundning till den största)
runda ()	Accepterar den enda faktiska parametern (som regel, ett nummer med en flytande punkt av dubbel noggrannhet) och returnerar närmaste heltal
mAGMUSKLER ()	Det absoluta värdet av ett nummer. Om en enda numerisk verklig parameter har ett negativt värde, returnerar funktionen motsvarande positiva tal; Om den faktiska parametern är positiv, returnar den faktiska parametern självfunktionen
min ()	Accepterar ett antal numeriska aktuella parametrar (men minst en) och returnerar de minsta av alla värden av aktuella parametrar
max ()	Tar ett antal numeriska aktuella parametrar (men minst en) och returnerar den största av alla värden på de faktiska parametrarna

Till exempel är resultatet av följande uttryck 3, eftersom värdet av varje uttryck med ett funktionssamtal är också 3:

PHP-kod $ resultat \u003d min (3, abs (-3), max (runda (2,7), tak (2,3), golv (3.9)));

Utveckling av slumpmässiga nummer

Två slumpmässiga nummer används i PHP (kallas respektive med funktioner. rand () och mt_rand ()). Med var och en av dessa generatorer är tre funktioner av samma ändamål anslutna: funktionen att ställa in det ursprungliga värdet ( srand () och mt_srand ()), funktionen att erhålla ett slumptal och en funktion som väljer det största heltalet som kan returneras av generatorn (( getRandMax () och mT_GETRANDMAX ())). GETRANDMAX () och MT_GETRANDMAX () -funktioner returneras det största antaletsom kan returneras av RAND () eller MT_RAND () -funktionen på windows-plattformar Detta värde är begränsat till 32768.

Välja en specifik utvecklingsmetod pseudo-slumpmässiga nummersom används i RAND () -funktionen kan bero på vilka bibliotek PHP-tolken kompilerades. Till skillnad från detta i MT_RAND () -generatorn används samma särdrag hos gruvan av pseudo-slumpmässiga nummer (MT - en minskning från Mersenne Twister) och författaren till operativ dokumentation för MT_RAND () -funktionen hävdar att den här funktionen är Också mer snabb och "mer slumpmässig" (ur kryptografins synvinkel) än RAND (). Vi har ingen anledning att tvivla på sanningen om dessa uttalanden, så vi föredrar att använda funktionen MT_RAND () och inte RAND ().

Vid användning av vissa PHP-versioner för vissa plattformar verkar det som att rand () och mt_rand () -funktionerna produceras vid första anblicken ganska acceptabla slumptal, även utan föregående värde. Men detta intryck bör inte lita på. Först, program där funktionerna i slumpmässiga nummer används utan att specificera det ursprungliga värdet, är det omöjligt att enkelt överföra till andra plattformar, och för det andra är den tillförlitliga funktionen av de angivna funktionerna utan att ange det ursprungliga värdet inte garanterat.

Ett typiskt sätt att ställa in det ursprungliga värdet för någon av de slumpmässiga generatorerna. pHP-nummer (Använda funktionen MT_Srand () eller Srand ()) är som följer:

PHP-kod MT_Srand ((dubbel) mikrotime () * 1000000);

Denna operatör ställer in det inledande värdet av generatorn som är lika med antalet mikrosekunder som har gått ut till den här tiden från det sista datumet för den sista hela. (Typstyp Dubbel i detta uttalande är verkligen nödvändigt, eftersom funktionen Microtime () returnerar en sträng som anses vara ett heltal i multiplikationsoperationen, men inte i parameteröverföringsoperationen till funktionen.) Vi rekommenderar läsaren att komma in i Specificerad operatör för att ställa in det ursprungliga värdet, även om han inte helt är helt klart utnämningen av denna operatör. bara satt nog den här operatören För varje pHP-sida, bara en gång innan du använder den motsvarande MT_RAND () eller RAND () -funktionen, och den här operatören kommer att säkerställa att utgångspunkten ändras och därmed varje gång de olika slumpmässiga sekvenserna kommer att framställas.

De specifik metod Uppgifterna för det ursprungliga värdet var djupt genomtänkt av de experter som fullt ut förstår alla nyanser av produktionen av pseudo-slumpmässiga nummer, är det mest troligt att förblir det bäst jämfört med några försök att någon separat programmerare kommer att komma med något mer "slapper".

Självklart returneras de angivna funktionerna för produktion av pseudo-slumpmässiga tal endast av heltal, men ett slumpmässigt heltal från ett givet sortiment kan enkelt omvandlas till motsvarande flytande punktnummer (säg i numret från intervallet från 0,0 till 1,0 inklusive) med användning av uttryck som rand () / getrandmax (). Därefter kan det angivna området skalas och skiftas efter behov. Följande är ett exempel:

PHP-kod // Antag att vi måste generera slumpmässigt nummer från 100,0 till 120,0 $ slumpmässigt \u003d 100,0 + 20,0 * MT_RAND () / MT_GETRANDMAX (); Echo $ slumpmässigt. "
"; // Utveckling av heltal (100-120); Echo Round ($ slumpmässig);

Prova uppfriskande sidan med den här koden flera gånger för att se till att slumpmässiga tal genereras.

Matematiska konstanter

I PHP version 4.0 fanns det bara en matematisk konstant som beskrivs i dokumentationen - M_PI (värdet av numret π representerade som en flytande punkt av dubbel noggrannhet). Och börjar S. version php. 4.0.2 Många nya konstanter introducerades. De flesta av dessa nya konstanter hänvisade till numret π (eller till flera värden till det), antalet E (eller till värdena till det), såväl som kvadratiska rötter; Dessutom tillhörde vissa konstanter till andra typer. Men i följande problem, av ett antal skäl minskade listan över konstanter igen till ett relativt litet antal förutbestämda matematiska konstanter:

Matematiska konstanter PHP.

Konstant	Beskrivning
M_pi	π
M_pi_2.	π / 2.
M_pi_4.	π / 4.
M_1_pi	1 / π.
M_2_pi	2 / π.
M_2_sqrtpi	2 / sqrt (π)
MIG.	e.
M_sqrt2.	sqrt (2)
M_sqrt1_2.	1 / sqrt (2)
M_log2e.	log 2 (e)
M_log10e.	lG (E)
M_ln2.	log e (2)
M_ln10.	log e (10)

Kontrollera formatnummer

PHP-språket ger ett antal funktioner som gör att du kan kontrollera korrektheten av presentationen av siffrorna. Även om det inte finns några strikta typer av PHP rekommenderas att det rekommenderas att det är nödvändigt att tillämpa några av dessa kontroller i koden för att kunna förutsäga egenskaperna hos de erhållna resultaten, såväl som bästa vägen deras bearbetning.

Den första och mest enkel check är att använda funktionen is_numeric (). Som i genomförandet av de flesta andra kontroller returnerar den IS_Numeric-funktionen Boolen Resultat - sant om parametern som sänds till den är numerisk data (med ett tecken eller inget tecken, heltal eller flytande punkt) eller ett matematiskt uttryck som returnerar ett tillåtet numeriskt värde .

Använda funktioner is_int () och is_float. Du kan avgöra om numret är heltal eller fraktionerad. Två två kontroller är lite mer komplexa: funktioner is_finite () och is_infinite () Låt dig utföra exakt de kontroller som anger deras namn (om numret är ändligt eller oändligt). Men strängt sett kan det värderingar som dessa funktioner distribueras inte kan inkludera relevant oändlighet (och kan det i allmänhet kontrolleras, har det oändligt stor betydelse?). I stället används gränserna för intervallet av flytande punktvärden i det specifika systemet.

Följande är ett exempel på att använda dessa funktioner:

PHP-kod is_numeric (4); // TRUE IS_NUMERIC (25 - 6); // TRUE IS_NUMERIC ("25"); // TRUE IS_NUMERIC ("25 - 6"); // falskt is_int (4); // sant is_int (4.2); // falskt is_int ("4"); // falskt - den här kontrollen Strängare än att kontrollera med funktionen IS_Numeric () is_Float (4); // Falsk Is_Float (4.0); // sant is_float (m_pi); // Sann.

Transformation av nummer system

Standard i PHP-språk för direkt och omvänd transformation numeriska värden Från den externa representationen i det interna tillämpar basen av nummer 10-systemet. Dessutom kan du informera PHP-tolken som i den externa representationen används. oktalantaldefinierad på basen 8 (för detta före numret är det nödvändigt att införa en ledning 0), eller hexadecimala siffrorDefinierad av basen 16 (för detta, före numret, måste du ange 0X-prefixet).

Naturligtvis, efter omvandling av nummer från den externa representationen till det inre, lagras de i binärt format, och alla större aritmetiska och matematiska beräkningar utförs i de flesta operativ system Baserat på 2. Dessutom tillhandahålls ett antal funktioner i PHP för att konvertera siffror från en bas av nummer-systemet till ett annat. Allmän Dessa funktioner visas i tabellen nedan:

Funktioner för konvertering av nummer system

Fungera	Beskrivning
BINDEC ()	Accepterar en enda strängparameter som representerar ett binärt heltal (antal för bas 2) och returnerar en strängrepresentation av detta nummer baserat på antalet nummer 10
Decbin ()	Liknande Bindec (), men omvandlar från basen av nummer 10-systemet till basen av nummer systemet 2
Octdec ()	Liknande Bindec (), men omvandlar från basen av nummer 8 till basen av nummer 10
Decoct ()	Liknande BINDEC (), men omvandlar från basen av nummer 10-systemet till basen av talsystemet 8
Hexdec ()	Liknande Bindec (), men omvandlar från basen av nummer 16 i basen av talsystemet 10
Dechex ()	Liknande Bindec (), men omvandlar från basen av talsystemet 10 till basen av talsystemet 16
base_convert ()	Accepterar en strängparameter (som representerar ett heltal som är föremål för transformation) och två heltalsparametrar (källa och önskad bas). Returnerar en sträng som representerar ett konverterat nummer. I den här raden är siffrorna äldre än 9 (från 10 till 35), presenterade symboler A-Z. Och originalet, och de önskade fundamenten måste vara i intervallet 2-36

Alla är speciella ändamålsfunktioner som konverterar siffror från en viss grund till en annan. Undantaget är funktionen base_convert (), som tar godtyckliga parametrar med beteckningen av den ursprungliga och resulterande basen.

Observera att alla funktioner omvandlingsfunktioner mottas av strängparametrar och retursträngvärden, men du kan använda decimala numeriska parametrar och förlita sig på den korrekta transformationen av PHP-tolken. Med andra ord leder alternativen för att ringa decbin ("1234") och decin (1234) till samma resultat.

Utställare och logaritm

PHP-språk innehåller standard exponentiella och logaritmiska funktioner av två multiplikemang - att arbeta på basen 10 och basen för E (som visas i tabellen).

På PHP-språket är EXP () -funktionen anordnad att upprepa numret E till den angivna examen, men det finns ingen funktion med en parameter, med vilken det skulle vara möjligt att bygga ett nummer 10 till den angivna examen. Men istället Av den här funktionen kan du använda funktionen POW () med två parametrar, inställning 10 som den första parametern.

Du kan se till att de exponentiella och logaritmiska funktionerna med samma bas är tillbaka till varandra, som har verifierat identiteten hos de erhållna resultaten på detta sätt:

PHP-kod $ TEST_449 \u003d 449,0; $ TEST_449 \u003d POW (10, Exp (Log10 ($ Test_449))); Echo "test_449 \u003d $ test_449"; // test_449 \u003d 449

Trigonometriska funktioner

PHP-språket ger en vanlig uppsättning grundläggande trigonometriska funktioner, den allmänna informationen som visas i tabellen:

Trigonometriska funktioner

Fungera	Beskrivning
pi ()	Mottar inte parametrar och returnerar det ungefärliga värdet av numret π (3.1415926535898). Kan användas som utbytbar med m_pi konstant
synd ()	Accepterar en numerisk parameter i radianer och returnerar en sinusparameter i form av ett dubbel-precision flytande punktnummer
cos ()	Tar en numerisk parameter i radianer och returnerar en cosinusparameter i form av en flytande punkt av dubbel noggrannhet
tan ()	Tar en numerisk parameter i radianer och returnerar en parameter tangent som en flytande punkt av dubbla noggrannhet
sOM I ()	Tar en numerisk parameter och returnerar arxinusparametern i radianer. Ingångsdata bör ligga i intervallet från -1 till 1 (mottagandet av ingångsdatafunktionen som lämnar gränserna för detta intervall leder till resultatet av NAN). Resultaten ligger i intervallet från -π / 2 till π / 2
aCOS ()	Tar en numerisk parameter och returnerar arquosinparametern i radianer. Inmatningsdata bör ligga i intervallet -1 till 1 (mottagning av ingångsdatafunktionen som går utöver gränserna för detta intervall leder till resultatet av NAN. Resultaten ligger i intervallet från 0 till π
eN BRÄNNA ()	Tar en numerisk parameter och returnerar parametern Arctantnence i radianer. Resultaten ligger i intervallet från -π / 2 till π / 2

Följande är ett exempel på att utarbeta en tabell med beräkning av trigonometriska funktioner för "standard" vinklar:

PHP-kod Funktion display_trigonometry ($ func_array, $ input_array) (// header funktion eko " ") Echo""; // visa resten av foreach tabellen ($ input_array som $ input) (echo" "; Foreach ($ func_array as $ func) (echo" ") Echo"") Echo"

Värde / funktion	$ Func.
".Sprintf ("%. 4f ", $ input)."	"; Printf ("% 4.4F ", $ func ($ input)); echo"

") Display_trigonometry (array (" synd "," cos "," tan "), array (0, m_pi / 6, m_pi / 3, m_pi / 2, m_pi);
Ett exempel på att använda trigonometriska funktioner i PHP

Förberedelsen av mycket stora (men inte oändliga) värden av tangent beror på det faktum att teoretiskt betecknar var noll, men i verkligheten skiljer de sig något från noll på grund av avrundningsfel.

Beräkning med godtycklig noggrannhet (med BC-funktioner)

Interisariella typer och typer av dubbel noggrannhet är fullt lämpade för att lösa de flesta matematiska uppgifter som uppstår vid exekvering av skript för webben, men för att lagra varje instans av det värde som representeras med hjälp av dessa typer, är en fast volym datorminne, så storleken och noggrannheten Av representationen av siffrorna är dessa typer oundvikligen införda begränsningar.

Naturligtvis kan de exakta intervallet av dessa typer av datavärden bero på arkitekturen hos serverdatorn, men värdena hos heltal kan vanligtvis ligga i intervallet från -2 31 -1 till 2 31 -1, och Den flytande punkten för dubbel noggrannhet kan representera siffrorna med en noggrannhet på ca 13-14 decimala siffror. Å andra sidan, för att lösa problem som kräver användning av ett bredare representationsområde eller större noggrannhet, tillhandahålls i PHP-språk matematiska funktioner med godtycklig noggrannhet (även kallad BC-funktioner med namnet på beräkningsverktyget med en godtycklig noggrannhet baserat på Unix-systemets medel).

Det kan vara att funktioner med godtycklig noggrannhet inte ingår i sammanställningen. tolk PHP., speciellt om användaren utförde en sådan kompilering på egen hand, eftersom den här användaren var tvungen att veta att vid konfigurationsinställningsfasen är det nödvändigt att inkludera rutan i kryssrutan -Able-bcmath. För att kontrollera om det finns tillgång till de angivna funktionerna, försök att beräkna BCADD-uttrycket ("1", "1"). Om ett felmeddelande är mottaget, vilket hänvisar till en osäker funktion, måste du justera konfigurationen och kompilera PHP-tolken.

I BC-funktioner används icke-numeriska typer med en fast längdrepresentation som parametrar och returvärden. Eftersom i PHP-språkstränglängden är begränsad endast av volymen besvarat minneDe siffror som används i beräkningarna kan ha någon längd. De grundläggande beräkningarna utförs i decimalform och liknar i stor utsträckning de som kan utföra personen med hjälp av en penna och papper (om det kan agera mycket snabbt och fast med tålamod). BC-funktioner som arbetar i heltal agerar exakt och låter dig använda så många nummer som behövs, och i funktioner som arbetar med flytande punktnummer utförs beräkningar med en noggrannhet i ett givet nummer. decimala utsläpp. Allmän information om BC-funktioner visas i tabellen nedan:

Matematiska funktioner med godtycklig noggrannhet (BC-funktioner)

Fungera	Beskrivning
bcadd ()	Tar två strängparametrar som representerar siffror och en valfri heltalsparameter med en märkningsmultiplikator. Returnerar mängden av de två första parametrarna som en sträng, med mängden decimalpositioner som ett resultat bestämt av parametern med beteckningen av skalan multiplikatorn. Om en parameter med en skala multiplikatorn inte är specificerad används standardmultiplikatorn.
bcsub ()	Liknande BCADD (), förutom att det returnerar resultatet av att subtrahera den andra parametern från den första
bcmui ()	Liknande BCADD (), förutom att det returnerar resultatet av att multiplicera sina parametrar
bCDIV ()	Liknande BCADD (), förutom att det returnerar resultatet av att dividera den första parametern till den andra
bcmod ()	Returnerar modulen (rester) från divisionen av den första parametern till den andra. Eftersom returvärdet hänvisar till en heltalstyp accepterar funktionen inte parametern med beteckningen av en storskalig multiplikator
bcpow ()	Earls den första parametern till den examen som anges av den andra parametern. Antalet decimalpositioner som ett resultat bestäms av en storskalig faktor om den är angiven
bcsqrt ()	Returnerar parameterns kvadratrot med antalet decimalpositioner, vilket bestäms av värdet av den frivilliga storskaliga multiplikatorn
bcscale ()	Ställer in standard storskalig multiplikator för efterföljande samtal av BC-funktionen

De flesta av dessa funktioner tas som den sista parametern en valfri storskalig multiplikator (heltal), som bestämmer hur många decimala positioner som ska vara ett resultat. Om en sådan parameter inte är specificerad används en storskalig multiplikator som en storskalig multiplikator, som i sin tur kan ställas in genom att ringa bcscale () -funktionen. Standardvärdet för detta standardvärde (dvs det värde som används om skriptet inte använder funktionen BCScale ()) kan också ställas in i PHP.INI Initialization-filen.

Nedan är ett exempel på att använda en funktion med godtycklig noggrannhet för att exakt utföra heltal-aritmetiska operationer. Exekvering av följande kod:

PHP-kod för ($ x \u003d 1; $ x< 25; $x++) { echo "$x^{$ X.} \u003d ".bcpow ($ x, $ x)."
"; } Noggrann beräkning av astronomiska värden med BC-funktioner

Om den vanliga heltalstypen av PHP användes för dessa beräkningar, skulle överbänken över slutet av beräkningen ha använts, därför i resten av cykeln skulle beräkningarna utföras för att erhålla ett ungefärligt flytande punktnummer.

Arrays Behandlingsformer 1 2 3 4 5 6 7 8 9 10

Detta ämne är viktigt eftersom det finns vissa datorer i nästan alla applikationer. Verksamheten på siffrorna presenteras i tabellen nedan.

Aritmetiska operationer i PHP

Jag tror att dessa operatörer inte behöver några stora förklaringar. Jag kommer att citera ett exempel på att använda var och en av dem:

\\ $ num2 \u003d ". $ num2; // Exempel på summering: Echo "
\\ $ num1 + \\ $ num2 \u003d ". ($ num1 + $ num2); // Exekvering Exempel: Echo "
\\ $ num1 - \\ $ num2 \u003d ". ($ num1 - $ num2); // Exempel på multiplikation: Echo "
\\ $ num1 * \\ $ num2 \u003d ". $ num1 * $ num2; // Exempel på division: Echo "
\\ $ num1: \\ $ num2 \u003d ". $ num1 / $ num2; // Exempel på en balans från division: Echo "
\\ $ num1% \\ $ num2 \u003d ". $ num1% $ num2; // Exempel på inkrement i prefixform: Echo "
++ \\ $ num1 \u003d ". ++ $ num1; // nu $ num1 \u003d 11 $ num1 \u003d 10; // tilldelad initial mening // Exempel på inkrement i posten med prefixformulär: Echo "
\\ $ num1 ++ \u003d ". $ num1 ++; // nu $ num1 \u003d 11 $ num1 \u003d 10; // Tilldelar den ursprungliga meningen // Exempel på minskning av prefixformulär: Echo "
- \\ $ num1 \u003d ". - $ num1; $ num1 \u003d 10; // prov postrefix minskning: Echo "
\\ $ num1-- \u003d ". $ num1 -?\u003e

Resultatet av utförandet ovan är skriftlig kod:

$ num1 \u003d 10
$ num2 \u003d 7
$ num1 + $ num2 \u003d 17
$ num1 - $ num2 \u003d 3
$ num1 * $ num2 \u003d 70
$ num1: $ num2 \u003d 1.42857142857
$ num1% $ num2 \u003d 3
++ $ num1 \u003d 11
$ num1 ++ \u003d 10
- $ num1 \u003d 9
$ num1-- \u003d 10

Skillnaden mellan prefixet och postrefixformen:

• i prefixformuläret (++ före variabeln), förekommer först en ökning av en, och sedan är resultatet utmatning.
• i postrefix form (++ stående efter en variabel) visar först resultatet, och ökar ökningen redan

För så att du bättre förstår skillnaden, kommer jag att ge klassiskt exempelsom finns i många programmeringstextböcker:

// Tilldela variablerna: $ num1 \u003d 10; $ num2 \u003d 7; $ rez \u003d ++ $ num1 + $ num2; // resultatet blir 18 Echo "
\\ $ rez \u003d ". $ rez; // Vi tilldelar $ num1 första betydelsen: $ num1 \u003d 10; $ rez \u003d $ num1 ++ + $ num2; // resultatet blir 17 Echo "
\\ $ rez \u003d ". $ rez; // Operation ++ och - kan också tillämpas på rader $ str \u003d "abc"; Echo "
". ++ $ str; // resultat blir linjen "ABD" ?>

Det är värt att notera att när du lägger till variabler kan du använda två typer av poster:

• $ num1 \u003d $ num1 + $ num2 - normal post;
• $ num1 + \u003d $ num2 - förkortad post. Resultatet av dessa operationer kommer att vara detsamma. Förkortade poster kan också tillämpas med subtrahering och multiplicitationer.

Jämförelsesoperatörer i PHP

Jämförelsesoperatörer används i inspektioner av om villkor, etc. Men i den här lektionen kommer vi inte att överväga villkorliga operatöreroch överväga endast jämförelsesoperatörer. Alla jämförelsesoperatörer visas i tabellen nedan:

Det finns inget komplicerat här, principen är densamma som i matematik. Den enda funktionen är att sant (sanning) är 1, och falskt (lögner) är 0. Låt oss ge detaljerat exempel PHP:

// Tilldela variablerna: $ num1 \u003d 10; $ num2 \u003d 7; Echo "\\ $ num1\u003e \\ $ num2 \u003d". ($ num1\u003e $ num2); // Ta emot 1 (10\u003e 7 - Höger) Echo "\\ $ num1 // ta emot 0 (10 // Du kan skriva enklare: Echo "
10 // 0 echo "
20 // 0 echo "
1 \u003d\u003d 1 \u003d ". (1 \u003d\u003d 1); // 1 eko"
0 \u003d\u003d \\ "\\" \u003d ". (0 \u003d\u003d" "); // 1 eko"
0 \u003d\u003d\u003d 0 \u003d ". (0 \u003d\u003d\u003d 0); // 1 eko"
0 \u003d\u003d\u003d \\ "\\" \u003d ". (0 \u003d\u003d\u003d" "); // 0 echo"
sant \u003d ". Sant; // 1 eko"
false \u003d ". FALSE; // 0?\u003e

notera:

• I fallet med falskt kommer 0 inte att visas
• ekvivalensoperatören returnerar 1 endast när det finns en exakt matchning. Till exempel 0 \u003d\u003d "" sant, och 0 \u003d\u003d\u003d "" är inte längre sant, eftersom det inte finns någon korrekt match.

Verksamhet med PHP-variabler (operatörer)

För implementering finns det olika grupper.

Operatören kallas något som består av ett eller flera värden (uttryck, om vi talar om programmering av jargong), som kan beräknas som ett nytt värde (sålunda kan hela designen betraktas som ett uttryck). Det följer att funktioner eller andra mönster som returnerar värdet (till exempel, skriv ut ()) är operatörer, i motsats till alla andra språkstrukturer (till exempel, echo ()) som inte returnerar någonting.

Aritmetiska operationer i PHP

Kom ihåg skolbaserna av aritmetik? Operatörerna som beskrivs nedan fungerar på samma sätt.

Divisionsoperationen ("/") returnerar alltid den verkliga typen, även om båda värdena var heltal (eller strängar som omvandlas till heltal). Annars kommer resultatet att vara fraktionellt.

Drift av beräkning av saldot från division " % "Det fungerar bara med heltal, så att användningen av fraktion kan leda till ett oönskat resultat.

Det är möjligt att använda parentes. Prioriteten för vissa matematiska operationer på andra och förändrade prioriteringar vid användning av parentes i aritmetiska uttryck motsvarar de vanliga matematiska reglerna.

Inkrement och minskningsoperationer

PHP, liknande C, upprätthåller prefix och postfix inkrement och minskningsoperatörer.

Postfix inkrement och minskningsoperatörer

Liksom i C-språket ökar dessa operatörer eller minskar värdet på variabeln, och i uttrycket returnerar de värdet på variabeln $ A. före ändring. Till exempel:

$ a \u003d 10;
$ b \u003d $ a ++;
echo "A \u003d $ a, b \u003d $ b"; // Visar A \u003d 11, B \u003d 10

Som du kan se, först variabel $ B. Värdet på variabeln tilldelades $ A.Och sedan ökade den senare. Emellertid är uttrycket vars värde tilldelats variabeln $ B.kanske svårare - i alla fall ökar $ A. Det kommer bara att hända efter beräkningen.

Prefix inkrement och minskningsoperatörer

Det finns också inkrement och minskningsoperatörer som anges, och inte efter det variabla namnet. Följaktligen returnerar de värdet av variabeln efter förändringen. Exempel:

$ a \u003d 10;
$ b \u003d - $ a;
echo "A \u003d $ a, b \u003d $ b"; // Visar A \u003d 9, B \u003d 9

Ökning och minskningsoperationer i praktiken används mycket ofta. Till exempel finns de i nästan vilken cykel som helst för .

eko. "

Postfix inkrement

" ;
$ a \u003d 5;
Echo "ska vara 5:". $ A ++. "
\\ n ";

\\ n ";

Eko. "

Prefix inkrement

" ;
$ a \u003d 5;
Echo "ska vara 6:". ++ $ a. "
\\ n ";
Echo "ska vara 6:". $ a. "
\\ n ";

Eko. "

Postfix minskning

" ;
$ a \u003d 5;
Echo "ska vara 5:". $ A -. "
\\ n ";

\\ n ";

Eko. "

Prefix minskning

" ;
$ a \u003d 5;
Echo "ska vara 4:". - $ a. "
\\ n ";
Echo "ska vara 4:". $ a. "
\\ n ";
?>

Strängoperationer

I PHP finns två operatörer att arbeta med rader. Den första är en koncatenationsoperatör ("."), Som returnerar unionen av vänster och höger argument. Den andra är anslagsoperatören med sammanlänkning, som förenar rätt argument till vänster. Låt oss ge ett specifikt exempel:

$ a \u003d "hej";
$ b \u003d $ a. "VÄRLD!" ; // $ b innehåller en sträng "Hello World!"

$ a \u003d "hej";
$ a. \u003d "värld!" ; // $ a innehåller strängen "Hello World!"
?>

Tappning

Dessa operationer är utformade för att fungera (installation / borttagning / kontroll) bitar i hela variabeln. Bitarna i ett heltal - det är inget mer än de enskilda utsläppen av samma nummer som är inspelat i det binära nummersystemet. Till exempel, i ett binärt system, kommer nummer 12 att se ut som 1100 och 2 - som 10, så uttrycket 12|2 Returnerar US nummer 14 (1110 i binär inspelning). Om variabeln inte är en helhet är den
Chal är avrundad, och sedan appliceras operatörerna nedan på den.

För att representera ett nummer används 32 bitar:

• 0000 0000 0000 0000 0000 0000 0000 0000 är noll;
• 0000 0000 0000 0000 0000 0000 0000 0001 är 1;
• 0000 0000 0000 0000 0000 0000 0000 0010 är 2;
• 0000 0000 0000 0000 0000 0000 0000 0011 är 3;
• 0000 0000 0000 0000 0000 0000 0000 0100 - Detta är 4;
• 0000 0000 0000 0000 0000 0000 0000 0101 är 5;
• 0000 0000 0000 0000 0000 0000 0000 1111 är 15;

Flaskanslutna operatörer:

Exempel	namn	Resultat
$ A & $ b	Bitvis "och"	Endast de bitar som är installerade i $ A och $ B är installerade.
$ a | $ B.	Bitvis "eller"	Installerade de bitar som är installerade antingen i $ a eller i $ b.
$ a ^ $ b	Exklusive eller	Bara de bitar som är installerade antingen bara $ a är installerade eller bara $ b
~ $ A.	Negation	Det finns de bitar som inte är installerade i $ A och vice versa.
$ A.<< $b	Skift till vänster	Alla variabla bitar $ ett skift till $ b positioner till vänster (varje position innebär "multiplikation med 2")
$ a\u003e $ b	Skift till höger	Alla variabla bitar $ ett skift till $ b positioner till höger (varje position innebär "division med 2")

Operationer av jämförelse

Jämförelseoperatörer, som kan ses från deras namn, låter dig jämföra två värden med varandra.

Detta är en slags unik operation, för oberoende av de typer av deras argument, återvänder de alltid en av två: falsk eller sann.. Jämförelseoperationer gör det möjligt för dig att jämföra två värden mellan sig och, om villkoret utförs, returneras sann., Och om inte - falsk.

PHP får endast jämföra skalärvariabler. Arrays och objekt i PHP kan inte jämföras. De kan till och med jämföras med jämlikhet (med operatören \u003d\u003d), men när man utför en sådan operation utfärdar PHP inte varningar. Så överraskande en gång, varför två helt olika arrays när de jämför dem med == Det är plötsligt detsamma, kom ihåg att innan man jämför båda operanderna omvandlas till ordet array. som jämförs därefter.

För detaljer om att jämföra arrays, se.

Jämförelseoperatörer:

Exempel	namn	Resultat
$ a \u003d\u003d $ b	Lika	Sann. Om $ a är $ b.
$ a \u003d\u003d\u003d $ b	Identiskt lika	Sann. Om $ a är $ b och har samma typ. (Läggas till php 4)
$ a! \u003d $ b	Inte jämnlikt	Sann. Om $ a är inte $ b.
$ A.<> $ B.	Inte jämnlikt	Sann. Om $ a är inte $ b.
$ a! \u003d\u003d $ b	Identiskt inte lika med	Sann. Om $ A inte är $ B eller om de är olika typer (PHP 4)
$ A.< $b	Mindre	Sann. Om $ a är strängt mindre än $ b.
$ a\u003e $ b	Mer	Sann. Om $ a är strängt mer $ b.
$ A.<= $b	Mindre eller lika	Sann. Om $ a är mindre än eller lika med $ b.
$ a\u003e \u003d $ b	Mer eller lika	Sann. Om $ a är större än eller lika med $ b.

Logiska operationer

Logiska operatörer är uteslutande avsedda för att arbeta med logiska uttryck och återvända också falsk eller sann..

Vi ger ett bord med logiska PHP-operatörer:

Det bör noteras att beräkningen av logiska uttryck som innehåller sådana operatörer alltid från vänster till höger, medan om resultatet redan är uppenbart (till exempel, falskt && något ger alltid falsk) Beräkningarna är trasiga, även om det finns funktionssamtal i uttrycket. Till exempel, i operatören $ logik \u003d 0 && (tid ()\u003e 100); Standardfunktion tid () kommer aldrig att orsakas.

Var försiktig med logiska operationer - glöm inte att dubbla symbolen. Observera att till exempel | och || - Två helt olika operatörer, varav en kan eventuellt returnera ett nummer och det andra falsk och sann..

Inkrementoperatörer (++) och minskning (-) fungerar inte med logiska variabler.

Ekvivalensoperatörer

PHP, som börjar med PHP4 finns en identisk jämförelsesoperatör - ett trippel tecken på jämlikhet === ,
eller verifieringsoperatör på. PHP är ganska tolerant hänvisar till det faktum att linjerna implicit omvandlas till siffror och vice versa.
Till exempel kommer följande kod att matas ut att värdena för variabler är lika:

$ a \u003d 10;
$ b \u003d "10";

Och det är trots det faktum att variabeln $ A. representerar ett nummer som $ B. - String. Herase överväger ett något annat exempel:

$ a \u003d 0; // noll
$ B \u003d ""; // tom linje
Om ($ a \u003d\u003d $ b) eko "A och B är lika // Visar "A och B är lika

Fastän $ A. och $ B. Det är klart inte lika även i den vanliga förståelsen av det här ordet, skriptet kommer att förklara att de sammanfaller. Varför händer det här? Faktum är att om en av operandernas operander kan tolkas som ett nummer, behandlas båda operanderna som siffror. I det här fallet blir den tomma linjen till 0 som sedan jämförs med noll. Inte undra på operatören eko. triggers.
Problemet löser ekvivalensoperatören === (Triple Equality). Det jämför inte bara två uttryck, men också deras typer. Vi skriver om vårt exempel med den här operatören.

Logiska operationer finns på alla programmeringsspråk och PHP. inte ett undantag. Förutom enkel division, multiplikation, tillägg eller subtraktion, finns det fortfarande heltal och resterande division, som vi kommer att prata om nu, och vi kommer också att analysera dem med hjälp av detaljerade exempel.

En heltal division är återkallandet av hela delen av divisionen. Till exempel, om vi delar 2, får vi 2, och inte 2,5.

Med resterande division är allt annorlunda. Detta är slutsatsen av resten från division av ett heltal. Till exempel, dela samma topp fem, kommer du att få inte 2 och 1, eftersom 5 dividing 2, vi får 2, och 1 förblir i återstoden.

Hur man utför heltal division i PHP

Till exempel, i Python, uppstår denna division med en enkel operatör: "//".

En B. PHP. Det är inte så lätt att göra det, men fortfarande kräver processen inte språk.

Låt oss ge ett exempel hur kan det implementeras.

I PHP. Den sjunde versionen är som följer:

Intiv ();

I den äldre versionen ser samma funktion så här:

Det finns också ett sätt för alla versioner:

Golv ();

Hur man ordnar?

Till exempel, ta den första funktionen, alla andra utförs ungefär.

$ resultat \u003d intdiv (10, 3); Echo $ resultat;

Återstående division i PHP

För att få ett heltal balans från att dela in Php Det är nog bara att sätta operatören "%".

$ i \u003d 10% 3; Echo $ i;

Som vi ser är allt ganska enkelt och kräver inte långsiktiga förklaringar.

Var kan jag använda?

Kunskap om heltal i PHP. Kommer vara mycket användbart om du behöver jämföra två nummer, skapa ett antal tvärgående (populärt motion), eller till exempel ett program som heter FizzBuzz. Dess väsen är att du måste skriva en cykel från 1 till 100, som delar varje nummer vid 3 och 5. Om numret dividerat med 3, i återstoden gav 0, skriver vi Fizz, om dividerat med 5, sedan buzz, Och om delning och 5, och 3, får vi 0 i resten, då skriver vi FizzBuzz. Detta är en mycket populär uppgift för intervjuer. Om du har genomfört det själv kan du vara stolt över det.

Eller till exempel måste vi erbjuda alla sina nummer (4, 5, 2) bland sina 452.

Slutsats

Naturligtvis är heltalet och restdivisionen användbar och finns ganska ofta, det är inte så bekvämt att använda dem som i Python, men fortfarande viktigt.

Nu går du närmare att lära dig programmeringsspråket Php Och i framtiden blir ännu närmare om du också kommer att flitigt övervinna svårigheter.