Php geheel getal uit deling. Nummerverwerking en wiskundige bewerkingen

Bewerkingen met PHP-variabelen (operatoren)

Er zijn verschillende groepen voor de uitvoering.

Een operator is iets dat bestaat uit een of meer waarden (expressies in programmeerjargon) die kunnen worden geëvalueerd als een nieuwe waarde (het hele construct kan dus als een expressie worden beschouwd). Hieruit volgt dat functies of andere constructies die een waarde retourneren (bijvoorbeeld afdrukken()) zijn operatoren, in tegenstelling tot alle andere taalconstructies (bijvoorbeeld echo()), die niets teruggeeft.

Rekenkundige bewerkingen in PHP

Weet je nog de basisprincipes van rekenen op school? De onderstaande uitspraken werken op dezelfde manier.

De delingsoperator ("/") retourneert altijd echte soort, zelfs als beide waarden gehele getallen waren (of tekenreeksen die naar gehele getallen worden omgezet). Anders zal het resultaat fractioneel zijn.

De bewerking van het berekenen van de rest van de verdeling " % " werkt alleen met hele getallen, dus toepassing ervan op breuken kan ongewenste resultaten opleveren.

Het is mogelijk om haakjes te gebruiken. Prioriteit van sommigen wiskundige bewerkingen over anderen en het veranderen van prioriteiten bij het gebruik van haakjes in rekenkundige uitdrukkingen overeenkomen met gewone wiskundige regels.

Verhogings- en verlagingsbewerkingen

PHP ondersteunt, vergelijkbaar met C, het voorvoegsel en postfix-operatoren verhogen en verlagen.

Operators voor het verhogen en verlagen van postfix

Net als in C verhogen of verlagen deze operators de waarde van een variabele, en retourneren ze in een uitdrukking de waarde van de variabele $ een vóór de verandering. Bijvoorbeeld:

$a=10;
$b=$a++;
echo "a=$a, b=$b"; // Afdrukken a=11, b=10

Zoals je kunt zien, eerst de variabele $b waarde toegewezen aan variabele $ een, en pas toen werd de laatste verhoogd. Dit is echter de expressie waarvan de waarde aan de variabele is toegewezen $b, kan moeilijker zijn - in ieder geval verhogen $ een zal pas gebeuren nadat het is berekend.

Operatoren voor het verhogen en verlagen van prefixen

Er zijn ook operatoren voor verhogen en verlagen, die worden opgegeven in plaats van achter de naam van de variabele. Dienovereenkomstig retourneren ze de waarde van de variabele na de wijziging. Voorbeeld:

$a=10;
$b=--$a;
echo "a=$a, b=$b"; // Drukt a=9, b=9 af

In de praktijk worden ophoog- en afbouwbewerkingen zeer vaak gebruikt. Ze komen bijvoorbeeld in vrijwel elke cyclus voor voor .

echo "

Postfix-toename

Echo "

Voorvoegselverhoging

Echo "

Postfix-verlaging

Echo "

Voorvoegsel verlagen

String-bewerkingen

PHP heeft twee operators voor het werken met strings. De eerste is de aaneenschakelingsoperator ("."), die de aaneenschakeling van de linker- en rechterargumenten retourneert. De tweede is een toewijzingsoperator met aaneenschakeling, die het rechterargument aan het linker toevoegt. Laten we een specifiek voorbeeld geven:

$a = "Hallo" ;
$b = $een. "Wereld!" ; // $b bevat de tekenreeks "Hallo wereld!"

$a = "Hallo" ;
$a .= "Wereld!" ; // $a bevat de tekenreeks "Hallo wereld!"
?>

Bitsgewijze bewerkingen

Deze bewerkingen zijn ontworpen om groepen bits in een gehele variabele te bedienen (instellen/uitschakelen/controleren). De bits van een geheel getal zijn niets meer dan individuele cijfers van hetzelfde getal, erin geschreven binair systeem Afrekening. In binair getal zou het getal 12 er bijvoorbeeld uitzien als 1100 en 2 als 10, dus de uitdrukking 12|2 zal ons het getal 14 teruggeven (1110 in binaire notatie). Als een variabele geen geheel getal is, dan is dat wel het geval
eerst afgerond, waarna de volgende operatoren erop worden toegepast.

Om één getal weer te geven worden 32 bits gebruikt:

• 0000 0000 0000 0000 0000 0000 0000 0000 is nul;
• 0000 0000 0000 0000 0000 0000 0000 0001 is 1;
• 0000 0000 0000 0000 0000 0000 0000 0010 is 2;
• 0000 0000 0000 0000 0000 0000 0000 0011 is 3;
• 0000 0000 0000 0000 0000 0000 0000 0100 is 4;
• 0000 0000 0000 0000 0000 0000 0000 0101 is 5;
• 0000 0000 0000 0000 0000 0000 0000 1111 is 15;

Bitwise-operatoren:

Vergelijkingsoperaties

Met vergelijkingsoperatoren kunt u, zoals hun naam al doet vermoeden, twee waarden vergelijken.

Dit zijn op hun eigen manier unieke bewerkingen omdat ze, ongeacht het type argumenten, altijd een van de volgende twee dingen retourneren: vals of WAAR. Vergelijkingsbewerkingen vergelijken twee waarden met elkaar en retourneren, als de voorwaarde waar is, WAAR, En indien niet - vals.

