ugrás a tartalomhoz

PHP class vélemény

tóthika · 2014. Aug. 14. (Cs), 20.44
Sziasztok!

Úgy érzem, hogy most már továbbléphetek egy másik programozási "taktika" felé (Bocs, ha most egy nagy marhaságot írtam :D), ezért nekiálltam egy kis olvasás után ezt megírni. Egy rendszerbe lenne beleépítve. Kérdésem annyi lenne, hogy ez így valahogy elfogadható-e, továbbtanulás szempontjából, és hogy gyorsabb-e egy ilyen osztály, mint 8 változó használata?

(Tudom, a kivételeknek majd utána kell néznem.)
  1. class Uzenet{  
  2.     //hiba kijelzése?  
  3.     private $hibajelzes = false;  
  4.       
  5.     private $profilid = 0;//üzenet-tulajdonos profiljának ID-je  
  6.     private $tipus = 0;//1-szöveges, 2-szöveg+médiafájl  
  7.     private $id = 0;//üzenet-száma  
  8.     private $megjelen = Array();//üzenet tartalma  
  9.     private $profkep = "";//felhasználó profilképje (aktuális)  
  10.     private $mediafel = "";//HA tipus == 2, akkor a médiafájl tartalma  
  11.     private $akkorinev = "";//az akkori neve  
  12.     private $ido = Array();//üzenet idejét tartalmazó tömb  
  13.       
  14.     public function setProfil($id)  
  15.     {  
  16.         if($id != "" && $id && $this)  
  17.         {  
  18.             $this->profilid = $id;  
  19.             return true;  
  20.         }  
  21.         else  
  22.         {  
  23.             if($this->hibajelzes == true)  
  24.             {  
  25.                 return "!2!";  
  26.             }  
  27.         }  
  28.     }  
  29.     public function getProfil()  
  30.     {  
  31.         if($this->profilid != "" && $this->profilid && $this)  
  32.         {  
  33.             return $this->profilid;  
  34.         }  
  35.         else  
  36.         {  
  37.             if($this->hibajelzes == true)  
  38.             {  
  39.                 return "!3!";  
  40.             }  
  41.         }  
  42.     }  
  43.     public function setTipus($type)  
  44.     {  
  45.         if($type != "" && $type && $this)  
  46.         {  
  47.             $this->tipus = $type;  
  48.             return true;  
  49.         }  
  50.         else  
  51.         {  
  52.             if($this->hibajelzes == true)  
  53.             {  
  54.                 return "!2!";  
  55.             }  
  56.         }  
  57.     }  
  58.     public function getTipus()  
  59.     {  
  60.         if($this->tipus != "" && $this->tipus && $this)  
  61.         {  
  62.             return $this->tipus;  
  63.         }  
  64.         else  
  65.         {  
  66.             if($this->hibajelzes == true)  
  67.             {  
  68.                 return "!3!";  
  69.             }  
  70.         }  
  71.     }  
  72.     public function setUzenetId($id)  
  73.     {  
  74.         if($id != "" && $id && $this)  
  75.         {  
  76.             $this->id = $id;  
  77.             return true;  
  78.         }  
  79.         else  
  80.         {  
  81.             if($this->hibajelzes == true)  
  82.             {  
  83.                 return "!2!";  
  84.             }  
  85.         }  
  86.     }  
  87.     public function getUzenetId()  
  88.     {  
  89.         if($this->id != "" && $this->id && $this)  
  90.         {  
  91.             return $this->id;  
  92.         }  
  93.         else  
  94.         {  
  95.             if($this->hibajelzes == true)  
  96.             {  
  97.                 return "!3!";  
  98.             }  
  99.         }  
  100.     }  
  101.     public function setUzenet($el$ma)  
  102.     {  
  103.         if($el != "" && $ma != "" && $el && $ma && $this)  
  104.         {  
  105.             $this->megjelen[0] = $el;  
  106.             $this->megjelen[1] = $ma;  
  107.             return true;  
  108.         }  
  109.         else  
  110.         {  
  111.             if($this->hibajelzes == true)  
  112.             {  
  113.                 return "!2!";  
  114.             }  
  115.         }  
  116.     }  
  117.     public function getUzenet()  
  118.     {  
  119.         if($this->megjelen != "" && $this->megjelen && $this)  
  120.         {  
  121.             return $this->megjelen;  
  122.             return true;  
  123.         }  
  124.         else  
  125.         {  
  126.             if($this->hibajelzes == true)  
  127.             {  
  128.                 return "!3!";  
  129.             }  
  130.         }  
  131.     }  
  132.     public function setImg($img)  
  133.     {  
  134.         if($img != "" && $img && $this)  
  135.         {  
  136.             $this->profkep = $img;  
  137.             return true;  
  138.         }  
  139.         else  
  140.         {  
  141.             if($this->hibajelzes == true)  
  142.             {  
  143.                 return "!2!";  
  144.             }  
  145.         }  
  146.     }  
  147.     public function getImg()  
  148.     {  
  149.         if($this->profkep != "" && $this->profkep && $this)  
  150.         {  
  151.             return $this->profkep;  
  152.         }  
  153.         else  
  154.         {  
  155.             if($this->hibajelzes == true)  
  156.             {  
  157.                 return "!3!";  
  158.             }  
  159.         }  
  160.     }  
  161.     public function setImgUp($img)  
  162.     {  
  163.         if($img != "" && $img && $this)  
  164.         {  
  165.             $this->media = $img;  
  166.             return true;  
  167.         }  
  168.         else  
  169.         {  
  170.             if($this->hibajelzes == true)  
  171.             {  
  172.                 return "!2!";  
  173.             }  
  174.         }  
  175.     }  
  176.     public function getImgUp()  
  177.     {  
  178.         if($this->media != "" && $this->media && $this)  
  179.         {  
  180.             return $this->media;  
  181.         }  
  182.         else  
  183.         {  
  184.             if($this->hibajelzes == true)  
  185.             {  
  186.                 return "!3!";  
  187.             }  
  188.         }  
  189.     }  
  190.     public function setDBNev($nev)  
  191.     {  
  192.         if($nev != "" && $nev && $this)  
  193.         {  
  194.             $this->akkorinev = $nev;  
  195.             return true;  
  196.         }  
  197.         else  
  198.         {  
  199.             if($this->hibajelzes == true)  
  200.             {  
  201.                 return "!2!";  
  202.             }  
  203.         }  
  204.     }  
  205.     public function getDBNev()  
  206.     {  
  207.         if($this->akkorinev != "" && $this->akkorinev && $this)  
  208.         {  
  209.             return $this->akkorinev;  
  210.         }  
  211.         else  
  212.         {  
  213.             if($this->hibajelzes == true)  
  214.             {  
  215.                 return "!3!";  
  216.             }  
  217.         }  
  218.     }  
  219.     public function setIdo($ido)  
  220.     {  
  221.         if($ido != "" && $ido && $this)  
  222.         {  
  223.             for($io=0;$io<count(explode(","$ido));$io++)  
  224.             {  
  225.                 $val = $this->ido;  
  226.                 $val[$io] = explode(","$ido);  
  227.                 $val[$io] = $val[$io][$io];  
  228.             }  
  229.             return true;  
  230.         }  
  231.         else  
  232.         {  
  233.             if($this->hibajelzes == true)  
  234.             {  
  235.                 return "!2!";  
  236.             }  
  237.         }  
  238.     }  
  239.     public function getIdo()  
  240.     {  
  241.         $valt = "";  
  242.         if($this->ido != "" && $this->ido && $this)  
  243.         {  
  244.             for($iu=0;$iu<count($this->ido);$iu++)  
  245.             {  
  246.                 $valt .= $this->ido[$iu];  
  247.             }  
  248.             if($valt != "" && $valt && $this)  
  249.             {  
  250.                 return $valt;  
  251.             }  
  252.             else  
  253.             {  
  254.                 if($this->hibajelzes == true)  
  255.                 {  
  256.                     return "!3!";  
  257.                 }  
  258.             }  
  259.         }  
  260.         else  
  261.         {  
  262.             if($this->hibajelzes == true)  
  263.             {  
  264.                 return "!3!";  
  265.             }  
  266.         }  
  267.     }  
  268. }  
  269.   
  270. $ll = new Uzenet;  
  271. echo $ll->setUzenet("Rövid cím""Hosszú üzenet");  
  272. $lu = $ll->getUzenet();  
  273. var_dump($lu);  
 
