Comment les opérateurs de comparaison d'égalité PHP (== double égal) et d'identité (=== triple égal) sont-ils différents?


Quelle est la difference entre == et === ?

  • Comment exactement la comparaison lâche fonctionne-t-elle?
  • Comment fonctionne exactement la comparaison stricte === ?

Quels seraient des exemples utiles?



Answers


Différence entre == et ===

La différence entre l'opérateur lâche == égal et l'opérateur strict === est exactement expliqué dans le manuel :

Opérateurs de comparaison

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ Example  │ Name      │ Result                                                    │
├──────────┼───────────┼───────────────────────────────────────────────────────────┤
│$a ==  $b │ Equal     │ TRUE if $a is equal to $b after type juggling.            │
│$a === $b │ Identical │ TRUE if $a is equal to $b, and they are of the same type. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

Vaguement == comparaison égale

Si vous utilisez l'opérateur == , ou tout autre opérateur de comparaison qui utilise une comparaison approximative telle que != , <> Ou == , vous devez toujours regarder le contexte pour voir quoi, où et pourquoi quelque chose est converti pour comprendre ce que qui se passe.

Règles de conversion

Type de tableau de comparaison

Comme référence et exemple, vous pouvez voir le tableau de comparaison dans le manuel :

Comparaisons lâches avec ==

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤
│ TRUE    │ TRUE  │ FALSE │ TRUE  │ FALSE │ TRUE  │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE   │ TRUE  │ FALSE │
│ FALSE   │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ TRUE  │ TRUE    │ FALSE │ TRUE  │
│ 1       │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 0       │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE   │ TRUE  │ TRUE  │
│ -1      │ TRUE  │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "1"     │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "0"     │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "-1"    │ TRUE  │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ NULL    │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ TRUE    │ FALSE │ TRUE  │
│ array() │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ TRUE    │ FALSE │ FALSE │
│ "php"   │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ TRUE  │ FALSE │
│ ""      │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE   │ FALSE │ TRUE  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

Strict === comparaison identique

Si vous utilisez l'opérateur === , ou tout autre opérateur de comparaison qui utilise une comparaison stricte telle que !== ou === , vous pouvez toujours être sûr que les types ne changeront pas comme par magie , car il n'y aura pas de conversion passe. Donc, avec une comparaison stricte, le type et la valeur doivent être les mêmes, pas seulement la valeur.

Type de tableau de comparaison

Comme référence et exemple, vous pouvez voir le tableau de comparaison dans le manuel :

Comparaisons strictes avec ===

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ TRUE  │ FALSE │   1   │   0   │  -1   │  "1"  │  "0"  │ "-1"  │ NULL  │ array() │ "php" │  ""   │
├─────────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼───────┼─────────┼───────┼───────┤
│ TRUE    │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ FALSE   │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 1       │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 0       │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ -1      │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "1"     │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "0"     │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "-1"    │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ NULL    │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE   │ FALSE │ FALSE │
│ array() │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE    │ FALSE │ FALSE │
│ "php"   │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ TRUE  │ FALSE │
│ ""      │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ TRUE  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘



L'opérateur == diffuse entre deux types différents s'ils sont différents, tandis que l'opérateur === effectue une 'comparaison de typesafe'. Cela signifie qu'il ne retournera vrai que si les deux opérandes ont le même type et la même valeur.

Exemples:

1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value

Attention : deux instances de la même classe avec des membres équivalents ne correspondent PAS à l'opérateur === . Exemple:

$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)



En ce qui concerne JavaScript:

L'opérateur === fonctionne de la même manière que l'opérateur ==, mais il requiert que ses opérandes aient non seulement la même valeur, mais aussi le même type de données.

Par exemple, l'exemple ci-dessous affichera 'x et y sont égaux', mais pas 'x et y sont identiques'.

var x = 4;
var y = '4';
if (x == y) {
    alert('x and y are equal');
}
if (x === y) {
    alert('x and y are identical');
}



Une image vaut mieux que mille mots:

PHP Double Equals == graphique d'égalité:

PHP Triple Equals === Tableau d'égalité:

Code source pour créer ces images:

https://github.com/sentientmachine/php_equality_charts

Guru Méditation

