Php partie entière de la division. Opérations avec des variables PHP (opérateurs). Incrémenter la forme du préfixe

Opérations de variables PHP (opérateurs)

Il existe différents groupes pour l'exercice.

Un opérateur est quelque chose composé d'une ou plusieurs valeurs (expressions, dans le jargon de programmation) qui peuvent être évaluées comme une nouvelle valeur (ainsi toute la construction peut être considérée comme une expression). Il s'ensuit que les fonctions ou toute autre construction qui renvoient une valeur (par exemple, imprimer ()) sont des opérateurs, contrairement à toutes les autres constructions de langage (par exemple, écho ()) qui ne renvoie rien.

Opérations arithmétiques en PHP

Rappelez-vous les principes fondamentaux de l'arithmétique à l'école ? Les opérateurs décrits ci-dessous fonctionnent de la même manière.

L'opérateur de division ("/") renvoie toujours un type réel, même si les deux valeurs étaient des entiers (ou des chaînes converties en entiers). Sinon, le résultat sera fractionnaire.

L'opération de calcul du reste de la division " % "ne fonctionne qu'avec des nombres entiers, donc l'appliquer à des fractions peut conduire à des résultats indésirables.

L'utilisation de parenthèses est possible. La priorisation de certaines opérations mathématiques par rapport à d'autres et la modification des priorités lors de l'utilisation de parenthèses dans des expressions arithmétiques suivent les règles mathématiques normales.

Opérations d'incrémentation et de décrémentation

PHP, comme C, prend en charge les opérateurs d'incrémentation et de décrémentation de préfixe et de postfixe.

Opérateurs d'incrémentation et de décrémentation de suffixe

Comme dans le langage C, ces opérateurs augmentent ou diminuent la valeur de la variable, et dans l'expression ils renvoient la valeur de la variable. $ un avant le changement. Par exemple:

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

Comme vous pouvez le voir, d'abord la variable $ b attribuer une valeur à une variable $ un, et ce n'est qu'alors que ce dernier a été incrémenté. Cependant, une expression dont la valeur est affectée à une variable $ b, cela peut être plus difficile - dans tous les cas, l'augmentation $ un ne se produira qu'une fois qu'il aura été calculé.

Opérateurs d'incrémentation et de décrémentation de préfixe

Il existe également des opérateurs d'incrémentation et de décrémentation qui apparaissent plutôt qu'après le nom de la variable. En conséquence, ils renvoient la valeur de la variable après le changement. Exemple:

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

Les opérations d'incrémentation et de décrémentation sont très souvent utilisées en pratique. Par exemple, ils se produisent dans presque tous les cycles. pour .

écho "

Incrément de suffixe

Écho "

Incrément de préfixe

Écho "

Décrément de suffixe

Écho "

Décrément de préfixe

Opérations de chaîne

PHP a deux opérateurs pour travailler avec des chaînes. Le premier est l'opérateur de concaténation ("."), qui renvoie la concaténation des arguments gauche et droit. Le second est l'opérateur d'affectation de concaténation, qui concatène l'argument de droite à l'argument de gauche. Donnons un exemple concret :

$ a = "Bonjour" ;
$ b = $ a. "Monde!" ; // $ b contient la chaîne "Hello World!"

$ a = "Bonjour" ;
$ a. = "Monde !" ; // $ a contient la chaîne "Hello World!"
?>

Opérations au niveau du bit

Ces opérations sont conçues pour faire fonctionner (mettre / effacer / vérifier) ​​des groupes de bits dans une variable entière. Les bits d'un entier ne sont rien de plus que des bits séparés du même nombre écrits dans système binaire compte. Par exemple, en binaire, le nombre 12 ressemblera à 1100 et 2 à 10, donc l'expression 12|2 nous renverra le nombre 14 (1110 en binaire). Si la variable n'est pas un entier, alors elle est
Chalet est arrondi, puis les opérateurs suivants lui sont appliqués.

32 bits sont utilisés pour représenter un nombre :

• 0000 0000 0000 0000 0000 0000 0000 0000 est zéro ;
• 0000 0000 0000 0000 0000 0000 0000 0001 est 1 ;
• 0000 0000 0000 0000 0000 0000 0000 0010 est 2 ;
• 0000 0000 0000 0000 0000 0000 0000 0011 est 3 ;
• 0000 0000 0000 0000 0000 0000 0000 0100 est 4 ;
• 0000 0000 0000 0000 0000 0000 0000 0101 est 5 ;
• 0000 0000 0000 0000 0000 0000 0000 1111 est 15 ;

Opérateurs au niveau du bit :

Opérations de comparaison

Les opérateurs de comparaison, comme leur nom l'indique, vous permettent de comparer deux valeurs.

Ce sont en quelque sorte des opérations uniques, car quel que soit le type de leurs arguments, elles renvoient toujours l'une des deux choses suivantes : faux ou vrai... Les opérations de comparaison permettent de comparer deux valeurs entre elles et, si la condition est remplie, de retourner vrai, Et sinon - faux.

