Elkezdtem normálisan használni a PHP MVC + ORM keretemet, nagyon klassz.

Példának egy controller-em ennyi:

BrandController

Szerintem könnyen átlátható bárki számára, plusz vannak még mögötte bőven lehetőségek.

Készítettem egy olyan mutatványt, amivel az alábbiakat tudom elérni Javascript és CSS állományok esetén:

- verziózás: style.css --> style_16546546.css, amennyiben módosítom: style_878645654.css Teljesen automata, cache megoldva.
- bundling: ha egy mappában van mondjuk 10 külön js/css fájl, akkor azokat le tudom küldeni egyben verziózva a kliensnek, cache itt is megoldva. Ha megváltozik az egyik fájl, akkor a bundling maga, tehát nem fog beragadni semmi sem.

Programkódban:
<link rel="stylesheet" href="<?php $this->Css("css/style.css"); ?>">
Kliensen:
<link rel="stylesheet" href="WebResource/Css/css/style_1334495916.css">

A bundling még nincs szépítve:
<script defer src="<?php System\Web\Resources\Optimizer::JsBund("js/test"); ?>"></script>
Kliensen:
<script defer src="WebResource/JsBund/-1282421670/js/test"></script>

Amennyiben a bundled állományok egymásra épülnek, az könnyen kezelhető, ha az adott fájl tartalmazza a függőségeinek a nevét (ui.jquery.js jelleggel).

Hogy mire lesznek jók, majd elválik!

typeof

function typeof($variable) {
return \System\Type::Of($variable);
}

Ezzel semmi mást nem érek el, csak kicsit olvashatóbbá tehetem a kódomat, globális függvényeket egyébként nem szabad használni semmire sem szerintem, de ez jól jön.

// tudom, hogy nem kellene a teljes névtér
$this->_binders->Get(\System\Type::Of($cl->name))->BindModel($controller);

helyett

$this->_binders->Get(typeof($cl->name))->BindModel($controller);

using

function using(\System\IDisposable $source, $func) {
if (!is_callable($func)) {
throw new \BadFunctionCallException();
}

try {
$ret = $func($source);

$source->Dispose();

return $ret;
} catch (\Exception $exc) {
$source->Dispose();
throw $exc;
}
}

Semmi mást nem tudok vele kezdeni, mint használni egy erőforrást anélkül, hogy külön rá kellene néznem arra, hogy elengedi-e. Az adott erőforrásnak implementálnia kell az IDisposable interface-t, és már használható is:

Az egyik legkirályabb dolog!

public function CreateAction() {
//ez még kicsit sántít, de majd szebb lesz ez is :D
return $this->View('create', new ACGroup);
}

public function CreatePostAction($p1, ACGroup $group) {
//akármi
//return $this->View('create', $group);
}

A lényeg a második metódusban van: paraméterként már eleve egy objektummal dolgozhatok, csak azt kell megoldanom pl. edit esetén, hogy rendesen frissüljön az entitás az adatbázisban.

A rendszerem még kezdetleges, de pl. a típusos paraméter állhat akárhanyadik helyen, minden GET paramétert rendesen kezelek mellette, és a default binder mellett megadhatok mindenféle típusra külön bindert (pl. /*...*/ ACGroupBinder /*...*/ implements IModelBinder /*...*/).

Sk8erPeter-nek

$test = "qwertzuiopőúsdjhcsdlfjksdfsdf0";

$s = microtime(1);
for ($j = 0; $j < 1000000; ++$j) {
//mb_strlen($test) < 10;
//strlen($test) < 10;
!isset($test[10]);
}
die(microtime(1) - $s);

A cél az, hogy a szöveg hossza nem érheti el a 10 karaktert.
Tudom, mit jelent az mb_.

PHP-val képesek vagyunk megoldani azt, hogy egy-egy objektumunk iterálható legyen foreach-csel, avagy kompletten tömbként működjön. Most vegyük az egyszerűbbet, és nézzük meg, hogyan kell iterálható osztályt írnunk:

http://php.net/manual/en/class.iterator.php

Készen is vagyunk, örülünk.

De.

A PHP SPL könyvtárában akad egy olyan varázslat, amit IteratorAggregate-nek hívunk. Ez szintén segít megoldani a problémánkat, csak sokkal egyszerűbben. Itt csak egy metódust kell implementálnunk, ami visszaad egy ArrayIterator-t. Ugye, hogy sokkal szebb?!

De.

Van egy másik hatalmas előnye a második verziónak: gyorsabb.
Készítettem egy házitesztet, aminek az eredménye ez lett:
IteratorAggregate: 12,5+ másodperc
Iterator: Fatal error: Maximum execution time of 200 seconds exceeded in D:\xampp\htdocs\ref\index.php on line 26

Nem tudom, hogy vagytok vele, de én frissítem a kódjaimat.

public function __construct() {
$this->HttpContext = System\Web\HttpContext::Instance();
$this->FormState = System\Web\Mvc\FormState::Instance();
}