PHP staat alleen toe dat scalaire variabelen worden vergeleken. Arrays en objecten kunnen in PHP niet met elkaar worden vergeleken. Ze kunnen niet eens worden vergeleken op gelijkheid (met behulp van de == operator), maar als je dit wel doet PHP-bewerkingen geeft geen waarschuwing. Dus ik heb me ooit afgevraagd waarom twee totaal verschillende arrays worden gebruikt bij het vergelijken ervan == plotseling hetzelfde blijken te zijn, onthoud dat vóór de vergelijking beide operanden naar een woord worden omgezet reeks, die vervolgens wordt vergeleken.

Zie Arrayvergelijking voor details.

Vergelijkingsoperatoren:

Logische bewerkingen

Logische operatoren zijn exclusief ontworpen voor het werken met Booleaanse expressies en retourneren ook vals of WAAR.

Hier is een tabel met logische PHP-operatoren:

Opgemerkt moet worden dat de berekening logische uitdrukkingen, die dergelijke operatoren bevat, gaat altijd van links naar rechts, en als het resultaat al duidelijk is (bijvoorbeeld vals&&iets geeft altijd vals), worden de berekeningen beëindigd, zelfs als de expressie functieaanroepen bevat. In de operator $logic = 0&&(time()>100); standaard functie tijd() zal nooit gebeld worden.

Wees voorzichtig met logische operaties- vergeet niet het symbool te verdubbelen. Houd er rekening mee dat bijvoorbeeld | En || - twee absoluut verschillende exploitanten, waarvan er één mogelijk elk getal kan retourneren, en de tweede alleen vals En WAAR.

De operators verhogen (++) en verlagen (--) werken niet met Booleaanse variabelen.

Equivalentie-operatoren

In PHP is er vanaf PHP4 een identieke vergelijkingsoperator: een drievoudig gelijkteken === ,
of de cheque-operator. PHP is redelijk tolerant als tekenreeksen impliciet worden omgezet in getallen, en omgekeerd.
De volgende code zal bijvoorbeeld afdrukken dat de waarden van de variabelen gelijk zijn:

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

En dit ondanks het feit dat de variabele $ een vertegenwoordigt een getal en $b- lijn. Laten we nu eens naar een iets ander voorbeeld kijken:

$a=0; // nul
$b=""; // lege regel
if($a==$b) echo "a en b zijn gelijk"; // Afdrukken "a en b zijn gelijk"

Hoewel $ een En $b duidelijk niet gelijk zijn, zelfs in de gebruikelijke zin van het woord, zal het script verklaren dat ze hetzelfde zijn. Waarom gebeurt dit? Het punt is dat als een van de operanden logische exploitant kunnen worden behandeld als een getal, dan worden beide operanden behandeld als getallen. In dit geval verandert de lege regel in 0 , die vervolgens wordt vergeleken met nul. Het is niet verwonderlijk dat de exploitant echo werken.
Het probleem wordt opgelost door de equivalentieoperator === (drievoudige gelijkheid). Het vergelijkt niet alleen twee uitdrukkingen, maar ook hun typen. Laten we ons voorbeeld herschrijven met deze operator.

Dit onderwerp is belangrijk omdat bijna alle toepassingen een of andere vorm van computerbewerkingen met zich meebrengen. Bewerkingen op getallen worden weergegeven in de onderstaande tabel.

Rekenkundige bewerkingen in php

Ik denk dat deze operators niet veel uitleg nodig hebben. Ik zal een voorbeeld geven van het gebruik van elk van deze:

\$num2 = ". $num2; //Voorbeeld van sommatie: echo "
\$num1 + \$num2 = ". ($num1 + $num2); //Voorbeeld van aftrekken: echo "
\$num1 - \$num2 = ". ($num1 - $num2); //Vermenigvuldigingsvoorbeeld: echo "
\$num1 * \$num2 = ". $num1 * $num2; //Voorbeeld van deling: echo "
\$num1: \$num2 = ". $num1 / $num2; //Voorbeeld van de rest van de deling: echo "
\$num1 % \$num2 = ". $num1 % $num2; //Een voorbeeld van ophogen in voorvoegselvorm: echo "
++\$num1 = ". ++$num1; //Nu $num1 = 11 $num1=10; // toegewezen initiële waarde //Voorbeeld van ophogen in post-prefixvorm: echo "
\$num1++ = ". $num1++; //Nu $num1 = 11 $num1=10; //heeft de oorspronkelijke waarde toegewezen //Een voorbeeld van verlaging in voorvoegselvorm: echo "
--\$num1 = ". --$num1; $num1=10; //Een voorbeeld van verlaging in de vorm na het voorvoegsel: echo "
\$num1-- = ". $num1--; ?>

Het resultaat van het uitvoeren van de bovenstaande code:

$num1 = 10
$num2 = 7
$num1 + $num2 = 17
$num1 - $num2 = 3
$num1 * $num2 = 70
$num1: $num2 = 1,42857142857
$num1 % $num2 = 3
+$num1 = 11
$num1++ = 10
--$num1 = 9
$num1-- = 10

Verschil tussen prefix- en postprefix-vorm:

• in voorvoegselvorm(++ staat vóór de variabele) eerst wordt deze met één verhoogd en vervolgens wordt het resultaat afgedrukt
• in postprefix-vorm(++ komt na de variabele) het resultaat wordt eerst weergegeven en vervolgens verhoogd

Om je te helpen het verschil beter te begrijpen, zal ik een klassiek voorbeeld geven dat in veel programmeerboeken wordt gegeven:

