In che modo differiscono gli operatori di confronto di uguaglianza PHP (== doppio uguale) e identità (=== triplo uguale)?


Qual è la differenza tra == e === ?

  • Come funziona esattamente il confronto approssimativo == ?
  • Come funziona esattamente il confronto rigoroso === ?

Quali sarebbero alcuni esempi utili?



Answers



Differenza tra == e ===

La differenza tra l'operatore uguale == uguale e l'operatore === identico è esattamente spiegata nel manuale :

Operatori di confronto

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ 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. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

Adeguatamente == confronto uguale

Se stai usando l'operatore == , o qualsiasi altro operatore di confronto che usa un confronto approssimativo come != , <> O == , devi sempre guardare il contesto per vedere cosa, dove e perché qualcosa viene convertito per capire cosa sta succedendo.

Convertire le regole

Digitare la tabella di confronto

Come riferimento ed esempio puoi vedere la tabella comparativa nel manuale :

Paragoni allentati con ==

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

Rigoroso === confronto identico

Se stai usando l'operatore === , o qualsiasi altro operatore di confronto che usa un confronto rigoroso come !== o === , allora puoi sempre essere sicuro che i tipi non cambieranno magicamente , perché non ci sarà alcuna conversione andando avanti. Quindi, con un confronto rigoroso, il tipo e il valore devono essere gli stessi, non solo il valore.

Digitare la tabella di confronto

Come riferimento ed esempio puoi vedere la tabella comparativa nel manuale :

Confronti rigorosi con ===

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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'operatore == esegue il cast tra due diversi tipi se sono diversi, mentre l'operatore === esegue un "confronto typesafe". Ciò significa che restituirà true solo se entrambi gli operandi hanno lo stesso tipo e lo stesso valore.

Esempi:

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

Attenzione : due istanze della stessa classe con membri equivalenti NON corrispondono all'operatore === . Esempio:

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



Per quanto riguarda JavaScript:

L'operatore === funziona come l'operatore ==, ma richiede che i suoi operandi abbiano non solo lo stesso valore, ma anche lo stesso tipo di dati.

Ad esempio, l'esempio seguente mostrerà 'x e y sono uguali', ma non 'x e y sono identici'.

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



Un'immagine vale più di mille parole:

Doppio Equals di PHP == grafico sull'uguaglianza:

PHP Triple Equals === Tabella delle uguaglianze:

Codice sorgente per creare queste immagini:

https://github.com/sentientmachine/php_equality_charts

Meditazione Guru

Coloro che desiderano mantenere la loro sanità mentale, non leggere oltre.

  1. '==' converte gli operandi sinistro e destro in numeri quando possibile (123 == "123foo", ma "123"! = "123foo"
  2. Una stringa esadecimale tra virgolette è occasionalmente un galleggiante e verrà castata contro di essa.
  3. == non è transitivo perché ("0" è == a 0, e 0 è == a "" ma "0"! = "")
  4. "6" == "6", "4.2" == "4.20" e "133" == "0133". Ma 133! = 0133, perché 0133 è ottale. Ma "0x10" == "16" e "1e3" == "1000"
  5. Le variabili PHP che non sono state ancora dichiarate sono false.

  6. False è uguale a 0, stringa vuota e matrice vuota e "0".

  7. Quando i numeri sono abbastanza grandi sono == Infinity.
  8. NAN non == stesso, ma è vero.

  9. Una nuova classe è == a 1.

  10. False è il valore più pericoloso perché False è == alla maggior parte delle altre variabili, per lo più sconfiggendo il suo scopo.

Speranza:

Se stai usando PHP, non usi l'operatore doppio uguale, usa sempre l'equazione tripla.




Un'aggiunta alle altre risposte relative al confronto degli oggetti:

== confronta gli oggetti usando il nome dell'oggetto e i loro valori. Se due oggetti sono dello stesso tipo e hanno gli stessi valori membro, $a == $b restituisce true.

=== confronta l'ID dell'oggetto interno degli oggetti. Anche se i membri sono uguali, $a !== $b se non sono esattamente lo stesso oggetto.

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



In termini più semplici:

== controlla se equivalente (solo valore)

=== controlla se lo stesso (valore e tipo)


Equivalente rispetto a Same: An Analogy

1 + 1 = 2 + 0 (equivalente)

1 + 1 = 1 + 1 (stesso)


In PHP:

true == 1 (true - equivalente in valore)

true === 1 (falso - non uguale in valore e tipo)

  • il vero è booleano
  • 1 è int



È tutto basato sui tipi di dati. Prendi un BOOL (vero o falso) per esempio:

true eguaglia anche 1 e false eguaglia 0

== non si preoccupa dei tipi di dati durante il confronto: quindi se avessi una variabile che è 1 (che potrebbe anche essere true ):

$var=1;

E poi confronta con == :

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

Ma $var realtà non è uguale true , true ? Ha invece il valore int di 1 , che a sua volta è uguale a true.

Con === , i tipi di dati vengono controllati per assicurarsi che le due variabili / oggetti / qualsiasi cosa stiano usando lo stesso tipo.

Quindi se l'avessi fatto

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

quella condizione non sarebbe vera, dato che $var !== true è solo == true (se sai cosa intendo).

Perché dovresti aver bisogno di questo?

Semplice: diamo un'occhiata a una delle funzioni di PHP: array_search() :

La funzione array_search() cerca semplicemente un valore in un array e restituisce la chiave dell'elemento in cui è stato trovato il valore. Se il valore non è stato trovato nell'array, restituisce false . Ma, cosa succede se hai fatto un array_search() su un valore che è stato memorizzato nel primo elemento dell'array (che avrebbe la chiave dell'array di 0 ) .... la funzione array_search() restituirebbe 0 ... che è uguale a falso ..

