Os 3 iguais iguais

149

Qual é a diferença entre =, ==e ===?

Eu acho que usar um sinal de igual é declarar uma variável, enquanto dois são iguais para uma condição de comparação e, finalmente, três são iguais para comparar valores de variáveis ​​declaradas.

morango
fonte
Confira o exemplo ... Eu
publiquei
1
Para usuários avançados de PHP, sabendo a diferença entre == e === e se perguntando "é mais rápido comparar com == ou com === quando tenho certeza de que ambos os operandos são do mesmo tipo?", Veja no meu script de benchmark abaixo.
Lucaferrario
@Strawberry Acho que a tag da pergunta também deve incluir a tag javascript, pois também se aplica a esse idioma.
Funk Quarenta Niner
(Atualização): adicionei a tag javascript em uma edição, pois houve algumas perguntas nas quais as pessoas estavam usando =javascript. Isso não se aplica apenas ao PHP, mas também a outras linguagens.
Funk Quarenta Niner
Fui em frente e apagado a tag JavaScript: todas as respostas aqui são apenas cerca de PHP (exceto a última, que é muito fraco), não são diferenças entre como as línguas lidar com isso, e já existe um facto canônica questão JavaScript semelhante de ( o que equivale O operador (== vs ===) deve ser usado nas comparações de JavaScript? ).
21418 JJJ

Respostas:

172

Você tem =o operador de atribuição , ==o operador de comparação 'igual' e ===o operador de comparação 'idêntico' .

$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)

Para mais informações sobre a necessidade de ==e ===e situações para usar cada um, olhar para os docs .

gnarf
fonte
quando comparo dois datetime idênticos, tenho resultado falso, por quê? exemplo: sandbox.onlinephpfunctions.com/code/…
stloc 8/16
3
@stloc, ===with objects diz se eles são o mesmo objeto, não se eles têm o mesmo conteúdo.
Andrea
Introduzido no PHP4, engraçado em Y2018 ;-)
mvorisek
22
  • = é o operador de atribuição
  • == é o operador de comparação (verifica se duas variáveis ​​têm valores iguais)
  • === é o operador de comparação idêntico (verifica se duas variáveis ​​têm valores iguais e são do mesmo tipo).
Rich Adams
fonte
8

= operador de atribuição

== verifica se duas variáveis ​​têm o mesmo valor

=== verifica se duas variáveis ​​têm o mesmo valor E se seus tipos são iguais

Silvio Donnini
fonte
1
Conheça também as versões! = E! == 'not' dos dois operadores de comparação. Alguns idiomas usam: = como atribuição, apenas para evitar esse tipo de confusão.
Phil Perry
3

O operador = atribui o valor a uma variável $ six = 6; o valor 6 é atribuído à variável $ seis

== operador verifica se o valor de ambas as variáveis ​​é igual e usado principalmente em condições como instruções if

$a = 2;
$b = 2;
if ($a == $b) { 
    echo both variables have the same value; 
}

=== operador semelhante a == (verifique se o valor é igual) e também verifique se ambos do mesmo tipo de dados

$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';
}

// aqui $ a é do tipo int, enquanto $ b é do tipo string. Então aqui a saída

Gideon Babu
fonte
0

Para usuários avançados de PHP, sabendo a diferença entre ==e ===perguntando a si mesmos "é mais rápido comparar com ==ou com ===quando tenho certeza de que os dois operandos são do mesmo tipo?"

A resposta curta e geral é: Não há ganho de desempenho no uso ===nesses casos; portanto, você provavelmente deve usá-lo ==.

Para os interessados ​​em compará-lo eles mesmos, você pode usar o seguinte código que escrevi ad-hoc e tentar diferentes valores para $ae $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";
?>

NOTA: A comparação é válida apenas quando cada "PRIMEIRA TENTATIVA" estiver muito próxima da "SEGUNDA TENTATIVA". Se forem significativamente diferentes, significa que o processador estava ocupado fazendo outra coisa enquanto executava as comparações e, portanto, os resultados não são confiáveis ​​e o benchmark deve ser executado novamente.

lucaferrario
fonte
9
Microbenchmarks como este não são muito confiáveis. Também é altamente improvável que você queira se preocupar ==ou ===como a causa do seu problema de desempenho. IMO: É melhor ser rigoroso ( ===), a menos que você queira se libertar explicitamente ( ==) de suas comparações. O número de casos extremos estranhos, ou seja, "5 is not a number" == 5pode levar a erros malucos. ===nunca sofre com esse problema.
Gnarf #
Meu teste foi dizer aos programadores que, se eles estão escolhendo ===por razões de desempenho, estão errados. Portanto, os programadores são livres para escolher ===ou com ==base em razões lógicas, mas não em razões de desempenho: existem casos diferentes para preferir um ou outro e o desempenho não deve ser levado em consideração.
Lucaferrario