Array nach Werten filtern

[Tilo]

Hallo,

ich habe ein Array, in dem Mitarbeiterdaten gespeichert sind:

z.B.
$user_array[$i][stadt]

$i ist numerisch, stadt ist ein schlüssel von mehreren. Ich möchte jetzt nach einer bestimmten Stadt filtern, z.B. sollen nur die aus "Berlin" berücksichtigt werden.

Bisher habe ich das so gemacht:

  
foreach($user_array AS $i) {  
  if ($i[stadt] == "Berlin") {  
    Verarbeitung;  
    break;  
  }  
}  

Aus Performance-Gründen möchte ich aber nicht mehr das komplette Array durchlaufen, sondern ich möchte es vorher filtern und dann durchlaufen. Geht sowas?

Gruß
Tilo

[Sven Rautenberg]

Moin!

ich habe ein Array, in dem Mitarbeiterdaten gespeichert sind:

z.B.
$user_array[$i][stadt]

$i ist numerisch, stadt ist ein schlüssel von mehreren. Ich möchte jetzt nach einer bestimmten Stadt filtern, z.B. sollen nur die aus "Berlin" berücksichtigt werden.

Bisher habe ich das so gemacht:

foreach($user_array AS $i) {
  if ($i[stadt] == "Berlin") {
    Verarbeitung;
    break;
  }
}

>   
> Aus Performance-Gründen möchte ich aber nicht mehr das komplette Array durchlaufen, sondern ich möchte es vorher filtern und dann durchlaufen. Geht sowas?  
  
Uiii, "Performance-Gründe" - die kannst du nur anführen, wenn du jetzt schon Meßergebnisse liefern kannst, wie lange dein Code derzeit läuft, und insbesondere, in welchen Abschnitten des Gesamtcodes wieviel Zeit draufgeht.  
  
Ohne zu messen kann man an der Performance nämlich nichts verbessern - man muß wissen, wie schnell etwas war, um erkennen zu können, ob sich durch Veränderung was verbessert oder verschlechtert hat.  
  