//Waarden toewijzen aan variabelen:$num1 = 10; $num2 = 7; $rez = ++$num1 + $num2; // resultaat zal 18 zijn echo "
\$rez = ". $rez; //Wijs $num1 toe aan de beginwaarde:$num1 = 10; $rez = $num1++ + $num2; // het resultaat is 17 echo "
\$rez = ". $rez; //Bewerkingen ++ en -- kunnen ook op tekenreeksen worden toegepast$str = "abc"; echo "
".++$str; // het resultaat is de string "abd" ?>

Het is vermeldenswaard dat u bij het toevoegen van variabelen twee soorten records kunt gebruiken:

• $num1 = $num1 + $num2 - reguliere entree;
• $num1 += $num2 is een verkorte notatie. Het resultaat van deze operaties zal hetzelfde zijn. Verkorte notatie kan ook worden gebruikt bij aftrekkingen en vermenigvuldigingen.

Vergelijkingsoperatoren in php

Vergelijkingsoperatoren worden gebruikt bij het testen van if-omstandigheden en dergelijke. In deze les gaan we daar echter niet op in Voorwaardelijke stellingen, maar houd alleen rekening met vergelijkingsoperatoren. Alle vergelijkingsoperatoren worden weergegeven in de onderstaande tabel:

Er is hier niets ingewikkelds, het principe is hetzelfde als in de wiskunde. De enige bijzonderheid is dat waar 1 is, en onwaar 0. Laten we geven gedetailleerd voorbeeld in PHP:

//Waarden toewijzen aan variabelen:$num1 = 10; $num2 = 7; echo "\$num1 > \$num2 = ". ($num1 > $num2); //krijg 1 (10 > 7 - waar) echo "\$num1 //krijg 0 (10 //Je kunt het eenvoudiger schrijven: echo "
10 // 0 echo "
20 // 0 echo "
1 == 1 = ". (1 == 1); // 1 echo "
0 == \"\" = ". (0 == ""); // 1 echo "
0 === 0 = ". (0 === 0); // 1 echo "
0 === \"\" = ". (0 === ""); // 0 echo "
waar = ". waar; // 1 echo "
false = ". false; // 0 ?>

opmerking:

• Als dit niet waar is, wordt er geen 0 uitgevoerd
• De equivalentieoperator retourneert alleen 1 als er een exacte overeenkomst is. 0 == "" is bijvoorbeeld waar, maar 0 === "" is niet langer waar, omdat er geen exacte overeenkomst is.

Programmeurs die gevoelige numerieke, wetenschappelijke of statistische berekeningen moeten uitvoeren, zullen een webscripttaal waarschijnlijk niet als een acceptabele kandidaat voor deze rol beschouwen. Maar ondanks het bovenstaande biedt de PHP-taal een uitstekende reeks functies die volledig een oplossing bieden voor de meeste wiskundige problemen die zich voordoen bij het uitvoeren van scripts voor het web. Bovendien biedt PHP enkele meer geavanceerde mogelijkheden, zoals willekeurige precisieberekeningen, hash-bibliotheken en cryptografische bibliotheken.

De ontwikkelaars van de PHP-taal kozen voor een gefundeerde aanpak en deden geen enkele poging om de voor dit doel ontworpen wielen opnieuw uit te vinden. Feit is dat veel van de meest fundamentele wiskundige functies die in PHP worden gebruikt eenvoudigweg om hun C-tegenhangers heen zitten.

Wiskundige bewerkingen

De meeste wiskunde in PHP wordt gedaan in de vorm van ingebouwde functies in plaats van bewerkingen. Naast vergelijkingsoperatoren biedt PHP vijf eenvoudige rekenkundige operatoren, evenals enkele snelkoppelingsoperatoren waarmee u kortere uitdrukkingen voor verhogen, verlagen en toewijzen kunt construeren.

Rekenkundige bewerkingen

De vijf rekenkundige basisbewerkingen omvatten de bewerkingen die gewoonlijk worden geïmplementeerd in elke rekenmachine met vier functies, plus modulo (%). Een korte beschrijving van rekenkundige bewerkingen wordt gegeven in de tabel:

Wanneer u de eerste drie hierboven beschreven rekenkundige bewerkingen (+, -, *) in een programma gebruikt, moet u er rekening mee houden dat bij het uitvoeren van deze bewerkingen typevoortplanting plaatsvindt van drijvende-kommawaarden met dubbele precisie naar gehele waarden. Wat dit betekent is dat als beide operanden van een bewerking gehele getallen zijn, het resultaat een geheel getal is, en als ten minste één van de operanden een drijvende-kommagetal met dubbele precisie is, het resultaat een drijvende-kommagetal met dubbele precisie is. nummer. Hetzelfde type voortplanting vindt plaats bij het uitvoeren van een delingsoperatie; Bovendien is er als bijkomend effect dat het resultaat een drijvende-kommagetal met dubbele precisie wordt als de deling niet (geheel) zonder rest wordt uitgevoerd.

De modulo (%) bewerking in PHP accepteert integer-operands, en wanneer deze bewerking wordt toegepast op drijvende-kommagetallen met dubbele precisie, worden deze getallen eerst omgezet in gehele getallen (door het fractionele deel weg te laten). Het resultaat van een dergelijke bewerking is altijd een geheel getal.

Verhogings- en verlagingsbewerkingen

Een groot deel van de syntaxis van PHP is afgeleid van C, en C-programmeurs staan ​​bekend om hun liefde voor beknoptheid en zijn daar trots op. De operatoren voor verhogen en verlagen, afkomstig uit de C-taal, maken het mogelijk om uitdrukkingen zoals $count = $count + 1 beknopter weer te geven, die meestal vrij vaak in programma's voorkomen.