Ceux qui souhaitent garder leur santé mentale, ne lisez pas plus loin.

  1. '==' convertit les opérandes gauche et droit en nombres si possible (123 == "123foo", mais "123"! = "123foo"
  2. Une chaîne hexadécimale entre guillemets est parfois un float et sera casté contre votre volonté.
  3. == n'est pas transitif parce que ("0" est == à 0, et 0 est == à "" mais "0"! = "")
  4. "6" == "6", "4.2" == "4.20" et "133" == "0133". Mais 133! = 0133, car 0133 est octal. Mais "0x10" == "16" et "1e3" == "1000"
  5. PHP Les variables qui n'ont pas encore été déclarées sont fausses.

  6. False est égal à 0, blankstring et array vide et "0".

  7. Quand les nombres sont assez grands, ils sont == Infinity.
  8. NAN n'est pas == lui-même, mais c'est vrai.

  9. Une nouvelle classe est == à 1.

  10. False est la valeur la plus dangereuse car False est == à la plupart des autres variables, la plupart du temps à l'encontre de son but.

Espérer:

Si vous utilisez PHP, vous n'utiliserez pas l'opérateur double equals, utilisez toujours triple equals.




Un complément aux autres réponses concernant la comparaison d'objets:

== compare les objets en utilisant le nom de l'objet et leurs valeurs. Si deux objets sont du même type et ont les mêmes valeurs membres, $a == $b renvoie true.

=== compare l'ID d'objet interne des objets. Même si les membres sont égaux, $a !== $b s'ils ne sont pas exactement le même objet.

class TestClassA {
    public $a;
}

class TestClassB {
    public $a;
}

$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();

$a1->a = 10;
$a2->a = 10;
$b->a = 10;

$a1 == $a1;
$a1 == $a2;  // Same members
$a1 != $b;   // Different classes

$a1 === $a1;
$a1 !== $a2; // Not the same object



En termes simples:

== vérifie si équivalent (valeur seulement)

=== vérifie si la même chose (valeur && type)


Équivalent vs. Même: une analogie

1 + 1 = 2 + 0 (équivalent)

1 + 1 = 1 + 1 (même chose)


En PHP:

vrai == 1 (vrai - équivalent en valeur)

vrai === 1 (faux - pas la même valeur && type)

  • true est booléen
  • 1 est int



Tout tourne autour des types de données. Prenez un BOOL (vrai ou faux) par exemple:

true est égal à 1 et false est égal à 0

Le == ne se soucie pas des types de données lors de la comparaison: Donc si vous aviez une variable qui est 1 (ce qui pourrait aussi être true ):

$var=1;

Et puis comparez avec le == :

if ($var == true)
{
    echo"var is true";
}

Mais $var n'est pas vraiment true , n'est-ce pas? Il a la valeur int de 1 place, ce qui, à son tour, est égal à vrai.

Avec === , les types de données sont vérifiés pour s'assurer que les deux variables / objets / tout utilisent le même type.

Donc si je l'ai fait

if ($var === true)
{
    echo "var is true";
}

cette condition ne serait pas vraie, car $var !== true it only == true (si vous savez ce que je veux dire).

Pourquoi auriez-vous besoin de cela?

Simple - jetons un coup d'œil à l'une des fonctions de PHP: array_search() :

La fonction array_search() recherche simplement une valeur dans un tableau et renvoie la clé de l'élément dans array_search() la valeur a été trouvée. Si la valeur n'a pas pu être trouvée dans le tableau, elle renvoie false . Mais, que faire si vous avez fait un array_search() sur une valeur qui a été stockée dans le premier élément du tableau (qui aurait la valeur array array de 0 ) .... la fonction array_search() retournera 0 ... qui est égal à faux ..

Donc si vous avez fait:

$arr = array("name");
if (array_search("name", $arr) == false)
{
    // This would return 0 (the key of the element the val was found
    // in), but because we're using ==, we'll think the function
    // actually returned false...when it didn't.
}

Alors, voyez-vous comment cela pourrait être un problème maintenant?

La plupart des gens n'utilisent pas == false lorsqu'ils vérifient si une fonction renvoie false. Au lieu de cela, ils utilisent le ! . Mais en fait, c'est exactement la même chose que d'utiliser ==false , donc si vous avez:

$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)

Donc, pour des choses comme ça, vous utiliserez le === place, de sorte que le type de données est vérifié.




Un exemple est qu'un attribut de base de données peut être null ou "":

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true



Donné x = 5

1) Opérateur: == est "égal à". x == 8 est faux
2) Opérateur: === est "exactement égal à" (valeur et type) x === 5 est vrai, x === "5" est faux




$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

Soyez prudent cependant. Voici un problème notoire.

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

contre.

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}



En résumé, === fonctionne de la même manière que == dans la plupart des autres langages de programmation.

PHP vous permet de faire des comparaisons qui n'ont pas vraiment de sens. Exemple:

$y = "wauv";
$x = false;
if ($x == $y)
    ...

Bien que cela permette des "raccourcis" intéressants, vous devriez vous méfier car une fonction qui retourne quelque chose qu'elle ne devrait pas (comme "erreur" au lieu d'un nombre) ne sera pas attrapée, et vous vous demanderez ce qui s'est passé.