1

Kezdetnek nem rossz, pár

Hidvégi Gábor · 2014. Aug. 14. (Cs), 23.23
Kezdetnek nem rossz, pár apróság, ami feltűnik:
- if($id != "" && $id && $this) A $this elvileg mindig igaz, mivel az objektum példányosítva lett, tehát létezik. A $id mindig igaz, ha a $id != "" is igaz. Tehát végeredményben elég így: if ($id) { Persze ez az ellenőrzés magában nem ér túl sokat.
- a visszaadott hibakódjaid egyrészt nem túl beszédesek (ez nem olyan nagy gond, a fogadó oldalnak kell tudnia, mit jelentenek), másrészt viszont túl kevés van belőlük, mármint csak kétfajtát adsz vissza, de jóval többfajta hiba történhet. Ez azt jelenti, hogy a hibakezelésnek kell viszonylag bonyolultnak lennie.
- public function setUzenet($el, $ma)Este 11-kor én már nem fogom kitalálni, ezek a paraméterek miknek a rövidítései, és fél év múlva te sem fogod tudni.
- for($io=0;$io<count(explode(",", $ido));$io++)Ez minden ciklusban lefuttatja az explode-ot, ami teljesen felesleges. Így jobb: for($io=0, $l = count(explode(",", $ido)); $io < $l; $io++)
- olvashatóbb a kód, ha az írásjelek közé szóközt teszel
- setter metódusokban a változó értékadását követően érdemes visszaadni a változót, így néha meg lehet spórolni egy plusz getter hívást: return $this->id = $id;
- a metódusaid eléggé hasonlítanak egymásra, a későbbiekben ezeket akár össze lehetne vonni eggyé, persze egy plusz paraméterrel
2

Inkább method chain

szabo.b.gabor · 2014. Aug. 15. (P), 08.53
Én a setterben az érték helyett inkább a $this-t adnám vissza.
8

Miért?

Hidvégi Gábor · 2014. Aug. 15. (P), 09.31
Miért?

Szerkesztve: közben leesett. A hozzászólások címeit sokszor nem látom, számomra ez használhatósági probléma már a kezdetek óta.
3

Sztem ezt ne

szabo.b.gabor · 2014. Aug. 15. (P), 08.57
  1. if($this->hibajelzes == true)  
4

Nagyon verbose a kód szerintem

szabo.b.gabor · 2014. Aug. 15. (P), 09.01
  1. public function getUzenetId()    
  2. {    
  3.     if($this->id != "" && $this->id && $this)    
  4.     {    
  5.         return $this->id;    
  6.     }    
  7.     else    
  8.     {    
  9.         if($this->hibajelzes == true)    
  10.         {    
  11.             return "!3!";    
  12.         }    
  13.     }    
  14. }   
  15.   
  16. /* VS */  
  17. public function getUzenetId()    
  18. {    
  19.     return $this->id ? $this->id : $this->error('!3!');  
  20. }   
  21.   
  22. public function error($msg){  
  23.    return $this->hibajelzes ? $msg : null;  
  24. }  
5

Ellenben a változók..

szabo.b.gabor · 2014. Aug. 15. (P), 09.05
  1. $valt = "";    
  2. if($this->ido != "" && $this->ido && $this)    
  3. {    
  4.     for($iu=0;$iu<count($this->ido);$iu++)    
  5.     {    
  6.         $valt .= $this->ido[$iu];    
  7.     }    
  8.     if($valt != "" && $valt && $this)    
  9.     {    
  10.         return $valt;    
  11.     }    
  12.     else    
  13.     {    
  14.         if($this->hibajelzes == true)    
  15.         {    
  16.             return "!3!";    
  17.         }    
  18.     }    
  19. }   
..azok meg nagyon titokzatosak :D

Ahogy Gábor is mondta.
6

Setter ami nem set-el

szabo.b.gabor · 2014. Aug. 15. (P), 09.09
  1. public function setIdo($ido)    
  2. {    
  3.     if($ido != "" && $ido && $this)    
  4.     {    
  5.         for($io=0;$io<count(explode(","$ido));$io++)    
  6.         {    
  7.             $val = $this->ido;    
  8.             $val[$io] = explode(","$ido);    
  9.             $val[$io] = $val[$io][$io];    
  10.         }    
  11.         return true;    
  12.     }    
  13.     else    
  14.     {    
  15.         if($this->hibajelzes == true)    
  16.         {    
  17.             return "!2!";    
  18.         }    
  19.     }    
  20. }    
7

De mit csinál?

szabo.b.gabor · 2014. Aug. 15. (P), 09.23
  1. class Uzenet{  
  2.   private $profilid = 0;//üzenet-tulajdonos profiljának ID-je    
  3.   private $tipus = 0;//1-szöveges, 2-szöveg+médiafájl    
  4.   private $id = 0;//üzenet-száma    
  5.   private $megjelen = Array();//üzenet tartalma    
  6.   private $profkep = "";//felhasználó profilképje (aktuális)    
  7.   private $mediafel = "";//HA tipus == 2, akkor a médiafájl tartalma    
  8.   private $akkorinev = "";//az akkori neve    
  9.   private $ido = Array();//üzenet idejét tartalmazó tömb    
  10.   
  11.   public function __get($name){  
  12.     if(property_exists($this,$name)){  
  13.       return $this->$name;  
  14.     }else{  
  15.       return null;  
  16.     }  
  17.   }  
  18.   
  19.   public function __set($name,$val){  
  20.     if(property_exists($this->$name)){  
  21.       $this->$name = $val;  
  22.       return $this;  
  23.     }  
  24.     trigger_error('property not exists '.$name,E_USER_ERROR);  
  25.   }  
  26. }  
Minimálisan egyszerűsítve ennyit csinál a kódod. ami nem rossz, ha mondjuk egy paraméterhalmazt akarsz kezelni és nem nyomi array-t használni amiben ki tudja mi van.
9

Kérdésed..

szabo.b.gabor · 2014. Aug. 15. (P), 09.32
Kérdésedre válaszolva amúgy elfogadható. A hibakezelést mindenképp emeld ki külön függvénybe (DRY!), arra figyelj, hogy ha hiba van ne string-et adj vissza (akkor ez most hiba vagy érték igazából?!), hanem trigger_error vagy throw new Exception().

Gyorsabb-e? Nyilván nem, de nem észrevehető a lassulás. Hibamentesebb? Igen. Ez a lényeg. Bár ha gyorsaságon nem a futásidőt értjük, hanem a fejlesztésre fordított időt, akkor gyorsabb.

Amúgy használj egy jó IDE-t (PhpStorm a legjobb jelenleg, Eclipse PDT? is jó, az ingyen is van). Nehogy valaki elkezdjen sírni, hogy dehát Java, meg lassan indul el, meg 'mennyi memóriát eszik Atyaúristen!', mert sírvafakadok.

Hajrá!
10

Off: eclipse+java tegnap

H.Z. · 2014. Aug. 15. (P), 09.47
Off: eclipse+java
tegnap megnéztem a netbeans, Ubuntu repoból elérhető változatát.
Sírva menekültem vissza az eclipse-hez.
Részben mert ocsmánynak tartom a swinges megjelenését, másrészt meg érezhetően lassúbb, mint az eclipse. Utóbbi csak lassan indul, de naponta/hetente/évente egyszer elviselhető.
11

Fontok?

DonPepito · 2014. Aug. 15. (P), 13.21
Es a fontok is meg mindig ocsmanyak? Valami baja volt sokaig, hogy nem lehetett akarmilyen fontot megetetni vele (talan pont a swing miatt?), de ha sikerult, akkor se ugy nezett ki, ahogy annak ki kellene neznie. :)
12

Emlekbe

DonPepito · 2014. Aug. 15. (P), 13.26
Ezt a sort (de akar az egesz osztalyt) tedd el emlekbe! :) Vicces lesz majd visszanezned par honap/ev mulva. :)
  1. if($this->id != "" && $this->id && $this)  
Epp a minap beszelgettunk a kollegaval vicces hibakrol, elnezesekrol, elirasokrol, hatha kesobb neked is okoz majd egy-ket kellemes percet. :)
13

;)

tóthika · 2014. Aug. 22. (P), 02.59
Köszönöm mindenkinek a jótanácsát ;)