De operator voor verhogen (++) wordt gebruikt om één op te tellen bij de waarde van de variabele die door de bewerking wordt beïnvloed, en de operator voor verlagen (--) trekt één af van de waarde van de variabele.

Elk van deze twee operaties heeft twee varianten: achtervoegsel(in deze vorm wordt het bewerkingsteken onmiddellijk na de variabele geplaatst die door de bewerking wordt beïnvloed) en voorvoegsel(in dit formulier wordt het bewerkingsteken onmiddellijk vóór de variabele geplaatst waarop de bewerking van toepassing is). Beide hebben hetzelfde neveneffect: het veranderen van de waarde van een variabele, maar operatoren voor achtervoegsels en voorvoegsels retourneren verschillende waarden wanneer ze als expressies worden gebruikt. De achtervoegselbewerking werkt zo dat de waarde van de variabele wordt gewijzigd nadat de waarde van de uitdrukking is geretourneerd, en de voorvoegselbewerking werkt zo dat de waarde eerst wordt gewijzigd en vervolgens de nieuwe waarde aan de variabele wordt geretourneerd. Dit verschil kan worden gedetecteerd door de operatoren voor verlagen en verhogen te gebruiken in toewijzingsoperatoren:

De volgende instructies produceren de volgende uitvoer in het browservenster:

Bewerkingen verhogen

In dit voorbeeld is de operator $result = $count++ volledig gelijk aan de operators:

Daarnaast is de operator $result = ++$count gelijk aan de volgende operators:

Toewijzingsoperatoren

Operatoren voor het verhogen (en verlagen) verminderen de hoeveelheid code die nodig is om er één toe te voegen aan de waarde van een variabele, maar verminderen niet de hoeveelheid code die aan een variabele het resultaat toekent van het optellen van de waarde aan een ander getal of het resultaat van andere rekenkundige bewerkingen . Gelukkig hebben alle vijf rekenkundige operatoren overeenkomstige toewijzingsoperatoren (+=, -=, *=, /= en %=), waarmee je het resultaat van een rekenkundige bewerking op de waarde van die variabele kunt toewijzen aan een variabele in één. korte uitdrukking. De exploitant bijvoorbeeld

kan worden afgekort als

Eenvoudige wiskundige functies

De volgende stap om een ​​programma complexer te maken dan een programma dat alleen maar rekenkundige bewerkingen gebruikt, is het gebruik van allerlei functies. Met functies kunt u taken uitvoeren zoals het converteren van het ene getaltype naar het andere (zie het artikel Gegevenstypen) en het vinden van het minimum- of maximumaantal in een reeks getallen. De volgende tabel toont eenvoudige wiskundige functies:

Het resultaat van de volgende expressie is bijvoorbeeld 3, omdat de waarde van elke functieaanroepexpressie ook 3 is:

Willekeurige getallen genereren

De PHP-taal maakt gebruik van twee generatoren voor willekeurige getallen (die respectievelijk worden aangeroepen met behulp van de functies rand() En mt_rand()). Elk van deze generatoren is geassocieerd met drie functies met hetzelfde doel: de functie van het instellen van de initiële waarde ( strand() En mt_srand()), de functie zelf voor het verkrijgen van een willekeurig getal en de functie die het grootste gehele getal bemonstert dat door de generator kan worden geretourneerd (( getrandmax() En mt_gerandmax())). De functies getrandmax() en mt_getrandmax() retourneren het grootste getal dat kan worden geretourneerd door rand() of mt_rand(), wat beperkt is tot 32768 op Windows-platforms.

De keuze van de specifieke functie voor het genereren van pseudowillekeurige getallen die wordt gebruikt in de functie rand() kan afhangen van de bibliotheken waarmee de PHP-interpreter is gecompileerd. Daarentegen gebruikt de mt_rand()-generator altijd dezelfde functie voor het genereren van pseudo-willekeurige getallen (mt is een afkorting van Mersenne Twister), en de auteur van de operationele documentatie voor de mt_rand()-functie beweert dat deze functie ook sneller is en " meer random" (vanuit cryptografisch oogpunt) dan rand(). We hebben geen reden om aan de waarheid van deze uitspraken te twijfelen, en daarom gebruiken we liever de functie mt_rand() dan rand().

Wanneer sommige versies van PHP op sommige platforms worden gebruikt, lijkt het erop dat de functies rand() en mt_rand() ogenschijnlijk redelijke willekeurige getallen produceren, zelfs zonder eerst een zaadje in te stellen. Maar een dergelijke indruk mag niet worden vertrouwd. Ten eerste kunnen programma's die functies gebruiken voor het genereren van willekeurige getallen zonder een beginwaarde op te geven, niet gemakkelijk worden overgedragen naar andere platforms, en ten tweede is de betrouwbare werking van deze functies zonder een beginwaarde op te geven niet gegarandeerd.

De typische manier om de startwaarde voor een van de PHP-generatoren voor willekeurige getallen in te stellen (met behulp van de functie mt_srand() of srand()) is als volgt:

Deze operator stelt de initiële waarde van de generator in, gelijk aan het aantal microseconden dat tegen die tijd is verstreken sinds de laatste hele seconde werd geteld. (De cast to double in deze instructie is eigenlijk nodig omdat de functie microtime() een string retourneert, die wordt behandeld als een geheel getal bij de vermenigvuldigingsbewerking, maar niet bij het doorgeven van parameters aan de functie.) We raden de lezer aan om in te voeren de gespecificeerde initialisatieoperator, zelfs als het doel van deze operator hem niet geheel duidelijk is; Door deze instructie slechts één keer op elke PHP-pagina te plaatsen, voordat u de overeenkomstige functie mt_rand() of rand() gebruikt, wordt ervoor gezorgd dat het startpunt verandert en daardoor elke keer een andere willekeurige reeks wordt geproduceerd.