En PHP, == compare les valeurs et effectue une conversion de type si nécessaire (par exemple, la chaîne "12343sdfjskfjds" deviendra "12343" dans une comparaison entière). === va comparer la valeur AND type et retournera false si le type n'est pas le même.

Si vous regardez dans le manuel de PHP, vous verrez que beaucoup de fonctions retournent "false" si la fonction échoue, mais elles pourraient retourner 0 dans un scénario réussi, c'est pourquoi ils recommandent de faire "if (function ()! faux) "pour éviter les erreurs.




Quelques exemples

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

PS

== Compare uniquement la valeur, cela ne dérange pas les types de données

contre.

=== Compare les valeurs et les types de données




Vous utiliseriez === pour tester si une fonction ou une variable est fausse plutôt que de simplement l'affecter à false (zéro ou une chaîne vide).

$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' was not found in ' . $haystack;
} else {
    echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}

Dans ce cas, strpos retournera 0 ce qui équivaudrait à faux dans le test

if ($pos == false)

ou

if (!$pos)

ce qui n'est pas ce que tu veux ici.




Quant à savoir quand utiliser l'un sur l'autre, prenons par exemple la fonction fwrite() en PHP.

Cette fonction écrit le contenu dans un flux de fichier. Selon PHP, " fwrite() renvoie le nombre d'octets écrits, ou FALSE en cas d'erreur.". Si vous voulez tester si l'appel de fonction a réussi, cette méthode est erronée:

if (!fwrite(stuff))
{
    log('error!');
}

Il peut retourner zéro (et est considéré comme réussi), et votre condition est toujours déclenchée. La bonne façon serait:

if (fwrite(stuff) === FALSE)
{
    log('error!');
}



Les variables ont un type et une valeur.

  • $ var = "test" est une chaîne contenant "test"
  • $ var2 = 24 est un entier dont la valeur est 24.

Lorsque vous utilisez ces variables (en PHP), vous n'avez parfois pas le bon type. Par exemple, si vous faites

if ($var == 1) {... do something ...}

PHP doit convertir ("lancer") $ var en entier. Dans ce cas, "$ var == 1" est vrai car toute chaîne non vide est castée à 1.

Lorsque vous utilisez ===, vous vérifiez que la valeur AND THE TYPE est égale, donc "$ var === 1" est faux.

