mehrdimensionales array einlesen - aber wie?

[janein]

Ja, so ungefähr. So ähnlich hatte ich es auch schon, nur bei Deinem Vorschlag und bei meinem durch die Verwendung von unset() die häßlichen Hinweise:

Notice: Undefined offset: 2 in ..

auf.



Ein weiteres Problem bei der Verwendung der Funktion mit dem Einbinden der Arrays einzeln ála:
[I]
$result = new_unique_array($a[0], $a[1], $a[2], $b[0], $b[1], $b[2], $b[3]); [⁄I]

entsteht dadurch, das die Zahl der Array variiert. Diese können also nicht einzeln eingebunden werden.

[Griecherus]

Original geschrieben von janein

Ein weiteres Problem bei der Verwendung der Funktion mit dem Einbinden der Arrays einzeln ála:

$result = new_unique_array($a[0], $a[1], $a[2], $b[0], $b[1], $b[2], $b[3]); [⁄I]

entsteht dadurch, das die Zahl der Array variiert. Diese können also nicht einzeln eingebunden werden.

Dazu habe ich dir mittlerweile schon drei Mal ausführlich erklärt, dass du genau aus diesem Grund in eine Funktion kapseln und func_get_args() benutzten sollst.
Tut mir leid, dass ich allmählich ungeduldig werde, aber das haben wir echt schon mehrfach durchgekaut. Wie gesagt, in den mittlerweile zahlreichen Postings haben sich eine Menge Tipps und Infos gesammelt. Lies sie, versuch sie zu verstehen und pack dein Problem an. Du siehst, dass es dich nicht weiter bringt, Code anzunehmen, der dann nicht deinen Anforderungen genügt. Du musst selbst verstehen, was du hast, was du willst und wie du dahin kommst. Hilfe zur Selbsthilfe haben wir dir jede Menge gegeben, dafür ist dieser Thread hier wohl ein Muster.

[janein]

In dieser Funktion wird func_get_args() verwendet und dennoch wird eine vordefinierte Zahl an array in der Funktion aufgerufen.

function new_unique_array()
{
$arrays = func_get_args();
$size = sizeof($arrays);
for ($i = 0; $i < $size; $i++) {
for ($j = 0; $j < $size; $j++) {
if ($arrays[$i][0] == $arrays[$j][0] && $j != $i) {
unset($arrays[$j]);
}
}
}
return $arrays;
}

[COLOR=red]$result = new_unique_array($a[0], $a[1], $a[2], $b[0], $b[1], $b[2], $b[3]);[/COLOR]

Hier werden trotz func_get_args() 7 arrays einbezogen, welche eigentlich zusammengehören. Vielleicht verstehe ich auch die Funktion nicht. Wie rufe ich den die Funnktion new_unique_array() auf ohne die array einzeln zu übergeben? Das verstehe ich nicht.

[Griecherus]

Ich glaube so langsam sieht du selbst den Wald vor lauter Bäumen nicht mehr. Solange es immernoch richtig ist, dass du genau zwei Arrays vergleichen möchtest, die selbst jedoch jeweils variabel viele Arrays beherbergen:

$array1 = array(/* was auch immer */);
$array2 = array(/* was auch immer */);

$result = deine_funktion($array1, $array2); 

deine_funktion(array $array1, array $array2) muss jetzt noch Sorge dafür tragen, die Länge resp. die Anzahl der Elemente (Sub-Arrays) zu ermitteln. Wie das geht, weißt du. Du count()est sie.

[janein]

function new_unique_array()
{
    $arrays = func_get_args();
    $size = sizeof($arrays);
    for ($i = 0; $i < $size; $i++) {
        for ($j = 0; $j < $size; $j++) {
            if ($arrays[$i][0] == $arrays[$j][0] && $j != $i) {
                unset($arrays[$j]);
            }
        }
    }
    return $arrays;
} 

