Perché === è più veloce di == in PHP?

Perché è ===più veloce che ==in PHP?

Poiché l'operatore di uguaglianza ==obbliga o converte il tipo di dati temporaneamente per vedere se è uguale all'altro operando, mentre ===(l'operatore di identità) non ha bisogno di fare alcuna conversione e quindi si fa meno lavoro, il che lo rende più veloce.

===non esegue la tipografia, quindi 0 == '0'valuta true, ma 0 === '0'- a false.

Innanzitutto, === verifica se i due argomenti sono dello stesso tipo , quindi il numero 1 e la stringa '1' non riescono sul controllo del tipo prima che vengano effettivamente eseguiti confronti. D'altra parte, == non controlla prima il tipo e va avanti e converte entrambi gli argomenti nello stesso tipo e quindi fa il confronto.

Pertanto, === è più veloce nel verificare una condizione di errore

Ci sono due cose da considerare:

1. Se tipi di operandi sono diversi quindi ==e ===producono risultati diversi . In tal caso la velocità degli operatori non ha importanza; ciò che conta è quale produce il risultato desiderato.

2. Se i tipi di operando sono uguali, è possibile utilizzare uno dei due ==o ===entrambi producono gli stessi risultati . In tal caso la velocità di entrambi gli operatori è quasi identica. Questo perché nessuna conversione di tipo viene eseguita da nessuno degli operatori.

Ho confrontato la velocità di:

• $a == $b vs $a === $b
• dove $aed $berano numeri casuali [1, 100]
• le due variabili sono state generate e confrontate un milione di volte
• i test sono stati eseguiti 10 volte

E qui ci sono i risultati:

 $a == $b $a === $b
--------- ---------
 0.765770  0.762020
 0.753041  0.825965
 0.770631  0.783696
 0.787824  0.781129
 0.757506  0.796142
 0.773537  0.796734
 0.768171  0.767894
 0.747850  0.777244
 0.836462  0.826406
 0.759361  0.773971
--------- ---------
 0.772015  0.789120

Puoi vedere che la velocità è quasi identica.

Non so davvero se è significativamente più veloce, ma === nella maggior parte delle lingue è un confronto diretto dei tipi, mentre == proverà a fare coercizione dei tipi se necessario / possibile per ottenere una corrispondenza.

Il == incorre in un overhead maggiore di conversione del tipo prima del confronto. === controlla prima il tipo, quindi procede senza eseguire alcuna conversione di tipo.

Perché === non è necessario forzare gli operandi per essere dello stesso tipo prima di confrontarli.

Dubito che la differenza di velocità sia molto però. In circostanze normali è necessario utilizzare qualsiasi operatore abbia più senso.

In conclusione === è più veloce perché non converte il tipo di dati per vedere se due variabili hanno lo stesso valore, ma quando devi vedere se due variabili hanno lo stesso valore utilizzerai == se non raccogli quale tipo sono variabili o === se è importante anche il tipo di variabili.

Più veloce non dovrebbe essere misurato solo in tempi di esecuzione diretta (i test di prestazione diretti sono quasi trascurabili in questo caso). Detto questo, avrei bisogno di vedere un test che coinvolge iterazione, o ricorsione, per vedere davvero se c'è una differenza significativa, cumulativa (se usata in un contesto realistico). Anche i tempi di test e debug che risparmierai nel trattare i casi limite dovrebbero essere significativi per te

In php (codice c) il valore è una "classe" come:

class value
{
    $int_;
    $float_;
    $string_;
    $array_;
    $object_;
}

Quando stai confrontando $a == $bed $aè di inttipo, ci sarà qualcosa di simile:

if ($a->int_ == $b->int_ || $a->int_ == (int) $b->float_ || $a->int_ == (int) $b->string_ || ...)

ma string '1'non verrà trasmesso in codice ASCII 49, lo sarà 1.

Quando stai confrontando $a === $bed $aè di inttipo, ci sarà qualcosa di simile:

if ($a->int_ == $b->int_)

Se i risultati del test sono corretti, deve trattarsi di un problema del compilatore,

Il processore farà tutto ciò che gli viene detto di fare su un ciclo di clock

Se ha meno da fare, sarà più veloce da fare

aggiunta:

Ah bene in realtà se il compilatore ha già creato un sacco di codice macchina da elaborare, quindi se ha già aggiunto miliardi di cose per far fronte a quale tipo di dati deve essere confrontato, la rimozione di un IF "minore" non cambierà molto la velocità affatto.

Se qualcuno continua a leggere questo, allora sono interessante per ulteriori discussioni.

Phil