Ceci est utile, par exemple, lorsque vous avez une fonction qui peut retourner false (en cas d'erreur) et 0 (résultat):

if(myFunction() == false) { ... error on myFunction ... }

Ce code est faux, comme si myFunction() renvoie 0, il est converti en false et vous semblez avoir une erreur. Le code correct est:

if(myFunction() === false) { ... error on myFunction ... }

parce que le test est que la valeur de retour "est un booléen et est faux" et non "peut être casté en faux".




L'opérateur === est supposé comparer l'égalité de contenu exacte tandis que l'opérateur == comparerait l'égalité sémantique. En particulier, il va contraindre les chaînes à des chiffres.

L'égalité est un vaste sujet. Voir l'article de Wikipédia sur l'égalité .




<?php

    /**
     * Comparison of two PHP objects                         ==     ===
     * Checks for
     * 1. References                                         yes    yes
     * 2. Instances with matching attributes and its values  yes    no
     * 3. Instances with different attributes                yes    no
     **/

    // There is no need to worry about comparing visibility of property or
    // method, because it will be the same whenever an object instance is
    // created, however visibility of an object can be modified during run
    // time using ReflectionClass()
    // http://php.net/manual/en/reflectionproperty.setaccessible.php
    //
    class Foo
    {
        public $foobar = 1;

        public function createNewProperty($name, $value)
        {
            $this->{$name} = $value;
        }
    }

    class Bar
    {
    }
    // 1. Object handles or references
    // Is an object a reference to itself or a clone or totally a different object?
    //
    //   ==  true   Name of two objects are same, for example, Foo() and Foo()
    //   ==  false  Name of two objects are different, for example, Foo() and Bar()
    //   === true   ID of two objects are same, for example, 1 and 1
    //   === false  ID of two objects are different, for example, 1 and 2

    echo "1. Object handles or references (both == and    ===) <br />";

    $bar = new Foo();    // New object Foo() created
    $bar2 = new Foo();   // New object Foo() created
    $baz = clone $bar;   // Object Foo() cloned
    $qux = $bar;         // Object Foo() referenced
    $norf = new Bar();   // New object Bar() created
    echo "bar";
    var_dump($bar);
    echo "baz";
    var_dump($baz);
    echo "qux";
    var_dump($qux);
    echo "bar2";
    var_dump($bar2);
    echo "norf";
    var_dump($norf);

    // Clone: == true and === false
    echo '$bar == $bar2';
    var_dump($bar == $bar2); // true

    echo '$bar === $bar2';
    var_dump($bar === $bar2); // false

    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    echo '$bar === $baz';
    var_dump($bar === $baz); // false

    // Object reference: == true and === true
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    echo '$bar === $qux';
    var_dump($bar === $qux); // true

    // Two different objects: == false and === false
    echo '$bar == $norf';
    var_dump($bar == $norf); // false

    echo '$bar === $norf';
    var_dump($bar === $norf); // false

    // 2. Instances with matching attributes and its values (only ==).
    //    What happens when objects (even in cloned object) have same
    //    attributes but varying values?

    // $foobar value is different
    echo "2. Instances with matching attributes  and its values (only ==) <br />";

    $baz->foobar = 2;
    echo '$foobar' . " value is different <br />";
    echo '$bar->foobar = ' . $bar->foobar . "<br />";
    echo '$baz->foobar = ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false

    // $foobar's value is the same again
    $baz->foobar = 1;
    echo '$foobar' . " value is the same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    // Changing values of properties in $qux object will change the property
    // value of $bar and evaluates true always, because $qux = &$bar.
    $qux->foobar = 2;
    echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
    echo '$qux->foobar is ' . $qux->foobar . "<br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    // 3. Instances with different attributes (only ==)
    //    What happens when objects have different attributes even though
    //    one of the attributes has same value?
    echo "3. Instances with different attributes (only ==) <br />";

    // Dynamically create a property with the name in $name and value
    // in $value for baz object
    $name = 'newproperty';
    $value = null;
    $baz->createNewProperty($name, $value);
    echo '$baz->newproperty is ' . $baz->{$name};
    var_dump($baz);

    $baz->foobar = 2;
    echo '$foobar' . " value is same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false
    var_dump($bar);
    var_dump($baz);
?>



PHP est un langage faiblement typé. L'utilisation de l'opérateur double égal permet une vérification approximative d'une variable.

La vérification approximative d'une valeur permettrait d'égaler des valeurs similaires mais non égales:

  • ''
  • nul
  • faux
  • 0

Toutes ces valeurs seraient égales en utilisant l'opérateur double égal.




Toutes les réponses ignorent jusqu'à présent un problème dangereux avec ===. Il a été noté en passant, mais pas souligné, que l'entier et le double sont des types différents, donc le code suivant:

$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );

donne:

 equal
 not equal

Notez qu'il ne s'agit PAS d'une "erreur d'arrondi". Les deux nombres sont exactement égaux jusqu'au dernier bit, mais ils ont des types différents.

C'est un vilain problème car un programme utilisant === peut fonctionner avec bonheur pendant des années si tous les nombres sont assez petits (où "assez petit" dépend du matériel et de l'OS que vous utilisez). Cependant, si par hasard, un nombre entier est suffisamment grand pour être converti en double, son type est changé "pour toujours" même si une opération ultérieure, ou de nombreuses opérations, peut le ramener à un petit entier en valeur. Et, ça devient pire. Il peut se propager - l'infection double-ness peut être transmise à tout ce qu'elle touche, un calcul à la fois.

Dans le monde réel, cela risque d'être un problème dans les programmes qui traitent des dates au-delà de l'année 2038, par exemple. À ce moment, les horodatages UNIX (nombre de secondes depuis 1970-01-01 00:00:00 UTC) nécessiteront plus de 32 bits, de sorte que leur représentation passera «magiquement» au double sur certains systèmes. Par conséquent, si vous calculez la différence entre deux temps, vous pourriez vous retrouver avec quelques secondes, mais en double, plutôt que le nombre entier qui se produit en l'an 2017.

Je pense que c'est bien pire que les conversions entre les chaînes et les nombres parce que c'est subtil. Je trouve facile de garder une trace de ce qui est une chaîne et ce qui est un nombre, mais le suivi du nombre de bits dans un nombre me dépasse.

Donc, dans les réponses ci-dessus, il y a quelques belles tables, mais pas de distinction entre 1 (entier) et 1 (double subtil) et 1.0 (double évident). De plus, le conseil que vous devriez toujours utiliser === et jamais == n'est pas génial parce que === échouera parfois où == fonctionne correctement. De plus, JavaScript n'est pas équivalent à cet égard car il n'a qu'un seul type de nombre (en interne il peut avoir différentes représentations par bits, mais cela ne pose pas de problèmes pour ===).

Mon conseil - n'utilisez ni l'un ni l'autre. Vous devez écrire votre propre fonction de comparaison pour vraiment réparer ce gâchis.