Was ist schneller: in_array oder isset? [geschlossen]

Diese Frage ist nur für mich, da ich immer gerne optimierten Code schreibe, der auch auf billigen langsamen Servern (oder Servern mit viel Verkehr) ausgeführt werden kann.

Ich sah mich um und konnte keine Antwort finden. Ich habe mich gefragt, was zwischen diesen beiden Beispielen schneller ist, wenn ich bedenke, dass die Schlüssel des Arrays in meinem Fall nicht wichtig sind (Pseudocode natürlich):

<?php
$a = array();
while($new_val = 'get over 100k email addresses already lowercased'){
    if(!in_array($new_val, $a){
        $a[] = $new_val;
        //do other stuff
    }
}
?>

<?php
$a = array();
while($new_val = 'get over 100k email addresses already lowercased'){
    if(!isset($a[$new_val]){
        $a[$new_val] = true;
        //do other stuff
    }
}
?>

Da der Punkt der Frage nicht die Array-Kollision ist, möchte ich hinzufügen, dass $a[$new_value]Sie verwenden können , wenn Sie Angst vor kollidierenden Inserts haben $a[md5($new_value)]. Es kann immer noch Kollisionen verursachen, würde jedoch einen möglichen DoS-Angriff verhindern, wenn aus einer vom Benutzer bereitgestellten Datei gelesen wird ( http://nikic.github.com/2011/12/28/Supercolliding-a-PHP-array.html ).

Die bisherigen Antworten sind genau richtig. Die Verwendung ist issetin diesem Fall schneller, weil

• Es verwendet eine O (1) -Hash-Suche für den Schlüssel, während in_arrayjeder Wert überprüft werden muss, bis eine Übereinstimmung gefunden wird.
• Als Opcode hat er weniger Overhead als das Aufrufen der in_arrayintegrierten Funktion.

Diese können mithilfe eines Arrays mit Werten (10.000 im folgenden Test) demonstriert werden, wodurch in_arraymehr Suchen erforderlich wird.

isset:    0.009623
in_array: 1.738441

Dies baut auf Jasons Benchmark auf, indem einige zufällige Werte eingegeben und gelegentlich ein Wert gefunden wird, der im Array vorhanden ist. Alles zufällig, also Vorsicht, dass die Zeiten schwanken.

$a = array();
for ($i = 0; $i < 10000; ++$i) {
    $v = rand(1, 1000000);
    $a[$v] = $v;
}
echo "Size: ", count($a), PHP_EOL;

$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    isset($a[rand(1, 1000000)]);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    in_array(rand(1, 1000000), $a);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

Welches ist schneller: isset()vs.in_array()

isset() ist schneller.

Während es offensichtlich sein sollte, isset()testet nur ein einzelner Wert. Während in_array()wird über das gesamte Array iteriert und der Wert jedes Elements getestet.

Grobes Benchmarking ist recht einfach microtime().

Ergebnisse:

Total time isset():    0.002857
Total time in_array(): 0.017103

Hinweis: Die Ergebnisse waren ähnlich, unabhängig davon, ob sie vorhanden waren oder nicht.

Code:

<?php
$a = array();
$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    isset($a['key']);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

$start = microtime( true );

for ($i = 0; $i < 10000; ++$i) {
    in_array('key', $a);
}

$total_time = microtime( true ) - $start;
echo "Total time: ", number_format($total_time, 6), PHP_EOL;

exit;

Zusätzliche Ressourcen

Ich möchte Sie ermutigen, sich auch Folgendes anzuschauen:

• PHP Benchmark
• PHPPerf
• XDebug

Die Verwendung isset()nutzt die schnellere Suche, da eine Hash-Tabelle verwendet wird , sodass keine O(n)Suche erforderlich ist .

Der Schlüssel wird zuerst mit der djb-Hash-Funktion gehasht, um den Bucket mit ähnlich gehashten Schlüsseln zu bestimmen O(1). Der Bucket wird dann iterativ durchsucht, bis der genaue Schlüssel in gefunden ist O(n).

Abgesehen von absichtlichen Hash-Kollisionen bietet dieser Ansatz eine viel bessere Leistung als in_array().

Beachten Sie, dass bei der Verwendung isset()in der von Ihnen gezeigten Weise zum Übergeben der endgültigen Werte an eine andere Funktion die array_keys()Erstellung eines neuen Arrays erforderlich ist . Ein Speicherkompromiss kann erzielt werden, indem die Daten sowohl in den Schlüsseln als auch in den Werten gespeichert werden.

Aktualisieren

Um zu sehen, wie sich Ihre Entscheidungen zum Code-Design auf die Laufzeitleistung auswirken, können Sie die kompilierte Version Ihres Skripts überprüfen :

echo isset($arr[123])

compiled vars:  !0 = $arr
line     # *  op                           fetch      ext  return  operands
-----------------------------------------------------------------------------
   1     0  >   ZEND_ISSET_ISEMPTY_DIM_OBJ              2000000  ~0      !0, 123
         1      ECHO                                                 ~0
         2    > RETURN                                               null

echo in_array(123, $arr)

compiled vars:  !0 = $arr
line     # *  op                           fetch      ext  return  operands
-----------------------------------------------------------------------------
   1     0  >   SEND_VAL                                             123
         1      SEND_VAR                                             !0
         2      DO_FCALL                                 2  $0      'in_array'
         3      ECHO                                                 $0
         4    > RETURN                                               null

Es wird nicht nur in_array()eine relativ ineffiziente O(n)Suche verwendet, sondern es muss auch eine Funktion ( DO_FCALL) aufgerufen werden, während hierfür isset()ein einzelner Opcode ( ZEND_ISSET_ISEMPTY_DIM_OBJ) verwendet wird.

Der zweite ist schneller, da nur nach diesem bestimmten Array-Schlüssel gesucht wird und nicht über das gesamte Array iteriert werden muss, bis es gefunden wird (jedes Array-Element wird angezeigt, wenn es nicht gefunden wird).