En PHP, seules les variables scalaires peuvent être comparées. Les tableaux et les objets ne peuvent pas être comparés en PHP. Ils ne peuvent même pas être comparés pour l'égalité (en utilisant l'opérateur ==), mais PHP n'émet pas d'avertissement lors de l'exécution d'une telle opération. Je me demande donc une fois pourquoi deux tableaux complètement différents en les comparant à l'aide == s'avèrent soudain identiques, rappelez-vous qu'avant la comparaison, les deux opérandes sont convertis en un mot déployer, qui est ensuite comparé.

Pour plus de détails sur la comparaison de tableaux, consultez.

Opérateurs de comparaison :

Opérations logiques

Les opérateurs booléens sont destinés uniquement à travailler avec des expressions booléennes et renvoient également faux ou vrai.

Voici un tableau des opérateurs logiques PHP :

Il est à noter que le calcul expressions logiques contenant de tels opérateurs va toujours de gauche à droite ; de plus, si le résultat est déjà évident (par exemple, faux && quelque chose donne toujours faux), les calculs sont abandonnés même s'il y a des appels de fonction dans l'expression. Par exemple, dans l'opérateur $ logique = 0 && (temps ()> 100); fonction standard temps () ne sera jamais appelé.

Attention à opérations logiques- n'oubliez pas de doubler le symbole. Notez que par exemple | et || - deux opérateurs complètement différents, dont l'un peut potentiellement renvoyer n'importe quel nombre, et le second uniquement faux et vrai.

Les opérateurs d'incrémentation (++) et de décrémentation (-) ne fonctionnent pas avec les variables booléennes.

Opérateurs d'équivalence

PHP puisque PHP4 a un opérateur de comparaison identique - le triple signe égal === ,
ou l'opérateur de contrôle pour. PHP tolère assez bien les chaînes qui sont implicitement converties en nombres et vice versa.
Par exemple, le code suivant déduira que les valeurs des variables sont égales :

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

Et ce malgré le fait que la variable $ un est un nombre et $ b- chaîne de caractères. Regardons maintenant un exemple légèrement différent :

$a = 0 ; // zéro
$b = "" ; // ligne vide
if ($ a == $ b) echo "a et b sont égaux" ; // Affiche "a et b sont égaux"

Bien que $ un et $ b ne sont clairement pas égaux, même dans le sens habituel du terme, le script déclarera qu'ils sont identiques. Pourquoi ça arrive ? Le fait est que si l'un des opérandes opérateur logique peut être traité comme un nombre, alors les deux opérandes sont traités comme des nombres. Dans ce cas, la ligne vide se transforme en 0 qui est ensuite comparé à zéro. Sans surprise, l'opérateur écho travaux.
Le problème est résolu par l'opérateur d'équivalence === (triple égalité). Il compare non seulement deux expressions, mais aussi leurs types. Réécrivons notre exemple en utilisant cet opérateur.

Toutes les opérations mathématiques de base sont disponibles en PHP. Les nombres entiers et les nombres réels peuvent être utilisés comme opérandes.

Opérateurs de soustraction, multiplication, division, modulo et addition

Les opérateurs de soustraction, multiplication, division, division modulo et addition sont utilisés de la même manière qu'en mathématiques. Ici, il convient de prêter attention aux opérateurs de division et de division modulo.

L'opérateur de division ("/") renvoie un nombre à virgule flottante, sauf si les deux valeurs sont des entiers (ou des chaînes converties en entiers) qui sont divisibles de manière égale, auquel cas une valeur entière est renvoyée.

résultat2 = $ résultat2
"; echo" result3 = $ result3
résultat4 = $ résultat4 " ;?>

Dans la division modulo, les opérandes sont convertis en nombres entiers (avec suppression de la partie fractionnaire) avant le début de l'opération. Le résultat de l'opération module% aura le même signe que le dividende :

Négation unaire

L'opérateur de négation unaire est désigné par le signe "-", il change la valeur de son seul opérande en l'inverse :

Dans ce cas, les parenthèses sont inutiles car la négation unaire a la priorité la plus élevée, mais elles aident à organiser le code de sorte qu'il soit clair que les nombres -5 et 4 sont ajoutés.

Incrément

L'opérateur d'incrémentation, noté ++ et peut être situé de part et d'autre de l'opérande avec lequel il opère. Il augmente cette valeur d'un, tout comme ajouter un à une valeur. Le résultat réel dépend de l'endroit où l'opérateur a été appliqué, avant ou après l'opérande avec lequel il a été appliqué. Cet opérateur est souvent utilisé avec des variables, et il arrive souvent à l'intérieur des boucles (les boucles seront discutées plus tard).

Incrémenter la forme du préfixe

