tring zu lernen oop und brauchen Hilfe zu verstehen, wie mehrere Variablen zu Funktion/Methoden übergeben

Question

ich neu zu oop und ich würde gerne wissen, wie mehrere Variablen/Eigenschaften zu einer Funktion innerhalb einer Klasse oder Methoden übergeben. zum Beispiel versuche ich, diesen Code unten zu oop zu konvertieren bitte nicht nur konvertieren es für mich id gerne wissen, wie man mehrere Eigenschaften statt mehrere Globals festlegen. sollte ich es mit dem Konstruktor tun oder es einfach über die Funktion übergeben, zB _comm ($ var1, $ var2, $ var3, $ var3) oder so? "neue comm_class ($ var1, $ var2, $ var3, $ var3);"

  function _comm($vresults) { 

      global $conn; 
      global $varfightno; 
      global $p_comm; 
      global $b_comm; 
      global $s_comm; 
      global $vtagid; 
      global $aid; 


      $fdetails = $conn->prepare("select distinct(fldusrcd) as vuser from tblplyrbetlisttemp where fldarenaid= ?"); 
      $fdetails->execute([$aid]); 
      $row_rscoll = $fdetails->fetch(); 

      if ($fdetails->rowCount() > 0) { 

       do { 

        $varuserid = $row_rscoll['vuser']; 
        $vtrandate = date("Y-m-d G:i:s"); 
        $T0  = 0; 

        if ($vresults == 'BANKER') { 

         $varodd = 'fldB0price'; 
         $win_comm = $b_comm; 

        } 

        if ($vresults == 'PLAYER') { 

         $varodd = 'fldP0price'; 
         $win_comm = $p_comm; 
        } 

        $sel_bet = $conn->prepare("select SUM({$varodd}),SUM(fldT0),SUM(fldPP0),SUM(fldBP0),SUM(fldAP0) FROM tblplyrbetlisttemp where fldarenaid = ? and fldusrcd = ?"); 
        $sel_bet->execute([$aid,$varuserid]); 
        $fetch_bet = $sel_bet->fetch(PDO::FETCH_NUM); 

        if ($sel_bet->rowCount() > 0) { 

         $sel_bet = null; 

          $OC = ($win_comm * $fetch_bet[0]) + 0; 
          $T0 = $fetch_bet[1] + 0; 
          $PP0 = $fetch_bet[2] + 0; 
          $BP0 = $fetch_bet[3] + 0; 
          $AP0 = $fetch_bet[4] + 0; 


         $sel_tranno = $conn->prepare("select max(fldtranno) from tblcollplasada where fldarenaid= ?"); 
         $sel_tranno->execute([$aid]); 
         $vtranno  = $sel_tranno->fetchColumn() + 1; 
         $sel_tranno = null; 

         $params  = array(
          $vtagid, 
          $vtranno, 
          $varfightno, 
          $vtrandate, 
          $varuserid, 
          $vresults, 
          $win_comm, 
          $s_comm, 
          $OC, 
          $T0, 
          $PP0, 
          $BP0, 
          $AP0, 
          $aid, 
         ); 
         $place_holders = implode(',', array_fill(0, count($params), '?')); 

         $ins   = $conn->prepare("INSERT INTO tblcollplasada(fldtag,fldtranno,fldfightno,fldtrandate,fldusrcd,fldwinner,fldpercomm,sys_comm,fld1010,fldD7,fldPP0,fldBP0,fldAP0,fldarenaid) VALUES({$place_holders})"); 
         $ins->execute($params); 
         $ins = null; 

        } 

       } while ($row_rscoll = $fdetails->fetch()); 

      } 

     } 

Answer 1

function test($one, $two, $three){} 
test($one, $two, $three); 

oder

function test($vars){} 
$vars = array('one' => $one, 'two' => $two, 'three' => $three); 
test($vars); 

Diese werden sowohl die Variablen in die Funktion übergeben, von dort können Sie sie jedoch verwenden Sie es wünschen.

Answer 2

Wenn die Variable in mehreren Funktionen der gleichen Klasse verwendet wird, ist die Weitergabe über die __construct() ein durchaus akzeptabler Weg.

Zum Beispiel global $conn; könnte in etwa so übergeben werden:

class ClassName 
{ 
    protected $conn = null; 

    public function __construct($conn) 
    { 
     $this->conn = $conn 
    } 
} 

Das ist besser, aber was noch besser ist, Type Hinting:

class ClassName 
{ 
    protected $conn = null; 

    public function __construct(PDO $conn) // Assuming it's PDO here 
    { 
     $this->conn = $conn 
    } 
} 

---

Ich empfehle nie in Argumente zu übergeben zu das Konstrukt über ein Array. Zum Beispiel __construct(['conn' => $conn ...], da Sie sich in IDEs von Autovervollständigung berauben und es macht die Verfolgung der Argumente schwieriger.

---

Es ist mehr als akzeptabel 3-4 Argumente an eine Funktion zu übergeben, mehr als das bedeutet in der Regel, dass die Funktion viele Dinge viel zu tun ist. Natürlich ist das alles subjektiv und sollte niemals als "in Stein gemeißelt" betrachtet werden. Es ist nur etwas zum Nachdenken.