Opérations en PHP. Opérations avec des variables PHP (opérateurs)
Ce sujet est important car presque toutes les applications impliquent un certain type d’opérations informatiques. Les opérations sur les nombres sont présentées dans le tableau ci-dessous.
Opérations arithmétiques en php
Je pense que ces opérateurs n'ont pas besoin de beaucoup d'explications. Je vais donner un exemple d'utilisation de chacun d'eux :
\$num2 = ". $num2; //Exemple de sommation :écho "
\$num1 + \$num2 = ". ($num1 + $num2); //Exemple de soustraction :écho "
\$num1 - \$num2 = ". ($num1 - $num2); //Exemple de multiplication :écho "
\$num1 * \$num2 = ". $num1 * $num2; //Exemple de division :écho "
\$num1 : \$num2 = ". $num1 / $num2; //Exemple de reste de division :écho "
\$num1 % \$num2 = ". $num1 % $num2; //Exemple d'incrémentation sous forme de préfixe :écho "
++\$num1 = ". ++$num1; //Maintenant $num1 = 11 $num1=10; //valeur initiale attribuée //Exemple d'incrémentation sous forme de préfixe post :écho "
\$num1++ = ". $num1++; //Maintenant $num1 = 11 $num1=10; //assigné la valeur d'origine //Un exemple de décrémentation sous forme de préfixe :écho "
--\$num1 = ". --$num1; $num1=10; //Un exemple de décrémentation sous forme post-préfixe :écho "
\$num1-- = ". $num1--; ?>
Le résultat de l'exécution du code ci-dessus :
$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
Différence entre la forme préfixe et postpréfixe :
- sous forme de préfixe(++ est devant la variable) elle est d'abord incrémentée de un, puis le résultat est imprimé
- sous forme de préfixe(++ vient après la variable) le résultat est d'abord affiché, puis incrémenté
Pour vous aider à mieux comprendre la différence, je vais donner un exemple classique qui est donné dans de nombreux manuels de programmation :
//Attribuer des valeurs aux variables :$num1 = 10 ; $num2 = 7 ; $rez = ++$num1 + $num2; // le résultat sera 18écho "
\$rez = ". $rez; //Attribue $num1 à la valeur initiale :$num1 = 10 ; $rez = $num1++ + $num2 ; // le résultat sera 17écho "
\$rez = ". $rez; //Les opérations ++ et -- peuvent également être appliquées aux chaînes$str = "abc" ; écho "
".++$str; // le résultat sera la chaîne "abd" ?>
Il convient de noter que lors de l'ajout de variables, vous pouvez utiliser deux types d'enregistrements :
- $num1 = $num1 + $num2 - entrée normale ;
- $num1 += $num2 est une notation abrégée. Le résultat de ces opérations sera le même. La notation abrégée peut également être utilisée avec des soustractions et des multiplications.
Opérateurs de comparaison en php
Les opérateurs de comparaison sont utilisés dans les tests de conditions if, etc. Cependant, dans cette leçon, nous n’examinerons pas les opérateurs conditionnels, mais uniquement les opérateurs de comparaison. Tous les opérateurs de comparaison sont présentés dans le tableau ci-dessous :
Il n'y a rien de compliqué ici, le principe est le même qu'en mathématiques. La seule particularité est que vrai vaut 1, et faux vaut 0. Voici un exemple détaillé en PHP :
//Attribuer des valeurs aux variables :$num1 = 10 ; $num2 = 7 ; echo "\$num1 > \$num2 = ". ($num1 > $num2); //obtient 1 (10 > 7 - vrai) echo "\$num1 //obtenir 0 (10 //Vous pouvez l'écrire plus simplement :écho "
10 // 0 écho "
20 // 0 écho "
1 == 1 = ". (1 == 1); // 1 écho "
0 == \"\" = ". (0 == ""); // 1 écho "
0 === 0 = ". (0 === 0); // 1 écho "
0 === \"\" = ". (0 === ""); // 0 écho "
vrai = ". vrai; // 1 écho "
faux = ". faux; // 0 ?>
Veuillez noter:
- Si faux, 0 ne sera pas affiché
- L'opérateur d'équivalence renvoie 1 uniquement s'il existe une correspondance exacte. Par exemple, 0 == "" est vrai, mais 0 === "" n'est plus vrai, car il n'y a pas de correspondance exacte.
Les opérations logiques existent dans tous les langages de programmation et PHP aucune exception. En plus des simples divisions, multiplications, additions ou soustractions, il existe également des divisions entières et restantes, 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 le résultat du reste lorsqu'il est divisé par un entier. Par exemple, en divisant le même cinq, vous obtiendrez non pas 2, mais 1, car en divisant 5 par 2, nous obtenons 2 et le reste est 1.
Comment faire une division entière en PHP
Par exemple, en Python cette division se fait à l'aide d'un simple opérateur : "//".
Et dans PHP ce ne sera pas si facile à faire, mais le processus ne nécessite toujours pas une grande connaissance de la langue.
Donnons un exemple de la façon dont cela peut être mis en œuvre.
DANS PHP La septième version de la fonction ressemble à ceci :
Intdiv();
Dans une ancienne version, la même fonction ressemble à ceci :
Il existe également une méthode pour toutes les versions :
Sol();
Comment postuler ?
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 afficher le reste entier de la division dans PHP Il suffit d'utiliser simplement l'opérateur "%".
$i = 10 % 3 ; écho $i;
Comme on peut le constater, tout est assez simple et ne nécessite pas de longues explications.
Où peut-il être utilisé ?
Connaissance de la division entière PHP sera très utile si vous devez comparer deux nombres, créer un nombre inversé (un exercice populaire) ou, par exemple, un programme appelé FizzBuzz. Son essence est qu'il faut écrire un cycle de 1 à 100, qui divise chaque nombre par 3 et 5. Si le nombre divisé par 3 a un reste de 0, alors on écrit Fizz, s'il est divisé par 5, alors Buzz, et si , en divisant 5 et 3, le reste est 0, alors nous écrivons FizzBuzz. Il s'agit d'une tâche d'entretien très populaire. Si vous l'avez réalisé vous-même, vous pouvez être fier de vous.
Ou, par exemple, nous devons dériver tous ses nombres (4, 5, 2) du nombre 452.
Conclusion
Bien sûr, les divisions entières et restantes sont utiles et assez courantes ; elles ne sont pas aussi pratiques à utiliser qu’en Python, mais elles restent importantes.
Vous êtes désormais sur le point d'apprendre un langage de programmation. PHP et à l'avenir, vous deviendrez encore plus proches si vous surmontez les difficultés avec autant de diligence.
Il est peu probable que les programmeurs qui doivent effectuer des calculs numériques, scientifiques ou statistiques sensibles considèrent un langage de script Web comme un candidat acceptable pour ce rôle. Mais malgré ce qui précède, le langage PHP offre un excellent ensemble de fonctions qui fournissent une solution complète à 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, les bibliothèques de hachage et les bibliothèques cryptographiques.
Les développeurs du langage PHP ont adopté une approche fondée et n'ont pas tenté de réinventer les roues conçues à cet effet. Le fait est que bon nombre des fonctions mathématiques les plus fondamentales utilisées en PHP sont simplement des enveloppes autour de leurs homologues C.
Opérations mathématiques
La plupart des mathématiques en PHP sont effectuées sous la forme de fonctions intégrées plutôt que d'opérations. En plus des opérateurs de comparaison, PHP propose cinq opérateurs arithmétiques simples, ainsi que des opérateurs de raccourci qui vous permettent de construire 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 incluent celles couramment mises en œuvre dans toute calculatrice à quatre fonctions, plus modulo (%). Une brève description des opérations arithmétiques est donnée dans le tableau :
| Opération | Description |
|---|---|
| + | Renvoie la somme des valeurs de ses deux opérandes |
| - | S'il y a deux opérandes, alors la valeur de l'opérande de droite est soustraite de la valeur de celui de gauche. S'il n'y a qu'un opérande de droite, alors l'opération renvoie la valeur de cet opérande avec le signe opposé |
| * | Renvoie le produit des valeurs de ses deux opérandes |
| / | Renvoie le résultat en virgule flottante de la division de la valeur de l'opérande de gauche par la valeur de l'opérande de droite |
| % | Renvoie le reste d'un entier divisé par la valeur de l'opérande de gauche par la valeur absolue de l'opérande de droite |
Lorsque vous utilisez les trois premières opérations arithmétiques décrites ci-dessus (+, -, *) dans un programme, vous devez tenir compte du fait que lors de l'exécution de ces opérations, la propagation du type se produit à partir de valeurs à virgule flottante double précision vers des valeurs entières. Cela signifie que 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. nombre. Le même type de propagation se produit lors de l'exécution d'une opération de division ; de plus, il existe un effet supplémentaire selon lequel le résultat devient un nombre à virgule flottante double précision si la division n'est pas effectuée sans reste (entièrement).
L'opération modulo (%) en PHP accepte les opérandes entiers, et lorsque cette opération est appliquée à des nombres à virgule flottante double précision, ces nombres sont d'abord convertis en nombres entiers (en supprimant la partie fractionnaire). Le résultat d’une telle opération est toujours un nombre entier.
Opérations d'incrémentation et de décrémentation
Une grande partie de la syntaxe de PHP est dérivée du C, et les programmeurs C sont connus pour leur amour de la brièveté et en sont fiers. Les opérateurs d'incrémentation et de décrémentation, tirés du langage C, fournissent une représentation plus succincte d'expressions telles que $count = $count + 1 , couramment rencontrées dans les programmes.
L'opérateur d'incrémentation (++) est utilisé pour ajouter un à la valeur de la variable affectée par l'opération, et l'opérateur de décrémentation (--) soustrait un de la valeur de cette variable.
Chacune de ces deux opérations a deux variétés - suffixe(sous cette forme, le signe de l'opération est placé immédiatement après la variable affectée par l'opération) et préfixe(sous cette forme, le signe de l'opération est placé immédiatement avant la variable à laquelle l'opération s'applique). Les deux ont le même effet secondaire de modifier la valeur d'une variable, mais les opérateurs de suffixe et de préfixe renvoient des valeurs différentes lorsqu'ils sont utilisés comme expressions. L'opération de suffixe fonctionne de manière à ce que la valeur de la variable soit modifiée une fois la valeur de l'expression renvoyée, et l'opération de préfixe fonctionne de manière à ce que la valeur soit d'abord modifiée, puis la nouvelle valeur soit renvoyée à la variable. Cette différence peut être détectée en utilisant les opérateurs de décrémentation et d'incrémentation dans les opérateurs d'affectation :
Code PHP $compte = 0 ; $résultat = $compte++ ; echo "Résultat de l'incrément de $count++ : ".$result.""; $count = 0; $result = ++$count; echo "Résultat de l'incrément de ++$count : ".$result."
";
Les instructions suivantes génèrent le résultat suivant dans la fenêtre du navigateur :
Opérations d'incrémentation
Dans cet exemple, l'opérateur $result = $count++ est tout à fait équivalent aux opérateurs :
Code PHP $résultat = $compte ; $compte = $compte + 1 ;Parallèlement à cela, l'opérateur $result = ++$count est équivalent aux opérateurs suivants :
Code PHP $compte = $compte +1 ; $résultat = $compte ;Opérateurs d'affectation
Les opérateurs d'incrémentation (et de décrémentation) réduisent la quantité de code nécessaire pour en ajouter un à la valeur d'une variable, mais ne réduisent pas la quantité de code qui attribue à une variable le résultat de l'ajout de sa valeur à un autre nombre ou le résultat d'autres opérations arithmétiques. . Heureusement, les cinq opérateurs arithmétiques ont des opérateurs d'affectation correspondants (+=, -=, *=, /= et %=), qui vous permettent d'attribuer le résultat d'une opération arithmétique sur la valeur de cette variable à une variable dans un expression courte. Par exemple, l'opérateur
Code PHP $count = $count * 3 ;peut être abrégé en
Code PHP $compte *= 3 ;Fonctions mathématiques simples
La prochaine étape pour rendre un programme plus complexe qu’un programme utilisant uniquement des opérations arithmétiques consiste à utiliser toutes sortes de fonctions. Les fonctions vous permettent d'effectuer des tâches telles que la conversion d'un type de nombre à 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 montre des fonctions mathématiques simples :
| Fonction | Description |
|---|---|
| sol() | Prend un seul paramètre réel (généralement un nombre à virgule flottante double précision) et renvoie le plus grand entier inférieur ou égal à ce paramètre réel (arrondi à l'inférieur). |
| plafond() | Le nom de cette fonction est une abréviation du mot plafond. La fonction prend un seul paramètre réel (généralement un nombre à virgule flottante double précision) et renvoie le plus petit entier supérieur ou égal à ce paramètre réel (arrondi au supérieur). |
| rond() | Prend un seul paramètre réel (généralement un nombre à virgule flottante double précision) et renvoie l'entier le plus proche |
| abdos() | Module numéro. Si le seul paramètre numérique réel a une valeur négative, alors la fonction renvoie le nombre positif correspondant ; si le paramètre réel est positif, alors la fonction renvoie le paramètre réel lui-même |
| min() | Accepte n'importe quel nombre de paramètres réels numériques (mais au moins un) et renvoie la plus petite de toutes les valeurs de paramètres réels |
| maximum() | Accepte n'importe quel nombre de paramètres numériques réels (mais pas moins d'un) et renvoie la plus grande de toutes les valeurs de paramètres réels |
Par exemple, le résultat de l'expression suivante est 3 car la valeur de chaque expression d'appel de fonction est également 3 :
Code PHP $result = min(3, abs(-3), max(round(2.7), ceil(2.3), floor(3.9)));Générer des nombres aléatoires
Le langage PHP utilise deux générateurs de nombres aléatoires (appelés respectivement grâce aux fonctions rand() Et mt_rand()). Chacun de ces générateurs est associé à trois fonctions ayant le même but : la fonction de fixation de la valeur initiale ( srand() Et mt_srand()), la fonction elle-même pour obtenir un nombre aléatoire et la fonction qui échantillonne le plus grand entier pouvant être renvoyé 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é à 32 768 sur les plateformes Windows.
Le choix de la fonction spécifique 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 opérationnelle de la fonction mt_rand() affirme que cette fonction est également plus rapide et " plus random" (d'un point de vue cryptographique) que rand(). Nous n'avons aucune raison de douter de la véracité de ces affirmations, c'est pourquoi nous préférons utiliser la fonction mt_rand() plutôt que rand().
Lors de l'utilisation de certaines versions de PHP sur certaines plates-formes, il semble que les fonctions rand() et mt_rand() produisent des nombres aléatoires apparemment raisonnables, même sans définir au préalable une graine. Mais il ne faut pas se fier à une telle impression. Premièrement, les programmes qui utilisent des fonctions pour générer des 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.
La manière typique de définir la valeur de départ pour l'un des générateurs de nombres aléatoires de PHP (en utilisant la fonction mt_srand() ou srand()) est la suivante :
Code PHP mt_srand((double)microtime()*1000000);Cette instruction définit la valeur initiale du générateur, égale au nombre de microsecondes écoulées pendant ce temps depuis le comptage de la dernière seconde entière. (Le transtypage en double dans cette instruction est en fait 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 au lecteur de saisir l'opérateur d'initialisation spécifié même si le but de cet opérateur ne lui est pas tout à fait clair ; Placer simplement cette instruction sur chaque page PHP, une seule fois, avant d'utiliser la fonction mt_rand() ou rand() correspondante, garantira que le point de départ change et produit donc une séquence aléatoire différente à chaque fois.
Cette méthode particulière de définition de la valeur initiale a été profondément réfléchie par les spécialistes qui comprennent parfaitement toutes les nuances de la génération de nombres pseudo-aléatoires. Elle restera donc très probablement toujours meilleure que toute tentative d'un programmeur individuel pour trouver quelque chose. plus « délicat ».
Évidemment, 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 facilement être converti en un nombre à virgule flottante correspondant (par exemple, un nombre compris entre 0,0 et 1,0 inclus) en utilisant une expression comme rand () /getrandmax(). La plage spécifiée peut ensuite être mise à l'échelle et décalée selon les besoins. Ci-dessous un exemple :
Code PHP // Disons que nous devons générer un nombre aléatoire de 100,0 à 120,0 $random = 100,0 + 20,0 * mt_rand() / mt_getrandmax(); echo $aléatoire.""; // Générer des entiers (100 - 120); echo round($random);
Essayez d'actualiser la page avec ce code plusieurs fois pour vous assurer que des nombres aléatoires sont générés.
Constantes mathématiques
Dans PHP version 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 PHP 4.0.2, de nombreuses nouvelles constantes ont été introduites. La plupart de ces nouvelles constantes concernaient π (ou ses multiples), e (ou ses multiples) et les racines carrées ; de plus, certaines constantes appartenaient à d’autres types. Mais dans les versions ultérieures, pour un certain nombre de raisons, la liste des constantes a de nouveau été réduite à un nombre relativement restreint de constantes mathématiques prédéfinies :
| Constante | Description |
|---|---|
| M_PI | π |
| M_PI_2 | π/2 |
| M_PI_4 | π/4 |
| M_1_PI | 1/π |
| M_2_PI | 2/π |
| M_2_SQRTPI | 2 / carré(π) |
| MOI | e |
| M_SQRT2 | carré (2) |
| M_SQRT1_2 | 1 / carré(2) |
| M_LOG2E | log2(e) |
| M_LOG10E | journal(e) |
| M_LN2 | loge(2) |
| M_LN10 | loge(10) |
Vérification du format du numéro
Le langage PHP propose un certain nombre de fonctions qui permettent de vérifier la bonne représentation des nombres. Bien que PHP ne dispose pas de vérification de type stricte, il est recommandé d'implémenter certaines de ces vérifications dans votre code lorsque cela est nécessaire afin que vous puissiez prédire les caractéristiques des résultats que vous recevez et également choisir la meilleure façon de les gérer.
La première et la plus simple vérification consiste à utiliser la fonction est_numérique(). Comme pour la plupart des autres tests de ce type, la fonction is_numeric renvoie un résultat booléen - vrai si le paramètre qui lui est transmis est une donnée numérique de n'importe quel type (signée ou non signée, entier ou à virgule flottante) ou une expression mathématique qui renvoie une valeur numérique valide.
Utiliser des fonctions est_int() Et est_float Vous pouvez déterminer si un nombre est un entier ou une fraction. Deux autres contrôles sont un peu plus complexes : les fonctions est_fini() Et est_infini() permettent d'effectuer exactement les tests que leurs noms indiquent (que le nombre soit fini ou infini). Mais, à proprement parler, la plage de valeurs sur laquelle s'étendent ces fonctions ne peut pas inclure l'infini réel (et peut-on même vérifier si un nombre a une valeur infiniment grande ?). Au lieu de cela, les limites de la plage de valeurs à virgule flottante autorisées sur un système particulier sont utilisées.
Vous trouverez ci-dessous un exemple d'utilisation de ces fonctions :
Code PHP est_numérique(4); // vrai is_numeric(25 - 6); // vrai is_numeric("25"); // vrai is_numeric("25 - 6"); // faux is_int(4); // vrai is_int(4.2); // faux is_int("4"); // false - cette vérification est plus stricte que la vérification utilisant la fonction is_numeric() is_float(4); // faux is_float(4.0); // vrai is_float(M_PI); // vraiConversion des systèmes numériques
Par défaut, PHP utilise la base 10 pour convertir les valeurs numériques de la représentation externe vers la représentation interne vers l'avant et vers l'arrière. Vous pouvez également indiquer à l'interpréteur PHP que la représentation externe utilise des nombres octaux en base 8 (pour ce faire, vous devez saisir 0 en tête). ), ou des nombres hexadécimaux spécifiés en base 16 (pour ce faire, vous devez préfixer le nombre par 0x).
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 d'exploitation lui-même en base 2. De plus, le langage PHP fournit un certain nombre de fonctions pour convertir les nombres d'une base du système de comptage en une autre. Un aperçu de ces fonctionnalités est fourni dans le tableau ci-dessous :
| Fonction | Description |
|---|---|
| BinDec() | Prend un paramètre de chaîne unique qui est un entier binaire (un nombre en base 2) et renvoie la représentation sous forme de chaîne en base 10 de ce nombre. |
| DécBin() | Similaire à BinDec(), mais convertit de la base 10 en base 2 |
| OctDéc() | Similaire à BinDec(), mais convertit de la base 8 en base 10 |
| Décocter() | Similaire à BinDec(), mais convertit de la base 10 en base 8 |
| HexDéc() | Similaire à BinDec(), mais convertit de la base 16 en base 10 |
| DécHex() | Similaire à BinDec(), mais convertit de la base 10 en base 16 |
| base_convert() | Accepte un paramètre de chaîne (représentant l'entier à convertir) et deux paramètres entiers (l'original et la base souhaitée). Renvoie une chaîne représentant le nombre converti. Dans cette ligne, les nombres supérieurs à 9 (10 à 35) sont représentés par les caractères a-z. Les bases originales et souhaitées doivent être comprises entre 2 et 36. |
Toutes les fonctions de conversion du système numérique sont des fonctions spéciales qui convertissent les nombres d'une base spécifique à une autre. Une exception est la fonction base_convert(), qui accepte des paramètres arbitraires indiquant les bases initiales et résultantes.
Notez que toutes les fonctions de conversion du système 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 compter sur l'interpréteur PHP pour effectuer correctement la conversion de type. En d’autres termes, DecBin("1234") et DecBin(1234) produisent tous deux le même résultat.
Exposants et logarithmes
Le langage PHP comprend des fonctions exponentielles et logarithmiques standard en deux variétés - pour travailler en base 10 et en base e (qui sont présentées dans le tableau).
PHP fournit une fonction exp() pour élever e à une puissance donnée, mais il n'existe pas de fonction à un paramètre pour élever 10 à une puissance donnée. Cependant, vous pouvez utiliser la fonction pow() à la place, qui prend deux paramètres, donnant 10. comme premier paramètre.
Vous pouvez vérifier que les fonctions exponentielles et logarithmiques de même base sont inverses les unes des autres en vérifiant l'identité des résultats ainsi obtenus :
Code PHP $test_449 = 449,0 ; $test_449 = pow(10, exp(log(log10($test_449)))); écho "test_449 = $test_449" ; //test_449 = 449Fonctions trigonométriques
Le langage PHP fournit un ensemble standard de fonctions trigonométriques de base, dont les informations générales sont données dans le tableau :
| Fonction | Description |
|---|---|
| pi() | Il ne prend aucun paramètre et renvoie une valeur approximative de π (3.1415926535898). Peut être utilisé de manière interchangeable avec la constante M_PI |
| péché() | Accepte un paramètre numérique en radians et renvoie le sinus du paramètre sous forme de nombre à virgule flottante double précision |
| cos() | Prend un paramètre numérique en radians et renvoie le cosinus du paramètre sous forme de nombre à virgule flottante double précision |
| tanné() | Accepte un paramètre numérique en radians et renvoie la tangente du paramètre sous forme de nombre à virgule flottante double précision |
| asin() | Prend un paramètre numérique et renvoie l'arc sinus du paramètre en radians. Les entrées doivent être comprises entre -1 et 1 (la fonction recevant des entrées en dehors de cette plage entraîne un résultat NAN). Les résultats vont de -π/2 à π/2 |
| acos() | Prend un paramètre numérique et renvoie l'arc cosinus du paramètre en radians. Les entrées doivent être comprises entre -1 et 1 (la fonction recevant des entrées en dehors de cette plage entraîne un résultat NAN. Les résultats sont compris entre 0 et π |
| atan() | Prend un paramètre numérique et renvoie l'arctangente du paramètre en radians. Les résultats vont de -π/2 à π/2 |
Vous trouverez ci-dessous un exemple d'élaboration d'un tableau de calcul de fonctions trigonométriques pour des angles « standards » :
Code PHP function display_trigonometry($func_array, $input_array) ( // En-tête de fonction echo "| Signification/fonction | $fonction | "; ) écho "
|---|---|
| ".sprintf("%.4f",$input)." | "; foreach($func_array as $func) ( echo ""; printf("%4.4f", $func($input)); echo " | "; ) écho "
Un exemple d'utilisation de fonctions trigonométriques en PHP Obtenir des valeurs tangentes très grandes (mais pas infinies) est dû au fait que les dénominateurs devraient théoriquement être nuls, mais en réalité sont légèrement différents de zéro en raison d'erreurs d'arrondi.
Calcul de précision arbitraire (à l'aide des fonctions BC)
Les types entiers et à virgule flottante double précision conviennent parfaitement à la plupart des problèmes mathématiques rencontrés dans les scripts Web, mais chaque instance de la valeur représentée par ces types nécessite une quantité fixe de mémoire informatique, donc la taille et la précision de la représentation numérique de ces types impose inévitablement des limites.
Bien entendu, les plages de valeurs 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. En revanche, pour résoudre des problèmes nécessitant l'utilisation d'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, du nom de l'utilitaire de calcul à précision arbitraire basé sur Unix).
Il se peut que des fonctions de précision arbitraires ne soient pas incluses dans la compilation de l'interpréteur PHP, surtout si l'utilisateur a fait la compilation lui-même, car pour cela, l'utilisateur devrait savoir qu'au stade de la configuration, il est nécessaire d'inclure une case à cocher dans le champ 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 un message d'erreur indiquant une fonction non définie, vous devrez reconfigurer l'interpréteur PHP et le recompiler.
Les fonctions BC utilisent des chaînes plutôt que des types numériques de longueur fixe comme paramètres et valeurs de retour. Puisqu'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 de base sont effectués sous forme décimale et ressemblent beaucoup à ceux qu'une personne peut faire avec un crayon et du papier (si elle peut travailler très rapidement et être patiente). Les fonctions entières BC sont précises et vous permettent d'utiliser autant de chiffres que nécessaire, tandis que les fonctions à virgule flottante effectuent des calculs précis à un nombre spécifié de décimales. Des informations générales sur les fonctions BC sont données dans le tableau ci-dessous :
| Fonction | Description |
|---|---|
| bcadd() | Accepte deux paramètres de chaîne représentant des nombres et un paramètre entier facultatif indiquant un facteur d'échelle. Renvoie la somme des deux premiers paramètres sous forme de chaîne, avec le nombre de décimales dans le résultat déterminé par le paramètre indiquant le facteur d'échelle. Si le paramètre indiquant le facteur d'échelle n'est pas spécifié, alors le facteur d'échelle par défaut est utilisé |
| bcsub() | Similaire à bcadd(), sauf qu'il renvoie le résultat de la soustraction du deuxième paramètre du premier |
| bcmui() | Similaire à bcadd(), sauf qu'il renvoie le résultat de la multiplication de ses paramètres |
| bcdiv() | Similaire à bcadd(), sauf qu'il renvoie le résultat de la division du premier paramètre par le second |
| bcmod() | Renvoie le module (reste) de division du premier paramètre par le second. La valeur de retour étant un entier, la fonction n'accepte pas de paramètre indiquant un facteur d'échelle. |
| bcpow() | Augmente le premier paramètre à la puissance spécifiée par le deuxième paramètre. Le nombre de décimales dans le résultat est déterminé par le facteur d'échelle, s'il est spécifié. |
| bcsqrt() | Renvoie la racine carrée du paramètre avec le nombre de décimales déterminé par la valeur du facteur d'échelle facultatif |
| bcscale() | Définit le facteur d'échelle par défaut pour les appels ultérieurs à la fonction BC |
La plupart de ces fonctions prennent comme dernier paramètre un facteur d'échelle facultatif (un entier), qui détermine le nombre de décimales que doit avoir le résultat. Si ce paramètre n'est pas spécifié, le facteur d'échelle par défaut est utilisé comme facteur d'échelle, qui peut à son tour ê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'appelle pas bcscale()) peut également être définie dans le fichier d'initialisation php.ini.
Vous trouverez ci-dessous un exemple d'utilisation d'une fonction de précision arbitraire pour effectuer des opérations arithmétiques entières avec précision. Exécution du code suivant :
Code PHP pour ($x = 1 ; $x< 25; $x++) { echo "$xx $= ".bcpow($x, $x).""; }
Calcul précis des quantités astronomiques à l'aide des fonctions BC Si le type entier normal de PHP était utilisé pour ces calculs, alors le dépassement d'entier se produirait bien avant la fin du calcul, de sorte que le reste de la boucle effectuerait des calculs pour obtenir un nombre à virgule flottante approximatif.
Traitement des formulaires de tableaux 1 2 3 4 5 6 7 8 9 10Opérations avec des variables PHP (opérateurs)
Il existe différents groupes de mise en œuvre.
Un opérateur est quelque chose composé d'une ou plusieurs valeurs (expressions dans le jargon de la programmation) qui peuvent être évaluées comme une nouvelle valeur (ainsi, la construction entière peut être considérée comme une expression). Il s'ensuit que les fonctions ou toute autre construction renvoyant une valeur (par exemple, imprimer()) sont des opérateurs, contrairement à toutes les autres constructions du langage (par exemple, écho()), qui ne renvoie rien.
Opérations arithmétiques en PHP
Vous vous souvenez des bases de l'arithmétique à l'école ? Les instructions 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 division " % " ne fonctionne qu'avec des nombres entiers, donc l'appliquer à des fractions peut produire des résultats indésirables.
Il est possible d'utiliser des parenthèses. La préséance de certaines opérations mathématiques sur d'autres et le changement de priorités lors de l'utilisation des parenthèses dans les expressions arithmétiques suivent les règles habituelles des mathématiques.
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 suffixe.
Opérateurs d'incrémentation et de décrémentation Postfix
Comme en C, ces opérateurs incrémentent ou décrémentent la valeur d'une variable, et dans une expression 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 valeur attribuée à la variable $un, et alors seulement le dernier a été incrémenté. Cependant, l'expression dont la valeur est affectée à la variable $b, peut être plus difficile - dans tous les cas, incrémenter $un n'arrivera qu'après avoir é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 sont spécifiés 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 dans la pratique. Par exemple, ils se produisent dans presque tous les cycles pour .
écho "Incrément de suffixe
"
;
$une = 5 ;
echo "Doit être 5 : " . $a++ . "
\n" ;
\n" ;
Écho "Incrément de préfixe
"
;
$une = 5 ;
echo "Doit être 6 : " . ++ $une . "
\n" ;
echo "Doit être 6 : " . $une . "
\n" ;
Écho "Décrémentation postfixe
"
;
$une = 5 ;
echo "Doit être 5 : " . $a -- . "
\n" ;
\n" ;
Écho "Décrément de préfixe
"
;
$une = 5 ;
echo "Doit être 4 : " . -- $a . "
\n" ;
echo "Doit être 4 : " . $une . "
\n" ;
?>
Opérations sur les chaînes
PHP dispose de 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 un opérateur d'affectation avec concaténation, qui ajoute l'argument de droite à celui de gauche. Donnons un exemple précis :
$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 (activer/désactiver/vérifier) des groupes de bits dans une variable entière. Les bits d'un entier ne sont rien de plus que des chiffres individuels du même nombre écrit dans le système de numérotation binaire. Par exemple, en binaire, le nombre 12 ressemblerait à 1100 et 2 à 10, donc l'expression 12|2
nous renverra le nombre 14 (1110 en notation binaire). Si une variable n’est pas un entier, alors c’est
d'abord arrondi, puis les opérateurs suivants lui sont appliqués.
Pour représenter un nombre, 32 bits sont utilisés :
- 0000 0000 0000 0000 0000 0000 0000 0000 est zéro ;
- 0000 0000 0000 0000 0000 0000 0000 0001 vaut 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 :
| Exemple | Nom | Résultat |
|---|---|---|
| $a et $b | Au niveau du bit "et" | Seuls les bits définis à la fois dans $a et $b sont définis. |
| $une | $b | "ou" au niveau du bit | Les bits définis dans $a ou $b sont définis. |
| $a^$b | Exclusif ou | Seuls les bits définis soit uniquement dans $a, soit uniquement dans $b sont définis. |
| ~$a | Négation | Les bits qui ne sont pas définis dans $a sont définis, et vice versa. |
| $un<< $b | Décaler vers la gauche | Tous les bits de la variable $a sont décalés de $b positions vers la gauche (chaque position implique une "multiplication par 2") |
| $a >> $b | Décaler vers la droite | Tous les bits de la variable $a sont décalés de $b positions vers la droite (chaque position implique une "division par 2") |
Opérations de comparaison
Les opérateurs de comparaison, comme leur nom l’indique, permettent de comparer deux valeurs.
Ce sont des opérations uniques à leur manière 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 vraie, de renvoyer vrai, et sinon - FAUX.
PHP permet uniquement de comparer des variables scalaires. Les tableaux et les objets ne peuvent pas être comparés en PHP. Leur égalité ne peut même pas être comparée (en utilisant l'opérateur ==), mais PHP n'émet pas d'avertissement lors de l'exécution d'une telle opération. Ainsi, après m'être demandé un jour pourquoi deux tableaux complètement différents en les comparant en utilisant == s'avèrent soudainement identiques, rappelez-vous qu'avant la comparaison, les deux opérandes sont convertis en un mot tableau, qui est ensuite comparé.
Voir Comparaison de tableaux pour plus de détails.
Opérateurs de comparaison :
| Exemple | Nom | Résultat |
|---|---|---|
| $a == $b | Égal | VRAI si $a est égal à $b. |
| $a === $b | Identiquement égal | VRAI si $a est égal à $b et a le même type. (Ajouté en PHP 4) |
| $une != $b | Pas égal | VRAI si $a n'est pas égal à $b. |
| $un<>$b | Pas égal | VRAI si $a n'est pas égal à $b. |
| $une !== $b | Identique n'est pas égal | VRAI si $a n'est pas égal à $b ou s'ils sont de types différents (Ajouté en PHP 4) |
| $un< $b | Moins | VRAI si $a est strictement inférieur à $b. |
| $a > $b | Plus | VRAI si $a est strictement supérieur à $b. |
| $un<= $b | Inférieur ou égal à | VRAI si $a est inférieur ou égal à $b. |
| $a >= $b | Supérieur ou égal à | VRAI si $a est supérieur ou égal à $b. |
Opérations logiques
Les opérateurs logiques sont conçus exclusivement pour travailler avec des expressions booléennes et renvoient également FAUX ou vrai.
Voici un tableau des opérateurs logiques PHP :
Il convient de noter que l'évaluation des expressions logiques contenant de tels opérateurs se fait toujours de gauche à droite, et si le résultat est déjà évident (par exemple, faux et quelque chose donne toujours FAUX), alors les calculs sont terminés, même si l'expression contient des appels de fonction. Par exemple, dans l'opérateur $logic = 0&&(time()>100); fonction standard temps() ne sera jamais appelé.
Soyez prudent avec les opérations logiques - n'oubliez pas le doublage des caractères. Veuillez noter 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
En PHP, à partir de PHP4, il existe un opérateur de comparaison identique - un triple signe égal ===
,
ou l'opérateur du chèque. PHP tolère assez bien que les chaînes soient implicitement converties en nombres, et vice versa.
Par exemple, le code suivant affichera que les valeurs des variables sont égales :
$a=10 ;
$b="10";
Et ce malgré le fait que la variable $un représente un nombre et $b- doubler. Regardons maintenant un exemple légèrement différent :
$a=0 ; // zéro
$b=""; // chaîne 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 cela se produit-il ? Le fait est que si l’un des opérandes d’un opérateur logique peut être interprété 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. Il n'est pas surprenant que 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 également leurs types. Réécrivons notre exemple en utilisant cet opérateur.