Quindi se l'hai fatto:

$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.
}

Quindi, vedi come questo potrebbe essere un problema ora?

La maggior parte delle persone non usa == false quando verifica se una funzione restituisce false. Invece, usano il ! . Ma in realtà, questo è esattamente lo stesso di usare ==false , quindi se lo facessi:

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

Quindi, per cose del genere, dovresti usare il === invece, in modo che il tipo di dati sia selezionato.




Un esempio è che un attributo del database può essere nullo o "":

$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



Dato x = 5

1) Operatore: == è "uguale a". x == 8 è falso
2) Operatore: === è "esattamente uguale a" (valore e tipo) x === 5 è vero, x === "5" è falso




$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

Stai attento però. Ecco un problema famigerato.

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

vs.

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



In breve, === funziona nello stesso modo che == fa nella maggior parte degli altri linguaggi di programmazione.

PHP ti permette di fare paragoni che non hanno molto senso. Esempio:

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

Sebbene ciò consenta alcune "scorciatoie" interessanti, dovresti fare attenzione, poiché una funzione che restituisce qualcosa che non dovrebbe (come "errore" invece di un numero) non verrà catturata, e ti verrà chiesto cosa è successo.

In PHP, == confronta i valori ed esegue la conversione del tipo, se necessario (ad esempio, la stringa "12343sdfjskfjds" diventerà "12343" in un confronto in interi). === confronterà il valore AND type e restituirà false se il tipo non è lo stesso.

Se guardi nel manuale PHP, vedrai che molte funzioni restituiscono "false" se la funzione fallisce, ma potrebbero restituire 0 in uno scenario di successo, motivo per cui raccomandano di fare "if (function ()! == falso) "per evitare errori.




Pochi degli esempi

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

== Confronta solo il valore, non si preoccuperà dei tipi di dati

vs.

=== Confronta i valori e i tipi di dati




Dovresti usare === per verificare se una funzione o una variabile è falsa invece di essere semplicemente uguale a false (zero o una stringa vuota).

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

In questo caso lo strpos restituirebbe 0 che equivarrebbe a falso nel test

if ($pos == false)

o

if (!$pos)

che non è quello che vuoi qui.




Per quanto riguarda quando utilizzare uno sull'altro, prendi ad esempio la funzione fwrite() in PHP.

Questa funzione scrive il contenuto in un flusso di file. Secondo PHP, " fwrite() restituisce il numero di byte scritti, o FALSE in caso di errore.". Se si desidera verificare se la chiamata alla funzione ha avuto esito positivo, questo metodo è difettoso:

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