Forme de préfixe- c'est à ce moment que l'opérateur d'incrémentation est situé avant l'opérande, cette forme de notation signifie que l'incrémentation sera effectuée en premier : elle augmente la valeur de l'opérande de un et alors seulement le reste de l'instruction est exécuté :

Forme de suffixe d'incrément

Forme suffixeécrit un peu différemment - l'incrément est situé dans ce cas après l'opérande. Avec la forme de notation suffixe, la première utilisation de l'opérande renvoie sa valeur actuelle, seulement après cela, la valeur sera augmentée de un :

Décrémenter

L'opérateur de décrémentation, désigné par le signe -, et contrairement à l'opérateur d'incrémentation, diminue, plutôt qu'augmente, de un la valeur de son opérande. La décrémentation permet également la notation préfixe et suffixe :

Les programmeurs qui doivent faire du calcul numérique, scientifique ou statistique responsable sont peu susceptibles de considérer un langage de script Web comme un candidat acceptable pour ce rôle. Malgré ce qui précède, PHP offre un excellent ensemble de fonctions qui résolvent entièrement la plupart des problèmes mathématiques qui surviennent lors de l'exécution de scripts pour le Web. De plus, PHP fournit des fonctionnalités plus avancées telles que l'arithmétique de précision arbitraire et les bibliothèques de hachage et de cryptographie.

Les développeurs de PHP ont adopté une approche bien fondée et n'ont pas tenté de réinventer les roues à cette fin. Le fait est que bon nombre des fonctions mathématiques les plus fondamentales utilisées en PHP sont simplement des enveloppes autour des analogues C de ces fonctions.

Opérations mathématiques

La plupart des calculs en PHP se font sous forme de fonctions intégrées, plutôt que sous forme d'opérations. En plus des opérations de comparaison, PHP propose cinq opérations simples opérations arithmétiques ainsi que quelques opérations abrégées pour créer des expressions d'incrémentation, de décrémentation et d'affectation plus courtes.

Opérations arithmétiques

Les cinq opérations arithmétiques de base comprennent les opérations qui sont généralement mises en œuvre dans n'importe quelle calculatrice à quatre fonctions, ainsi que l'opération de division par module (%). Une brève description des opérations arithmétiques est donnée dans le tableau :

Lorsque vous utilisez les trois premières opérations arithmétiques décrites ci-dessus (+, -, *) dans le programme, gardez à l'esprit que lors de l'exécution de ces opérations, le type se propage des valeurs à virgule flottante double précision aux valeurs entières. Cela implique ce qui suit : si les deux opérandes d'une opération sont des entiers, alors le résultat est un entier, et si au moins un des opérandes est un nombre à virgule flottante double précision, alors le résultat est un nombre à virgule flottante double précision . Le même type de propagation de type se produit lors de l'exécution d'une opération de division ; en outre, il y a un effet supplémentaire selon lequel le résultat devient un nombre à virgule flottante double précision si la division n'est pas complète.

L'opération modulo (%) en PHP accepte les opérandes entiers, et si cette opération est appliquée aux nombres à virgule flottante double précision, ces nombres sont pré-convertis en entiers (en supprimant la partie fractionnaire). Le résultat d'une telle opération est toujours un entier.

Opérations d'incrémentation et de décrémentation

Une grande partie de la syntaxe de PHP est héritée du langage C, et les programmeurs C sont réputés pour leur amour de la brièveté et leur fierté. Les opérations d'incrémentation et de décrémentation, tirées du langage C, permettent de représenter de manière plus concise des expressions comme $ count = $ count + 1, qui se retrouvent généralement assez souvent dans les programmes.

L'opération d'incrémentation (++) est utilisée pour ajouter un à la valeur de la variable à laquelle cette opération s'applique, et l'opération de décrémentation (-) soustrait un à la valeur d'une telle variable.

Chacune de ces deux opérations a deux saveurs - suffixe(sous cette forme, le signe de l'opération est placé immédiatement après la variable à laquelle s'applique l'opération) et préfixe(sous cette forme, le signe de l'opération est placé juste avant la variable à laquelle s'applique l'opération). Les deux versions ont le même effet secondaire de modifier la valeur d'une variable, mais les opérations de suffixe et de préfixe renvoient des valeurs différentes lorsqu'elles sont utilisées comme expressions. Une opération de suffixe est telle que la valeur d'une variable est modifiée après le retour de l'expression, et une opération de préfixe est que la valeur est modifiée en premier, puis une nouvelle valeur est retournée à la variable. Cette différence peut être découverte en utilisant les opérations de décrémentation et d'incrémentation dans les opérateurs d'affectation :

Ces opérateurs génèrent la sortie suivante dans la fenêtre du navigateur :

Opérations d'incrémentation

Dans cet exemple, l'opérateur $ result = $ count ++ est totalement équivalent aux opérateurs :

Parallèlement à cela, l'opérateur $ result = ++ $ count est équivalent aux opérateurs suivants :

