o que é mais rápido: in_array ou isset? [fechadas]

Esta pergunta é apenas para mim, pois sempre gosto de escrever código otimizado que pode ser executado também em servidores lentos e baratos (ou servidores com MUITO tráfego)

Olhei em volta e não consegui encontrar uma resposta. Eu queria saber o que é mais rápido entre esses dois exemplos, tendo em mente que as chaves do array no meu caso não são importantes (pseudo-código naturalmente):

<?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
    }
}
?>

Como o ponto da questão não é a colisão array, eu gostaria de acrescentar que, se você tem medo de colidir inserções para $a[$new_value], você pode usar $a[md5($new_value)]. ele ainda pode causar colisões, mas impediria um possível ataque DoS ao ler um arquivo fornecido pelo usuário ( http://nikic.github.com/2011/12/28/Supercolliding-a-PHP-array.html )

As respostas até agora são precisas. Usar issetneste caso é mais rápido porque

• Ele usa uma pesquisa hash O (1) na chave, enquanto in_arraydeve verificar todos os valores até encontrar uma correspondência.
• Por ser um opcode, ele tem menos sobrecarga do que chamar a in_arrayfunção integrada.

Isso pode ser demonstrado usando uma matriz com valores (10.000 no teste abaixo), forçando in_arraya fazer mais pesquisas.

isset:    0.009623
in_array: 1.738441

Isso se baseia no benchmark de Jason, preenchendo alguns valores aleatórios e, ocasionalmente, encontrando um valor que existe na matriz. Tudo aleatório, então tome cuidado, pois os tempos irão flutuar.

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

O que é mais rápido: isset()vsin_array()

isset() é mais rápido.

Embora deva ser óbvio, isset()testa apenas um único valor. Visto que in_array()irá iterar em todo o array, testando o valor de cada elemento.

O benchmarking aproximado é bastante fácil de usar microtime().

Resultados:

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

Nota: Os resultados foram semelhantes, independentemente se existiam ou não.

Código:

<?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;

Recursos adicionais

Eu o encorajo a olhar também para:

• Benchmark de PHP
• PHPPerf
• XDebug

O uso isset()aproveita a pesquisa mais rápida porque usa uma tabela hash , evitando a necessidade de O(n)pesquisas.

A chave é hash primeiro usando a função djb hash para determinar o intervalo de chaves com hash semelhantes em O(1). O balde é então pesquisado iterativamente até que a chave exata seja encontrada em O(n).

Excluindo quaisquer colisões de hash intencionais , essa abordagem produz um desempenho muito melhor do que in_array().

Observe que, ao usar isset()da maneira que você mostrou, passar os valores finais para outra função requer o uso array_keys()para criar um novo array. Um compromisso de memória pode ser feito armazenando os dados nas chaves e valores.

Atualizar

Uma boa maneira de ver como suas decisões de design de código afetam o desempenho do tempo de execução, você pode verificar a versão compilada de seu script:

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

Não apenas in_array()usa uma O(n)pesquisa relativamente ineficiente , mas também precisa ser chamada como uma função ( DO_FCALL), enquanto isset()usa um único opcode ( ZEND_ISSET_ISEMPTY_DIM_OBJ) para isso.

O segundo seria mais rápido, pois está procurando apenas por aquela chave de array específica e não precisa iterar em todo o array até que seja encontrado (vai olhar para cada elemento do array se não for encontrado)