PHP array operations up to 10x faster than the original

nuno_php_array_ops.php

/**
 * Home mande method to do array_diff ~10x faster that PHP built-in.
 *
 * @param The array to compare from
 * @param An array to compare against
 *
 * @return an array containing all the entries from array1 that are not present in array2.
 */
function nuno_array_diff($array1, $array2) {
  $diff = array();

  // we don't care about keys anyway + avoids dupes
  foreach ($array1 as $value) {
    $diff[$value] = 1;
  }

  // unset common values
  foreach ($array2 as $value) {
    unset($diff[$value]);
  }

  return array_keys($diff);
}


/**
 * Home mande method to do array_intersect ~10x faster that PHP built-in.
 *
 * @param The array to compare from
 * @param An array to compare against
 *
 * @return an array containing all the entries from array1 that are present in array2.
 */
function nuno_array_intersect($array1, $array2) {
  $a1 = $a2 = array();

  // we don't care about keys anyway + avoids dupes
  foreach ($array1 as $value) {
    $a1[$value] = $value;
  }
  foreach ($array2 as $value) {
    $a2[$value] = 1;
  }

  // unset different values values
  foreach ($a1 as $value) {
    if (!isset($a2[$value])) {
      unset($a1[$value]);
    }
  }

  return array_keys($a1);
}

It is nice, aslong you are not goging to compare arrays with numbers as string in it, or with floats, or floats with the lovely exponent letter...

Otherwise you might either run into a type juggling problem later because the returned value will be an integer and not a string anymore as it was in the original array, or you'll have a floating point issue or a key that is an int.

Example for these problems using the intersect function:
$a1 = ['123', 12.34, 1e23, 2.0]; $a2 = [123, 12, "1.0E+23", 200376420512301056, 8.5-6.4-0.1]; $resMain = array_intersect($a1, $a2) $resNuno = nuno_array_intersect($a1, $a2);
So handle with care!

Use for non numeric strings to prevent type juggling or arrays that contains integers.
Don't use for floats or strings of numbers!

Maybe a solution could be to add a prefix ('_'.$value) to the keys, when the values get used as key. It is a bit hacky, but in this way you force php to keep all as string, so it compares all as string.
In the last foreach do isset('_'.$value) instead !isset() and add the result there to an array instead of using array_keys().
Should give then almost the same results as array_unique(array_inteesect()) I think, but I didn't checked the performance. For doing more equal, check in the first foreach if the key isset()