Mam 2 tablice:

1.

[PHP] pobierz, plaintext 
Array
(
    [0] => Array
        (
            [Knt_Telefon1] => 322035105 
            [Knt_Telefon2] =>  
        )
 
    [1] => Array
        (
            [Knt_Telefon1] => 322065105
            [Knt_Telefon2] => 322065115 
        )
 
    [2] => Array
        (
            [Knt_Telefon1] => 322289156
            [Knt_Telefon2] =>  
        )
 
    [3] => Array
        (
            [Knt_Telefon1] => 322033117
            [Knt_Telefon2] => 322012105 
        )
)
 
[PHP] pobierz, plaintext 

2.

[PHP] pobierz, plaintext 
Array
(
    [0] => Array
        (
            [nr] => 322065105
        )
 
    [1] => Array
        (
            [nr] => 322289156
        )
 
    [2] => Array
        (
            [nr] => 322033117
        )
 
    [3] => Array
        (
            [nr] => 322562336
        )
 
    [4] => Array
        (
            [nr] => 322503669
        )
)
 
[PHP] pobierz, plaintext 

Chce porównać obie tablice tak aby zwróciło wszystkie numery z tablicy 1 których nie ma w tablicy 2.

Próbowałem z array_diff_assoc ale nie działa. Robiłem też w pętli foreach ale skrypt przerywa działanie i nie wywala żadnego błędu. I co najważniejsze w tablicy nr 1 jest ponad 80 000 kluczy (razy 2 [Knt_Telefon1] i [Knt_Telefon2]) oraz w tablicy nr 2 jest około 70 000 rekordów.

Da się to jakoś optymalnie rozegrać?

1. Wygeneruj sobie druga tablicę tak aby wyglądała w ten sposób:

[PHP] pobierz, plaintext 
Array
(
    [0] => 322065105
    [1] => 322289156
   //itd
)
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
foreach($tablica1 as $k => $v) {
 
     if(!in_array($v['Knt_Telefon1'], $tablica2)
        && !in_array($v['Knt_Telefon2'], $tablica2)) {
 
              $newArray[] = $v;
     }
}
[PHP] pobierz, plaintext 

Jeżeli robisz to jednorazowo to nie ma co za bardzo kombinowac z optymalnością. Sugeruje dać set_time_limit na duży i większy przydział pamięci jeżeli jest potrzebny

Co do kodu spróbuj po prostu:

[PHP] pobierz, plaintext 
$tab1in; // TAB 1
$tab2in; // TAB 2
$tab1 = array();
$tab2 = array();
$tab3 = array(); // TAB w której będą numery z tab1in ktorych nie ma w tab2in
 
// Konwertujemy tabele (tak będzie łatwiej)
 
foreach($tab1in AS $nr)
{
	$tab1[] = $nr['Knt_Telefon1'];
	$tab1[] = $nr['Knt_Telefon2'];
}
 
foreach($tab2in AS $nr)
{
	$tab2[] = $nr['nr'];
}
 
 
foreach($tab1 AS $t1)
{
	if(!in_array($t1,$tab2)) $tab3[] = $t1;
}
 
 
[PHP] pobierz, plaintext 

Proste, chwilę potrwa ale powinno działać

HTH!

Dzięki wielkie, @ephirus - próbowałem w podobny sposób jednak nagle po sprawdzeniu około 30-35 tyś kluczy przestawało działać (zero błędu przy czym limity czasowe i pamięciowe ściągnięte). Puściłem kod CuteOne i się póki co mieli.
Co do częstotliwości to mniej więcej musi chodzić co tydzień.

To takie dodatkowe info - żeby wiedzieć co się dzieje w danej chwili zawsze możesz co jakiś czas (co ileś operacji sprawdzania) dać loga. To znaczy nadpisać plik z info, ile rekordów przemieliło itd... Wtedy jak coś się skrzaczy masz info kiedy i jak dobrze to napiszesz także "dlaczego" Ja tak kiedyś skasowałem sporą bazę bo mi się jedna literka pomyliła ;P (backup był)

P.S. Pamiętam też, że w zależności od ustawień serwera może nie działać ustalanie czasu trwania skryptu - serwer ustawia to wedlug siebie - spotkałem się z tym w Nginx na przykład - więc jak nic nie pomoże to sprawdź też czy Ci po prostu serwer na "chama" skryptu nie killuje

Wyszukiwanie różnic w dwóch tablicach po ~100 000 elementów nie powinno trwać aż tak długo, żeby można było powiedzieć "póki co się mieli". Żeby przyspieszyć działanie takiego skryptu trzeba zastosować hashtablice (wyszukiwanie elementów w hashtablicy jest znacznie szybsze, niż porównywanie po kolei n elementów zwykłej tablicy). Jako że w PHP tablice asocjacyjne mogą być traktowane jako hashtablice, to kod jest bardzo prosty. W praktyce sprowadza się do tego, co pokazali CuteOne i Sephirus, tyle że klucze tablic zamienione są z wartościami:

[PHP] pobierz, plaintext 
<pre>
<?php
 
$startTime = microtime( true );
 
// Wczytujemy drugą tablicę i zamieniamy jej format z:
// array (
//   array( "nr" => 1234 ),
//   array( "nr" => 2345 ),
//   array( "nr" => 9876 ),
//   ...
// );
//
// na:
// array (
//   1234 => 1,
//   2345 => 1,
//   9876 => 1,
//   ...
// );
include "arr2.php";
 
$telArray = array();
foreach( $arr2 as $item )
{
    $telArray[$item["nr"]] = 1;
}
 
 
// Wczytujemy pierwszą tablicę i sprawdzamy każdy jej 
// numer telefonu z drugą tablicą. Jeśli NIE znajduje 
// się w drugiej tablicy dodajemy taki numer do 
// wynikowej tablicy $diffTelArray
include "arr1.php";
 
$diffTelArray = array();
foreach( $arr1 as $item )
{
    $tel1 = $item["Knt_Telefon1"];
    $tel2 = $item["Knt_Telefon2"];
 
    if( !empty( $tel1 ) && !isset( $telArray[$tel1] ) )
    {
        $diffTelArray[$tel1] = 1;
    }
    if( !empty( $tel2 ) && !isset( $telArray[$tel2] ) )
    {
        $diffTelArray[$tel2] = 1;
    }
}
 
// Jako że wynikowa tablica również ma format:
// numer_telefonu => 1
// "poprawiamy" ją funkcją array_keys   
$diffTelArray = array_keys( $diffTelArray );
 
 
echo "Time: " . round( microtime( true ) - $startTime, 3 ) . " s\n";
echo "Peak memory: " . number_format( memory_get_peak_usage() / 1024 / 1024, 2, ".", " " ) . " MB\n\n";
 
?>
</pre>
[PHP] pobierz, plaintext 

Wygenerowałem sobie tablice 1 i 2 zawierające odpowiednio 70 000 i 80 000 elementów (za telefony przyjąłem wartości losowe z zakresu 320000000 - 329999999) i powyższy kod wykonuje się u mnie w 0.75 sekundy i zajmuje w szczytowym momencie niecałe 80MB pamięci.


PS. Jeśli ma się to wykonywać raz, lub raz na tydzień jakoś w nocy, to faktycznie nie trzeba się przejmować wydajnością. W przeciwnym wypadku warto się nad tym zastanowić, bo wzrost wydajności jest znaczny.