mehrdimensionales array einlesen - aber wie?

[janein]

Meinst Du so etwas für den 2. count:
...
for($j=0;$j<count($array01[ [COLOR=red]$j-$i[/COLOR]]);$j++){
...

Diese array_splice() Funktion hatte ich auch schon begutachtet. Mit ist jedoch nicht klar wie ich sie anwenden soll, da ja ein Bereich definiert wird. Ich dachte ich ziehe damit den letzten Wert ab. Klappt aber nicht.

array_slice($a[$i],$i,-1) ...

[Griecherus]

array_slice funktioniert ähnlich wie substr. Und mit substr kannst du ja durchaus auch nur ein Zeichen aus einer Zeichenkette entfernen:

$string = 'hello';

echo substr($string, 0, 1); // gibt `h` aus

echo substr($string, 1, 3); // gibt `ell` aus 

-> substr($string, $start, $length)
-> array_slice($array, $offset, $length)

Zu count:
Nein. Du machst grundsätzlich etwas falsch. Kapsel den Vergleichsalgorithmus in eine Funktion, wie wir es zu Beginn schon hatten:

function array_first_key_is_equal()
{
    $arrays = func_get_args(); // wichtig: damit ermöglichst du eine beliebige Anzahl an arrays
} 

Und in Sachen Länge bzw. Anzahl der Durchläufe orientierst du dich jetzt an $arrays resp. count($arrays). Für die innere Schleife: Wie gesagt, du suchst die Anzahl der Arrays, die noch vor dir liegen.

[janein]

Bin in beiden Punkten noch nicht weiter gekommen. Verstehe nicht was die gekapselte Funktion bewirken soll.

[Griecherus]

Das liegt daran, dass du anscheinend noch grundlegende Verständnisprobleme hast.

$a[0] = array("a", "b", "c");
$b[0] = array("a", "a", "z");

Wieso $a[0] und $b[0]? Das ist Quatsch. Die Arrays liegen dir wie folgt vor:

$array1 = array(value1, value2, value3);
$array2 = array(value1, value2, value3);
$array3 = array(value1, value2, value3);
...
$arrayn = array(value1, value2, value3);

und nicht

$array1[0] = array(); usw.

Von diesen Arrays interessiert uns dann vorerst nur der Schlüssel 0 ([0]), das ist richtig. Bei der Zuweisung hat der aber noch nichts zu suchen.

Den Algorithmus in eine Funktion kapseln solltest du aus mindestens einem (bestimmten) Grund. Und den habe ich dir auch schon genannt (siehe den Kommentar innerhalb der Funktion aus meinem letzten Posting).

Du möchtest beliebig viele Arrays verarbeiten, richtig? Je nachdem, wie viele Datensätze du aus deinen Dateien ausgelesen und zu Arrays zusammengefügt hast. Das können zwei sein, oder es sind zwanzig, oder siebzehn... Soweit klar? Und da macht sich func_get_args() nützlich, da es alle an die Funktion übergebenen Parameter in ein "großes" Array packt, mit dem du dann arbeiten kannst, das du in Schleifen durchlaufen kannst.

Und was substr resp. array_slice angeht: Jetzt lies mal bitte nochmal im PHP Manual nach... Da sind sogar Beispiele. Und nimm dir mal fünf Minuten, das anhand eines simplen Beispiels (das am besten nichts mit dem jetzigen Problem zu tun hat) auszuprobieren. Da gibts keine Hilfe mehr von mir, denn das ist echt nur lesen und anwenden.

[janein]

Original geschrieben von Griecherus
Das liegt daran, dass du anscheinend noch grundlegende Verständnisprobleme hast.

Wieso $a[0] und $b[0]? Das ist Quatsch ...

Ausgangspunkt sind zwei Dateien mit folgendem Inhalt, welche auf doppelte Einträge an Position [n][0] überprüft werden sollen.
1. (a)
a,b,c
h,w,d

2.(b)
a,f,z
b,x,a
Diese werden so zu einem mehrdimensionalen array eingelesen:
foreach (explode("\n", $lines1) as $line1)
{
$result1[] = explode('|', $line1);

}

Dieses ist eine andere Zuweisung:
$a[0] = Array("a", "b", "c");
$a[1] = Array("h", "w", "d");

$b[0] = Array("a", "f", "z");
$b[1] = Array("b", "x", "a");
Edit:
[COLOR=red]Warum meist Du sei das Quatsch?[/COLOR]

Im Ergebnis zeigen beide:

Array
(
[0] => Array
(
[0] => a
[1] => b
[2] => c
)

[1] => Array
(
[0] => b
[1] => w
[2] => d
)

[2] => Array
(
[0] => a
[1] => f
[2] => z
)

[3] => Array
(
[0] => b
[1] => x
[2] => a
)

)




[QUOTE]
Den Algorithmus in eine Funktion kapseln solltest du aus mindestens einem (bestimmten) Grund. Und den habe ich dir auch schon genannt (siehe den Kommentar innerhalb der Funktion aus meinem letzten Posting).
[⁄QUOTE]
Du meinst darum?
"... // wichtig: damit ermöglichst du eine beliebige Anzahl an arrays ..."

Was bedeutet, dass es hilfreich aber nicht notwendig ist, wenn ich Dich richtig verstehe. Doppelt gefundene Werte werde damit nicht verhindert. Auch richtig?

[Griecherus]

Irgendwie läufts darauf hinaus, dass deine Anforderungen zu schwammig formuliert sind oder ich komplett neben der Spur bin... Denn in deinem Eingangsposting ist nur von einer Datei die Rede gewesen. Dass zwei existieren, ist mir neu.

Diese (nun also) zwei Arrays können aber beliebig viele Elemente enthalten, oder? Da sie zeilenweise aus einer Datei ausgelesen und geparst werden, hängt die Anzahl der Elemente von der Anzahl der Zeilen ab, in denen Daten stehen. Richtig?


Doppelt gefundene Werte werden damit nicht verhindert, nein. Du sorgst damit nur, dass das, was du vorhast, ordentlich oder überhaupt funktionieren kann.
Wie du die doppelten Werte los wirst oder besser gesagt dafür sorgst, dass sie erst gar nicht entstehen, dazu habe ich dir schon einige Tipps gegeben. Und an der Benutzung von array_slice solls doch wirklich nicht scheitern, oder?

Vielleicht schnappst du dir wirklich mal Zettel und Stift, und schreibst genau auf, was gegeben sein kann, wie das Ergebnis aussehen soll und wie man das erreichen könnte. Gehs im Kopf durch, Schritt für Schritt, als wärst du der PHP Interpreter, und mach dir mal ein paar Gedanken. Der Topic hier strotzt so langsam nur vor Tipps, mach was draus

[janein]

...
Diese (nun also) zwei Arrays können aber beliebig viele Elemente enthalten, oder?

Ja. (Sorry, ich hatte auch nur eine Datei erwähnt. Das Prinzip bleibt doch gleich.)

Da sie zeilenweise aus einer Datei ausgelesen und geparst werden, hängt die Anzahl der Elemente von der Anzahl der Zeilen ab, in denen Daten stehen. Richtig?
...

Ja. Doch cont() stellt doch bereits fest wie viele arrays bzw. Einträge/Zeilen vorhanden sind und $arrays = func_get_args(); macht dann doch nicht mehr, oder doch?

Noch einmal zu array_slice() und das Löschen der doppelten Einträge. Mit folgendem werden alle doppelten Einträge gelöscht, nur dieser offset Fehler taucht auf.

if($array01[$i][0] == $array02[$i][0]){
unset($array01[$i]);

Benutze ich array_slice() wird kein Eintrag gelöscht ...

if($array01[$i][0] == $array02[$i][0]){
array_slice($array01[$i],0,$i);

Es sieht so aus, dass es nur an dem dem Löschen mit array_slice scheitert ...

[janein]

Mist, falscher Knopf!

[Griecherus]

Und wie wärs wenn du das Ergebnis (den Rückgabewert) von array_slice noch einer Variable zuordnet?

[janein]

Original geschrieben von Griecherus
Und wie wärs wenn du das Ergebnis (den Rückgabewert) von array_slice noch einer Variable zuordnet?

Habe ich bereits versucht - Ergebniss ist jedoch Quatsch, sollte es doch wie bei unset() das bereinigte array sein.
$x[]= array_slice($array01[$i],0,$i);

Noch ein weiteres Problem: tauchen zweimal identische Werte auf klappt das nicht mehr mit dem löschen. Es wird nur der erste idenische Wert gefunden bzw. gelöscht, der zweite bleibt leider.

[TheFish511]

Hab mich auch mal drangesetzt. Was hälst du von der Funktion?

$result1 = array('a','b','c', 'w', 'ö', 'f', 'f', 'f', 'z', 'p', 'g', 'h', 'v');
$result2 = array('l','a','m','w', 'a', 'f', 'ä');
$result3 = array('b', 'f', 'e', 'h', 'k', 'g', 'f');


function new_unique_array()
{
    $arrays = func_get_args();
    for ($i = 0; $i < sizeof($arrays); $i++) {
        $sizes[$i] = count($arrays[$i]);
    }
    $max = max($sizes);
    $p = 0;
    for ($i = 0; $i < sizeof($arrays); $i++) {
        for ($j = 0; $j < $max; $j++) {
        $array[$p] = $arrays[$i][$j];
        $p++;
        }    
    }
    $unique = array_unique($array);
    return $unique;
}

$result = new_unique_array($result1, $result2, $result3);
print_r($result); 

[janein]

Nicht schlecht und so schnell, nur geht das nicht mit mehrdimensionalen arrays.

So sieht es z.Z. bei mir aus, klappt nur leider noch nicht so wie es soll.

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

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


$treffer = "";
$h =1;
// vergleichen
for($i=0;$i<count($array01);$i++){
    for($j=0;$j<count($array01[$i]);$j++){
        if($a[$i][0] == $b[$i][0]){
            $p = $i-1;
      #  unset($a[$i]);
       $x[]= array_slice($a[$i],$p,1);
            // Treffer 
         $treffer[] = $a[$i][0];

            $h++;
}

echo '<pre> Treffer: <br>';
print_r($treffer);
echo 'Bereinigt  <br>';
print_r($x);
echo 'Alles <br>';
print_r(array_merge($a,$b));

echo'</pre>'; 

Das Ergebniss müsste so aussehen:

Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
            [2] => c
        )

    [1] => Array
        (
            [0] => b
            [1] => w
            [2] => d
        )
    [2] => Array
        (
            [0] => g
            [1] => l
            [2] => o
        )
) 

[TheFish511]

Hmm, ich verstehe gerade nicht genau, wie du es haben willst.
Deine Beispielausgabe stellt doch einfach nur das Array $a da und $b ist nicht vorhanden?!?

Naja, neuer Versuch:

$result1[0] = Array("a", "b", "c");
$result1[1] = Array("b", "w", "d");
$result1[2] = Array("g", "w", "o");
$result2[0] = Array("a", "f", "w");
$result2[1] = Array("w", "x", "a", "w", "m", "z");

function new_unique_array()
{
    $arrays = func_get_args();
    // Länge des größten Arrays wird ermittelt
    for ($i = 0; $i < sizeof($arrays); $i++) {
        $sizes[$i] = count($arrays[$i]);
    }
    $max = max($sizes);
    // macht numerisches Array
    $p = 0;
    for ($i = 0; $i < sizeof($arrays); $i++) {
        for ($j = 0; $j < $max; $j++) {
        $array[$p] = $arrays[$i][$j];
        $p++;
        }    
    }
    // Entfernt doppelte Einträge
    $unique = array_unique($array);
    // Wenn Arrays ungleich lange sind
    $leerstelle = sizeof($arrays[0]);
    unset($unique[$leerstelle]);
    // macht wieder mehrdeminsionale Arrays draus
    $p = 0;
    for ($j = 0; $j < sizeof($arrays); $j++) {
        for ($i = 0; $i < $max; $i++) {
            if ($unique[$p] != NULL) {
                $unique_dim[$j][$i] = $unique[$p];
            }
            $p++;
        }
    }
    return $unique_dim;
}

$result = new_unique_array($result1[0], $result1[1], $result1[2], $result2[0], $result2[1]);
echo "<pre>";
print_r ($result);
echo "</pre>"; 

Meinst du das so oder doch anders? Sprich dich aus, sonst kann ich dir nicht helfen.

[janein]

So sieht das array aus. Je Unter-Array sind drei Werte vorhanden. Der Wert an der 1. Position soll mit der anderen Werden an der 1. Position verglichen werden. Um doppelte Einträge zu vermeiden, sollen die Arrays mit doppelten Einträge gelöscht werden, dass nur noch einer übrig bleibt.

In diesem Array ist array[0][0] gleich mit array[3][0]. Also soll das gesammte array[3] - mit den dazugehörigen Positionen array[3][0], array[3][1] und array[3][2] - gelöscht werden. Das Ergebnis ist ein Array wie das folgende, nur mit der gelöschten Position. Das Ergebnis-Array hat dann nur noch 3 Arrays mit den jeweiligen 3 Positionen.

Array
(
    [0] => Array
        (
            [0] => a1
            [1] => b
            [2] => c
        )

    [1] => Array
        (
            [0] => a2
            [1] => w
            [2] => d
        )

    [2] => Array
        (
            [0] => a3
            [1] => l
            [2] => o
        )

    [3] => Array
        (
            [0] => a1
            [1] => x
            [2] => a
        )
) 

Das Array wird aus zwei Dateien erzeugt:

1. Datei

a1, b,c
a2, w,d
a3,l,o

2. Datei

a1,x, a

Evt. liege ich selber auch völlig falsch mit meiner Herangehensweise und es ist ganz einfach.

[TheFish511]

Ahh, da war ich ja vollkommen auf dem Holzweg.
Es soll nur geschaut werden, ob array[n][0] gleich array[n][0] ist und wenn es gleich ist, soll das zweite gelöscht werden?

Neuer Code:

$a[0] = Array("a", "b", "c");
$a[1] = Array("b", "w", "d");
$a[2] = Array("g", "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);
    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;
}

$result = new_unique_array($a[0], $a[1], $a[2], $b[0], $b[1], $b[2], $b[3]);
echo "<pre>";
print_r ($result);
echo "</pre>";