Le 3 est égal à

Quelle est la différence entre =, ==, et ===?

Je pense que l'utilisation d'un signe égal est de déclarer une variable, alors que les deux signes égal sont pour une condition de comparaison et, enfin, les trois signes égal sont pour comparer les valeurs des variables déclarées.

découvrez l'exemple ... j'ai posté il permettrait de clarifier plusieurs choses ..
Pour l'avancée des utilisateurs de PHP, de connaître la différence entre == et === et en demandant à soi "est-il plus rapide pour comparer avec == ou avec === quand je suis sûr que les deux opérandes sont de même type?", merci de regarder ma référence en matière de script ci-dessous.
Je sens la question de la balise doit également inclure la javascript de la balise, car il s'applique également à cette langue.
(Update): j'ai ajouté la balise javascript dans un edit, depuis il y a eu pas mal de questions où les gens ont été en utilisant = en javascript. Cela ne s'applique pas uniquement à PHP, mais d'autres langues également.
Je suis allé de l'avant et supprimé la balise JavaScript: toutes les réponses ici sont uniquement à propos de PHP (à l'exception de la dernière qui est très faible), il y a des différences entre la manière dont les langues de la poignée, et il y a déjà une similaire de facto canonique JavaScript question (Qui est égal à l'opérateur (== vs ===) devrait être utilisé en JavaScript comparaisons?).

InformationsquelleAutor Strawberry | 2010-01-14

170

Vous avez = la opérateur d'affectation, == la 'égal' opérateur de comparaison et === la 'identique' opérateur de comparaison.
```
$a = $b     Assign      Sets $a to be equal to $b.
$a == $b    Equal       TRUE if $a is equal to $b.
$a === $b   Identical   TRUE if $a is equal to $b, and they are of the same type. (introduced in PHP 4)
```
Pour plus d'info sur la nécessité pour == et ===, et les situations d'utilisation de chacun, regardez les docs.
- quand je compare les deux identiques datetime, j'ai de résultat faux, pourquoi ? exemple : sandbox.onlinephpfunctions.com/code/...
- avec des objets qui vous indique si elles sont le même objet, pas si ils ont le même contenu.
- Introduit en PHP4, drôle dans Y2018 😉
InformationsquelleAutor gnarf
22
- = est l'opérateur d'affectation
- ==
  est l'opérateur de comparaison (vérifie si
  deux variables ont des valeurs égales)
- === est l'identique de comparaison
  opérateur (vérifie si les deux variables
  ont des valeurs égales et sont de la même
  type).
InformationsquelleAutor Rich Adams
8

opérateur d'affectation =

== vérifie si deux variables ont la même valeur

=== vérifie si deux variables ont la même valeur ET si leurs types sont les mêmes
- Également le savoir != et !== "pas des" versions des deux opérateurs de comparaison. Certaines langues utilisent := comme la cession, juste pour éviter ce genre de confusion.
InformationsquelleAutor Silvio Donnini
2

L'opérateur = n'affecte la valeur à une variable
$six = 6; la valeur 6 est assignée à la variable $six

== opérateur de vérifier si la valeur des deux variables est égale et principalement utilisés dans des conditions telles que si les déclarations
```
$a = 2;
$b = 2;
if ($a == $b) { 
    echo both variables have the same value; 
}
```
=== opérateur similaire à == (vérifier si la valeur est égal à) et également de vérifier si les deux du même type de données
```
$a = 2;
$b = "2";
if ($a === $b) {
    echo "both variable have same value and of same data type";
} else {
    echo 'both variable is either not equal or not of same data type';
}
```
//ici $a est de type int alors que $b est de type string. Donc, ici, la sortie

InformationsquelleAutor Gideon
0

Pour l'avancée des utilisateurs de PHP, de connaître la différence entre ==et === et de se demander "est-il plus rapide pour comparer avec == ou avec === quand je suis sûr que les deux opérandes sont de même type?"

Court et de manière générale, la réponse est: Il n'y a pas de gain de performance à l'aide de === dans ce cas, vous devriez probablement utiliser ==.

Pour ceux intéressés à l'analyse comparative eux-mêmes, vous pouvez utiliser le code suivant, j'ai écrit ad-hoc et d'essayer différentes valeurs pour $a et $b:
```
<?php
//CONFIGURATION
$cycles = 1000000;
$a = 'random string 1';
$b = 'random string 2';
//FUNCTIONS
function compare_two_equals($a, $b) {
if ($a == $b) {
return TRUE;
} else {
return FALSE;
}
}
function compare_three_equals($a, $b) {
if ($a === $b) {
return TRUE;
} else {
return FALSE;
}
}
//EXECUTION
$time = microtime(TRUE);
for ($count_a = 0; $count_a < $cycles; $count_a++) {
compare_two_equals($a, $b);
}
$time_two_a = microtime(TRUE) - $time;
$time = microtime(TRUE);
for ($count_a = 0; $count_a < $cycles; $count_a++) {
compare_three_equals($a, $b);
}
$time_three_a = microtime(TRUE) - $time;
$time = microtime(TRUE);
for ($count_a = 0; $count_a < $cycles; $count_a++) {
compare_two_equals($a, $b);
}
$time_two_b = microtime(TRUE) - $time;
$time = microtime(TRUE);
for ($count_a = 0; $count_a < $cycles; $count_a++) {
compare_three_equals($a, $b);
}
$time_three_b = microtime(TRUE) - $time;
$time = microtime(TRUE);
//RESULTS PRINTING
print "<br />\nCOMPARE == (FIRST TRY): " . number_format($time_two_a, 3) . " seconds";
print "<br />\nCOMPARE == (SECOND TRY): " . number_format($time_two_b, 3) . " seconds";
print "<br />\nCOMPARE === (FIRST TRY): " . number_format($time_three_a, 3) . " seconds";
print "<br />\nCOMPARE === (SECOND TRY): " . number_format($time_three_b, 3) . " seconds";
?>
```
NOTE: La comparaison est valide seulement lors de chaque "PREMIER essai" est très proche de sa "SECONDE chance". Si ils sont nettement différents, cela signifie que le processeur est occupé à faire autre chose pendant l'exécution des comparaisons et donc les résultats ne sont pas fiables et le point de référence doit être exécuté de nouveau.
- Microbenchmarks comme ce ne sont pas très fiables. Il est également très peu probable que vous avez envie de vous inquiéter à propos de == ou === comme la cause de votre problème de performances. OMI: C'est mieux d'être strict ( === ), à moins que vous ne souhaitiez être lâche (==) à propos de vos comparaisons. Le nombre d'étrange cas de bord c'est à dire "5 is not a number" == 5 peut conduire à des farfelus de bugs. === de ne jamais souffrir de ce problème.
- Mon test a été de dire programmeurs que s'ils sont le choix === pour des raisons de performances, ils ont tort. Si les programmeurs sont libres de choisir === ou == fondée sur des raisons logiques, mais pas sur les raisons de performances: il existe différents cas de préférer l'un ou l'autre et de la performance ne doit pas être pris en compte à tous.
InformationsquelleAutor lucaferrario

Vous devez vous connecter pour publier un commentaire.