Aber damit das hier nicht nur ein leeres Gejammer wird: Handbuch gecheckt? Vermutlich nein, denn es gibt eine Funktion, die perfekt zu deinem Betreff passt. "Array nach Werten filtern" -> [array_filter()](http://de.php.net/array_filter)  
  
 - Sven Rautenberg

[Tilo]

Hi,

danke für Deine Antwort.

Zur Performance, ich muss diese Abläufe einige zig-tausend mal durchlaufen. Wenn ich da diesen Array-Durchlauf (über mehrere hundert Mitarbeiter) abspecken könnte, wäre mir sicher schon etwas geholfen.

Aus der array_filter Funktion werde ich nicht so richtig schlau.
Ich habe jetzt diesen Ansatz:

Nochmal zum $user_array:
Array ( [0] => Array ( [name] => "Müller" [stadt] => "Berlin" [geburtsstadt] => "Frankfurt" ) [1] => Array ( [name] => etc.

  
function filter($value) {  
  if ($value==$stadt) {  
    return $value;  
  }  
}  
  
function auswertung;  
  
  $stadt = "Berlin";  //wird übrigens in einer übergeordneten Schleife immer unterschiedlich belegt  
  
  $user_array_gefiltert = array_filter($user_array,"filter");  
  
  if ($user_array_gefiltert!=NULL) {  
     foreach($user_array_gefiltert AS $i) {  
       Verarbeitung;  
     }  
  }  
}  

So funktioniert es aber nicht, das $user_array_gefiltert ist immer leer.

Es ist mir nicht ganz klar, wie ich die Filterfunktion definiere. Ich muss doch der Funktion "filter" die Stadt mitgeben. Ich habe oben in der Funktion $value mitgegeben, muss ich das dann bei array_filter() gar nicht mehr angeben?
Außerdem soll der Filter nur auf das Feld "stadt" angewendet werden, aber auf keinen Fall auf z.B. "geburtsstadt". Mir ist leider noch nicht klar, wie ich das machen kann?

Gruß
Tilo

[Sven Rautenberg]

Moin!

Zur Performance, ich muss diese Abläufe einige zig-tausend mal durchlaufen. Wenn ich da diesen Array-Durchlauf (über mehrere hundert Mitarbeiter) abspecken könnte, wäre mir sicher schon etwas geholfen.

Das glaube ich eben nicht.

Und bevor du irgendwiw weiter experimentierst mit etwas, was dich nur Zeit kostet, aber nach meiner Erfahrung keinen Vorteil bringt, sollten wir deine zu erledigende Aufgabe lieber mal etwas mehr im Detail diskutieren, um eine gute Lösung zu finden.

Du hast also ein großes Array mit Mitarbeiterdaten und musst irgendwie damit etwas tun, je nachdem, welche Stadt im Datensatz steht.

Was du tun musst, ist im ersten Schritt gar nicht mal von Belang. Aber wichtig zu wissen ist: Welche Datensätze werden wann bearbeitet?

Gib mal mehr Details:

Wie entsteht das Array? Datenbankabfrage? Dateiinhalt?

Wieso stehen "alle" Mitarbeiter in dem Array?

Müssen in einem Skriptablauf auch alle Datensätze verarbeitet werden?

Muss das Ergebnis irgendwie sortiert erscheinen?

Oder nochmal anders formuliert: Was willst du eigentlich insgesamt erreichen?

- Sven Rautenberg

[Tilo]

Also es soll eine Leistungs-Auswertung der Mitarbeiter werden. Die geleisteten Stunden kommen aus der Zeiterfassung. Dafür mache ich als erstes eine SQL-Abfrage (tabelle stunden), in der ich auch mit den nötigen Einschränkungen einige zig-tausend Datensätze bekomme. Das Beispiel mit der Stadt hatte ich nur zum besseren Verständnis, es geht eigentlich um die "uid".

Jeder dieser Datensätze muss nun mit Daten des entsprechenden Benutzers erweitert werden zur Anzeige bzw. Berechnung (name, kostenstelle, stundensatz, etc). Dazu habe ich mir vorher ein Benutzer-Array mit allen relevanten Daten der Mitarbeiter aufgebaut, um nicht bei jedem Datensatz der Leistungen eine SQL-Abfrage auf Benutzertabelle + Kostenstellentabelle + Lohntabelle durchführen zu müssen. In diesem Benutzer-Array können sogar Benutzer mehrfach auftauchen, wenn dieser Benutzer mehrere Kostenstellen hat (z.B. mit Kst1 -> Anteil 70% und Kst2 -> Anteil 30%).

Die berechneten Daten schreibe ich in eine Zwischentabelle, was natürlich auch eine Menge Zeit kostet. Das hat aber den Vorteil, wenn die Auswertung einmal berechnet ist, kann der Benutzer mit Hilfe von Links Detaildaten auf- und zuklappen, ohne das die ganze Berechnung nochmal durchgeführt werden muss.

Bei der Berechnung machen die mehrfach auftretenden Benutzer pro Kostenstelle die Sache komplizierter, ich kann leider nicht das Benutzerarray so aufbauen $user_array[$uid][name], damit könnte ich direkt auf die Werte zugreifen, das geht nun aber leider nicht. Deshalb möchte ich das array auf den entsprechenden Benutzer eingrenzen, und dann durchlaufen.

  
$q = "SELECT * from stunden WHERE datum>='$von' and datum<='$bis' and ((tid>=200 and tid<300) or (tid>=800 and tid<900)) order by uid";  
$r = mysql_query($q, $cid);  
  
while ($row = mysql_fetch_object($r)) {  
  
  Benutzerdaten ermitteln;  
  Werte berechnen;  
  
  Satz in Zwischentabelle schreiben;  
  
}  

Ich hoffe, das war soweit verständlich.

[Tilo]

Bei der Berechnung machen die mehrfach auftretenden Benutzer pro

Kostenstelle die Sache komplizierter

andersrum wird ein Schuh draus: mehrere Kostenstellen pro Benutzer.

Zugriffe auf das Array sehen dann so aus:
$user_array[$i][uid]
und
$user_array[$i][kst]
etc.

[Sven Rautenberg]

Moin!

Also es soll eine Leistungs-Auswertung der Mitarbeiter werden. Die geleisteten Stunden kommen aus der Zeiterfassung. Dafür mache ich als erstes eine SQL-Abfrage (tabelle stunden), in der ich auch mit den nötigen Einschränkungen einige zig-tausend Datensätze bekomme. Das Beispiel mit der Stadt hatte ich nur zum besseren Verständnis, es geht eigentlich um die "uid".

Das ist dein SELECT * from stunden WHERE datum>='$von' and datum<='$bis' and ((tid>=200 and tid<300) or (tid>=800 and tid<900)) order by uid?

Kosmetischer Hinweis am Rande: SQL kennt auch den BETWEEN-Vergleich, damit kriegt man viele Abfragen deutlich lesbarer hin.

SELECT * FROM stunden WHERE datum BETWEEN '$von' AND '$bis' AND (tid BETWEEN 200 AND 299 OR tid BETWEEN 800 AND 899)) ORDER BY uid

Ich gehe mal davon aus, dass 'tid' eine Integerspalte ist, und tid < 900 äquivalent zu tid <=899.

Mehr Performance wegen weniger Datenmenge kriegt man auch, wenn man kein "SELECT *" abfragt, sondern alle Spalten explizit auflistet, die man haben will. Das macht's auch zum Helfen leichter, weil die relevanten Spalten bekannt sind, insbesondere wenn es um JOINs geht. Und das sollte es wahrscheinlich auch bei diesem Problem.

Und nur so als Eingangsbemerkung: Meine Ahnung war korrekt, dass dein Problem nicht ist, dass dein Array gefiltert werden muss, denn deine erste foreach-Schleife hat genausoviel Code, wie eine Array-Filterung haben würde. In Wirklichkeit geht es um effektive Anordnung von Daten in Arrays und das Vermeiden von sinnloser Doppelarbeit.

Jeder dieser Datensätze muss nun mit Daten des entsprechenden Benutzers erweitert werden zur Anzeige bzw. Berechnung (name, kostenstelle, stundensatz, etc).

Das ist die klassische Aufgabe eines JOINs, würde also von der Datenbank gelöst werden können. Ebenfalls wäre zu prüfen, ob die Berechnung nicht schon direkt in der Datenbank erledigt werden könnte.

Dazu habe ich mir vorher ein Benutzer-Array mit allen relevanten Daten der Mitarbeiter aufgebaut, um nicht bei jedem Datensatz der Leistungen eine SQL-Abfrage auf Benutzertabelle + Kostenstellentabelle + Lohntabelle durchführen zu müssen. In diesem Benutzer-Array können sogar Benutzer mehrfach auftauchen, wenn dieser Benutzer mehrere Kostenstellen hat (z.B. mit Kst1 -> Anteil 70% und Kst2 -> Anteil 30%).

Das ist halt die andere Alternative, wenn man komplexere Berechnungen durchführt, die man nicht in die Datenbank tun kann oder will.

Die berechneten Daten schreibe ich in eine Zwischentabelle, was natürlich auch eine Menge Zeit kostet. Das hat aber den Vorteil, wenn die Auswertung einmal berechnet ist, kann der Benutzer mit Hilfe von Links Detaildaten auf- und zuklappen, ohne das die ganze Berechnung nochmal durchgeführt werden muss.

Das ist genau der Punkt: Ich vermute mal, deine Berechnungslogik verbraucht deshalb soviel Zeit, weil sie insgesamt viel Zeit braucht - nicht weil das Benutzerarray so groß ist und gefiltert die Sache schneller laufen würde.

Bei der Berechnung machen die mehrfach auftretenden Benutzer pro Kostenstelle die Sache komplizierter, ich kann leider nicht das Benutzerarray so aufbauen $user_array[$uid][name], damit könnte ich direkt auf die Werte zugreifen, das geht nun aber leider nicht. Deshalb möchte ich das array auf den entsprechenden Benutzer eingrenzen, und dann durchlaufen.

[Aus deinem Ergänzungsposting:]

Zugriffe auf das Array sehen dann so aus:
$user_array[$i][uid]
und
$user_array[$i][kst]
etc.

Offenbar ist die Organisation deines Benutzerdatenarrays suboptimal. Gib mal Beispieldaten und die Struktur genau an. PHP-Arrays sind eine ganz wunderbare Datenstruktur, die sich sehr flexibel einsetzen lässt, wenn man weiß wie.

$q = "SELECT * from stunden WHERE datum>='$von' and datum<='$bis' and ((tid>=200 and tid<300) or (tid>=800 and tid<900)) order by uid";
$r = mysql_query($q, $cid);

while ($row = mysql_fetch_object($r)) {

Benutzerdaten ermitteln;
  Werte berechnen;

Satz in Zwischentabelle schreiben;

}

> Ich hoffe, das war soweit verständlich.  
  
Ja, dein Pseudocode lässt aber leider den relevanten Part komplett unbeleuchtet, nämlich "Benutzerdaten ermitteln" und "Werte berechnen", ggf. auch noch "Satz in Zwischentabelle schreiben".  
  
Das sind die Dinge, die hier die Zeit verbrauchen. Vernünftiges Profiling wäre hier angesagt, also die Ermittlung der tatsächlich in jedem dieser Schritte verbrauchten Zeit. Denn nur wenn du weißt, bei welcher Aktion die meiste Zeit draufgeht, kannst du entscheiden, wo eine Optimierung das meiste Potential hat.  
  
Mal plastisch gesprochen: Wenn du ermittelst, dass "Benutzerdaten ermitteln" pro Datensatz 0,1 Sekunde braucht, aber "Satz in Zwischentabelle schreiben" 1,0 Sekunden, dann bringt es dir ganz wenig, wenn du bei den Benutzerdaten optimierst.  
  
Deshalb musst du als allererstes mal Rechenzeit messen. In PHP 5 liefert dir die Funktion `microtime(true)`{:.language-php} die aktuelle Mikrosekundenuhrzeit als Float-Wert. Wenn du die Zeit vor und nach einer Funktion nimmst, ist deren Differenz die Laufzeit. Mit diesem Ergebnis kannst du dann etwas Statistik betreiben, indem du in deiner while-Schleife die Laufzeit für jeden der dort betriebenen Schritte ermittelst und immer weiter summierst.  
  
Am Ende erhältst du dann die Summe an Laufzeit für jeden Schritt. Bei Bedarf kannst du dir auch noch den Durchschnitt ausrechnen, und ggf. auch noch Minimum und Maximum der einzelnen Laufzeiten speichern.  
  
Solch eine Laufzeitanalyse hilft dir dann, zu identifizieren, welcher Schritt bei dir am meisten Zeit verbraucht. Und die Erfassung von Minimum und Maximum würde dir erlauben zu sehen, ob ein Schritt höchst unterschiedliche Laufzeiten hat.  
  
Sowas geht auch automatisierter mit Xdebug und anderen Extensions, aber die muss man auf dem Server auch einbinden und aktivieren dürfen. Definitiv nix für den Live-Server.  
  
 - Sven Rautenberg

[Tilo]

Nochmal vielen Dank, ich werde mir Deine Tips zu Herzen nehmen.

Das Benutzer-Array sieht so aus:

[0] => Array ( [uid] => 3 [persnr] => 58 [persnr4] => 0058 [nachname] => K.. [vorname] => S.. [anteil] => 100 [kst] => 2302 [sollzeit] => 160 [lohn] => 0 [stdsatz_soll] => 0 ) [1] => Array ( [uid] => 4 [persnr] => 52 [persnr4] => 0052 [nachname] => R.. [vorname] => E.. [anteil] => 100 [kst] => 2302 [sollzeit] => 64 [lohn] => 0 [stdsatz_soll] => 0 ) [2] => Array ( [uid] => 5 [persnr] => 45 [persnr4] => 0045 [nachname] => F.. [vorname] => R.. [anteil] => 70 [kst] => 2400 [sollzeit] => 100 [lohn] => 0 [stdsatz_soll] => 0 ) [3] => Array ( [uid] => 5 [persnr] => 45 [persnr4] => 0045 [nachname] => F.. [vorname] => R.. [anteil] => 30 [kst] => 2500 [sollzeit] => 100 [lohn] => 0 [stdsatz_soll] => 0 )

[2] und [3] sind identisch bis auf kst und anteil, deswegen weiß ich nicht wie ich das Array anders organisieren kann.

Hier der ausführliche Code:

  
$q = "SELECT * from stunden WHERE datum>='$von' and datum<='$bis' and ((tid>=200 and tid<300) or (tid>=800 and tid<900)) order by uid";  
$r = mysql_query($q, $cid);  
  
while ($row = mysql_fetch_object($r)) {  
  
  Benutzerdaten ermitteln; //wie gesagt, die hole ich aus dem Benutzer-Array  
                           //das Benutzer-Array zu erstellen mache ich einmal (bzw. bis 3 mal wenn ich mehrere Zeiträume auswerte),  
                           //->das dauert nicht lange, das habe ich schon getestet  
      if ($user_array!=NULL) {  
        foreach($user_array AS $i) {  
  
         $uid = $i[uid];  
  
         if ($_uid==$uid) //$_uid kommt aus dem SELECT  
         {  
  
           Werte berechnen;  
  
           $betrag_leistung = (($_dauer / 3600) * $i[stdsatz_soll]);  
           $betrag_leistung2 = (($_dauer / 3600) * $_satz_stunden);  
  
           if (($betrag_leistung != 0) || ($betrag_leistung2 != 0)) {  
  
             //Kostenstelle wird vorrangig aus der Zeiterfassung gezogen, wenn leer dann von Benutzer  
             if ($_kostnr!=NULL) {  
               $kst = $_kostnr;  
               $anteil = 100;  
               //bei eingetragener Kostenstelle in stunden nur einen Benutzer verwenden, deshalb am Ende ein break setzen  
             } else {  
               $kst = $i[kst] . $i[persnr4];  
               $anteil = $i[anteil];  
             }  
             $anteil = $i[anteil];  
             $betrag_leistung = ($betrag_leistung / 100 * $anteil);  
             $betrag_leistung2 = ($betrag_leistung2 / 100 * $anteil);  
  
  
             Satz in Zwischentabelle schreiben;  
             // Abfrage ob Satz schon importiert  
             $qb = "SELECT id from kore_leistungsanalyse WHERE id_stunden=$_id";  
             $rb = mysql_query($qb, $cid);  
             $count_stunden = mysql_num_rows($rb);  
             mysql_free_result($rb);  
  
             if ($count_stunden==0) //die Abfrage brauche ich, da es sonst bei mehreren sich überschneidenden  
                                    //Zeiträumen zu mehrfachen Einträgen kommen würde  
             {  
  
               $qi = "INSERT INTO kore_leistungsanalyse (verteilung_id,typ,kst,uid,name,betrag,betrag2,muid) VALUES (0,'M',$kst,$uid,'$i[nachname]',$betrag_leistung,$betrag_leistung2,$zuid)";  
               //sind eigentlich noch ein paar Felder mehr, die der Kategorisierung dienen  
               mysql_query($qi, $cid) OR die("Error: $qi <br>" . mysql_error());  
               }  
             }  
}  

Ich werde mal die Dauer der einzelnen Abschnitte messen. Wenn es haupsächlich am INSERT liegt, kann ich da nicht viel machen. Das Anzeigen der Daten nur aus der Zwischentabelle geht ruck-zuck, das möchte ich auch so lassen.
Es sind halt viele Schleifendurchläufe, da machen wahrscheinlich kleine Verbesserungen etwas aus.

Gruß
Tilo

[Sven Rautenberg]

Moin!

Das Benutzer-Array sieht so aus:

Klarer Fall von schlechter Organisation, wie wir ja schon feststellten.

Auch wenn das Array so aus der Datenbank rauskommt, heißt das noch nicht, dass man es auch so lassen muss. Denn in der Tat suchst du dir hier einen Wolf, wenn du alle Array-Einträge einer bestimmten UID brauchst.

[2] => Array (
  [uid] => 5
  [persnr] => 45
  [persnr4] => 0045
  [nachname] => F..
  [vorname] => R..
  [anteil] => 70
  [kst] => 2400
  [sollzeit] => 100
  [lohn] => 0
  [stdsatz_soll] => 0 )

[3] => Array (
  [uid] => 5
  [persnr] => 45
  [persnr4] => 0045
  [nachname] => F..
  [vorname] => R..
  [anteil] => 30
  [kst] => 2500
  [sollzeit] => 100
  [lohn] => 0
  [stdsatz_soll] => 0 )

Wie schon von dir zutreffend festgestellt, benötigst du die UID nicht in den Daten, sondern als Index. Und wie man an den zwei Elementen oben sieht, sind sehr viele Informationen, die sich auf dieselbe UID beziehen, natürlich identisch und somit redundant. Also verzichtbar.

Deshalb mein Vorschlag zur Neuorganisation:

[UID (5)] => Array (
  [persnr] => 45
  [persnr4] => 0045
  [nachname] => F..
  [vorname] => R..
  [sollzeit] => 100
  [lohn] => 0
  [stdsatz_soll] => 0
  [verteilung] => Array(
    [0] => Array(
      [anteil] => 30
      [kst] => 2500)
    [1] => Array(
      [anteil] => 70
      [kst] => 2400)
    )
 )

So wäre ein vernünftig aufgebautes Array für die Aufgabe nutzbar. Du kriegst direkten Zugriff via UID auf alle Personalstammdaten, und der Subindex "Verteilung" enthält ein Array mit allen Details zur Aufteilung auf die jeweiligen Kostenstellen. Ich habe dabei angenommen, dass "Lohn" und "Stdsatz_Soll" Bestandteil der Personalstammdaten sind, wenn die zur Kostenstellenaufteilung gehören, müssen die natürlich jeweils mit ins Array hinein.

So ein Array lässt sich beim Auslesen der entsprechenden DB-Abfrage mit ein wenig Umkopieren der abgefragten Daten relativ problemlos herstellen. Entsprechend wird dann die Schleife bei der Berechnung umgebaut.

Ich werde mal die Dauer der einzelnen Abschnitte messen. Wenn es haupsächlich am INSERT liegt, kann ich da nicht viel machen. Das Anzeigen der Daten nur aus der Zwischentabelle geht ruck-zuck, das möchte ich auch so lassen.

INSERT ist eine DB-Schreiboperation. Deren Geschwindigkeit hängt von einigen Faktoren ab, die man ebenfalls beeinflussen kann:

• Beim Schreiben von vielen gleichartigen Daten in dieselbe Tabelle lassen sich INSERTs zusammenfassen zu einem einzigen Befehl. Der wird dann insgesamt schneller ausgeführt, als die Summe aller Einzelbefehle.

• Wenn die Datenbank parallel in derselben Tabelle auch viel gelesen wird, wäre es eine Idee, die Storage-Engine zu checken. MyISAM sperrt zum Schreiben immer die gesamte Tabelle, InnoDB sperrt nur den jeweiligen Datensatz.

• Das Schreiben von Indexen kostet ebenfalls zusätzliche Zeit. Zuviele Indexe sind also eher negativ, insbesondere wenn sie tatsächlich nirgendwo benötigt werden.

Es sind halt viele Schleifendurchläufe, da machen wahrscheinlich kleine Verbesserungen etwas aus.

Definitiv. Der Gewinn von einer Millisekunde pro Schleifendurchlauf sorgt bei hunderttausend Durchläufen für einen Zeitgewinn von hundert Sekunden.

Deshalb ist es innerhalb deiner Berechnungsschleife auch wichtig, dass du überflüssigen Code rauswirfst. Alle Prüfungen, die sich in jeder Schleife wiederholen, deren Ergebnis sich innerhalb der Schleife aber nicht ändern kann, sind überflüssig und gehören nach außerhalb der Schleife platziert.

Beispielsweise:

if ($user_array!=NULL) { - warum prüfst du immer und immer wieder, ob deine Benutzerdaten vorhanden sind?

$uid = $i[uid]; - Warum kopierst du Variablen? Nutze doch einfach direkt $i[uid].

Außerdem halte ich es für extrem fragwürdig, dass du vor jedem INSERT noch ein SELECT auf die Datenbank machst. Damit kriegst du wirklich jede Performance kaputt. Wenn dein Skript als Auswertungstool statistische Daten sammelt und zwischenspeichert, dann kann es die errechneten Werte auch erstmal in einem Array ablegen, und erst ganz am Ende in die Tabelle schreiben. Vorteil: Der prüfende Zugriff, ob ein Ergebnis schon existiert, kommt ohne DB-Query aus und ist tausendmal schneller.

- Sven Rautenberg

[Tilo]

Deine Hilfe ist wirklich super. Ich werde mich mal daran machen, und das umsetzen. Danke Dir.

Gruß
Tilo

[Tilo]

Hi,

[UID (5)] => Array (
  [persnr] => 45
  [persnr4] => 0045
  [nachname] => F..
  [vorname] => R..
  [sollzeit] => 100
  [lohn] => 0
  [stdsatz_soll] => 0
  [verteilung] => Array(
    [0] => Array(
      [anteil] => 30
      [kst] => 2500)
    [1] => Array(
      [anteil] => 70
      [kst] => 2400)
    )
)

Durch diesen Aufbau habe ich jetzt einen Geschwindigkeitsvorteil.

Ich bin mir nicht mehr sicher, aber ich meine mit so einem ähnlichen Array Probleme bekommen zu haben. Das lag meines Erachtens daran, dass unterschiedliche Typen, d.h. Arrays und Strings/Zahlen nebeneinander vorkamen. Also dass Werte wie [nachname] parallel zu einem Array wie [verteilung] existieren. Dabei wurden Anfangsbuchstaben von bestimmten Werten kopiert und an undefinierte Stellen gesetzt. Kann sowas bei diesem Aufbau vorkommen?

Gruß
Tilo

[Sven Rautenberg]

Moin!

Ich bin mir nicht mehr sicher, aber ich meine mit so einem ähnlichen Array Probleme bekommen zu haben. Das lag meines Erachtens daran, dass unterschiedliche Typen, d.h. Arrays und Strings/Zahlen nebeneinander vorkamen. Also dass Werte wie [nachname] parallel zu einem Array wie [verteilung] existieren. Dabei wurden Anfangsbuchstaben von bestimmten Werten kopiert und an undefinierte Stellen gesetzt. Kann sowas bei diesem Aufbau vorkommen?

Sowas passiert nur, wenn du Mist baust. Der Zugriff auf Arrays mit Zahlenindex ist identisch zum Zugriff auf einzelne Zeichen eines Strings: $array['key'][2]

Wenn du auf den falschen Key zugreifst, nämlich fälschlich auf einen String statt ein Array, und dann Werte reinschreibst, entsteht Datenmüll. Und selbst wenn du nur liest, kriegst du halt exakt einen Buchstaben (genauer gesagt ein Byte als Zeichen).

- Sven Rautenberg