Opérations en PHP. Instruction conditionnelle if dans PHP Variables booléennes dans php informations générales

La leçon couvrira les instructions conditionnelles php : l'instruction if et l'instruction switch

Les instructions conditionnelles php sont représentées par trois constructions principales :

• opérateur de condition si,
• changer d'opérateur changer
• et opérateur ternaire.

Regardons chacun d'eux de plus près.

PHP if instruction

Figure 3.1. Opérateur conditionnel SI, version abrégée

Riz. 3.2. Syntaxe de l'instruction conditionnelle IF ELSE

Riz. 3.3. Syntaxe complète pour l'instruction conditionnelle IF elseif

Résumons :

La syntaxe complète est :

if (condition) (// si la condition est vraie opérateur1; opérateur2;) elseif (condition) (opérateur1; ...) else (// si la condition est fausse opérateur1; opérateur2;)

• La syntaxe raccourcie peut ne contiennent pas une partie de la construction avec else et ne contiennent pas de condition supplémentaire elseif
• Au lieu du mot de fonction elseif, vous pouvez écrire else if (séparément)
• Il peut y avoir plusieurs elseifs dans une instruction if. La première expression elseif rencontrée égale à TRUE sera exécutée.
• S'il existe une autre condition elseif, la clause else doit arriver en dernier dans la syntaxe.

Un deux-points peut être utilisé dans une instruction conditionnelle : au lieu de accolades... Dans ce cas, l'opérateur termine par le mot de service endif

Riz. 3.4. Instruction conditionnelle If et Endif en php

Exemple:

if ($ x> $ y): echo $ x. "supérieur à". $ y; elseif ($ x == $ y): // lors de l'utilisation de ":" vous ne pouvez pas écrire séparément else if echo $ x. "est égal à". $ y; else : echo $ x. "pas> et pas =". $ y ; fin si;

Important: Lorsque vous utilisez un deux-points au lieu d'accolades elseif, vous ne pouvez pas écrire en deux mots !

Opérations logiques dans une condition

Les opérations suivantes peuvent être présentes dans la clause if entre parenthèses :

Exemple: vérifier la valeur d'une variable numérique : si elle est inférieure ou égale à 10, afficher un message "Nombre inférieur ou égal à 10", dans le cas contraire, émettre un message "Le nombre est supérieur à 10"

nombre $ = 15 ; si (nombre de $<=10) { echo "число меньше или равно 10"; } else { echo "число больше 10"; }

Des blocs de code php peuvent être brisés, prenons un exemple :

Exemple: Afficher le code html "A est égal à 4" si la variable $ a est bien 4

2 solutions :

A est égal à 4

Travail PHP 3_1 : Afficher la traduction des couleurs de l'anglais vers le russe, en vérifiant la valeur de la variable (dans laquelle la couleur est affectée : $ a = "bleu")

Travail PHP 3_2 : Trouver le maximum de trois nombres

Opérations de comparaison et règle du mensonge

Dans l'instruction if, il doit y avoir une expression logique ou une variable entre parenthèses qui est considérée du point de vue de l'algèbre logique, renvoyant des valeurs vraies ou fausses

Celles. une seule variable peut être utilisée comme condition. Prenons un exemple :

$a = 1 ; si ($ a) (écho $ a;)

Dans l'exemple, le traducteur de langage php considérera la variable entre parenthèses pour la règle des mensonges :

La règle du MENSONGE ou ce qui est considéré comme faux :

• logique Faux
• entier zéro ( 0 )
• zéro valide ( 0.0 )
• ligne vide et la ligne «0»
• tableau sans éléments
• objet sans variables
• type spécial NUL

Ainsi, dans l'exemple considéré, la variable $ a est égale à un, respectivement, la condition sera vraie et l'opérateur echo $ a ; affichera la valeur de la variable.

Travail PHP 3_3 :étant donné une variable a avec une valeur de chaîne. Si a est égal au nom, alors la sortie "Bonjour nom!", si a est égal à une valeur vide, alors la sortie "Salut étranger!"

Constructions logiques AND OR et NOT dans un opérateur conditionnel

1. Parfois, il est nécessaire de prévoir la réalisation de plusieurs conditions en même temps. Alors les conditions se combinent opérateur logique ET — && :

$a = 1 ; if ($ a> 0 || $ a> 1) (écho "a> 0 ou a> 1";)

2. Pour indiquer que la condition est fausse, utilisez opérateur logique NON — ! :

1 2 3 4

$a = 1 ; si (! ($ un< 0 ) ) { echo "a не < 0" ; }

$a = 1 ; si (! ($ un<0)) { echo "a не < 0"; }

Changer d'instruction PHP

L'instruction switch ou "switch" remplace plusieurs instructions if consécutives. Ce faisant, il compare une variable avec un ensemble de valeurs. C'est donc le remède le plus pratique. pour l'organisation de multi-branches.

Syntaxe:

1 2 3 4 5 6 7 8 9 10

switch ($ variable) (case "valeur1": instruction1; break; case "value2": statement2; break; case "value3": statement3; break; [défaut: statement4; break;])

switch ($ variable) (case "valeur1": instruction1; break; case "value2": statement2; break; case "value3": statement3; break;)

• L'opérateur peut vérifier à la fois les valeurs de chaîne (auquel cas elles sont indiquées entre guillemets) et les valeurs numériques (sans guillemets).
• L'instruction break dans la construction est obligatoire. Il sort de la construction si la condition est vraie et l'opérateur correspondant à la condition est exécuté. Sans interruption, toutes les instructions case seront exécutées quelle que soit leur véracité.

Riz. 3.5. Instruction de commutation conditionnelle

Exemple: un tableau avec des noms masculins complets est donné. Vérifiez le premier élément du tableau et, selon le nom, lancez un message d'accueil avec un nom court.

$ names = array ("Ivan", "Peter", "Semyon"); switch (noms $) (case "Peter": echo "Bonjour, Petya!"; break; case "Ivan": echo "Bonjour, Vanya!"; break; case "Semyon": echo "Bonjour, Vanya!"; break ; par défaut : echo "Bonjour, $ noms!"; break;)

Travail PHP 3_4 :

• Créez une variable $ day et attribuez-lui une valeur numérique arbitraire
• Utilisez l'instruction switch pour afficher la phrase "C'est un jour ouvrable" si la valeur de la variable $ jour se situe dans la plage de nombres de 1 à 5 (inclus)
• Sortir la phrase "C'est un jour de congé" si la valeur de la variable $ jour est 6 ou 7
• Sortir la phrase "Jour inconnu" si la valeur de la variable $ jour n'est pas dans la plage de nombres de 1 à 7 (inclus)

Complétez le code :

Commutateur (...) (cas 1 : cas 2 : ... echo "Ceci est un jour ouvrable" ; pause ; cas 6 : ... par défaut : ...)

Opérateur ternaire PHP

Opérateur ternaire, c'est à dire. avec trois opérandes, a une syntaxe assez simple, dans laquelle à gauche du ? la condition est écrite, et à droite - deux opérateurs séparés par le signe :, à gauche du signe l'opérateur est exécuté si la condition est vraie, et à droite du signe : l'opérateur est exécuté si la condition est faux.

état? opérateur1 : opérateur2 ;

PHP prend en charge les opérateurs logiques standard ET et &&, OU et || ,! (pas) et XOR. Opérateurs logiques vous permettent de comparer les résultats de deux opérandes (valeur ou expression) afin de déterminer si l'un ou les deux ont renvoyé vrai ou faux et de sélectionner la suite appropriée du script en fonction de la valeur renvoyée. Comme les opérateurs de comparaison, les opérateurs logiques renvoient une valeur booléenne - vrai ou faux, selon les valeurs de chaque côté de l'opérateur.

OU logique (OU et ||)

L'opérateur logique OU est noté OU ou || ... Il effectue une opération OU logique sur deux opérandes. Si un ou les deux opérandes sont vrais, il renvoie vrai. Si les deux opérandes sont faux, il renvoie faux. Vous avez probablement une question, pourquoi avez-vous fait deux versions d'un opérateur ? L'intérêt de deux variantes différentes de l'opérateur « OU logique » est qu'elles fonctionnent avec des priorités différentes.

Voyons d'abord comment fonctionne l'opérateur ||. ... Et donc, si l'un ou les deux de ses opérandes sont vrais, il renvoie vrai. Si les deux opérandes retournent des valeurs fausses, il retournera faux.

L'opérateur OU fonctionne de la même manière que || à une exception près, si l'opérateur OR est utilisé avec une affectation, il évaluera d'abord et retournera la valeur de l'opérande de gauche, sinon il fonctionnera exactement comme l'opérateur ||. , c'est à dire. si l'un ou les deux de ses opérandes sont vrais, il renvoie vrai. Si les deux opérandes retournent des valeurs fausses, il retournera faux.

Pour mieux comprendre leur fonctionnement, donnons l'exemple suivant :

1 // Tout d'abord, la variable reçoit la valeur false, puis le deuxième opérande est calculé // Action prioritaire : ($ var2 = false) ou true $ var2 = false ou true ; echo $ var2; // false n'est pas affiché // ($ var3 = 0) ou 3 $ var3 = 0 ou 3; écho "
$ var3 "; // => 0?>

Toutes les comparaisons et opérateurs logiques peuvent être combinés dans des constructions plus complexes :

Il y a un autre point important à mentionner concernant à la fois l'OR et || ... L'opérateur "OU logique" commence ses calculs à partir de son opérande gauche, s'il retourne vrai, alors l'opérande droit ne sera pas évalué. Cela permet de gagner du temps d'exécution, mais il faut faire attention à ne pas mettre le code dont le bon fonctionnement du programme dépend du bon opérande.

ET logique (ET et &&)

L'opérateur logique AND est appelé AND ou &&. Il effectue une opération ET logique sur deux opérandes. Il renvoie vrai si et seulement si les deux opérandes sont vrais. Si un ou les deux opérandes renvoient faux, l'opérateur renvoie faux. La signification des deux versions différentes de l'opérateur « ET logique » est la même que pour les deux opérateurs précédents, à savoir qu'ils fonctionnent avec des priorités différentes.

Voyons d'abord comment fonctionne l'opérateur &&. Et donc, si ses deux opérandes sont vrais, il retourne vrai. Si au moins un de ses opérandes ou les deux retournent faux, il retournera également faux.

L'opérateur AND fonctionne exactement comme l'opérateur &&, à une exception près, si l'opérateur AND est utilisé avec l'affectation, il évaluera d'abord et retournera la valeur de l'opérande gauche, sinon il fonctionnera de la même manière que l'opérateur &&. Si au moins un de ses opérandes retourne faux, il retournera également faux, et si les deux opérandes retournent des valeurs fausses, il retournera faux.

Pour comprendre, examinons maintenant comment cela fonctionne dans la pratique :

$ bar3 "; // => 9?>

OU exclusif (XOR)

L'opérateur OU exclusif est désigné par XOR. Elle renvoie vrai si un et un seul des opérandes est vrai. Si les deux opérandes sont vrais, l'opérateur renverra faux.

Étant donné que la priorité de l'opérateur XOR est la même que celle des opérateurs AND et OR (inférieure à l'opérateur d'affectation) et qu'il est utilisé dans une expression d'affectation, il évalue d'abord et renvoie la valeur de l'opérande gauche.

6 $ a1 = 19 x ou 5> 6 ; var_dump ($ a1) ; // => 19 var_dump (true xor true); // false var_dump ((2< 3) xor (5 != 5)); // true ?>

NON logique (!)

Opérateur NON logique, il est aussi appelé négation dénoté par le signe ! ... C'est un opérateur unaire placé avant un seul opérande. L'opérateur booléen NOT est utilisé pour inverser la valeur booléenne de son opérande et renvoie toujours vrai ou faux.

Si vous devez inverser la valeur d'une expression, par exemple a && b, vous devrez utiliser des parenthèses : ! (A && b). Aussi avec l'aide de l'opérateur! vous pouvez convertir n'importe quelle valeur de x en son équivalent logique en utilisant l'opérateur : !!x deux fois.

>> J'ai lu quelques-unes de ces réponses et très honnêtement, je n'en ai "pas trouvé une qui expliquait les différences entre les opérateurs" || "et" OU ".

La différence est expliquée dans le lien vers sur la priorité des opérateurs.

Le "||" les opérateurs sont évalués avant l'affectation ("="), tandis que les opérateurs "ou" sont évalués après l'affectation. Dans votre deuxième exemple, vous dites à PHP d'affecter d'abord le résultat de "(choix1! = False?" Hah ":" boo ")" à $ val, puis "ou" contre le reste de l'instruction. Essayez l'exemple ci-dessous et vous verrez ce que je veux dire (notez les crochets supplémentaires pour appliquer la priorité) :

define ("choix1", faux);
define ("choix2", "chien");
define ("default1", "autre");
$ val = tableau ();

$ val ["Test 1"] = (choix1! = false? "hah": "boo") || (choix2! = faux? "hah2": "boo2") || (default1! = false? "hah3": "boo3");
$ val ["Test 1b"] = ((choix1! = false? "hah": "boo") || (choice2! = false? "hah2": "boo2") || (default1! = false? "hah3 ":" boo3 "));
$ val ["Test 2"] = (choice1! = false? "hah": "boo") ou (choice2! = false? "hah2": "boo2") ou (default1! = false? "hah3": " boo3 ");
$ val ["Test 2b"] = ((choix1! = false? "hah": "boo") ou (choice2! = false? "hah2": "boo2") ou (default1! = false? "hah3": "boo3"));

Foreach ($ val as $ test => $ result) (
print ("$ test:"); var_dump ($ résultat); imprimer "
\ n
\ n ";
}
?>

tester sur hto dot com

Parce que le raccourci OR pour un bloc if peut produire plus
code lisible avec moins de frappe, il est tentant de produire des fonctions qui renverront FALSE en cas d'échec ou un autre type de données en cas de succès. Comme mysql_connect, qui "Renvoie un identifiant de lien MySQL en cas de succès, ou FALSE en cas d'échec."

Le développeur php php novice doit éviter de créer des fonctions qui pourraient produire un FAUX en cas d'échec et un entier en cas de succès, s'il y a une chance que l'entier soit nul.

bla bla bla;
$ i = give_me_liberty() ou die ("FATAL DB ERROR!");
bla bla bla;
?>

ironmo67 sur yahoo dot com

J'ai découvert une différence quelque peu ennuyeuse entre PHP et Perl :

if (! some_function ()) renvoie false ;
?>

ne peut pas être réécrit comme le plus joli :

fonction some_function () (retourne faux ;)
some_function () ou renvoie false ;
?>

Les éléments suivants fonctionneront cependant :

fonction some_function () (retourne faux ;)
some_function () ou die ();
?>

Pouvez-vous deviner pourquoi? Simplement, die() est une fonction et "return" est une instruction (comme la différence entre print() et echo, en quelque sorte). C'est vraiment dommage car je trouve la version if (!) () fatiguée et illisible, mais bon, c'est mieux que if (some_c_function == 0) (faire quelque chose).

Une grande partie de la discussion ci-dessous aurait pu être évitée simplement en étant clair que &, | et ^ ne sont * pas * des opérateurs logiques. C'est "c'est pourquoi ils" ne sont pas répertoriés sur cette page. Ce sont des "opérateurs qui agissent sur les binaires de nombres. Ils ne prennent pas de valeurs logiques (c'est-à-dire "vrai" ou "faux") comme arguments sans les convertir au préalable respectivement en nombres 1 et 0. Ils ne renvoient pas non plus de valeurs logiques. Bien sûr, vous pouvez plus tard traiter ces nombres comme s'il s'agissait de valeurs logiques (auquel cas 0 est converti en "faux" et tout le reste est converti en "vrai"), mais cela "est une conséquence de PHP " règles de transtypage de type, et rien à voir avec le comportement des opérateurs.

Si vous voulez des opérations logiques, utilisez des opérateurs logiques ; si vous voulez des opérations au niveau du bit, utilisez des opérateurs au niveau du bit ... utiliser l'un pour l'autre semble être un bon moyen de rendre les choses difficiles.

kws_ à hotpop dot com

« Juste parce que vous le pouvez, cela ne veut pas dire que vous devriez. »

Je pense aussi que contourner l'évaluation de court-circuit et se fier aux effets secondaires dans les expressions conditionnelles est un mauvais style. Écrire du code qui se documente lui-même en utilisant des constructions claires et directes me semble être une bien meilleure pratique que d'utiliser une expression alambiquée et difficile à lire et de l'expliquer avec des commentaires (ou pire encore, de ne pas la documenter du tout !) En effet, le code source devrait être écrit pour les yeux du programmeur "plus que pour l'ordinateur".

L'utilisation des opérateurs au niveau du bit dans un contexte logique pourrait violer les attentes du lecteur et peut créer une confusion car les opérateurs au niveau du bit impliquent des opérandes de champ de bits.

Je pense également qu'en supposant que l'évaluation de court-circuit est la meilleure pour les constructions logiques EST dans les "droits" du compilateur, car lorsque les opérateurs logiques sont utilisés aux fins prévues, les hypothèses selon lesquelles le court-circuit rend * SONT * logiques, et ne (encore une fois, lorsqu'il est utilisé correctement) optimiser l'évaluation des expressions logiques.

Je n'ai pas l'intention de critiquer ou d'insulter directement qui que ce soit, mais seulement de décourager l'utilisation d'un style médiocre et d'encourager les programmeurs nouveaux (et même certains expérimentés) à écrire un code clair et prolixe, et à penser aux programmeurs plutôt qu'aux ordinateurs qui pourraient finir par essayer de déchiffrer vos créations.

En réponse à braintreno :

Le deuxième exemple que vous avez apporté est la bonne façon de procéder ! Ce n'est pas du tout une logique alambiquée, c'est ce qui rend votre code lisible en ne s'appuyant pas sur des effets secondaires obscurs !! Il est beaucoup plus facile à lire que le premier et il est de loin plus facile à entretenir.

Pour que l'idée de laisser une fonction CheckThisOrOther () renvoyer les informations à l'utilisateur seul, vous devez être déchu de votre licence de codage. Si jamais je devais maintenir l'un de vos scripts, je "devrais vous détester.

Il ne s'agit pas d'un coup de flamme comme cela pourrait paraître ! Le code source n'est pas écrit pour que les ordinateurs s'exécutent, mais pour que les codeurs le lisent ! Gardez cela à l'esprit et vos collègues vous en remercieront !

braintrino

La publication de Shadedecho pour forcer l'évaluation des deux expressions OU est en fait exactement ce qui doit être fait pour supprimer l'optimisation des courts-circuits.

Il existe de nombreuses occasions où vous ne voulez pas que le compilateur court-circuite une évaluation, en particulier lorsque vous souhaitez effectuer une situation et / ou. L'évaluation de court-circuit effectue une opération OU mais pas une opération ET / OU !!!

Par exemple, si je veux que le formulaire de requête de l'utilisateur vérifie si l'utilisateur a manqué de répondre à une entrée ET / OU si l'utilisateur a dupliqué la même réponse pour plus d'une entrée, alors je dois renvoyer le formulaire à le client informant ce que je veux être corrigé.

Fonction SomeAnswersAreMissing ()
{
...
echo "Oups ! Vous avez manqué de répondre à certaines questions.";
renvoie VRAI ;
}

Fonction CertainesRéponsesSontDupliquées ()
{
...
echo "Oups ! Vous pouvez répondre aux deux de la même manière.";
renvoie VRAI ;
}

Si (SomeAnswersAreMissing () || SomeAnswersAreDuplicated ())
SendFormAgain ();

Si je fais cela, l'utilisateur ne verra que l'avertissement de réponse manquante mais pas l'avertissement de réponse dupliquée, même si les deux sont vrais. Ceci n'est pas informatif pour l'utilisateur car il devra soumettre à nouveau le formulaire deux fois avant de réaliser tout ce qu'il a fait de mal et de frustrer le piratage. Ce n'est pas convivial.

Si (Certaines réponses sont manquantes () | Certaines réponses sont dupliquées ())
SendFormAgain ();

Ensuite, les deux messages d'avertissement sont envoyés en même temps et l'utilisateur peut les corriger en un seul renvoi.

Merci shadedecho, je cherchais un moyen de remplacer l'optimisation stupide des courts-circuits du compilateur. L'ordinateur ne peut pas simplement supposer que le court-circuit est le meilleur :(

BTW, bien sûr, vous pouvez faire :

$ you_made_a_mistake = false;

Si (Certaines réponses sont manquantes ())

si (Certaines réponses sont dupliquées ())
$ you_made_a_mistake = vrai ;

Si ($ you_made_a_mistake)
SendFormAgain ();

Mais c'est une logique alambiquée !!!

sauter

Cher débutant,

(car je ne vois pas de telles idées se faufiler dans l'esprit des programmeurs expérimentés ...)

S'il vous plaît, ne faites pas attention au message de shadedecho du 14 mars 2003 à 04:02 ! Il s'appuie fortement sur des effets secondaires obscurs, ce qui est non seulement une très mauvaise pratique de programmation, mais n'atteint pas non plus l'optimisation qu'il pense être.

La bonne façon de faire cela

echo $a;
}

Travaillez comme le veut shadedecho (bien que l'exemple dans son ensemble soit plutôt inadapté) :

$ a. = bla ();
$ a. = bla2 ();

Si ($ a) (écho $ a;)

Si vous lisez la discussion à laquelle il renvoie, vous constaterez qu'il voulait vraiment obtenir toutes les entrées distinctes de deux tables de base de données différentes. Là encore, il se trompe. La bonne façon de procéder consiste à traiter la première table, puis à traiter la deuxième table.
Ce n'est pas seulement beaucoup plus lisible que la solution de contournement avec "|", ce n'est pas non plus le moins lent.

ombre decho

Il semble (après des recherches et des discussions très frustrantes mais finalement utiles sur des forums comme tek-tips) que le
|| et le && sont "court-circuités" comme cela a été noté précédemment MAIS le | et les opérateurs & (documentés par PHP en tant qu'opérateurs au niveau du bit) se comportent respectivement comme leurs homologues non court-circuités.

Fonction bof () (
echo " bonjour< br>";
retour "de bla ()< br>";
}

Fonction blah2 () (
echo "monde \< br>";
retour "de blabla2 ()< br>";
}

Si (($ a. = Blah ()) || ($ a. = Blah2 ())) (
echo $a;
}

Cela donnerait le résultat suivant :

Bonjour
de bla ()

Remarquez que le "monde" n'a "pas eu d'écho" d et que le "de blah2 ()" n'a "pas été concaténé" d dans la variable $ a, car la première affectation à $ a a réussi, donc le "court-circuit" démarre et le test booléen se termine sans évaluer le reste.

CEPENDANT, si vous remplacez || avec juste | dans cette instruction "if", vous obtenez la sortie :

Bonjour
monde
de bla ()
de blabla2 ()

Eurêka ! toutes les parties du test booléen sont évaluées, de la manière attendue de gauche à droite, et en suivant toutes les règles de préséance normales, pour autant que je puisse voir.

C'est tout à fait logique... En utilisant les opérateurs au niveau du bit, ce qui se passe est l'opération au niveau du bit sur le résultat de deux opérations non au niveau du bit (les affectations). Si une opération non au niveau du bit renvoie null (en d'autres termes, la valeur attribuée s'avère être nulle ou 0), l'opérateur au niveau du bit se liera à cela (ou, de manière plus appropriée, le « verra ») comme un « 0 », sinon, il verrait un non-zéro (chaîne de bits avec au moins un "1" dedans).

Puis un bitwise | est fait sur les deux valeurs, et si l'une ou l'autre est non nulle (contient des bits "1"), le résultat contiendra ces bits "1" (non nuls), et l'instruction if interprétera tout non- valeur zéro comme vraie dans un test booléen. De même, si les deux opérandes du | étaient nuls ou 0, alors le résultat serait une valeur zéro, que "si" interpréterait comme faux.

L'instruction if ci-dessus effectue un | sur (dans ce cas) deux valeurs non nulles (avec "1" au niveau du bit), donc le | L'opération renvoie une valeur non nulle qui est ensuite réinterprétée par l'instruction if comme TRUE !

Ainsi, dans ce cas particulier où vous essayez d'enchaîner des tests booléens non court-circuités, ces opérateurs travaillent sur leurs opérandes au niveau du bit, et comme ce ne sont pas des opérateurs de comparaison mais des opérateurs mathématiques, ils ne peuvent "pas être court-circuités". et le comportement résultant est un "test booléen" non court-circuité.

Je sais, vous devez penser que je suis fou d'essayer de contourner une optimisation intégrée comme celle-ci, mais je vous assure qu'il y a une très bonne raison à cela, et si cela vous intéresse, vous pouvez consulter ce fil comme je l'ai fait un très long post là-dedans qui explique ce que j'essayais de faire:

C'est le 9ème post vers le bas, où vous trouverez ma description de ma requête de base de données "ing que je voulais optimiser.

Ce qui n'est probablement "pas ce que vous voulez".

Cela peut aider ceux qui aiment que leur code se lise comme de l'anglais, et pourraient penser que les différences de précédence de ces opérateurs sont relativement exotiques : ils ne le sont pas.

Quant à moi, j'ai rencontré ce problème car il n'y a pas de XOR logique symbolique (par exemple, pas de ^^) donc je devais utiliser XOR, puis j'ai pensé qu'à des endroits similaires, je "devrais utiliser AND et OR, puis mon code cassé :)

Alors maintenant, je " dois
$ a = ($ b x ou $ c);

Jesse Thompson
bend.com

yohgaki à hotmail point com

En PHP4, "et", "ou", "&&", "||" - tous sont en "court-circuit" comme en C/C++. En PHP3, je pense que non.

« Court-circuit » signifie que le langage arrête l'évaluation de l'expression lorsque les conditions sont déterminées. (La plupart des langages utilisent une évaluation de court-circuit pour la condition logique)

$ a = vrai ;
$ b = faux ;
si ($ a || $ b) (
}

Cette instruction "if" n'évalue que $ a, puisque $ a est vrai et que la condition entière doit être vraie. (c'est-à-dire si $ b est une fonction au lieu d'une valeur, la fonction ne sera pas appelée)

muerte à web-ster dot com

J'espérais trouver un opérateur similaire aux fonctions || = en perl. Ma première pensée serait :

$ i = $ i ou "par défaut"

Mais ou ne "fonctionne pas comme ça. Si vous souhaitez affecter une valeur par défaut à vos variables uniquement si elles" ne sont pas déjà affectées, vous POUVEZ cependant faire :

$ i ou $ i = "par défaut"

Le premier exemple ne fonctionne PAS car l'opérateur ou n'est pas surchargé comme il l'est en Perl.

dante à heartme point com

Je voulais faire quelque chose comme ça :

$ choix1 = "" ;
$ choix2 = "chien" ;
$ par défaut = "autre" ;
$ val = $ choix1 || $ choix2 || $ par défaut ;

Mais alors $ val1 ne contiendra que 1 ou 0. Au lieu de cela, j'ai fait ceci :

$ choix1 = "" ;
$ choix2 = "chien" ;
$ par défaut = "autre" ;
$ val = $ choix1 ou $ choix2 ou $ par défaut ;

Maintenant, $ val contenait la chaîne "chien". C'est
bizarre que "ou" soit différent de "||" ... et je voudrais
pense que le "||" devrait être assez intelligent pour gérer
chaînes ... comme le fait PERL. Je ne pense pas. Peut-être que c'est
un choix de conception.

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.

Si (état) (
la condition est satisfaite, on fait ça
}
autre
{
la condition n'est pas remplie, nous faisons autrement
}
J'espère que la logique de l'opération conditionnelle est claire. Regardons maintenant un exemple.

$a = 5 ;
$b = 25 ;

// Maintenant attention ! Condition : si $ b est supérieur à $ a
// Signes> et< , как и в математике, обозначают больше и меньше
si ($ b> $ a)
{
// si la condition est remplie, alors nous effectuons cette action
echo "$ b est supérieur à $ a" ;
}
autre
{
// si non satisfait, alors ceci
echo "$ a est supérieur ou égal à $ b" ;
}
?>
Manifestation Télécharger les sources
En conséquence, le script affichera 25 plus que 5... L'exemple est assez simple. J'espère que tout est clair. Je propose maintenant de considérer la situation plus difficile, où plusieurs conditions doivent être réunies. Chaque nouvelle condition contiendra après la condition principale si ()- auxiliaire, qui s'écrit comme sinon si ()... Au final ce sera comme d'habitude autre.

Tâche: Les tests sont effectués à l'école. Le script doit calculer le score, connaissant les conditions d'obtention de chaque note et le score de l'élève lui-même. Voyons comment l'écrire, et n'oubliez pas de lire le commentaire.

$ test = 82 ; // disons qu'un étudiant a écrit un test pour 82 points

// écrire la première condition pour les cinq
si ($ test> 90)
{
// si la condition est remplie, alors nous effectuons cette action.
echo "Catégorie 5" ;
}
// Le signe && signifie "et, union", que la condition est remplie si les deux alors, puis vrai
// c'est-à-dire que le score est inférieur à 91 et supérieur à 80, puis 4. Sinon, les conditions sont lues plus loin
sinon si ($ test< 91 && $test > 80)
{
echo « 4e année » ;
}
sinon si ($ test< 81 && $test > 70)
{
echo "Classe 3" ;
}
autre
{
echo "Je devrais refaire le test...";
}
?>
Manifestation Télécharger les sources
Notre étudiant qui a le temps de se détendre et d'écrire un test obtient normalement niveau 4! Et j'espère que le principe de travail est clair.

Un bref enregistrement de l'opération d'une opération conditionnelle est également possible, lorsque vous n'avez besoin d'une action que si la condition est remplie.

$ âge = 19 ; // variable avec l'âge

Si ($ âge> 17) (
echo "Ça y est ! Je peux faire ce que je veux ! J'ai déjà $ age !";
}
Un bel exemple de notation courte pour une opération conditionnelle. autre il n'est pas nécessaire d'écrire.

Opérateurs de comparaison PHP

Exemple Titre Résultat
$ a == $ b Égal à Vrai si $ a est égal à $ b
$ a === $ b Identiquement vrai si $ a est égal à $ b et que les deux variables sont du même type
$ a! = $ b Différent de True si $ a n'est pas égal à $ b
$ a === $ b Non identique Vrai si $ a n'est pas égal à $ b et que les deux types ne sont pas identiques
$ a> $ b Supérieur à Vrai si $ a est supérieur à $ b
$ un< $b Меньше чем True, если $a меньше, чем $b
$ a> = $ b Supérieur ou égal à Vrai si $ a est supérieur ou égal à $ b
$ un<= $b Меньше или равно True, если $a меньше или равно $b
Voyons maintenant les opérateurs par des exemples:

// contrairement à l'habitude, = signifie affecter une valeur à une variable, et == est égal
si ($a == 5) (
echo "$ a vaut 5" ; // affiche "5 vaut 5"
) autre (
echo "$ a n'est pas égal à 5" ;
}

Si ($ a! = 6) (
echo "$ a n'est pas égal à 6" ; // affichera "5 n'est pas égal à 6". Nécessaire en cas de refus
) autre (
echo "$ a est en quelque sorte égal à 6" ;
}

// avec plus et moins je pense que tout est clair. Donc l'exemple est plus compliqué
si ($ un<= 6){
echo "$ a est inférieur ou égal à 6" ; // affichera "5 est inférieur ou égal à 6"
) autre (
echo "$ a est supérieur à 6" ;
}

Opérateurs logiques PHP

Exemple Titre Résultat
$ a et $ b Booléen et VRAI si à la fois $ a et $ b sont VRAI.
$ a ou $ b Booléen "ou" VRAI si $ a ou $ b est VRAI.
$ a x ou $ b Exclusive ou TRUE si $ a, ou $ b TRUE, mais pas les deux.
! $ a Négation VRAI si $ a n'est pas VRAI.
$ a && $ b Booléen "et" VRAI si à la fois $ a et $ b sont VRAI.
$ un || $ b Booléen ou VRAI si $ a ou $ b est VRAI.
J'ai déjà remarqué que pour les opérations et et ou y a-t-il des opérateurs supplémentaires ? Ceci est fait afin de prioriser les opérations de comparaison complexes. Dans le tableau, les opérateurs logiques sont répertoriés par ordre de priorité : du plus bas au plus élevé, c'est-à-dire, par exemple, || a priorité sur ou.

Nous passons aux exemples

$a = 5 ;
$b = 6 ;
$c = 7 ;

// condition : Si 5 n'est pas égal à 6 (VRAI) ET 6 n'est pas égal à 7 (VRAI)
si ($ un< 6 && $b != $c){
echo "Vraiment !"; // affichera "Vraiment!" puisque LES DEUX conditions sont CORRECTES
) autre (
echo "Une des conditions n'est pas vraie" ;
}

// condition : Si 6 n'est pas égal à 6 (FAUX) OU 6 n'est pas égal à 7 (CORRECT)
si ($ b! = 6 || $ b! = $ c) (
echo "C'est vrai!"; // affiche "C'est vrai!" au moins UNE des conditions est CORRECTE
) autre (
echo "Les deux conditions ne sont pas vraies" ;
}

Opérateur ternaire

L'essentiel du code :(état) ? valeur a si vrai : valeur a si faux

Ainsi, nous raccourcissons la notation de l'instruction if. Cependant, cette opération n'est valable que lors de l'affectation de valeurs à une variable. Voyons maintenant l'exemple terminé.

// Un exemple d'utilisation de l'opérateur ternaire
$ paramètres = (vide ($ _ POST ["paramètres"])) ? "Par défaut": $ _POST ["paramètres"];

// Le code ci-dessus est similaire au bloc suivant utilisant if / else
if (vide ($ _ POST ["paramètres"])) (
$ paramètres = "Par défaut" ; // Si rien n'est passé, laisser "Par défaut"
) autre (
$ paramètres = $ _POST ["paramètres"] ; // Si passé, alors $ settings reçoit la valeur transmise.
}
?>
Lisez les commentaires du code et tout devrait être clair.

Merci pour l'attention!