Deze specifieke methode voor het instellen van de initiële waarde is diep doordacht door die specialisten die alle nuances van het genereren van pseudo-willekeurige getallen volledig begrijpen, daarom zal het hoogstwaarschijnlijk voor altijd beter blijven dan alle pogingen van een individuele programmeur om met iets te komen. meer ‘lastig’.

Het is duidelijk dat deze functies die pseudo-willekeurige getallen genereren alleen gehele getallen retourneren, maar een willekeurig geheel getal uit een bepaald bereik kan eenvoudig worden geconverteerd naar een corresponderend getal met drijvende komma (bijvoorbeeld een getal uit het bereik van 0,0 tot en met 1,0) met behulp van een uitdrukking als rand () /getrandmax(). Het opgegeven bereik kan vervolgens indien nodig worden geschaald en verschoven. Hieronder ziet u een voorbeeld:

Probeer de pagina meerdere keren met deze code te vernieuwen om er zeker van te zijn dat er willekeurige getallen worden gegenereerd.

Wiskundige constanten

In PHP versie 4.0 werd er slechts één wiskundige constante beschreven in de documentatie: M_PI (de waarde van π, weergegeven als een drijvende-kommagetal met dubbele precisie). En vanaf PHP 4.0.2 zijn er veel nieuwe constanten geïntroduceerd. De meeste van deze nieuwe constanten hadden betrekking op π (of veelvouden ervan), e (of veelvouden ervan) en vierkantswortels; bovendien behoorden sommige constanten tot andere typen. Maar in daaropvolgende releases werd de lijst met constanten om een ​​aantal redenen opnieuw teruggebracht tot een relatief klein aantal vooraf gedefinieerde wiskundige constanten:

Getalnotatie controleren

De PHP-taal biedt een aantal functies waarmee u de juiste weergave van getallen kunt controleren. Hoewel PHP geen strikte typecontrole kent, wordt aanbevolen dat u indien nodig een aantal van deze controles in uw code implementeert, zodat u de kenmerken van de resultaten die u ontvangt kunt voorspellen en ook de beste manier kunt kiezen om ermee om te gaan.

De eerste en eenvoudigste controle is het gebruik van de functie is_numeriek(). Zoals bij de meeste andere soortgelijke tests retourneert de functie is_numeric een Booleaans resultaat - true als de parameter die eraan wordt doorgegeven numerieke gegevens van welk type dan ook is (met of zonder teken, geheel getal of drijvende komma) of een wiskundige uitdrukking die een geldige numerieke waarde retourneert.

Functies gebruiken is_int() En is_zweven U kunt bepalen of een getal een geheel getal of een breuk is. Nog twee controles zijn iets complexer: functies is_eindig() En is_oneindig() kunt u precies de tests uitvoeren die hun naam aangeeft (of het aantal eindig of oneindig is). Maar strikt genomen kan het bereik van waarden waarover deze functies zich uitstrekken niet de werkelijke oneindigheid omvatten (en kan er zelfs worden gecontroleerd of een getal een oneindig grote waarde heeft?). In plaats daarvan worden de grenzen van het bereik van drijvende-kommawaarden gebruikt die op het specifieke systeem zijn toegestaan.

Hieronder ziet u een voorbeeld van het gebruik van deze functies:

Conversie van nummersystemen

Standaard gebruikt PHP grondtal 10 om numerieke waarden van de externe naar de interne representatie voorwaarts en achterwaarts te converteren. U kunt de PHP-interpreter ook vertellen dat de externe representatie octale getallen met grondtal 8 gebruikt (hiervoor moet u voorloop 0 invoeren). ), of hexadecimale getallen gespecificeerd in basis 16 (hiervoor moet u het getal vooraf laten gaan door 0x).

Uiteraard worden ze, na het converteren van getallen van een externe representatie naar een interne, in binair formaat in het geheugen opgeslagen en worden alle elementaire rekenkundige en wiskundige berekeningen uitgevoerd in het besturingssysteem zelf in basis 2. Bovendien biedt de PHP-taal een aantal functies voor het omzetten van getallen van de ene basis van het systeem naar de andere. Een overzicht van deze functies vindt u in de onderstaande tabel:

Alle conversiefuncties voor getalsystemen zijn functies voor speciale doeleinden die getallen van het ene specifieke grondtal naar het andere converteren. Een uitzondering is de functie base_convert(), die willekeurige parameters accepteert die de initiële en resulterende bases aangeven.

Houd er rekening mee dat alle conversiefuncties voor getalsystemen tekenreeksparameters accepteren en tekenreekswaarden retourneren, maar u kunt decimale numerieke parameters gebruiken en erop vertrouwen dat de PHP-interpreter de typeconversie correct uitvoert. Met andere woorden: zowel DecBin("1234") als DecBin(1234) leveren beide hetzelfde resultaat op.

Exponenten en logaritmen

De PHP-taal bevat standaard exponentiële en logaritmische functies in twee varianten: voor het werken met grondtal 10 en grondtal e (die in de tabel worden weergegeven).