Opérations d'affectation

Les opérations d'incrémentation (et de décrémentation) peuvent réduire la quantité de code nécessaire pour ajouter un à la valeur d'une variable, mais elles ne vous permettent pas de réduire la quantité de code dans laquelle une variable est affectée le résultat de l'ajout de sa valeur à un autre nombre ou le résultat de l'exécution d'autres opérations arithmétiques. Heureusement, les cinq opérations arithmétiques ont des affectations correspondantes (+ =, - =, * =, / = et% =), qui vous permettent d'affecter à une variable dans une expression courte le résultat d'une opération arithmétique sur la valeur de cette variable. Par exemple, l'opérateur

peut être abrégé en

Fonctions mathématiques simples

L'étape suivante dans la complication du programme par rapport à celle dans laquelle seules les opérations arithmétiques sont utilisées est d'utiliser toutes sortes de fonctions. Les fonctions vous permettent d'effectuer des tâches telles que la conversion d'un type numérique à un autre (voir l'article Types de données) et la recherche du nombre minimum ou maximum dans un ensemble de nombres. Le tableau suivant présente des fonctions mathématiques simples :

Par exemple, le résultat de l'expression suivante est 3, car la valeur de chaque expression avec un appel de fonction est également 3 :

Générer des nombres aléatoires

PHP utilise deux générateurs de nombres aléatoires (appelés respectivement à l'aide des fonctions rand () et mt_rand ()). Trois fonctions de même finalité sont associées à chacun de ces générateurs : la fonction de réglage de la valeur initiale ( srand () et mt_srand ()), la fonction elle-même pour obtenir un nombre aléatoire et la fonction qui sélectionne le plus grand entier pouvant être retourné par le générateur (( getrandmax () et mt_getrandmax ())). Les fonctions getrandmax() et mt_getrandmax() renvoient le plus grand nombre pouvant être renvoyé par rand() ou mt_rand(), qui est limité à 32768 sur les plateformes Windows.

Le choix de la fonction particulière de génération de nombres pseudo-aléatoires utilisée dans la fonction rand() peut dépendre des bibliothèques avec lesquelles l'interpréteur PHP a été compilé. En revanche, le générateur mt_rand() utilise toujours la même fonction de génération de nombres pseudo-aléatoires (mt est l'abréviation de Mersenne Twister), et l'auteur de la documentation en ligne de la fonction mt_rand() affirme que cette fonction est également plus rapide et " plus random "(en termes de cryptographie) que rand(). Nous n'avons aucune raison de douter de la véracité de ces déclarations, nous préférons donc utiliser la fonction mt_rand() plutôt que rand().

Lors de l'utilisation de certaines versions de PHP pour certaines plates-formes, il apparaît que les fonctions rand() et mt_rand() génèrent des nombres aléatoires apparemment parfaitement acceptables, même sans spécifier au préalable la valeur initiale. Mais une telle impression n'est pas digne de confiance. Premièrement, les programmes qui utilisent les fonctions de génération de nombres aléatoires sans spécifier de valeur initiale ne peuvent pas être facilement transférés vers d'autres plates-formes et, deuxièmement, le fonctionnement fiable de ces fonctions sans spécifier de valeur initiale n'est pas garanti.

Une manière typique de définir la graine pour l'un des générateurs de nombres aléatoires de PHP (à l'aide de la fonction mt_srand () ou srand ()) est la suivante :

Cet opérateur fixe la valeur initiale du générateur, égale au nombre de microsecondes écoulées depuis la dernière seconde entière. (Le transtypage pour taper double dans cet opérateur est vraiment nécessaire, car la fonction microtime () renvoie une chaîne, qui est traitée comme un entier dans l'opération de multiplication, mais pas dans l'opération de transmission de paramètres à la fonction.) Nous recommandons que le le lecteur saisit l'opérateur de valeur initiale spécifié, même s'il ne comprend pas tout à fait le but de cet opérateur ; il suffit de mettre cet opérateur par page PHP, une seule fois, avant d'utiliser la fonction mt_rand () ou rand () appropriée, et cette instruction garantira que le point de départ change et qu'une séquence aléatoire différente sera donc générée à chaque fois.

Cette méthode particulière de définition de la valeur initiale a été profondément réfléchie par les experts qui comprennent parfaitement toutes les nuances de la génération de nombres pseudo-aléatoires. avec quelque chose de plus "difficile".

De toute évidence, ces fonctions de génération de nombres pseudo-aléatoires ne renvoient que des entiers, mais un entier aléatoire d'une plage donnée peut être facilement converti en un nombre à virgule flottante approprié (disons, un nombre de 0,0 à 1,0 inclus) en utilisant une expression comme rand () / getrandmax (). Après cela, la plage spécifiée peut être mise à l'échelle et décalée selon les besoins. Un exemple est présenté ci-dessous :