Può restituire zero (ed è considerato successo) e la tua condizione viene comunque attivata. La strada giusta sarebbe:

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



Le variabili hanno un tipo e un valore.

  • $ var = "test" è una stringa che contiene "test"
  • $ var2 = 24 è un valore intero di vhose 24.

Quando usi queste variabili (in PHP), a volte non hai il buon tipo. Ad esempio, se lo fai

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

PHP deve convertire ("cast") $ var in intero. In questo caso, "$ var == 1" è vero perché qualsiasi stringa non vuota viene castata su 1.

Quando si usa ===, si controlla che il valore AND THE TYPE siano uguali, quindi "$ var === 1" è falso.

Ciò è utile, ad esempio, quando si ha una funzione che può restituire false (su errore) e 0 (risultato):

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

Questo codice è sbagliato come se myFunction() restituisce 0, viene castato in falso e sembra che tu abbia un errore. Il codice corretto è:

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

perché il test è che il valore restituito "è un valore booleano ed è falso" e non "può essere castato in falso".




L'operatore === dovrebbe confrontare l' esatta uguaglianza dei contenuti mentre l'operatore == confronta l'uguaglianza semantica. In particolare, costringerà le stringhe ai numeri.

L'uguaglianza è un argomento vasto. Vedi l'articolo di Wikipedia sull'uguaglianza .




<?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 è un linguaggio vagamente dattiloscritto. L'utilizzo dell'operatore doppio uguale consente di controllare liberamente una variabile.

Il controllo approssimativo di un valore consentirebbe per alcuni valori simili, ma non uguali, di uguagliare come lo stesso:

  • ''
  • nullo
  • falso
  • 0

Tutti questi valori equivarrebbero uguali usando il doppio operatore uguale.




Tutte le risposte finora ignorano un problema pericoloso con ===. È stato notato di passaggio, ma non sottolineato, che i numeri interi e i tipi doppi sono diversi, quindi il seguente codice:

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

dà:

 equal
 not equal

Si noti che questo NON è un caso di "errore di arrotondamento". I due numeri sono esattamente uguali fino all'ultimo bit, ma hanno tipi diversi.

Questo è un problema sgradevole perché un programma che usa === può funzionare felicemente per anni se tutti i numeri sono abbastanza piccoli (dove "abbastanza piccolo" dipende dall'hardware e dal sistema operativo in esecuzione). Tuttavia, se per caso, un intero sembra essere abbastanza grande da essere convertito in un doppio, il suo tipo viene modificato "per sempre" anche se un'operazione successiva, o molte operazioni, potrebbero riportarla a un valore intero piccolo. E, peggiora. Può diffondersi - l'infezione a doppio taglio può essere trasmessa a tutto ciò che tocca, un calcolo alla volta.

Nel mondo reale, questo è probabilmente un problema nei programmi che gestiscono date oltre l'anno 2038, per esempio. A questo punto, i timestamp UNIX (numero di secondi dal 1970-01-01 00:00:00 UTC) richiederanno più di 32 bit, quindi la loro rappresentazione "magicamente" passerà a raddoppiare su alcuni sistemi. Pertanto, se si calcola la differenza tra due volte si potrebbe finire con un paio di secondi, ma come un doppio, piuttosto che il risultato intero che si verifica nell'anno 2017.

Penso che questo sia molto peggio delle conversioni tra stringhe e numeri perché è sottile. Trovo facile tenere traccia di cosa sia una stringa e di cosa sia un numero, ma tenere traccia del numero di bit in un numero è oltre me.

Quindi, nelle risposte di cui sopra ci sono delle belle tabelle, ma nessuna distinzione tra 1 (come numero intero) e 1 (doppio sottile) e 1.0 (doppio ovvio). Inoltre, i consigli che dovresti sempre usare === e mai == non sono grandi perché === a volte falliscono dove == funziona correttamente. Inoltre, JavaScript non è equivalente in questo senso perché ha solo un tipo di numero (internamente può avere rappresentazioni differenti bit-wise, ma non causa problemi per ===).

Il mio consiglio: non usare né È necessario scrivere la propria funzione di confronto per risolvere davvero questo casino.