Wenn man bei dieser Funktion anstatt diesem Funktionsaufruf:
[PHP]
$result = new_unique_array($a[0], $a[1], $a[2], $b[0], $b[1], $b[2], $b[3]);
[⁄PHP]
diesen verwendet:
[PHP]
$result = new_unique_array($a, $b);
[⁄PHP]
und damit zwei mehr dimensionale arrays, kommt man durch den Aufruf jedoch zu unterschiedlichen Ergebnissen. Der erste Aufruf filtert die doppelten Einträge heraus. Der zweite nicht ...

Wie würde man den die doppelte Einträge in einem einzigen Array auf Position array[n][0] überprüfen?

[Griecherus]

Original geschrieben von janein
[
[PHP]
$result = new_unique_array($a, $b);
[⁄PHP]
und damit zwei mehr dimensionale arrays, kommt man durch den Aufruf jedoch zu unterschiedlichen Ergebnissen. Der erste Aufruf filtert die doppelten Einträge heraus. Der zweite nicht ...

Wie würde man den die doppelte Einträge in einem einzigen Array auf Position array[n][0] überprüfen?

Diese Funktion erwartet die Parameter auch genau so:

new_unique_array($a[0], $a[1], $a[2], $b[0], $b[1], $b[2], $b[3]);

Möchtest du das ganze jetzt so haben

new_unique_array($a, $b);

, musst du die Funktion auch dahingehend ändern. Du kannst ja nicht erwarten, dass sie das für dich tut...

Und jetzt fang endlich mal an, selbst zu denken, statt immer nur nach Hilfe zu fragen. Auf mich hast du noch nicht den Eindruck gemacht, als hättest du dir besonders viel Mühe gemacht, sowohl was die grundlegenden Überlegungen angeht als auch die Recherchen im PHP Manual. Falls das nicht stimmt, tuts mir leid.

Ich klinke mich hier so langsam erstmal aus. Zumindest so lange, bis ich nicht mehr das Gefühl habe, mehr in deine Problemlösung gesteckt zu haben, als du selbst.

Sei mir nicht böse.

[janein]

In bin Dir nicht böse, sondern sehr dankbar für Deine Hilfe. Selber habe ich auch eine Menge probiert, allerdings fehlt mir tatsächlich etwas der Überblick ...

Zwei Fragen habe ich noch:

Wie wandel ich die Funktion um, dass sie für mehrdimensionale Array anwendbar ist, ein Ansatz und woran erkenne ich das die arrays so und nicht anders übergeben werden müssen?

Wie überprüfe ich doppelte Werte in einem einzigen Array anstatt mit einem zweiten (Auch an einer bestimmter Position array[n][0])?

[TheFish511]

Also so leicht lässt es sich nicht ändern. Wenn du meinen Code nicht 100% verstehst, dann wirst du sie auch nicht umformen können, zumindest nich so nebenbei.

Ein paar Tipps.
Immer Print_r einsetzen, um zu sehen, wie dein aktuelles array aussieht.
Wenn du meine Kernfunktion behalten willst, dann musst du das array erst zerlegen, weil wenn du die funktion so aufrufst: "new_unique_array($a, $b)", dann hast du per func_get_args() ein solches Array: Array[][][].
Das musst du dann erst zerlegen in ein solches Array[][]. Danach musst du es wieder zusammenfügen.

[janein]

In der Deinem Vorschlag löscht Du Array mit unset($arrays[$j]); das ruft eine Menge

Notice: Undefined offset: 6 Mitteilungen auf.

1. Wie verhinderst Du, diese Meldungen? Mit array_slice() habe ich es nicht geschaft.

2. Wäre das der Ansatz?

function new_unique_array()
{
    $arrays = func_get_args();
    $size = sizeof($arrays);
 for ($k = 0; $k < $size; $k++) {
    for ($i = 0; $i < $size; $i++) {
        for ($j = 0; $j < $size; $j++) {
            if ($arrays[$k][$i][0] == $arrays[$k][$j][0] && $j != $i) {
                unset($arrays[$k][$j]);
            }
        }
    }
}
    return $arrays;
} 

Nur wie weiter, Du sprichst von wieder zusammenfügen?

[TheFish511]

Mit 3 Schleifen ineinander könnte es auch gehen....
Bei deiner Variante müsste man nichts zusammenfügen, da man auch nichts auseinander getan hat.
Ich hätte es jetzt anders gelöst.

error_reporting(E_ALL);
$a[0] = Array("a", "b", "c");
$a[1] = Array("b", "w", "d");
$a[2] = Array("g", "l", "o");
$a[3] = Array("f", "l", "p");
$a[4] = Array("z", "l", "p");
$a[5] = Array("f", "l", "p");
$a[6] = Array("f", "l", "p");

$b[0] = Array("a", "f", "z");
$b[1] = Array("g", "p", "o");
$b[2] = Array("s", "f", "z");
$b[3] = Array("b", "f", "z");
$b[4] = Array("x", "l", "p");


function new_unique_array()
{
    $arrays = func_get_args();
    $size = sizeof($arrays);
    $all = 0;
    // länge des größten arrays ermitteln
    // komplettlänge aller arrays
    for ($i = 0; $i < $size; $i++) {
        $sizes[$i] = count($arrays[$i]);
        $all = $all + $sizes[$i];
    }
    $max = max($sizes);
    
    // zerlegung des Arrays
    for ($i = 0; $i < $size; $i++) {
        $p = $i * $max;
        $j = 0;
            while ($p < $max*$size) {
                if (isset($arrays[$i][$j][0]) && $arrays[$i][$j][0] != NULL) {
                    $new_array[$p][0] = $arrays[$i][$j][0];
                    $new_array[$p][1] = $arrays[$i][$j][1];
                    $new_array[$p][2] = $arrays[$i][$j][2];
                    }
                $p++;
                $j++;
            }
    }
    
    // Filterung nach gleichen Werten
    for ($i = 0; $i < $all; $i++) {
        for ($j = 0; $j < $all; $j++) {
            if (isset($new_array[$i][0]) && isset($new_array[$j][0])
                && $new_array[$i][0] == $new_array[$j][0]
                && $j != $i) {
                unset($new_array[$j]);
            }
        }
    }
    
    // danach wird das array wieder aufgebaut
    for ($i = 0; $i < $size; $i++) {
        $p = $i * $max;
        $j = 0;
            while ($p < $max*($i+1)) {
                if (isset($new_array[$p][0]) && $new_array[$p][0] != NULL) {
                    $unique[$i][$j][0] = $new_array[$p][0];
                    $unique[$i][$j][1] = $new_array[$p][1]; 
                    $unique[$i][$j][2] = $new_array[$p][2];
                    }
                $p++;
                $j++;
            }
    }
    
    // sortieren
    for ($i = 0; $i < $size; $i++) {
        sort($unique[$i]);
    }
    
    return($unique);
}

$result = new_unique_array($a, $b);
echo "<pre>";
print_r($result);
echo "</pre>"; 

Versuche trotzdem mal deine Möglichkeit weiter, die sollte auf jeden Fall perfomanter sein.

[janein]

$a[0] = Array("s", "b", "c");
$a[1] = Array("a", "w", "d");
$a[2] = Array("w", "l", "o");
$a[3] = Array("w", "l", "o");

$b[0] = Array("a", "f", "z");
$b[1] = Array("b", "x", "a");

function new_unique_array()
{
    $arrays = func_get_args();
    $size = sizeof($arrays);

    // Filterung nach gleichen Werten
for ($k = 0; $k < $size; $k++) {
  for ($i = 0; $i < $size; $i++) {
        for ($j = 0; $j < $size; $j++) {
            if      ( isset($arrays[$k][$i][0]) && isset($arrays[$k][$j][0]) &&
                 $arrays[$k][$i][0] == $arrays[$k][$j][0]
                && $j != $i
                    )
                {
                unset($arrays[$k][$j]);
            }
        }
    }
}
    return $arrays;
}

$result = new_unique_array($a,$b);
echo "<pre>";
#print_r($treffer);
print_r ($result);
echo "</pre>"; 

Leider gibt es trotz der Prüfung immer noch doppelte Werte. Warum sehe ich nicht.

Das geniale an Deiner komplizierte Lösung ist: Sie filtert auch doppelte Werte aus nur einem Array!

[TheFish511]

So, hab nochmal etwas umgeschrieben. Jetzt kann man die Funktion auf unendlich viele Arrays anwenden, deren Arrays auch unterschiedlich lang sein können. Das Skript kann ich auch gleich für mein eigenes Projekt verwenden.

Deinen code schaue ich mir mal morgen an.

error_reporting(E_ALL);
$a[0] = Array("a", "b", "c", "g");
$a[1] = Array("b", "w", "d", "l");
$a[2] = Array("g", "l", "o");
$a[3] = Array("f", "l", "p", "t", "k", "ö");

$b[0] = Array("a", "f", "z");
$b[1] = Array("g", "p", "o");
$b[2] = Array("s", "f", "z");
$b[3] = Array("b", "f", "z");

$c[0] = Array("b", "f", "z");
$c[1] = Array("a", "l", "p", "d");
$c[2] = Array("s", "l", "p", "d");
$c[3] = Array("q", "l", "p", "d");

$d[0] = Array("ü", "l", "p", "d");
$d[1] = Array("q", "l", "p", "d");
$d[2] = Array("k", "l", "p", "d");

$e[0] = Array("f", "l", "p", "d");
$e[1] = Array("q", "l", "p", "d");
$e[2] = Array("v", "l", "p", "d");

function new_unique_array()
{
    $arrays = func_get_args();
    $size = sizeof($arrays);
    $all = 0;
    // länge des größten arrays ermitteln
    // komplettlänge aller arrays
    for ($i = 0; $i < $size; $i++) {
        $sizes[$i] = count($arrays[$i]);
        $all = $all + $sizes[$i];
    }
    $max = max($sizes);
    $all = $all + $size;
   
    // zerlegung des Arrays
    for ($i = 0; $i < $size; $i++) {
        $p = $i * $max;
        $j = 0;
            while ($p < $max*$size) {
                if (isset($arrays[$i][$j][0])) {
                    for ($d = 0; $d < $max; $d++) {
                        if (isset($arrays[$i][$j][$d])) {
                            $new_array[$p][$d] = $arrays[$i][$j][$d];
                        }
                    }
                }
                $p++;
                $j++;
            }
    }
    
    // Filterung nach gleichen Werten
    for ($i = 0; $i < $all; $i++) {
        for ($j = 0; $j < $all; $j++) {
            if (isset($new_array[$i][0]) && isset($new_array[$j][0])
                && $new_array[$i][0] == $new_array[$j][0]
                && $j != $i) {
                unset($new_array[$j]);
            }
        }
    }
    
    // danach wird das array wieder aufgebaut
    for ($i = 0; $i < $size; $i++) {
        $p = $i * $max;
        $j = 0;
            while ($p < $max*($i+1)) {
                if (isset($new_array[$p][0])) {
                    for ($d = 0; $d < $max; $d++) {
                        if (isset($new_array[$p][$d])) {
                            $unique[$i][$j][$d] = $new_array[$p][$d];
                        }
                    }
                }
                $p++;
                $j++;
            }
    }
    
    // sortieren
    for ($i = 0; $i < $size; $i++) {
        if (isset($unique[$i])) {
            sort($unique[$i]);
        }
    }
    
    return($unique);
}

$result = new_unique_array($a, $b, $c, $d, $e);
echo "<pre>";
print_r($result);
echo "</pre>";