A Singleton (és bármi hozzá hasonló) nagyon szép meg jó, néha tényleg hasznos, de a fenti példa rossz, egy gyökér volt, aki csinálta (én). Mi ezzel a gond? Bármilyen globális állapot használata magában hordozza azt, hogy valami egyszer működik, egyszer nem, mert nem látunk a rendszer mélyébe, ahol a fekete mágia történik. Ha kapunk egy kódhalmazt, ami pl. használni vagy tesztelni kellene, és tele van ilyen globális megoldásokkal, akkor azon fogjuk kapni magunkat:

- fogalmunk sincs, hogyan kell használni
- nem tudunk rá tesztet írni az első pont miatt, vagy azért, mert egyszerűen nem tudunk teszteseteket beletolni a rendszerbe

Érdemes elgondolkodni azon is, ha pl. egy C# kódban valaki DateTime.Now-ot használ, az vajon globális állapotnak minősül-e, avagy sem? (Szerintem mindenképp annak.)

Singleton és más sötét erők használata helyett igyekezzen mindenki elmélyedni az igazi OO szépségeiben, próbálja meg felépíteni az alkalmazása objektumfáját úgy, hogy egyértelmű legyen, mi mitől és hogyan függ, melyik elemnek mire van szüksége (dependency injection).

SessionHandlerInterface

class SessionHandler implements SessionHandlerInterface {

public int close ( void ) {}
public int destroy ( string $sessionid ) {}
public int gc ( int $maxlifetime ) {}
public int open ( string $save_path , string $sessionid ) {}
public string read ( string $sessionid ) {}
public int write ( string $sessionid , string $sessiondata ) {}

}

Regisztrációja:

session_set_save_handler(new SessionHandler);

Ilyen helyett:

session_set_save_handler(
array($obj, "open"),
array($obj, "close"),
array($obj, "read"),
array($obj, "write"),
array($obj, "destroy"),
array($obj, "gc")
);

Cool.

A PHP 5.4-es verziója még nincs készen, de már most érdeme foglalkozni az újításokkal, hiszen a szokásos hibajavítások, teljesítményfokozások mellett nyelvi újdonságokat is fog hozni magával.

A címből villámgyorsan kiderül, mivel is szeretnék most foglalkozni: trait. PHP-ban ez egy új kód-újrahasználati lehetőséget biztosít számunkra, osztályainkat tudjuk bővíteni trait-ek használatával, de nem olyan módon, ahogyan azt öröklésnél megszokhattuk. Ha egy új osztályt származtatunk egy meglévőből, akkor tulajdonképpen a szülőt vertikálisan bővítjük, ezzel szemben a trait-ek ezt horizontálisan tudják megtenni.

Miért is jó ez nekünk? Szerintem mindenkivel előfordult már, hogy 2 osztályban hasonló dolgot szeretett volna megvalósítani, de örökléssel nem igazán azt érte volna el, amit szeretne, mert a két osztálynak egyébként semmi köze egymáshoz. Kézenfekvő példa a Singleton minta. Ezt magam is sokszor eljátszottam, eljátszom, hogy az osztályaim megírását azzal kezdem, hogy belezongorázom mindbe a Singleton-hoz szükséges elemeket, amelyek gyakorlatilag minden egyes osztálynál megegyeznek, ami hatalmas pazarlást jelenthet.

Manapság tilos a dohányzás gyakorlatilag mindenhol, ami nekem nem is gáz, mert nem élek vele, de...
Most senki sem tud kijelölt dohányzóhelyen tolni a cuccot, ezért a marha kimegy az utcára, ahol sikeresen a hozzám hasonlók pofájába tolja a füstöt. Nagyszerű, innentől gyakorlatilag élek vele.

És még egy kis suttyó is a buszmegállóban szívta.

Ez az, amit sose csinálj. Semmilyen nyelven. Semmilyen hasonló szituációban (nem IEnumerable és/vagy nem null).
Ha ilyet művelsz, akkor megtöröd a kód logikáját hiszen, ha valamitől azt várjuk, hogy egy bejárható típust ad vissza, erre kap egy null referenciát azért, mert nincs visszaadható elemet tartalmazó szekvencia, akkor felkészítés hiányában azonnal elszáll az alkalmazás. Nem olyan régen kellett "megoldanom ezt a problémát" C#-ban, íme pár lehetőség:

A faék
public IEnumerable<int> GetIntegers()
{
return new int[0];
}

Az elegáns
public IEnumerable<int> GetIntegers()
{
return Enumerable.Empty<int>();
}

Smart
public IEnumerable<int> GetIntegers()
{
yield break;
}

Hegesztettem egy "wrappert" a PHP DateTime osztályához. Annyi a lényege, hogy segítene használni, mert a beépített annyira nem egyszerű történet, én körülményesnek tartom, illetve a működése sem az igazi számomra. Ha valaki kipróbálja, az vegye észre, hogy nem a DateTime-tól van származtatva!
Nem teszteltem le mindenét.