Essayez d'actualiser la page avec ce code plusieurs fois pour vous assurer qu'il génère des nombres aléatoires.

Constantes mathématiques

En PHP 4.0, il n'y avait qu'une seule constante mathématique décrite dans la documentation - M_PI (la valeur de , représentée par un nombre à virgule flottante double précision). Et à partir de Versions PHP 4.0.2 de nombreuses nouvelles constantes ont été introduites. La plupart de ces nouvelles constantes concernaient π (ou des multiples de celui-ci), e (ou des multiples de celui-ci) et les racines carrées ; en outre, certaines constantes étaient d'autres types. Mais dans les versions suivantes, pour un certain nombre de raisons, la liste des constantes a de nouveau été réduite à un nombre relativement petit de constantes mathématiques prédéfinies :

Vérification du format des nombres

PHP fournit un certain nombre de fonctions qui vous permettent de vérifier l'exactitude de la représentation des nombres. Bien que PHP manque de typage fort, il est recommandé d'appliquer certaines de ces vérifications dans votre code si nécessaire pour pouvoir prédire les caractéristiques des résultats obtenus, et choisir la meilleure voie leur traitement.

La première vérification, et la plus simple, consiste à utiliser la fonction est_numérique ()... Comme pour la plupart des autres vérifications de ce type, is_numeric renvoie un résultat booléen - vrai si le paramètre qui lui est transmis est n'importe quel type de données numériques (signées ou non signées, entières ou à virgule flottante) ou une expression mathématique qui renvoie une valeur numérique valide.

Utilisation des fonctions is_int () et is_float vous pouvez déterminer si le nombre est entier ou fractionnaire. Deux autres vérifications sont un peu plus complexes : les fonctions est_fini () et est_infini () permettent d'effectuer exactement les vérifications que leurs noms indiquent (que le nombre soit fini ou infini). Mais, à proprement parler, la plage de valeurs à laquelle s'étendent ces fonctions ne peut pas inclure l'infini réel (et peut-il être vérifié du tout si un nombre a une valeur infinie ?). Au lieu de cela, il utilise les limites spécifiques au système de la plage à virgule flottante.

Un exemple d'utilisation de ces fonctions est présenté ci-dessous :

Conversion de systèmes numériques

Par défaut, PHP utilise la base 10 pour la conversion avant et arrière des valeurs numériques de la représentation externe vers la représentation interne. Alternativement, vous pouvez indiquer à l'interpréteur PHP que la représentation externe utilise des nombres octaux en base 8 (pour ce faire, vous devez entrer le premier 0) ou des nombres hexadécimaux spécifiés en base 16 (pour cela, vous devez saisir le préfixe 0x avant le nombre).

Bien entendu, après avoir converti les nombres d'une représentation externe en une représentation interne, ils sont stockés en mémoire au format binaire et tous les calculs arithmétiques et mathématiques de base sont effectués dans le système opérateur base 2. De plus, PHP fournit un certain nombre de fonctions pour convertir des nombres d'une base à une autre. informations générales Ces fonctions sont résumées dans le tableau ci-dessous :

Toutes les fonctions de conversion du système numérique sont des fonctions but spécial convertir des nombres d'une base particulière à une autre. Une exception est la fonction base_convert (), qui accepte des paramètres arbitraires avec la désignation de la base de départ et résultante.

Notez que toutes les fonctions de conversion numérique acceptent les paramètres de chaîne et renvoient des valeurs de chaîne, mais vous pouvez utiliser des paramètres numériques décimaux et vous fier à l'interpréteur PHP pour effectuer correctement la conversion de type. En d'autres termes, les options d'appel de DecBin ("1234") et DecBin (1234) produisent le même résultat.

Exposants et logarithmes

Le langage PHP comprend des fonctions exponentielles et logarithmiques standard de deux manières différentes - pour un fonctionnement en base 10 et en base e (qui sont indiqués dans le tableau).

PHP fournit la fonction exp () pour élever le nombre e à la puissance spécifiée, mais il n'y a pas de fonction avec un paramètre qui pourrait élever le nombre 10 à la puissance spécifiée. Cependant, au lieu de cette fonction, vous pouvez utiliser le pow () fonction avec deux paramètres, donnant 10 comme premier paramètre.

Vous pouvez vous assurer que les fonctions exponentielles et logarithmiques de même base sont inverses l'une par rapport à l'autre en vérifiant l'identité des résultats obtenus de cette manière :

Fonctions trigonométriques

PHP fournit un ensemble standard de fonctions trigonométriques de base, dont les informations générales sont données dans le tableau :

Vous trouverez ci-dessous un exemple de compilation d'un tableau de calcul des fonctions trigonométriques pour des angles « standards » :

L'obtention de valeurs très grandes (mais pas infinies) de la tangente est due au fait qu'en théorie les dénominateurs devraient être égaux à zéro, mais en réalité ils diffèrent légèrement de zéro en raison d'erreurs d'arrondi.

