Jnnbo: Ausgabe in Kategorien zusammenfassen

Moin,

meine Funktion sieht wie folgt aus

function test456($mysqli, $lo) {
$stmt = $mysqli->prepare("SELECT p_id, p_type, p_pkategorie, p_code, p_hersteller, p_serie, p_geraet, p_bezeichnung, p_bild, p_artnr, p_farbe, p_inhalt, p_preis, p_bestand, p_hinweis, p_status 
		FROM web_produkte WHERE p_geraet =? ");
$stmt->bind_param("s", $lo);
$stmt->execute();
$stmt->bind_result($p_id, $p_type, $p_pkategorie, $p_code, $p_hersteller, $p_serie, $p_geraet, $p_bezeichnung, $p_bild, $p_artnr, $p_farbe, $p_inhalt, $p_preis, $p_bestand, $p_hinweis, $p_status);
		$stmt->store_result();
	 	
		if($stmt->num_rows() >  0) {     
			while ($stmt->fetch()){
				$test456[] = array( 
					'p_id' 			=> $p_id,
					'p_type'		=> $p_type,
					'p_pkategorie'		=> $p_pkategorie, 
					'p_code'		=> $p_code,
					'p_hersteller' 		=> $p_hersteller, 
					'p_serie' 		=> $p_serie, 
					'p_geraet' 		=> $p_geraet, 
					'p_bezeichnung' 	=> $p_bezeichnung, 
					'p_bild' 		=> $p_bild, 
					'p_artnr' 		=> $p_artnr, 
					'p_farbe' 		=> $p_farbe, 
					'p_inhalt' 		=> $p_inhalt, 
					'p_preis' 		=> $p_preis,
					'p_bestand'		=> $p_bestand, 
					'p_hinweis'		=> $p_hinweis,
					'p_status'		=> $p_status
				);
			}
			return $test456;
			
			}
	}

Meine Ausgabe so

<?php foreach($test456 as $array){?>
<?php echo htmlspecialchars($array['p_code']); ?>
<?php } ?>

Klappt auch alles wunderbar, nun möchte ich die Ausgabe gerne etwas optimieren und zwar gibt es im Feld "p_pkategorie" Zahlen (Kategorien wie z.B. Toner, Tinte usw.), nach denen ich gerne die Ausgabe Gruppieren möchte, sprich im Feld "p_pkategorie" steht eine 1, dann sollte die Überschrift "1" lauten darunter alle Einträge die zu dieser Kategorie passen, in der gleichen Abfrage kommt vielleicht eine "3" vor, dann soll wieder eine neue Überschrift beginnen und darunter eben alle Artikel die zur Kategorie "3" passen.

Kann ich das mit meiner Funktion erreichen oder muss ich da noch weitere Funktionen erstellen.

akzeptierte Antworten

  1. Tach!

    [...] sprich im Feld "p_pkategorie" steht eine 1, dann sollte die Überschrift "1" lauten darunter alle Einträge die zu dieser Kategorie passen, in der gleichen Abfrage kommt vielleicht eine "3" vor, dann soll wieder eine neue Überschrift beginnen und darunter eben alle Artikel die zur Kategorie "3" passen.

    Was du möchtest, nennt sich Gruppenwechsel. Man merkt sich den vorhergehenden Wert und vergleicht den aktuellen damit. Weicht er ab, hast du eine neue Gruppe und kannst dann das ausgeben, was da ausgegeben werden soll (sprich die Überschrift).

    dedlfix.

    1. Liebe Mitdenker, liebe Wissende, liebe Neugierige,

      [...] sprich im Feld "p_pkategorie" steht eine 1, dann sollte die Überschrift "1" lauten darunter alle Einträge die zu dieser Kategorie passen, in der gleichen Abfrage kommt vielleicht eine "3" vor, dann soll wieder eine neue Überschrift beginnen und darunter eben alle Artikel die zur Kategorie "3" passen.

      Was du möchtest, nennt sich Gruppenwechsel. Man merkt sich den vorhergehenden Wert und vergleicht den aktuellen damit. Weicht er ab, hast du eine neue Gruppe und kannst dann das ausgeben, was da ausgegeben werden soll (sprich die Überschrift).

      Zweckmäßigerweise sollte die Liste vorher nach der zu gruppierenden Spalte in erster Kategorie sortiert sein. Untersortierung innerhalb der Gruppe nach einer zweiten Kategorie ist oft zusätzlich sinnvoll.

      Spirituelle Grüße
      Euer Robert
      robert.r@online.de

      --
      Möge der wahre Forumsgeist ewig leben!
    2. Hallo dedlfix,

      Was du möchtest, nennt sich Gruppenwechsel. Man merkt sich den vorhergehenden Wert und vergleicht den aktuellen damit. Weicht er ab, hast du eine neue Gruppe und kannst dann das ausgeben, was da ausgegeben werden soll (sprich die Überschrift).

      hab dazu hier etwas gefunden, allerdings kann ich damit nicht wirklich etwas anfangen. Kennst du eine Seite, wo das gut beschrieben wird?

      1. Liebe Mitdenker, liebe Wissende, liebe Neugierige,

        Was du möchtest, nennt sich Gruppenwechsel. Man merkt sich den vorhergehenden Wert und vergleicht den aktuellen damit. Weicht er ab, hast du eine neue Gruppe und kannst dann das ausgeben, was da ausgegeben werden soll (sprich die Überschrift).

        hab dazu hier etwas gefunden, allerdings kann ich damit nicht wirklich etwas anfangen. Kennst du eine Seite, wo das gut beschrieben wird?

        Ich habe Dir das mal als Beispiel gepostet.

        Du musst auch nicht in jeder Zeile den PHP-Parser ein- und ausschalten, sondern kannst das am Anfang und am Ende eines mehrzeiligen Programmstückes tun.

        Spirituelle Grüße
        Euer Robert
        robert.r@online.de

        --
        Möge der wahre Forumsgeist ewig leben!
  2. Liebe Mitdenker, liebe Wissende, liebe Neugierige,

    meine Funktion sieht wie folgt aus

    function test456($mysqli, $lo) {
    $stmt = $mysqli->prepare("SELECT p_id, p_type, p_pkategorie, p_code, p_hersteller, p_serie, p_geraet, p_bezeichnung, p_bild, p_artnr, p_farbe, p_inhalt, p_preis, p_bestand, p_hinweis, p_status 
    		FROM web_produkte WHERE p_geraet =? ");
    $stmt->bind_param("s", $lo);
    $stmt->execute();
    $stmt->bind_result($p_id, $p_type, $p_pkategorie, $p_code, $p_hersteller, $p_serie, $p_geraet, $p_bezeichnung, $p_bild, $p_artnr, $p_farbe, $p_inhalt, $p_preis, $p_bestand, $p_hinweis, $p_status);
    		$stmt->store_result();
    	 	
    		if($stmt->num_rows() >  0) {     
    			while ($stmt->fetch()){
    				$test456[] = array( 
    					'p_id' 			=> $p_id,
    					'p_type'		=> $p_type,
    					'p_pkategorie'		=> $p_pkategorie, 
    					'p_code'		=> $p_code,
    					'p_hersteller' 		=> $p_hersteller, 
    					'p_serie' 		=> $p_serie, 
    					'p_geraet' 		=> $p_geraet, 
    					'p_bezeichnung' 	=> $p_bezeichnung, 
    					'p_bild' 		=> $p_bild, 
    					'p_artnr' 		=> $p_artnr, 
    					'p_farbe' 		=> $p_farbe, 
    					'p_inhalt' 		=> $p_inhalt, 
    					'p_preis' 		=> $p_preis,
    					'p_bestand'		=> $p_bestand, 
    					'p_hinweis'		=> $p_hinweis,
    					'p_status'		=> $p_status
    				);
    			}
    			return $test456;
    			
    			}
    	}
    

    Meine Ausgabe so

    <?php foreach($test456 as $array){?>
    <?php echo htmlspecialchars($array['p_code']); ?>
    <?php } ?>
    

    Klappt auch alles wunderbar, nun möchte ich die Ausgabe gerne etwas optimieren und zwar gibt es im Feld "p_pkategorie" Zahlen (Kategorien wie z.B. Toner, Tinte usw.), nach denen ich gerne die Ausgabe Gruppieren möchte, sprich im Feld "p_pkategorie" steht eine 1, dann sollte die Überschrift "1" lauten darunter alle Einträge die zu dieser Kategorie passen, in der gleichen Abfrage kommt vielleicht eine "3" vor, dann soll wieder eine neue Überschrift beginnen und darunter eben alle Artikel die zur Kategorie "3" passen.

    Kann ich das mit meiner Funktion erreichen oder muss ich da noch weitere Funktionen erstellen.

    Das Ergebnisarray sollte zweckmäßigerweise nach der Spalte, nach der Du die Gruppen bilden willst, sortiert sein. Dann funktiniert der Gruppenwechsel so, wie Dedlfix ihn schon kurz beschrieben hat.

    <?php 
        if (is_array($test456))  ## sind Artikeldaten da?
        {
            $group = '';         ## bisher gab es keine Gruppe, also initialisieren
    
            foreach($test456 as $record)
            {
                if ($group != $record['p_pkategorie'])  ## Wenn die Grupp von der vorigen abweicht
                {   
                    echo '<h2>' . htmlspecialchars($record['p_pkategorie']) . "</h2>\r\n";  ## Gruppe ausgeben
                    $group = $record['p_pkategorie'];  ## neue Gruppe merken
                }
    
                echo '<p>' . htmlspecialchars($record['p_code']) ."</p>\r\n";  ## Artikeldaten ausgeben
            }
        }
     
    ?>
    

    ungetestet. Fehler darfst Du bitte hier mitteilen

    Du solltest Dir angewöhnen, sprechende Variablenbezeichner zu wählen. Das vereinfacht das Programmieren in größeren Programmen erheblich :-)

    Spirituelle Grüße
    Euer Robert
    robert.r@online.de

    --
    Möge der wahre Forumsgeist ewig leben!
    1. Das Ergebnisarray sollte zweckmäßigerweise nach der Spalte, nach der Du die Gruppen bilden willst, sortiert sein. Dann funktiniert der Gruppenwechsel so, wie Dedlfix ihn schon kurz beschrieben hat.

      Das ist kein Muss und kann teilweise sogar unerwünscht sein. Wenn man einen eher funktionalen Ansatz wählt, dann kann diese Randbedingung, die sich bei prozeduraler Programmierung ergibt, vermieden werden. Ich würde auch dazu tendieren, den Gruppenwechsel von der unmittelbaren Ausgabe zu entkoppeln und stattdessen in einem Zwischenschritt für jede Gruppe eine eigene Kollektion anzulegen, sodass man ein Array von Arrays erhält. Zum Beispiel:

      $groups = array_reduce($flatArray, function ($accumulator, $entry){
         $group = $entry['p_pkategorie'];
         if (!is_array($accumulator[$group]) {
            $accumulator[$group]] = array();
         }
         $accumulator[$group][] = $entry;
         return $accumulator
      }, array());
      

      In diesem Snippet wird das flache Eingabearray $flatArray Zeile für Zeile durchlaufen, für jeden Eintrag im Array wird dann festgestellt, ob es bereits eine Kollektion für die zugehörige Gruppe gibt. Falls nicht, dann wird ein neue Kollektion angelegt. Am Ende einer Iteration wird der Eintrag schließlich der Kollektion hinzugefügt.

      Dieser Gruppenwechsel ist leider nicht wirklich wiederverwendbar, weil $entry['p_pkategorie'] für diesen speziellen Gruppenwechsel zugeschnitten ist, das Verhalten kann man weiter abstrahieren und sich so eine wiederverwendbare Funktion für den Gruppenwechsel basteln:

      function groupBy ($column, array $flatArray) {
         return array_reduce($flatArray, function ($accumulator, $entry) use ($column) {
            $group = $entry[$column];
            if (!is_array($accumulator[$group]) {
               $accumulator[$group] = array();
            }
            $accumulator[$group][] = $entry;
            return $accumulator
         }, array());
      }
      

      Diese Funktion ist wiederverwendbar und in der Praxis für viele Fälle ausreichend. Manchmal hat man aber auch den Fall, dass man den Gruppenwechsel nicht einfach an einer Spalte im Array ausmachen kann, zum Beispiel wenn die Einträge im Eingabearray Objekte sind, oder wenn die Gruppenzugehörigkeit aus mehreren Spalten/Eigenschaften eines Eintrags abgeleitet wird. Wir können unsere Funktion weiter abstrahieren, indem wir als ersten Parameter keinen Spaltennamen mehr entgegen nehmen, sondern einfach eine Funktion, die die Gruppenzugehörigkeit auf irgendein beliebige Art ermittelt.

      function groupBy (callable $groupId, array $flatArray) {
         return array_reduce( $flatArray, function ($accumulator, $entry) use ($groupId) {
            $group = groupId($entry);
            if (!is_array($accumulator[$group]) {
               $accumulator[$group] = array();
            }
            $accumulator[$group][] = $entry;
            return $accumulator
         }, array());
      }
      
      1. Liebe Mitdenker, liebe Wissende, liebe Neugierige,

        Das Ergebnisarray sollte zweckmäßigerweise nach der Spalte, nach der Du die Gruppen bilden willst, sortiert sein. Dann funktiniert der Gruppenwechsel so, wie Dedlfix ihn schon kurz beschrieben hat.

        Das ist kein Muss und kann teilweise sogar unerwünscht sein.

        Wenn man so vorgehen will, wie Dedlfix das skizziert hat und ich ausformuliert, dann schon.

        Wenn man einen eher funktionalen Ansatz wählt, dann kann diese Randbedingung, die sich bei prozeduraler Programmierung ergibt, vermieden werden. Ich würde auch dazu tendieren, den Gruppenwechsel von der unmittelbaren Ausgabe zu entkoppeln und stattdessen in einem Zwischenschritt für jede Gruppe eine eigene Kollektion anzulegen, sodass man ein Array von Arrays erhält. Zum Beispiel:

        $groups = array_reduce($flatArray, function ($accumulator, $entry){
           $group = $entry['p_pkategorie'];
           if (!is_array($accumulator[$group]) {
              $accumulator[$group]] = array();
           }
           $accumulator[$group][] = $entry;
           return $accumulator
        }, array());
        

        In diesem Snippet wird das flache Eingabearray $flatArray Zeile für Zeile durchlaufen, für jeden Eintrag im Array wird dann festgestellt, ob es bereits eine Kollektion für die zugehörige Gruppe gibt. Falls nicht, dann wird ein neue Kollektion angelegt. Am Ende einer Iteration wird der Eintrag schließlich der Kollektion hinzugefügt.

        Dieser Gruppenwechsel ist leider nicht wirklich wiederverwendbar, weil $entry['p_pkategorie'] für diesen speziellen Gruppenwechsel zugeschnitten ist, das Verhalten kann man weiter abstrahieren und sich so eine wiederverwendbare Funktion für den Gruppenwechsel basteln:

        function groupBy ($column, array $flatArray) {
           return array_reduce($flatArray, function ($accumulator, $entry) use ($column) {
              $group = $entry[$column];
              if (!is_array($accumulator[$group]) {
                 $accumulator[$group] = array();
              }
              $accumulator[$group][] = $entry;
              return $accumulator
           }, array());
        }
        

        Diese Funktion ist wiederverwendbar und in der Praxis für viele Fälle ausreichend. Manchmal hat man aber auch den Fall, dass man den Gruppenwechsel nicht einfach an einer Spalte im Array ausmachen kann, zum Beispiel wenn die Einträge im Eingabearray Objekte sind, oder wenn die Gruppenzugehörigkeit aus mehreren Spalten/Eigenschaften eines Eintrags abgeleitet wird. Wir können unsere Funktion weiter abstrahieren, indem wir als ersten Parameter keinen Spaltennamen mehr entgegen nehmen, sondern einfach eine Funktion, die die Gruppenzugehörigkeit auf irgendein beliebige Art ermittelt.

        function groupBy (callable $groupId, array $flatArray) {
           return array_reduce( $flatArray, function ($accumulator, $entry) use ($groupId) {
              $group = groupId($entry);
              if (!is_array($accumulator[$group]) {
                 $accumulator[$group] = array();
              }
              $accumulator[$group][] = $entry;
              return $accumulator
           }, array());
        }
        

        Dein eher theoretischer Ansatz ist zwar möglich und mag auch "elegant" sein, ist aber um einiges teuerer, als der "Einmaldurchlauf". Aber man kann Dinge auch beliebig kompliziert machen, obwohl sie einfach behandelt sogar leicht verständlich sind ;-P

        Spirituelle Grüße
        Euer Robert
        robert.r@online.de

        --
        Möge der wahre Forumsgeist ewig leben!
        1. Dein eher theoretischer Ansatz ist zwar möglich und mag auch "elegant" sein, ist aber um einiges teuerer, als der "Einmaldurchlauf".

          Das ist keine pure Theorie, gerade in der JavaScript-Welt ist solcher Code eher der Normalfall, in PHP ist funktionale Programierung noch recht jung und unerforscht, aber auch da zeichnet das Interesse eine positive Tendenz ab.

          Den Tradeoff Wiederverwendbarkeit für Performanz würde ich zudem ohne zu zögern fast immer eingehen, jede IO-Operation wirkt sich vermutlich um Potenzen stärker auf die reale Laufzeit aus. Ansonsten bleibt immernoch der Griff zu einer Lazy-Evaluation-Bibliothek, ebenfalls ein Konzept der funktionalen Programmierung, damit lassen sich Iterationen (wie hier die Datenaufbereitung und die Ausgabe) diskret modellieren und bei der Ausführung wird trotzdem jeder Datensatz nur höchstens einmal iteriert. Bei komplexen Kontrollflüssen wäre man dann wahrscheinlich sogar besser dran.

          Aber man kann Dinge auch beliebig kompliziert machen, obwohl sie einfach behandelt sogar leicht verständlich sind ;-P

          Mir ging es nicht primär um Einfachheit, mir ging es in erster Linie um Wiederverwendbarkeit und Robustheit (gegenüber Vorsortierung). Die Einfachheit folgt dann bei der Anwendung der Funktion, wenn das Problem sich ein zweites oder drittes Mal stellt, muss man nicht wieder den verwobenen, prozeduralen Code runterrackern, sondern kann die einmal geschriebene Funktion dann einfach wiederverwenden.

        2. Aber man kann Dinge auch beliebig kompliziert machen, obwohl sie einfach behandelt sogar leicht verständlich sind ;-P

          Ich habe nochmal in die Richtung recherchiert und die groupBy-Funktion taucht in ähnlicher Form in diversen Bibliotheken immer wieder als Helferlein auf. Das sollte jeden Entwickler, der dieses Muster einmal verstanden hat, freuen, denn das erleichert es ihm, sein Wissen auf neue Umgebungen zu übertragen und gleich produktiv zu sein. Außerdem vereinfacht das natürlich die Kommunikation unter Entwicklern enorm, weil die schmutzigen Details des Gruppenwechsels nicht ständig aufs Neue diskutiert werden müssen, man kann stattdessen mit einem Stichwort sofort eine Lösung zu dem Problem angeben. Darin liegt für mich persönlich die wahre Eleganz dieses Ansatzes.

    2. Hallo robertroth,

      Das Ergebnisarray sollte zweckmäßigerweise nach der Spalte, nach der Du die Gruppen bilden willst, sortiert sein. Dann funktiniert der Gruppenwechsel so, wie Dedlfix ihn schon kurz beschrieben hat.

      <?php 
          if (is_array($test456))  ## sind Artikeldaten da?
          {
              $group = '';         ## bisher gab es keine Gruppe, also initialisieren
      
              foreach($test456 as $record)
              {
                  if ($group != $record['p_pkategorie'])  ## Wenn die Grupp von der vorigen abweicht
                  {   
                      echo '<h2>' . htmlspecialchars($record['p_pkategorie']) . "</h2>\r\n";  ## Gruppe ausgeben
                      $group = $record['p_pkategorie'];  ## neue Gruppe merken
                  }
      
                  echo '<p>' . htmlspecialchars($record['p_code']) ."</p>\r\n";  ## Artikeldaten ausgeben
              }
          }
       
      ?>
      

      ungetestet. Fehler darfst Du bitte hier mitteilen

      vielen vielen vielen vielen Dank, es funktioniert wunderbar. Sorry dass ich mich jetzt erst wieder melde, hatte heute Nachmittag kein Internet (schreckliche Zeit) :/ So schaut meine Ausgabe derzeit aus, genau was ich erwartet habe :)

      Alternativ-Text

      1. Hallo robertroth,

        ich hab noch eine Frage zu deinem Code, meine Ausgabe sieht nun so aus

        Alternativ-Text

        möchte gerne zwischen die einzelnen Rubriken Abstand bringen, ich dachte ich erreiche das so

                <?php 
        		$group = '';         ## bisher gab es keine Gruppe, also initialisieren
        
                foreach($test456 as $record)
                {
                    if ($group != $record['p_pkategorie'])  ## Wenn die Grupp von der vorigen abweicht
                    {   
                        echo "<div class=\"klio\">";
        				echo '<h2 class="toner_titel">' . htmlspecialchars($record['pk_titel']) . "</h2>";  ## Gruppe ausgeben
                        $group = $record['p_pkategorie'];  ## neue Gruppe merken
                    }
        
                    echo '<p>' . htmlspecialchars($record['p_bezeichnung']) ."</p>";  ## Artikeldaten ausgeben
                } 
        					echo "</div>";
        		?>
        

        Hier auf mein "<div class="klio">" achten, leider ohne Erfolg. Bei "## Gruppe ausgeben" fängt doch die jeweilige Kategorie an und hört bei "## Artikeldaten ausgeben" auf?

        1. Liebe Mitdenker, liebe Wissende, liebe Neugierige,

          Hallo robertroth,

          ich hab noch eine Frage zu deinem Code, meine Ausgabe sieht nun so aus

          Alternativ-Text

          möchte gerne zwischen die einzelnen Rubriken Abstand bringen, ich dachte ich erreiche das so

                  <?php 
          		$group = '';         ## bisher gab es keine Gruppe, also initialisieren
          
                      $groupend = '';
          
              foreach($test456 as $record)
              {
                  if ($group != $record['p_pkategorie'])  ## Wenn die Grupp von der vorigen abweicht
                  {   
                      echo $groupend;
          
                        echo "<div class=\"klio\">";
          
            		echo '<h2 class="toner_titel">' . htmlspecialchars($record['pk_titel']) . "</h2>";  ## Gruppe ausgeben
                      $group = $record['p_pkategorie'];  ## neue Gruppe merken
          
                        $groupend = "</div>\r\n";
          
                  }
          
                  echo '<p>' . htmlspecialchars($record['p_bezeichnung']) ."</p>";  ## Artikeldaten ausgeben
              } 
            			echo "</div>\r\n";
            ?>
          
          
          Hier auf mein "<div class=\"klio\">" achten, leider ohne Erfolg. Bei "## Gruppe ausgeben" fängt doch die jeweilige Kategorie an und hört bei "## Artikeldaten ausgeben" auf? 
          

          Ja, bei if( != ) fängt die neue Gruppe an und direkt davor hört die alte auf. Das bedeutet alo, dass die alte Gruppe erst beendet werden muss ( </div> ), bevor die neue anfängt. Nur bei der ersten Gruppe hört vorher keine alte auf. Das kannst du mit einem Flag oder einem Zähler lösen oder einem kleinen Intialisierungstrick. Den baue ich Dir mal ein.

          Spirituelle Grüße
          Euer Robert
          robert.r@online.de

          --
          Möge der wahre Forumsgeist ewig leben!
  3. Moin!

    function test456($mysqli, $lo) {
    

    Noch ein Tipp "neben" dem angefragten Problem. Es ist durchaus nicht völlig illegal sondern in der Mehrzahl der Fälle auch zur Sicherheit und vor allem der Bequemlichkeit des Programmierers angebracht, derart häufig wiederverwendete Objekte (oder Daten), hier $mysqli, in eine globale Variable (hier optimal $GLOBALS['mysqli']) zu speichern, statt diese in den Funktionsaufrufen mitzuschleppen.

    Jörg Reinholz

    1. function test456($mysqli, $lo) {
      

      Noch ein Tipp "neben" dem angefragten Problem. Es ist durchaus nicht völlig illegal sondern in der Mehrzahl der Fälle auch zur Sicherheit und vor allem der Bequemlichkeit des Programmierers angebracht, derart häufig wiederverwendete Objekte (oder Daten), hier $mysqli, in eine globale Variable (hier optimal $GLOBALS['mysqli']) zu speichern, statt diese in den Funktionsaufrufen mitzuschleppen.

      Buh! Niemals gloable Variablen für solche Zwecke missbrauchen, du müllst damit nicht einfach nur den globalen Gültigkeitsbereich zu, sondern machst dir auch eine ganze Abstaktionsschicht kaputt, weil alle Funktionsaufrufe dann auf ein und dem selben mysqli-Handle arbeiten. Wenn man einmal eine zweite Datenbank kontaktieren möchte, möchte man nicht alle seine Funktionen für diese Datenbank-Verbindung neuschreiben müssen. Dependency-Injection wäre eine elgantere Lösung für das Problem, das du ankreidest, und bei der man sich nicht fünfzig neue Probleme schafft.

    2. Liebe Mitdenker, liebe Wissende, liebe Neugierige,

      function test456($mysqli, $lo) {
      

      Noch ein Tipp "neben" dem angefragten Problem. Es ist durchaus nicht völlig illegal sondern in der Mehrzahl der Fälle auch zur Sicherheit und vor allem der Bequemlichkeit des Programmierers angebracht, derart häufig wiederverwendete Objekte (oder Daten), hier $mysqli, in eine globale Variable (hier optimal $GLOBALS['mysqli']) zu speichern, statt diese in den Funktionsaufrufen mitzuschleppen.

      Wenn schon "global", dann bitte eine Funktion, die das Handle liefert. Die kann dann auch berücksichtigen, mehrere Kanäle zu bedienen und|oder als Singleton zu arbeiten, usw.

          function test456(get_db_con(), $lo) 
          {
              ### ...
          }
      

      Und get_db_con($channel = 1, $duplicate = false) kann dann auch vorbelegte Funktionsargumente haben, die beim Aufruf nur angegeben werden müssen, wenn man die Abweichung vom Normalfall haben will.

      Der Vorteil:

      • Die Funktion ist globalen Scope von PHP überall verfügbar
      • Die Variable ist geschützt gegen versehentliche Veränderung

      Und objektorientiert ist noch viel mehr möglich, obwohl ich da der Klarheit halber keine geschützte Eigenschaft nehmen würde, sondern eine Methode.

      Spirituelle Grüße
      Euer Robert
      robert.r@online.de

      --
      Möge der wahre Forumsgeist ewig leben!
      1. Moin!

            function test456(get_db_con(), $lo) 
            {
                ### ...
            }
        

        Beim Erstellen der Funktion (das zeigt Dein Code) oder Methode wird das wohl nicht gehen - beim Aufruf der Funktion/Methode indes schon. Fragt sich aber, ob es dann nicht doch etwas einfacher und übersichtlicher wäre, gleich das "Datenbankverbindungsobjekt" zu übergeben.

        Jörg Reinholz

        1. Liebe Mitdenker, liebe Wissende, liebe Neugierige,

              function test456(get_db_con(), $lo) 
              {
                  ### ...
              }
          

          Beim Erstellen der Funktion (das zeigt Dein Code) oder Methode wird das wohl nicht gehen - beim Aufruf der Funktion/Methode indes schon. Fragt sich aber, ob es dann nicht doch etwas einfacher und übersichtlicher wäre, gleich das "Datenbankverbindungsobjekt" zu übergeben.

          Sorry, das war auch nicht so gemeint.

             echo test456(get_db_con(), $lo);
          

          Da war ich gedanklich wohl gerade woanders, wegen Telefon beim Schreiben...

          Spirituelle Grüße
          Euer Robert
          robert.r@online.de

          --
          Möge der wahre Forumsgeist ewig leben!
      2. Tach!

        Wenn schon "global", dann bitte eine Funktion, die das Handle liefert. Die kann dann auch berücksichtigen, mehrere Kanäle zu bedienen und|oder als Singleton zu arbeiten, usw.

            function test456(get_db_con(), $lo) 
            {
                ### ...
            }
        

        Syntaxfehler. An der Stelle werden Parameternamen erwartet.

        Und get_db_con($channel = 1, $duplicate = false) kann dann auch vorbelegte Funktionsargumente haben, die beim Aufruf nur angegeben werden müssen, wenn man die Abweichung vom Normalfall haben will.

        Wenn du das so machen willst, dann musst du jeder Funktion, die diese Funktion verwenden will, optionale Parameter spendieren, damit man da im Einzelfall was anderes holen kann. Und damit noch nicht genug, auch diese verwendenden Funktionen brauchen solche Parameter. Am Ende haben alle Funktionen diese Parameter und reichen sich gegenseitig die Default-Werte durch, nur weil es da mal einen Fall geben kann, der abweicht. Das Konzept gefällt mir nicht - oder ich habe es falsch verstanden.

        dedlfix.