PHP biedt een functie exp() om e tot een bepaalde macht te verheffen, maar er is geen functie met één parameter om 10 tot een bepaalde macht te verheffen. Je kunt in plaats daarvan echter de functie pow() gebruiken, die twee parameters nodig heeft, wat 10 oplevert als eerste parameter.

U kunt verifiëren dat exponentiële en logaritmische functies met hetzelfde grondtal het omgekeerde van elkaar zijn door de identiteit van de op deze manier verkregen resultaten te controleren:

Trigonometrische functies

De PHP-taal biedt een standaardset trigonometrische basisfuncties, waarover algemene informatie in de tabel wordt gegeven:

Hieronder ziet u een voorbeeld van het samenstellen van een tabel voor het berekenen van goniometrische functies voor "standaard" hoeken:

De reden voor het verkrijgen van zeer grote (maar niet oneindige) raakwaarden is dat de noemers theoretisch nul zouden moeten zijn, maar in werkelijkheid enigszins afwijken van nul vanwege afrondingsfouten.

Willekeurige precisieberekening (met behulp van BC-functies)

Drijvende-kommagetypen met gehele getallen en dubbele precisie zijn perfect geschikt voor de meeste wiskundige problemen die je tegenkomt bij webscripting, maar elke instantie van de waarde die door deze typen wordt weergegeven, vereist een vaste hoeveelheid computergeheugen, dus de grootte en precisie van de getallen die deze typen vertegenwoordigen onvermijdelijk beperkingen opleggen.

Uiteraard kunnen de exacte waardebereiken van deze gegevenstypen afhangen van de architectuur van de servercomputer, maar gehele waarden kunnen doorgaans variëren van -2 31 -1 tot 2 31 -1, en drijvende-kommagetallen met dubbele precisie kunnen vertegenwoordigt getallen met een nauwkeurigheid van ongeveer 13 tot 14 decimalen. Aan de andere kant, om problemen op te lossen die het gebruik van een breder representatiebereik of grotere precisie vereisen, biedt PHP willekeurige precisie wiskundige functies(ook wel BC-functies genoemd, genoemd naar het op Unix gebaseerde hulpprogramma voor computergebruik met willekeurige precisie).

Het kan zijn dat willekeurige precisiefuncties niet zijn opgenomen in de compilatie van de PHP-interpreter, vooral als de gebruiker de compilatie zelf heeft gedaan, omdat de gebruiker hiervoor zou moeten weten dat het in de configuratiefase nodig is om een ​​selectievakje in de parameters --enable-bcmath. Om te controleren of de opgegeven functies beschikbaar zijn, probeert u de uitdrukking bcadd("1", "1") te evalueren. Als u een foutmelding ontvangt waarin staat dat er een ongedefinieerde functie is, moet u de PHP-interpreter opnieuw configureren en opnieuw compileren.

BC-functies gebruiken tekenreeksen in plaats van numerieke typen met een vaste lengte als parameters en retourwaarden. Omdat in PHP de lengte van strings alleen wordt beperkt door de hoeveelheid beschikbaar geheugen, kunnen de getallen die in berekeningen worden gebruikt elke lengte hebben. De basisberekeningen worden in decimale vorm uitgevoerd en lijken veel op de berekeningen die iemand met potlood en papier kan maken (als hij heel snel kan werken en geduld kan hebben). BC-functies voor gehele getallen zijn nauwkeurig en stellen u in staat zoveel cijfers te gebruiken als nodig is, terwijl functies met drijvende komma berekeningen uitvoeren die nauwkeurig zijn tot op een bepaald aantal decimalen. Algemene informatie over BC-functies vindt u in de onderstaande tabel:

De meeste van deze functies gebruiken als laatste parameter een optionele schaalfactor (een geheel getal), die bepaalt hoeveel decimalen het resultaat moet hebben. Als deze parameter niet is opgegeven, wordt de standaardschaalfactor gebruikt als schaalfactor, die op zijn beurt kan worden ingesteld door de functie bcscale() aan te roepen. De standaardwaarde voor deze standaardwaarde (dat wil zeggen de waarde die wordt gebruikt als het script bcscale() niet aanroept) kan ook worden ingesteld in het initialisatiebestand php.ini.

Hieronder ziet u een voorbeeld van het gebruik van een willekeurige precisiefunctie om rekenkundige bewerkingen met gehele getallen nauwkeurig uit te voeren. Het uitvoeren van de volgende code:

Als voor deze berekeningen een normaal PHP-getal zou worden gebruikt, zou de integer-overflow lang vóór het einde van de berekening plaatsvinden, zodat de rest van de lus berekeningen zou uitvoeren om een ​​benaderend drijvende-kommagetal te verkrijgen.

Laatste update: 1/11/2015

In PHP kunnen we verschillende operatoren gebruiken: rekenkundige, logische, enz. Laten we elk type bewerking bekijken.

Rekenkundige bewerkingen

+ (optelling)

Bijvoorbeeld $a + 5

- (aftrekking)

Bijvoorbeeld $a - 5

* (vermenigvuldiging)

Bijvoorbeeld $a * 5

/ (divisie)

Bijvoorbeeld $a/5

% (het verkrijgen van de rest van de verdeling)

Bijvoorbeeld: $a=12; echo $a% 5; // is gelijk aan 2

++ (waarde verhogen/verhogen met één)

Bijvoorbeeld ++$a

Het is belangrijk om het verschil te begrijpen tussen de uitdrukkingen ++$a en $a++ . Bijvoorbeeld:

$a=12; $b=++$a; // $b is gelijk aan 13 echo $b;