Calcul de précision arbitraire (à l'aide des fonctions BC)

Les types entiers à double précision et à virgule flottante sont parfaitement adaptés à la résolution de la plupart des problèmes mathématiques qui surviennent lors de l'exécution de scripts pour le Web, mais il existe une quantité fixe de mémoire informatique pour stocker chaque instance d'une valeur représentée par ces types, donc la taille et la précision de la représentation des nombres des restrictions sont inévitablement imposées à ces types.

Bien entendu, les plages exactes de ces types de données peuvent dépendre de l'architecture de l'ordinateur serveur, mais les valeurs entières peuvent généralement aller de -2 31 -1 à 2 31 -1, et les nombres à virgule flottante double précision peuvent représentent des nombres avec une précision d'environ 13 à 14 chiffres décimaux. D'autre part, pour résoudre des problèmes nécessitant une plus large gamme de représentation ou une plus grande précision, PHP fournit fonctions mathématiques de précision arbitraire(également appelées fonctions BC, d'après un utilitaire de calcul à précision arbitraire basé sur Unix).

Il peut s'avérer que des fonctions avec une précision arbitraire ne soient pas incluses dans la compilation de l'interpréteur PHP, surtout si l'utilisateur a effectué une telle compilation par lui-même, car pour cela l'utilisateur devait savoir que lors de l'étape de configuration, la case à cocher doit être incluse dans les paramètres --enable-bcmath... Pour vérifier si les fonctions spécifiées sont disponibles, essayez d'évaluer l'expression bcadd ("1", "1"). Si vous recevez une erreur indiquant une fonction non définie, vous devrez à nouveau peaufiner la configuration et recompiler l'interpréteur PHP.

Les fonctions BC utilisent des chaînes plutôt que des types numériques de longueur fixe comme paramètres et valeurs de retour. Étant donné qu'en PHP, la longueur des chaînes n'est limitée que par la quantité de mémoire disponible, les nombres utilisés dans les calculs peuvent être de n'importe quelle longueur. Les calculs fondamentaux sont effectués sous forme décimale et ressemblent à bien des égards à ceux qu'une personne peut effectuer avec un crayon et du papier (si elle peut agir très rapidement et être patiente). Les fonctions Integer BC sont précises et vous permettent d'utiliser autant de chiffres que vous le souhaitez, tandis que les fonctions à virgule flottante effectuent des calculs jusqu'au nombre spécifié de décimales. Un aperçu des fonctions BC est présenté dans le tableau ci-dessous :

La plupart de ces fonctions prennent comme dernier paramètre un facteur d'échelle facultatif (entier) qui détermine le nombre de décimales devant figurer dans le résultat. Si aucun paramètre de ce type n'est spécifié, le facteur d'échelle par défaut est utilisé comme facteur d'échelle, qui à son tour peut être défini en appelant la fonction bcscale (). La valeur par défaut de cette valeur par défaut (c'est-à-dire la valeur utilisée si le script n'utilise pas l'appel de fonction bcscale()) peut également être définie dans le fichier d'initialisation php.ini.

Ce qui suit est un exemple d'utilisation d'une fonction de précision arbitraire pour effectuer avec précision des opérations arithmétiques entières. Exécuter le code suivant :

Si le type d'entier PHP standard était utilisé pour ces calculs, le débordement d'entier se produirait bien avant la fin du calcul, de sorte que le reste de la boucle serait effectué pour obtenir un nombre approximatif à virgule flottante.

Dernière mise à jour : 1.11.2015

En PHP, nous pouvons utiliser différents opérateurs : arithmétiques, logiques, etc. Considérons chaque type d'opération.

Opérations arithmétiques

+ (opération d'addition)

Par exemple, $ a + 5

- (opération de soustraction)

Par exemple, $ a - 5

* (multiplication)

Par exemple, $ a * 5

/ (partie)

Par exemple, $ a / 5

% (obtenir le reste de la division)

Par exemple : $ a = 12 ; écho $ a% 5; // est égal à 2

++ (incrémenter / incrémenter la valeur de un)

Par exemple ++ $ a

Il est important de comprendre la différence entre ++ $ a et $ a ++. Par exemple:

$a = 12 ; $ b = ++ $ a; // $ b vaut 13 echo $ b;

Ici, d'abord, un est ajouté à la valeur de la variable $ a, puis sa valeur est assimilée à la variable $ b. Ce serait différent si l'expression ressemblait à ceci : $ b = $ a ++; ... Ici, dans un premier temps, la valeur de la variable $ a a été assimilée à la variable $ b, puis la valeur de la variable $ a a été augmentée.

- (décrémenter / décrémenter la valeur de un)

Par exemple - $ a. Et tout comme dans le cas de l'incrément, il existe deux types de notation : - $ a et $ a--

Opérations d'affectation

Définit une variable à une valeur spécifique : $ a = 5

Addition suivie de l'affectation du résultat. Par exemple : $ a = 12 ; $ a + = 5 ; echo $a; // est égal à 17

Soustraction suivie de l'affectation du résultat. Par exemple : $ a = 12 ; $ a - = 5 ; echo $a; // est égal à 7

Multiplication suivie d'affectation du résultat : $ a = 12 ; $a * = 5 ; echo $a; // est égal à 60

Division suivie de l'affectation du résultat : $ a = 12 ; $ a / = 5 ; echo $a; // est égal à 2,4

Concaténation de chaînes avec affectation de résultat. S'applique à deux lignes. Si les variables ne stockent pas de chaînes, mais, par exemple, des nombres, leurs valeurs sont converties en chaînes, puis l'opération est effectuée : $ a = 12 ; $ a. = 5 ; echo $a; // égal à 125 // identique à $ b = "12"; $ b. = "5" ; // est égal à 125

Obtenir le reste de la division avec l'affectation subséquente du résultat : $ a = 12 ; $ a% = 5 ; echo $a; // est égal à 2

Opérations de comparaison

Les opérations de comparaison sont généralement utilisées dans constructions conditionnelles lorsqu'il est nécessaire de comparer deux valeurs, et en fonction du résultat de la comparaison, effectuer certaines actions. Les opérations de comparaison suivantes sont disponibles.

L'opérateur d'égalité compare deux valeurs et si elles sont égales il retourne vrai, sinon il retourne faux : $ a == 5

L'opérateur d'identité compare également deux valeurs, et si elles sont égales, il renvoie vrai, sinon il renvoie faux : $ a === 5

Compare deux valeurs, et si elles ne sont pas égales, renvoie vrai, sinon renvoie faux : $ a! = 5

Compare deux valeurs, et si elles ne sont pas égales, renvoie vrai, sinon renvoie faux : $ a! == 5

Compare deux valeurs, et si la première est supérieure à la seconde, elle renvoie vrai, sinon elle renvoie faux : $ a> 5

Compare deux valeurs, et si la première est inférieure à la seconde, elle renvoie vrai, sinon elle renvoie faux : $ a< 5

Compare deux valeurs, et si la première est supérieure ou égale à la seconde, elle renvoie vrai, sinon elle renvoie faux : $ a> = 5

Compare deux valeurs, et si la première est inférieure ou égale à la seconde, elle renvoie vrai, sinon elle renvoie faux : $ a<= 5

Opérateur Égalité et Identité

Les deux opérateurs comparent deux expressions et renvoient vrai si les expressions sont égales. Mais il y a des différences entre eux. Si deux valeurs de types différents sont prises dans l'opération d'égalité, elles sont alors réduites à une seule - celle que l'interpréteur trouve optimale. Par exemple:

Évidemment, les variables stockent différentes valeurs de différents types. Mais une fois comparés, ils seront réduits au même type - numérique. Et la variable $ a sera réduite au nombre 22. Et par conséquent, les deux variables seront égales.

Ou, par exemple, les variables suivantes seront également égales :

$ a = faux ; $b = 0 ;

Pour éviter de telles situations, l'opération d'équivalence est utilisée, qui prend en compte non seulement la valeur, mais aussi le type de la variable :

$a = "22a" ; $b = 22 ; if ($ a === $ b) echo "égal" ; else echo "pas égal" ;

Maintenant, les variables ne seront pas égales.

Les opérateurs d'inégalité! = Et! == fonctionnent de la même manière.

Opérations logiques

Les opérations booléennes sont couramment utilisées pour combiner les résultats de deux opérations de comparaison. Par exemple, nous devons effectuer une certaine action si plusieurs conditions sont vraies. Les opérations logiques suivantes sont disponibles :

Renvoie vrai si les deux opérations de comparaison renvoient vrai, sinon renvoie faux : $ a == 5 && $ b = 6

Similaire à && : $ a == 5 et $ b> 6

Renvoie vrai si au moins une opération de comparaison renvoie vrai, sinon renvoie faux : $ a == 5 || $b = 6

De la même manière que l'opération || : $ un< 5 or $b > 6

Renvoie vrai si l'opération de comparaison renvoie faux : ! ($ A> = 5)

Renvoie vrai si une seule des valeurs est vraie. Si les deux sont vrais ou si aucun n'est vrai, renvoie faux. Par exemple : $ a = 12 ; $b = 6 ; if ($ a x ou $ b) echo "true" ; else echo "faux" ;

Ici, le résultat de l'opération booléenne sera faux, puisque les deux variables ont une certaine valeur. Modifions le code :

$a = 12 ; $ b = NULL ; if ($ a x ou $ b) echo "true" ; else echo "faux" ;

Ici, le résultat sera déjà vrai, puisque la valeur d'une variable n'est pas définie. Si la variable est NULL, alors dans les opérations logiques sa valeur sera considérée comme fausse

Opérations au niveau du bit

Les opérations au niveau des bits sont effectuées sur des bits individuels d'un nombre. Les nombres sont considérés en représentation binaire, par exemple, 2 en représentation binaire 010, nombre 7 - 111.

& (multiplication logique)

La multiplication est effectuée bit par bit, et si les deux opérandes ont des valeurs de bit égales à 1, alors l'opération renvoie 1, sinon le nombre est renvoyé 0. Par exemple : $ a1 = 4 ; // 100 $ b1 = 5; // 101 echo $ a1 & $ b1; // est égal à 4

Ici, le nombre 4 dans le système binaire est 100 et le nombre 5 est 101. Multipliez les nombres bit par bit et obtenez (1 * 1, 0 * 0, 0 * 1) = 100, c'est-à-dire le nombre 4 en décimal format.

| (addition logique)

Cela ressemble à une multiplication logique, l'opération est également effectuée sur des chiffres binaires, mais maintenant un est renvoyé si au moins un nombre dans le chiffre donné a un un. Par exemple : $ a1 = 4 ; // 100 $ b1 = 5; // 101 echo $ a1 | $b1 ; // est égal à 5

~ (négation logique)

inverse tous les chiffres : si la valeur du chiffre est 1, alors il devient égal à zéro, et vice versa. $b = 5 ; echo ~ $ b;

X<

x >> y - décale le nombre x vers la droite de y chiffres. Par exemple, 16 >> 1 décale le nombre 16 (qui correspond à 10 000 en binaire) d'un chiffre vers la droite, c'est-à-dire qu'il se termine par 1 000 ou 8 en décimal

Chaînes de concaténation

L'opérateur point est utilisé pour concaténer des chaînes. Par exemple, concaténons plusieurs lignes :

$ a = "Bonjour,"; $ b = "monde" ; echo $ a. $ b. "!";

Si les variables ne représentent pas des chaînes, mais d'autres types, par exemple des nombres, leurs valeurs sont converties en chaînes, puis l'opération de concaténation de chaînes se produit également.

Les opérations logiques existent dans tous les langages de programmation et PHP pas une exception. En plus de la simple division, multiplication, addition ou soustraction, il existe également des divisions entières et résiduelles, dont nous allons maintenant parler, et les analyser également à l'aide d'exemples détaillés.

La division entière est la sortie de la partie entière de la division. Par exemple, si nous divisons 5 par 2, nous obtenons 2 et non 2,5.

Avec la division résiduelle, tout est différent. C'est la sortie du reste d'une division par un entier. Par exemple, en divisant tout de même cinq, on obtient non pas 2, mais 1, car en divisant 5 par 2, on obtient 2, et le reste reste 1.

Comment effectuer une division entière en PHP

Par exemple, en Python cette division se fait avec un opérateur simple : "//".

Et en PHP ce ne sera pas si facile à faire, mais néanmoins le processus ne nécessite pas une connaissance superflue de la langue.

Donnons un exemple de la façon dont cela peut être mis en œuvre.

V PHP La septième version de la fonction ressemble à ceci :

Intdiv ();

Dans une ancienne version, la même fonction ressemble à ceci :

Il y a aussi un moyen pour toutes les versions :

Sol ();

Comment s'inscrire?

Par exemple, prenons la première fonction, toutes les autres sont exécutées à peu près de la même manière.

$ résultat = intdiv (10, 3); echo $ résultat ;

Division restante en PHP

Pour imprimer le reste entier d'une division en PHP, il suffit de mettre l'opérateur "%".

$ i = 10 % 3 ; echo $ i;

Comme on peut le voir, tout est assez simple et ne nécessite pas de longues explications.

Où peut-il être appliqué ?

Connaissance de la division entière en PHP sera très utile si vous devez comparer deux nombres, créer un nombre flip (un exercice populaire), ou, par exemple, un programme appelé FizzBuzz. Son essence est que vous devez écrire un cycle de 1 à 100, qui divise chaque nombre par 3 et 5. Si le nombre divisé par 3 donne 0 dans le reste, alors nous écrivons Fizz, s'il est divisé par 5, alors Buzz, et si en divisant à la fois 5 et 3, nous obtenons 0 dans le reste, alors nous écrivons FizzBuzz. Il s'agit d'un entretien d'embauche très apprécié. Si vous l'avez fait vous-même, vous pouvez être fier de vous.

Ou, par exemple, nous devons déduire tous ses nombres du nombre 452 (4, 5, 2).

Conclusion

Bien sûr, les divisions entières et résiduelles sont utiles et se produisent assez souvent, elles ne sont pas aussi pratiques à utiliser qu'en Python, mais restent importantes.

Vous êtes maintenant un pas de plus vers l'apprentissage d'un langage de programmation PHP, et à l'avenir, vous deviendrez encore plus proche si vous surmontez les difficultés avec la même diligence.