DateTimeHelper

DayOfWeek

DateTimeParseException

TimeZones

Social codingra fel!

Napokban volt téma a PHP topikban a mysqli objektumorientált használatáról. Adnék egy kis vázat azoknak, akik még most ismerkednek a témával, és egy kis segítségre szorulnak.

[ DataContext osztály ]

[ Kicsi-gagyi teszt ]

Ha van még kérdés, nem kell habozni. Szerintem nem vészes a történet. Látszik, hogy a DataContext csak egy wrapper class a mysqli köré, hogy kicsit szebben és kényelmesebben lehessen használni.

Ha valaki kipróbálja, és valahol elhasal, szóljon, mert ez csak a sajátom (ORM modellemből van) kibelezett változata.

Ez történik, ha a PHP-t kényelmesen szeretnéd használni:

Nem minden sima tároló cucc, a TableEntity az ORM modellem része, de ez is szolgál tárolóként. Az egyes osztályokban csak az érdekesebb dolgokat emeltem ki, a többi vagy öröklött vagy unalmas(abb).

Az IEnumerable-től származó Select-et kellene még felturbózni azzal, hogy anonymous objecteket lehessen vele ügyesen gyártani, illetve egy Union kellene (TableEntity-be is feltétlenül, hiszen SQL-ben is van UNION).

Így már egészen jól lehet dolgozni.

A három testőr és D'Artagnan a web világában

Sokan fejlesztenek PHP alapú dolgokat, kicsivel kevesebben tolják igazán a szekeret és használnak IDE-t hozzá, és ebből a kicsi halmazból is csak kevesen tudják, hogy lehet a PHP-t normálisan is debuggolni. Magam sem használtam eddig semmilyen különleges debug megoldást, de most már eljutottam odaig, hogy a szakdolgozatomat úgysem tudom időre leadni, így adtam magamnak lehetőséget beizzítani az Xdebug-ot.
Ahhoz, hogy használni tudjuk mindenképpen szükség van a három testőrre vagy valamelyik hasonmásukra.

Elsőnek az Xdebug-ot kell beépítenünk a PHP-ba. Legegyszerűbb ide kattintani, és megadni a phpinfo() kimenetünket, ami alapján segítséget kaphatunk abban, hogy melyik binary kell nekünk, és hová, hogyan kell pakolnunk. Nagyon fontos, hogy nem a HTML forrását, hanem szimplán a generált lap szövegét kell kimásolnunk a textarea-ba.

Nálam ezt dobta:

Download php_xdebug-2.1.2-5.3-vc6.dll
Move the downloaded file to \xampp\php\ext
Update D:\xampp\php\php.ini and change the line
zend_extension = \xampp\php\ext\php_xdebug-2.1.2-5.3-vc6.dll
Restart the webserver

Ez helyes is, csak a php.ini-ben mást is be kellene lőni az XDebug szekcióban:

A Singleton (magyarul Singleton) tervezési minta lényege az, hogy az egész rendszerben pontosan egy darabra korlátozzuk az adott elemből létrehozható objektumok darabszámát. .NET-ben nincsenek globális változók, amelyekkel a fenti problémát meg lehetne oldani, hiszen tisztán objektum orientált környezettel van dolgunk. A globális változókkal egyébként is lenne még egy probléma: a tényleges felhasználásuk előtt is igényelnek erőforrást. Ha az alkalmazásunk képes több szálon dolgozni, és egyszerre több szál is használhatja a singleton objektumunkat, akkor adódhatnak gondjaink, ha nem szálbiztosra tervezzük meg az osztályunkat, szerencsére erre több megoldás is létezik, meg fogjuk nézni ezeket. Singleton-t használhatnak komplexebb tervezési minták is, például a Factory, amivel lehetőségünk van arra, hogy megoldjuk a Singleton paraméterproblémáját (ha a singletonunk képes lenne paramétereket fogadni, akkor abból gondunk adódna).

Mi is szükséges a Singleton minta implementálásához:

$c = $this->_acdc->acgroups()->AsEnumerable();

foreach ($c->GroupBy(function ($e) {
return $e->ParentID();
}) as $value) {
/* @var $value ObjectGroup */
echo "#" . $value->Key() . "#\n";
foreach ($value->Items() as $g) {
echo "----" . $g->Name() . "\n";
}
}

$c->GroupBy(function ($e) {
return $e->ParentID();
}

KIMENET:

##
----Administrators
----nullable
----reftest
----tttt
----gregrgre
#1#
----hdhd
#10#
----index
----recgroup
#5#
----parent

Hasonlóan van Where, OrderBy, de akad Max-Min-Average-Count is First-Last +OrDefault mellett.

$f = function ($data = 1) use (&$f) {
echo $data;
if ($data < 10) {
$f($data + 1);
}
};

$f();