Hier wordt eerst één opgeteld bij de waarde van de variabele $a, en vervolgens wordt de waarde ervan gelijkgesteld aan de variabele $b. Het zou anders zijn als de uitdrukking er zo uit zou zien: $b=$a++; . Hier was eerst de waarde van de variabele $a gelijk aan de variabele $b, en daarna werd de waarde van de variabele $a verhoogd.

-- (waarde met één verlagen/verlagen)

Bijvoorbeeld --$a . En ook, net als in het geval van increment, zijn er twee soorten opnames: --$a en $a--

Toewijzingsoperatoren

Stelt een variabele gelijk aan een specifieke waarde: $a = 5

Optelling gevolgd door toekenning van het resultaat. Bijvoorbeeld: $a=12; $a += 5; echo $a; // gelijk aan 17

Aftrekken gevolgd door toewijzing van het resultaat. Bijvoorbeeld: $a=12; $a -= 5; echo $a; // is gelijk aan 7

Vermenigvuldiging gevolgd door toekenning van het resultaat: $a=12; $a *= 5; echo $a; // is gelijk aan 60

Deling gevolgd door toekenning van het resultaat: $a=12; $a /= 5; echo $a; // gelijk aan 2,4

Voeg rijen samen en wijs het resultaat toe. Geldt voor twee regels. Als de variabelen geen strings opslaan, maar bijvoorbeeld getallen, dan worden hun waarden geconverteerd naar strings en wordt vervolgens de bewerking uitgevoerd: $a=12; $a.= 5; echo $a; // gelijk aan 125 // identiek aan $b="12"; $b.="5"; // gelijk aan 125

Het verkrijgen van de rest van de deling en het toekennen van het resultaat: $a=12; $een%= 5; echo $a; // is gelijk aan 2

Vergelijkingsoperaties

Vergelijkingsbewerkingen worden meestal gebruikt in voorwaardelijke constructies wanneer het nodig is om twee waarden te vergelijken en, afhankelijk van het resultaat van de vergelijking, bepaalde acties uit te voeren. De volgende vergelijkingsbewerkingen zijn beschikbaar.

De gelijkheidsoperator vergelijkt twee waarden en retourneert waar als ze gelijk zijn, en retourneert anders onwaar: $a == 5

De identiteitsoperator vergelijkt ook twee waarden, en retourneert waar als ze gelijk zijn, en retourneert anders onwaar: $a === 5

Vergelijkt twee waarden en retourneert waar als ze niet gelijk zijn, en retourneert anders false: $a != 5

Vergelijkt twee waarden en retourneert waar als ze niet gelijk zijn, en retourneert anders false: $a !== 5

Vergelijkt twee waarden, en als de eerste groter is dan de tweede, retourneert dan waar, retourneert anders onwaar: $a > 5

Vergelijkt twee waarden, en als de eerste kleiner is dan de tweede, retourneert deze waar, en retourneert anders onwaar: $a< 5

Vergelijkt twee waarden, en als de eerste groter is dan of gelijk is aan de tweede, retourneert dan waar, retourneert anders onwaar: $a >= 5

Vergelijkt twee waarden, en als de eerste kleiner is dan of gelijk is aan de tweede, retourneert dan waar, retourneert anders onwaar: $a<= 5

Gelijkheid en identiteit operator

Beide operatoren vergelijken twee expressies en retourneren waar als de expressies gelijk zijn. Maar er zijn verschillen tussen hen. Als de gelijkheidsoperatie twee waarden van verschillende typen aanneemt, worden ze teruggebracht tot één: degene die de tolk optimaal vindt. Bijvoorbeeld:

Het is duidelijk dat variabelen verschillende waarden van verschillende typen opslaan. Maar als ze worden vergeleken, worden ze teruggebracht tot hetzelfde type: numeriek. En de variabele $a wordt teruggebracht tot het getal 22. En uiteindelijk zullen beide variabelen gelijk zijn.

Of de volgende variabelen zijn bijvoorbeeld ook gelijk:

$a = onwaar; $ b = 0;

Om dergelijke situaties te voorkomen, wordt de equivalentiebewerking gebruikt, waarbij niet alleen rekening wordt gehouden met de waarde, maar ook met het type variabele:

$a = "22a"; $ b = 22; if($a===$b) echo "gelijk"; anders echo "niet gelijk";

Nu zullen de variabelen niet gelijk zijn.

De ongelijkheidsoperatoren != en !== werken op dezelfde manier.

Logische bewerkingen

Logische bewerkingen worden doorgaans gebruikt om de resultaten van twee vergelijkingsbewerkingen te combineren. We moeten bijvoorbeeld een bepaalde actie uitvoeren als meerdere voorwaarden waar zijn. De volgende logische bewerkingen zijn beschikbaar:

Retourneert waar als beide vergelijkingsbewerkingen waar retourneren, retourneert anders false: $a == 5 && $b = 6

Vergelijkbaar met de &&-bewerking: $a == 5 en $b > 6

Retourneert waar als ten minste één vergelijkingsbewerking waar retourneert, retourneert anders false: $a == 5 || $ b = 6

Vergelijkbaar met de bewerking || : $een< 5 or $b > 6

Retourneert waar als de vergelijkingsbewerking false retourneert: !($a >= 5)

Retourneert waar als slechts één van de waarden waar is. Als beide waar zijn of geen van beide waar is, wordt onwaar geretourneerd. Bijvoorbeeld: $a=12; $b=6; if($a xor $b) echo "waar"; anders echo "vals";

Hier zal het resultaat van de logische bewerking onwaar zijn, omdat beide variabelen een specifieke waarde hebben. Laten we de code veranderen:

$a=12; $b=NULL; if($a xor $b) echo "waar"; anders echo "vals";

Hier zal het resultaat al waar zijn, omdat de waarde van één variabele niet is ingesteld. Als een variabele de waarde NULL heeft, wordt de waarde ervan bij logische bewerkingen als false behandeld

Bit-operaties

Bitbewerkingen worden uitgevoerd op individuele bits van een getal. Getallen worden in binaire weergave beschouwd, bijvoorbeeld 2 in binaire weergave is 010, het getal 7 is 111.

& (logische vermenigvuldiging)

De vermenigvuldiging wordt bitsgewijs uitgevoerd en als beide operanden bitwaarden gelijk aan 1 hebben, retourneert de bewerking 1, anders wordt het getal 0 geretourneerd. Bijvoorbeeld: $a1 = 4; //100 $b1 = 5; //101 echo $a1 & $b1; // is gelijk aan 4

Hier is het getal 4 in het binaire systeem 100, en het getal 5 is 101. Vermenigvuldig de getallen bitsgewijze en krijg (1*1, 0*0, 0 *1) = 100, dat wil zeggen het getal 4 in decimaal formaat.

| (logische toevoeging)

Net als bij logische vermenigvuldiging wordt de bewerking ook uitgevoerd op binaire cijfers, maar nu wordt er één geretourneerd als ten minste één getal in een bepaald cijfer een één heeft. Bijvoorbeeld: $a1 = 4; //100 $b1 = 5; //101 echo $a1 | $b1; // is gelijk aan 5

~ (logische ontkenning)

keert alle bits om: als de bitwaarde 1 is, wordt deze nul, en omgekeerd. $ b = 5; echo ~$b;

X<

x>>y - verschuift het getal x met y cijfers naar rechts. Met 16>>1 verschuift bijvoorbeeld 16 (wat 10.000 is in binair getal) één plaats naar rechts, wat resulteert in 1000 of 8 in decimaal getal.

Aaneengeschakelde tekenreeksen

De puntoperator wordt gebruikt om tekenreeksen aan elkaar te koppelen. Laten we bijvoorbeeld verschillende lijnen verbinden:

$a="Hallo,"; $b="wereld"; echo $a. $b. "!";

Als de variabelen andere typen dan strings vertegenwoordigen, zoals getallen, dan worden hun waarden geconverteerd naar strings en vindt ook de aaneenschakeling van de strings plaats.

Logische bewerkingen bestaan ​​in alle programmeertalen en PHP geen uitzondering. Naast eenvoudig delen, vermenigvuldigen, optellen of aftrekken, zijn er ook delingen met gehele getallen en resten, waarover we het nu zullen hebben en die we ook zullen analyseren aan de hand van gedetailleerde voorbeelden.

Deling van gehele getallen is de uitvoer van het gehele deel van de deling. Als we bijvoorbeeld 5 door 2 delen, krijgen we 2, en niet 2,5.

Bij restdeling is alles anders. Dit is de uitvoer van de rest, gedeeld door een geheel getal. Als je bijvoorbeeld dezelfde vijf deelt, krijg je niet 2, maar 1, want als je 5 door 2 deelt, krijgen we 2 en de rest is 1.

Hoe gehele getallen te delen in PHP

In Python wordt deze deling bijvoorbeeld gedaan met behulp van een eenvoudige operator: "//".

En in PHP dit zal niet zo eenvoudig zijn, maar toch vereist het proces geen superkennis van de taal.

Laten we een voorbeeld geven van hoe dit kan worden geïmplementeerd.

IN PHP de zevende versie ziet de functie er als volgt uit:

Intdiv();

In een oudere versie ziet dezelfde functie er als volgt uit:

Er is ook een methode voor alle versies:

Vloer();

Hoe solliciteren?

Laten we bijvoorbeeld de eerste functie nemen; alle andere worden op ongeveer dezelfde manier uitgevoerd.

$resultaat = intdiv(10, 3); echo $resultaat;

Restverdeling in PHP

Om de gehele rest van de deling in weer te geven PHP Het is voldoende om gewoon de operator "%" te gebruiken.

$i = 10% 3; echo $i;

Zoals we kunnen zien, is alles vrij eenvoudig en vereist het geen lange uitleg.

Waar kan het worden gebruikt?

Kennis van gehele deling PHP zal erg handig zijn als je twee getallen moet vergelijken, een omgekeerd getal moet maken (een populaire oefening) of bijvoorbeeld een programma genaamd FizzBuzz. De essentie ervan is dat je een cyclus moet schrijven van 1 tot 100, die elk getal deelt door 3 en 5. Als het getal gedeeld door 3 een rest van 0 heeft, dan schrijven we Fizz, indien gedeeld door 5, dan Buzz, en als, door zowel 5 als 3 te delen, de rest 0 is, dan schrijven we FizzBuzz. Dit is een zeer populaire interviewtaak. Als je het zelf hebt voltooid, kun je trots op jezelf zijn.

Of we moeten bijvoorbeeld alle getallen (4, 5, 2) afleiden uit het getal 452.

Conclusie

Natuurlijk zijn delingen van gehele getallen en resten nuttig en vrij gebruikelijk; ze zijn niet zo handig in gebruik als in Python, maar ze zijn nog steeds belangrijk.

Nu bent u een stap dichter bij het leren van een programmeertaal PHP en in de toekomst zul je nog hechter worden als je moeilijkheden net zo ijverig overwint.