Statikus osztálytagok. Ne adjon nekik, hogy tönkretegyék a kódot. Statikus PHP módszerek Primsel Static PHP P

Nem titok, hogy szeretsz kérdéses kérdéseket feltenni az interjúkra. Nem mindig megfelelő, nem mindig a valósághoz kapcsolódik, de a tény továbbra is tény - megkérdezi. Természetesen felmerül a kérdés, probléma, és néha az a kérdés, első pillantásra látszólag buta, valójában célzó ellenőrzés, milyen jól ismeri a nyelvet írsz.

Próbáljuk meg szétszerelni a "csontot" ezeket a kérdéseket - mit jelent a "statikus" szó a PHP-ben és miért jelentkezik?

A kulcsszó statikusnak három különböző értéke van a PHP-ben. Kronológiai sorrendben elemezzük őket, mivel megjelentek a nyelvben.

Az első érték egy statikus helyi változó

Funkció Foo () ($ A \u003d 0, Echo $ A; $ A \u003d $ A + 1;) Foo (); // 0 foo (); // 0 foo (); // 0.

A helyi PHP változókban. Ez azt jelenti, hogy a függvényen belüli változó és a függvényen belüli érték csak a funkció végrehajtása során létezik (módszer). A módszer elhagyásakor a helyi változó megsemmisül, és amikor újra bejutás, akkor folytatódik. A fenti kód egy ilyen lokális változó $ a változó - csakis akkor van benne a Foo () függvényt, és minden alkalommal, amikor ezt a funkciót tilos. A változó növekedése ebben a kódban értelmetlen, mert a kód következő sorában a funkció befejezi működését, és a változó értéke elveszik. Hányszor nem okozott a Foo () funkciót, mindig 0 ...

Mindazonáltal minden megváltozik, ha a kulcsszót a hozzárendelés előtt helyezzük el:

Funkció Foo () (statikus $ a \u003d 0, echo $ a; $ A \u003d $ A + 1;) foo (); // 0 foo (); // 1 foo (); // 2.

A helyi változó értékének megadása előtt írt statikus kulcsszó a következő hatásokat eredményezi:

1. A hozzárendelés csak egyszer történik, amikor először hívja a funkciót
2. Az így megjelölt érték a változó a művelet befejezése után kerül mentésre.
3. A következő funkcióval a hozzárendelés helyett a változó megkapja a korábban mentett értéket

A szó statikus szó használata statikus helyi változó.

Statikus változó víz alatti kövek

Természetesen, mint mindig PHP-ben, ez nem költség nélkül "buktatók".

A kő az első statikus változó csak állandókhoz vagy állandó kifejezésekhez rendelhető. Itt van a kód:
Statikus $ a \u003d bar ();
Az elkerülhetetlenség egy parser hibához vezet. Szerencsére az 5.6-os verzióval kezdődően megengedett, hogy nem csak állandókat, hanem állandó kifejezéseket is hozzárendelhet (például - "1 + 2" vagy ""), vagyis olyan kifejezések, amelyek nem függnek a másik kódtól, és lehetnek számítva a fordítási szakaszban

A kő második módszerek léteznek egyetlen példányban.
Minden bonyolultabb itt. A lényeg megértéséhez a kódot adom:
A osztály (Public Function Foo () (statikus $ x \u003d 0, echo ++ $ x,)) $ A1 \u003d Új A; $ A2 \u003d Új A; $ A1-\u003e Foo (); // 1 $ A2-\u003e Foo (); // 2 $ A1-\u003e Foo (); // 3 $ A2-\u003e Foo (); // négy
Ellentétben az intuitív várakozással a "különböző tárgyak - különböző módszerek", vizuálisan látjuk ezt a példát, hogy a dinamikus módszerek a PHP "nem szaporodnak." Még akkor is, ha van egy száz tárgya ennek az osztálynak, a módszer csak egy példányban létezik, csak az egyes hívásokkal különböző $ -t végeznek.

Az ilyen viselkedés váratlan lehet a fejlesztő számára felkészületlen és hibák forrásként szolgálhat. Meg kell jegyezni, hogy az osztály öröklése (és módszer) azt eredményezi, hogy új módszer jön létre:

A osztály (Public Function Foo () (statikus $ x \u003d 0, echo ++ $ x;)) B osztály kiterjeszti a () $ A1 \u003d újat; $ b1 \u003d új B; $ A1-\u003e Foo (); // 1 $ b1-\u003e foo (); // 1 $ A1-\u003e Foo (); // 2 $ b1-\u003e foo (); // 2.

Következtetés: A PHP dinamikus módszerei az osztályok kontextusában léteznek, nem objektumok. És csak a rangsorban van egy helyettesítés "$ this \u003d current_object"

A második - statikus tulajdonságok és osztályú módszerek

A PHP objektummodellben nemcsak objektumok - osztályú példányok, hanem egy osztályhoz is beállítható tulajdonságok és módszerek beállítása. Ehhez a Static kulcsszót is szolgálja:

A osztály (nyilvános statikus $ x \u003d "foo"; nyilvános statikus funkcióvizsgálat () (visszatérés 42;)) Echo A: $ x; // "foo" echo a :: teszt (); // 42.
Az ilyen tulajdonságokhoz és módszerekhez való hozzáféréshez a kettős vastagbél ("Paamayim Nekudotayim") szerkezeteket használnak, például a NAME_NAME :: $ Cél és Name_Name :: Namemode ().

Magától értetődik, hogy a statikus tulajdonságok és a statikus módszerek saját jellemzői és "buktatói", amit tudnod kell.

Jellemzője az első, banális - nincs $. Valójában ez a statikus módszer meghatározásából származik - mivel az osztályhoz kapcsolódik, és nem egy objektum, ez nem érhető el a Pseudo-hőmérséklet $ -hoz, amely dinamikus módszerekkel jelezhető az aktuális objektumhoz. Mi teljesen logikus.

Azonban tudnod kell, hogy más nyelvekkel ellentétben a PHP nem határozza meg a helyzetet "a statikus módszerben $ this írva" az elemzés vagy összeállítás színpadán. Hasonló hiba fordulhat elő csak ratiaryime esetén, ha megpróbálja végrehajtani a kódot a statikus módszeren belül.

Típus kód:
A osztály (nyilvános $ id \u003d 42, statikus nyilvános függvény foo () (Echo $ this-\u003e id;)))
Nem vezet minden hibára, amíg nem próbálja meg használni a Foo () módszert a nem megfelelő módon:
$ A \u003d Új A; $ a-\u003e foo (); (és azonnal kapjon "végzetes hibát: $ ez, ha nem az objektum kontextusban")

A két statikus funkció nem egy axioma!
A osztály (Statikus Public Function Foo () (Echo 42,)) $ A \u003d Új A; $ a-\u003e foo ();
Mint ez, igen. Statikus módszer, ha nem tartalmazza a $ kódban, akkor dinamikus kontextusban lehet felhívni az objektum módszerét. Ez nem hiba a PHP-ben.

A fordított nem igaz:
A osztály (Public Function Foo () (Echo 42;)) A :: Foo ();
A $ -t nem használó dinamikus módszer statikus kontextusban végezhető el. Azonban figyelmeztetést kapsz "nem statikus módszer a :: foo () nem szabad statikusan" e_strict szintre. Ott megoldani - vagy szigorúan kövesse a kódolatokat, vagy elnyomja a figyelmeztetéseket. Az első természetesen előnyös.

És egyébként, minden fent írott, csak a módszerekre vonatkozik. A statikus tulajdonságok használata "-\u003e" segítségével lehetetlen, és végzetes hibához vezet.

Az érték a harmadik, nyilvánvaló a legnehezebb - később statikus kötődés

A PHP-nyelv fejlesztői nem álltak meg a "statikus" és az 5.3-as verziójú kulcsszó két értékén, amelyet egy másik "funkció" nyelvet adott hozzá, amelyet ugyanaz a szó hajt végre! Ezt "később statikus kötés" vagy LSB-nek nevezik (késői statikus kötés).

Értsd meg az LSB lényegét a legegyszerűbb módja annak, hogy egyszerű példák legyenek:

Osztály modell (nyilvános statikus $ táblázat \u003d "táblázat"; nyilvános statikus funkció gettable () (visszatérés önmagát :: $ táblázat;)) Echo Model :: gettable (); // "Asztal"
Az önkulcsszó a PHP mindig azt jelenti, hogy "osztálynév, ahol ez a szó meg van írva." Ebben az esetben az önmagát helyettesíti a modellosztály, és az én :: $ táblázat - a modell :: $ táblázat.
Az ilyen nyelvi lehetőséget "korai statikus kötésnek" nevezik. Miért korán? Mivel az önmagának és az osztály sajátos nevének kötelező ereje nem fordul elő a rangsorban, hanem a korábbi szakaszokban - elemzés és összeállítás a kód. Nos, "statikus" - mert statikus tulajdonságokkal és módszerekkel beszélünk.

Kissé változtatja meg a kódot:

Osztály modell (nyilvános statikus $ táblázat \u003d "asztal", nyilvános statikus funkció gettable () (visszatérő én :: $ táblázat;)) Osztályfelhasználó kiterjeszti a modellt (nyilvános statikus $ táblázat \u003d "Felhasználók";) ; // "Asztal"

Most értsd meg, hogy miért viselkedik a PHP ebben a helyzetben nem lehet. Az Én a modellosztályhoz kapcsolódott, amikor a felhasználói osztály még nem ismert, ezért jelzi a modellt.

Hogyan legyen?

A dilemma megoldásához a "késői" kötő mechanizmust találták meg, a rangsorban. Ez nagyon egyszerűen működik - elegendő a "Self" írás helyett "statikus", és a kapcsolat telepítve lesz az osztályhoz, amely ezt a kódot okozza, és nem az, hogy hol van írva:
Osztály modell (nyilvános statikus $ táblázat \u003d "táblázat"; nyilvános statikus funkció gettable () (Return Static :: $ táblázat;)) Osztályfelhasználó kiterjeszti a modellt (nyilvános statikus $ táblázat \u003d "Felhasználók";) ; // "felhasználók"

Ez egy titokzatos "később statikus kötés."

Meg kell jegyezni, hogy a PHP nagyobb kényelméért, kivéve a "statikus" szót, még mindig van egy speciális funkció, amelyen a get_called_class (), amely tájékoztatja Önt - melyik osztályban jelenleg a kódja van.

Sikeres interjúk!

A világon két fajta pHP fejlesztő van. Egyesek inkább statikus módszereket preferálnak, mert könnyen kezelhető velük, mások, ezzel szemben, a statikus módszerek - a gonoszság, és nem használják őket a gyakorlatukban.
Ebben a cikkben megpróbálom felhasználni a tapasztalatokat több keretgel, hogy megmagyarázzam, miért figyelmen kívül hagyja a legjobb gyakorlatokat, és használjon egy csomó statikus módszert.

Ki szeret statikus módszereket?

Különösen gyakran olyan fejlesztőket használnak, akik valaha is használtak munkaköri kódexkönyvükben.

A statisztikai módszerek követői közé tartoznak a legtöbb Kohana és Lylavel fejlesztők.
Lehetetlen, hogy ne is megemlítsük azt a tényt, hogy a programozók, akik úgy döntenek, hogy elkezdenek írni saját dolgokat, általában megtagadják a Codigiter használatát.

Miért kérdezed?

CodeIgniter támogatott PHP 4 előtt statikus módszer adunk PHP 5. Ezenfelül CodeIgniter használ egy „szuper tárgy”, amely egyenlő hozzáférés minden osztály hozzárendelt vezérlő. Így hozzáférhetővé válnak az egész rendszerben.

Ez azt jelenti, hogy az osztályok bármely modellből elérhetők a __get () módszerrel, amely a kért ingatlant használó get_instance () -\u003e ($ var). Korábban, amikor a támogatást a funkció __get () nem volt a PHP 4, erre használjuk a foreach kialakítás révén Ci_Controller paramétereket, majd azokat soroltuk a $ this változó a modellben.

A könyvtárban meg kell hívnia a Get_instance-t. A könyvtár nem örököl egy osztályt egy kötelező sorrendben, így nincs mód arra, hogy megkerülje az __get () funkciót.

Hangerő ...

Kiderül egy meglehetősen nehézkes design a kód eléréséhez. Pontosan ugyanazok a funkcionalitás, anélkül, hogy további erőfeszítéseket találnának statikus módszerrel.

Igen, és nincs különösebb értelme, hogy vitatkozzon egy ilyen kialakításról. Nos, elérheti a munkamenet adatait a modellben. De miért kell ezt tennie?

"Döntés"

Kohana fejlesztők voltak az első, akik komolyan dolgoztak a statikus módszereknél. A következő változtatásokat tették:
// volt $ this-\u003e input-\u003e get ("foo"); // lett bemenet :: Get ("foo");
Sok codigniter fejlesztők számára az elavult PHP 4, aki a Kohana keretbe költözött, hogy élvezze az összes PHP 5 varázsat, ebben semmi szokatlan ebben. De a kevesebb karakter, annál jobb, igaz?

És mi a probléma?

Sok PHP fejlesztő (különösen azok, akik megértik a Symfony és a Zend) azt fogják mondani: "Nyilvánvaló - használja a függőségek bevezetését!" De a Codeigniter közösségben nem sok fejlesztő valódi tapasztalattal rendelkezik ezzel a folyamattal, mivel nagyon bonyolult.

Az üzemanyag PHP-keretrendszerének másik ténye továbbra is elsősorban a statikus módszerek interfészként hatnak. Például a logika még mindig problémái vannak a statikus, különösen akkor, ha a HMVC koncepció aktiválódik.

Ez egy pszeudokód, amelyet nem használtam üzemanyagphp-ben, az 1.1-es verzióval kezdődően:
Osztályvezérlés kiterjeszti a vezérlőt (Public Function Action_Foo () (Echo bemenet :: Get ("Param");))
Szép szabványos kód. Ez a módszer az értéket adja meg ? Bar \u003d. a módszerben.

Mi történik, ha hmvc kérést teszünk erre a módszerre?
Osztályirányító kiterjeszti a vezérlőt (echo bemenet :: get ("param"); \u200b\u200becho "&"; echo kérés :: Forge ("Controllera / Foo? Param \u003d Val1") -\u003e Execute ();)
Hívás a böngészőben controllerb / Baz.Látni fogja a "Val1" kimenetet, de ha kapsz controllerb / Baz? Param \u003d felülbírálásMindkét kihívást kapja, hogy megkapja az azonos értékű módszert.

Relevancia

A globális kód nem ad semmilyen kapcsolatot. Egy példa jobb, mint bármely szó:
$ this-\u003e kérés-\u003e input-\u003e get ("param");
A kért objektum minden lekérdezéshez teljesen új példányt tartalmaz, majd az objektum bejegyzését minden egyes kéréshez hozzák létre, amely csak egy konkrét lekérdezéshez tartozó bemeneti adatokat tartalmaz. Ez igaz a FAUDEPHP 2.0 tervekre, és megoldja a függőség hozzáadásának problémáját, valamint a HMVC problémáit.

Hogyan kell kezelni a Bruttó szintaxist?

Symfony- vagy Zend fejlesztők nem szenvednek annyira, de azok, akik CodeIgniter sokáig fognak rémálmaim „vissza a PHP 4”.

$ Ez mindig az "aktuális" objektumra utal, és nem szükséges a globális kód eléréséhez.

$ this this-\u003e kérés-\u003e input-\u003e Get () úgy néz ki, mint egy hosszúkás kodeigniter-szintaxis forma, de valójában egyszerűen a vezérlőben vagyunk. Amikor a vezérlő létrehozza az új lekérdezés példányát, a lekérdezési konstruktor egy példányt is kap a bemeneten.

Ha modell vagy más osztályban van, akkor a hozzáférés a $ this-\u003e kérés-\u003e input-\u003e Foo () nem fog működni, mert $ ez nem a vezérlő.

Bemenet :: Get Design ("foo") létrehoz egy homlokzatot a logikai példányok a háttérben. De ez nem oldja meg a globális kód munkájához kapcsolódó kérdéseket. A lusta, ha az alkalmazások tesztelése két mód között válthat, anélkül, hogy az új keret teljes mértékben használná az új keretet.

Van egy nagyszerű videó a Taylor Oblla (Creator vagy Lyestavel 4), amelyben leírja, hogyan cserélheti ki a statikus kódot egyetlen példányt a DIC tartályán keresztül.

LIGEAVEL 4 - IOC Controller injekció és egység tesztelése a Vimeo-on.

Ez egy kiváló bemutató, hogyan lehet a Laravel statikus módszereinek használata nélkül. Bár néhány modern keret, első pillantásra nagyon emlékeztetnek Kohana, teljesen megoldani a legtöbb szabványos feladatokat különböző módon.

Ez a szomorú megjegyzés ...

Most részt veszek a Pyrocms konverzióval a Linavel Codigiterrel. Próbálok közvetlenül a globális kódtól a PHP 4-ből mozogni, hogy a függőségek tökéletes végrehajtása abszolút öngyilkosság. A CI Bootloader használata előtt - a PHP 5, az automatikus betöltött PSR-2 kód használata, egy csomó statikus módszerrel. Nos, miközben még mindig a kodeigniterben vagyunk.

A statika átmenete a DIC-kódra könnyen megjeleníthető, ha végül átálltunk Linavelre.

A fő feladat a SUBLINK CLECIGNITITER kódjára való áttérés a PSR-2 teszteltől. A Pyro csapat már az úton van - és ez epikus lesz.

A PHP-ben lehet meghatározni a módszert statikusnak. A statikus módszernek nincs hozzáférése az objektum tulajdonságaihoz. Az ilyen módszereket csak az osztály kontextusában lehet okozni, de nem az objektum kontextusában.

A legfontosabb dolog az, hogy megértsük - statikus tulajdonságokat és módszereket mutatnak az osztályok, nem objektumok.

A példa azonnal világossá válik. Hozzunk létre egy matematikai objektumot (a matematika rövidítése angolul).

"$ Math_1 \u003d új matematika (); $ Math_2 \u003d Új matematika (); $ Math_3 \u003d új matematika (); $ math_4 \u003d új matematika (); echo" létrehozott objektumok: "Matematika :: getcount () ;?

Ez az osztály olyan eszközöket biztosít, amelyek matematikai funkciókkal dolgozhatnak anélkül, hogy szükség lenne egy objektum létrehozására. Az osztálynak van egy konstruktorja, amely növeli az egységenkénti $ számláló statikus tulajdonságát. Az osztály emlékszik erre a tulajdonság értékére, mivel statikus.

By the way, a szó statikus szó a módszert vagy a statikus tulajdonságot, és a szó önmagát egy kettős vastagbélhez használják a statikus tulajdonság eléréséhez "::".

Mindez a legjobban érthető, különösen a munkapélda összehasonlításában a hibás. Tegyük ki a példánkat.

számláló ++; ) Nyilvános statikus funkció: Calcsin ($ x) (Sin ($ x);) Nyilvános statikus funkció Calcsqrt ($ x) (RETURN SQRT ($ x);) Public Static Function GetCount (Return Self :: $ Count;) Getcounter () ($ this this-\u003e számláló visszatérése;)) Echo Math :: Calcsin (1); Echo "
"Echo Math :: Calsqrt (9); Echo"
"$ Math_1 \u003d új matematika (); $ Math_2 \u003d új matematika (); $ Math_3 \u003d új matematika (); $ math_4 \u003d új matematika (); echo" létrehozott tárgyak: "Matematika :: getcount (); echo"
", Echo" létrehozott objektumok: "$ math_4-\u003e getcounter ();?\u003e

Ebben a példában adtuk hozzá a szokásos $ számláló tulajdonság osztályát, szintén növelte a konstruktorban. De a szokásos tulajdon az objektumhoz tartozik, ezért nem kerül mentésre az objektumok kihívásai között. Egy osztály (objektum) példányának megteremtésével az ingatlan egyenlő lesz Nulo, a tervezőben, amelyet egy megnövekszik.

A statikus ingatlan az osztályhoz tartozik, így értéke mentésre kerül.

Az alábbiakban néhány példa, amely feltárja a statikus tulajdonságok és módszerek munkáját.

A STATIC MÓDSZERBEN A $ A változó hibát eredményez (végzetes hiba: a $ -t, ha nem az objektum kontextusban).

kor. "RÉGI."; // ez egy hiba "$ ez, ha nem az objektum kontextusban". )) $ Testclass \u003d új testclass (); $ Testclass-\u003e Sayhello (); ?\u003e

Az úton, karakterlánc nélkül:

$ Testclass-\u003e Sayhello ();

a hibák nem lesznek, de amint megpróbálja elindítani a statikus módszert a $ -ból a változóból, azonnal hibaüzenetet kap.

Ha ebben a példában távolítsa el a statikus szót, akkor a hibák nem lesznek.

Ha a statikus módszertől származó objektum tulajdonságra utal, akkor hibát eredményez. Csak a statikus tulajdonságokra vonatkozhat az önmagával :: $ Kor design segítségével. Kérjük, vegye figyelembe, hogy van egy $ jel a változó neve előtt, ellentétben a $ this-\u003e korral.

köszönj (); ?\u003e

Ha ebben a példában távolítsa el a statikus szót az ingatlan neve előtt, akkor a "hozzáférés a be nem jelentett statikus tulajdonság" hiba történik.

A statikus tulajdonságok hiányoznak az osztály tárgyakban.

"; Nyomtatás_r ($ testclass); echo""; ?>

A statikus módszer az önmagát :: módszer () módszer használatával lehet hívni. Példa:

printhello (); ?\u003e

A statikus tulajdonság az osztályban a szintaxis segítségével érhető el:

echo testclass :: $ kor;

Ezenkívül a szokásos tulajdonra való hivatkozás kísérlete tehát hibát eredményez: "Végzetes hiba: hozzáférés a be nem jelentett statikus tulajdonsághoz".

A statikus tulajdonság az osztályban a szintaxis segítségével módosítható:

Testclass :: $ kor + \u003d 20; // például

A statikus módszerekkel és tulajdonságokkal rendelkező kód másik példája

Ebben a példában egyszerűbb lehetőségek a statikus módszerek és tulajdonságok használatához. Minél egyszerűbb kódot fogsz megérteni, annál jobban emlékszel az anyagra.

".Testclass :: $ kor; // echo testclass :: $ txt; // hiba: végzetes hiba: Hozzáférés a be nem jelentett statikus tulajdonsághoz. Echo"
"; Testclass :: Sayhi (); echo"
"Testclass :: Sayhello (); //, így hozzáférhetek egy statikus változóhoz az objektumon keresztül ($ obj :: $ kor) ... echo"
", $ obj \u003d új testclass; echo" Az objektumon keresztül egy statikus változó diplomát kapunk: "$ OBJ :: $ Kor;?\u003e

Megjegyzés, és ez fontos, ebben a példában a SayHi () nem statikus módszerhez fordultunk a statikus osztályelemekhez való hozzáférés szintaxisával.

Összefoglaló

• Fő: Statikus tulajdonságok az osztályokhoz, nem tárgyakhoz tartoznak.
• A statikus módszerből lehetetlen kapcsolatba lépni az osztály szokásos tulajdonságaival és módszerei, a $ this-\u003e név nem működik itt.
• A statikus módszerrel a statikus tulajdonságokra utalhat az önmagát :: $ name segítségével.
• A statikus osztály tulajdonságai nem állnak rendelkezésre objektumok számára.
• A szokásos módszer a statikus tulajdonságra utalhat önmagával :: $ nevet.
• Statikus tulajdonságok érhetők el az osztály keretében szintaxis: TestClass :: $ Age.
• A szokásos módszer nevezhető az összefüggésben és az objektum ($ tárgy-\u003e módszerrel ()), és az osztályban a TestClass szintaxis :: módszer ().
• A $ objektum szintaxisával: $ Kor, sikerült elérnöm a statikus tulajdonságot az objektumon keresztül.

JavaScript párhuzamosan

A JavaScript olyan matematikai osztályt tartalmaz, amely sok különböző matematikai funkciót tartalmaz.

Elvégzésére matematikai számítások (számítása sinus vagy kiállítási) JavaScript, nem szükséges, hogy hozzon létre egy objektum osztály matematika, hiszen a módszerek statikus. A PHP tanulmányozása előtt nem értettem, hogy mi volt, és csak az osztályok és tárgyakat tanulmányozta a PHP-ben a fejemben mindent a polcaimra esett.

Valójában nagyon kényelmes, közvetlen hozzáférést biztosít a matematikai osztály matematikai módszereihez, elkerülve az objektum létrehozását.

Hosszú ideig akartam írni erről a témáról. Az első sokk volt a cikk Miško HEVERY "Statikus módszerek a halál a Testability". Response cikket írtam, de soha nem jelentette meg. De a közelmúltban látott valamit, amit "osztályorientált programozásnak" nevezhetünk. Ez frissítette a témát, és itt az eredmény.

Az "osztályorientált programozás" az, amikor csak statikus módszerekkel és tulajdonságokkal rendelkező osztályokat használnak, és az osztálypéldányt soha nem hozták létre. Ebben a cikkben beszélek:

• nem ad semmilyen előnyt az eljárási programozáshoz képest.
• ne adjon fel az objektumokat
• az osztály statikus tagjainak elérhetősége! \u003d Halálvizsgálatok

Bár ez a cikk a PHP-ről, a fogalmak más nyelvekre vonatkoznak.

Függőségek

Általában a kód a másik kódtól függ. Például:

$ Foo \u003d substr ($ bar, 42);
Ez a kód a $-sávváltozótól és az SUPTR funkcióktól függ. $ Bar csak egy helyi változót meghatározott valamivel magasabb ugyanazt a fájlt, és azonos hatásúak. Az aljzat a PHP kernel funkció. Minden itt egyszerű.

Most egy ilyen példa:

Class BloomFilter (... Nyilvános funkció __construct ($ M, $ K) (...) Nyilvános statikus funkció Getk ($ M, $ N) (Visszatérés Ceil ($ M / $ N) * Napló (2) ;) ...)
Ez a kis kiegészítő funkció egyszerűen egy wrapper egy speciális algoritmust, amely segít kiszámítani egy jó számot a $ k érv alkalmazott a kivitelező. Mivel Az osztálypéldány létrehozása előtt létre kell hozni, statikusnak kell lennie. Ez az algoritmusnak nincs külső függősége, és valószínűleg nem helyettesíthető. Ez így használatos:

$ M \u003d 10.000; $ n \u003d 2000; $ B \u003d új BloomFilter ($ M, BloomFilter :: Getk ($ M, $ N);
Nem hoz létre további függőséget. Az osztály függ magamtól.

Alternatív tervező. Jó példa a PHP-be épített DateTime osztály. A példánya két különböző módon hozható létre:

$ Date \u003d új DateTime ("2012-11-04"); $ Date \u003d DateTime :: CreateFromformat ("D-M-y", "04-11-2012");
Mindkét esetben az eredmény a DateTime példánya, mindkét esetben a kód a DateTime osztályhoz kötődik. Statikus módszer DateTime :: CreateFromFromat az objektum alternatív objektuma, amely ugyanaz, mint az új DateTime, de további funkciók használata. Hol lehet írni az új osztályt, írhat és osztály :: Módszer (). Nincsenek új függőségek.

A statikus módszerek fennmaradó alkalmazása a kötelező érvényű, és implicit függőségeket képezhet.

Szó az absztrakcióról

Miért van ez a szünet függőséggel? Képesség absztrakt! A termék növekedésével bonyolultságát növeli. És az absztrakció a bonyolultság kezelésének kulcsa.

Például van egy alkalmazásosztály, amely bemutatja az alkalmazást. Kommunikálja a felhasználói osztályt, amely a felhasználó megelőzése. Amely adatokat kap az adatbázisból. Adatbázis-osztálynak szüksége van adatbiztonságra. A DataBaseDriver szükség van kapcsolat beállításaira. Stb. Ha egyszerűen hívja az alkalmazást :: Start () Statikusan, amely a felhasználótól :: GetData () statikusan, amely az adatbázist statikusan és így tovább fogja eredményezni, abban a reményben, hogy minden réteg foglalkozik a függőségeivel, akkor kaphat szörnyű rendetlenség, ha valami nem így megy. Nem lehet kitalálni, hogy az alkalmazás :: Start () hívás fog működni, mert nem nyilvánvaló, hogy a belső függések hogyan viselkednek. Még rosszabb, hogy az alkalmazás viselkedésének egyetlen módja :: Start (), hogy megváltoztassa az osztály forráskódját és az osztálykódot, hogy az osztály és az osztálykód, hogy az osztályok megjelennek ... a házban A Jack épült.

A komplex alkalmazások létrehozásakor a leghatékonyabb megközelítés az egyes részek létrehozása, amelyeket a jövőben elutasíthat. Azok a részek, amelyek leállíthatók gondolkodás, amelyben biztos lehet benne. Például a statikus adatbázis hívásakor :: Fetchall (...), nincsenek garanciák, hogy az adatbázishoz való csatlakozás már telepítve van, vagy telepítve lesz.

Funkció (Adatbázis $ adatbázis) (...)
Ha a funkción belüli kódot végrehajtják - ez azt jelenti, hogy az adatbázis-példány sikeresen átvihető, ami azt jelenti, hogy az adatbázis objektum példánya sikeresen létrehozásra került. Ha az adatbázisosztály helyesen van kialakítva, biztos lehet benne, hogy az osztály egy példányának jelenléte az adatbázis iránti kérelmek végrehajtásának képességét jelenti. Ha az osztálypéldány nem, akkor a funkció testét nem fogják végrehajtani. Ez azt jelenti, hogy a funkciónak nem szabad gondoskodnia az adatbázis állapotáról, az adatbázisosztály maga is megteszi. Ez a megközelítés lehetővé teszi, hogy elfelejtse a függőségeket és a problémák megoldására koncentráljon.

A lehetőség nélkül nem gondolkodhatok ezeknek a függőségeknek a függőségeiről és függőségeire, szinte lehetetlen legalább összetett alkalmazást írni. Az adatbázis lehet egy kis csomagolóosztály vagy egy óriási többrétegű szörny, egy csomó függőséggel, és egy kis csomagolásként kezdődik, és egy óriási szörnyben időben megkezdheti az adatbázisosztályt, és átadhatja a leszármazott funkciót, ez Nem minden fontos a funkcióhoz (adatbázis $ adatbázis), mindaddig, amíg az adatbázis nyilvános felülete nem változik. Ha az osztályokat a függőség végrehajtásával megfelelően elválasztják az alkalmazás többi részétől, akkor mindegyiket a dugók használatával tesztelheti a függőségük helyett. Ha tesztelt egy osztályban elég, hogy megbizonyosodjon arról, hogy működik, ahogy kellene, akkor dobja ki több felesleges a fejét, csak tudja, hogy kell használni a Database fokon munkát az adatbázisban.

Az osztályorientált programozás nonszensz. Ismerje meg az OOP használatát.

Reg.ru: Domainek és hosting

A legnagyobb felvevő és hosting szolgáltató Oroszországban.

Több mint 2 millió domainnév a karbantartáshoz.

Promóció, postai küldemények, üzleti megoldások.

Több mint 700 ezer ügyfelet világszerte már választottak.

* Egér át a görgetés felfüggesztéséhez.

Előre halad

Statikus módszerek és tulajdonságok a PHP-ben

A korábbi anyagokban elsajátítottuk az objektumorientált programozás főbb lehetőségét PHP-ben, és most a bonyolultabb és érdekesebb szempontok tanulmányozásához mennek.

Ezt megelőzően mindig tárgyakkal dolgoztunk. Osztályokat írtunk le, mint sablonok, amelyekkel az objektumok létrehozása és objektumok - mint aktív komponensek, azoknak a módszereknek, amelyekről hívunk, és amelyek tulajdonságai hozzáférhetünk.

Innen követte azt a következtetést, hogy az objektumorientált programozás során a tényleges munkát az osztályok példányaival végzik. És az osztályok végül csak sablonok az objektumok létrehozásához.

De valójában nem minden olyan egyszerű. Mindkét módszert és tulajdonságot elérhetjük egy osztály keretében, és nem egy objektumot. Az ilyen módszereket és tulajdonságokat "statikusnak" nevezik, és kulcsszót használnak statikus..

Osztály staticexample (statikus nyilvános $ anum \u003d 0, statikus nyilvános függvény Sayhello () (Nyomtatás Hello! ";))

Statikus módszerek - Ezek az osztály keretében használt funkciók. Ők maguk nem kaphatnak hozzáférést a közös osztály tulajdonságaihoz, mivel az ilyen tulajdonságok az objektumokhoz tartoznak.

Azonban a statikus módszerek, amint valószínűleg kitaláltad, a statikus tulajdonságokra utalhat. És ha megváltoztatja a statikus tulajdonságot, akkor az osztály minden példánya új értékhez férhet hozzá.

Mivel a statikus elemhez való hozzáférés az osztályon keresztül történik, és nem egy objektumpéldányon keresztül, nincs szükség egy olyan változóra, amely az objektumra utal. Ehelyett egy osztálynevet használnak, miután két színt jeleznek "::".

PRINT STATICEXAMPLE :: $ anum; Staticexample :: Sayhello ();

Ezzel a szintaxissal már ismernie kell az OOP alapját a PHP-ben. A "::" designt használtuk egy kulcsszóval kombinálva szülő. Annak érdekében, hogy hozzáférjen az újradefiniált szülőosztályhoz.

Most, mint akkor, fellebbezünk az osztályba, és nem az objektumban található adatokra. Az osztálykódban kulcsszót használhat szülő. A Superclass eléréséhez az osztály neve használata nélkül.

Ahhoz, hogy hozzáférhessen a statikus módszerhez vagy tulajdonsághoz ugyanabból az osztályból (és nem egy gyermekosztályból), akkor a kulcsszót fogjuk használni maga..

Kulcsszó maga. A jelenlegi osztályra és a pszeudo-elpusztult $ Ez - az aktuális objektumhoz. Ezért az osztályon kívülről Staticexample Felhívjuk a tulajdonát $ Anum Az osztály nevét használva.

Staticexample :: $ anum;

És az osztályon belül Staticexample Használhat egy kulcsszót maga..

Osztály staticexample (statikus nyilvános $ anum \u003d 0, statikus nyilvános függvény Sayhello () (Self :: $ anum ++; nyomtatás "hi! (". Önmagát :: $ anum ") \\ n") \\ n

Jegyzet: Amellett, hogy jogorvoslati kérelmek az újraértelmezett szülő osztály módszer, a „::” design mindig csak a hozzáférési statikus metódusokat vagy tulajdonságokat.

Definíció szerint a statikus módszereket az objektum kontextusában nem hívják fel. Ezért a statikus módszereket és tulajdonságokat gyakran változók és osztály tulajdonságai nevezik. Ennek eredményeként lehetetlen használni a pszeudo-elpusztult $ Ez a statikus módszer belsejében.

Miért használja a statikus módszert vagy tulajdonságot?

Így elértük a legfontosabb problémát. Az a tény, hogy a statikus elemek számos hasznos jellemzővel rendelkeznek.

ElőszörEzek a parancsfájl bármely pontjáról kaphatók (feltéve, hogy hozzáférhet az osztályhoz). Ez azt jelenti, hogy elérheti a funkciókat anélkül, hogy az osztály példányát az egyik objektumról a másikra küldné, vagy még rosszabb, mentve egy objektum példányát egy globális változóban.

Másodszor, Statikus tulajdonság áll rendelkezésre az osztály tárgyának minden egyes példányához. Ezért meghatározhatja az ilyen típusú objektumokra vonatkozó értékeket.

És végül harmadikAz a tény, hogy nem kell, hogy egy objektumpéldányt hozzáférést a statikus tulajdonság vagy metódus fog kerülni példányok létrehozása tárgyak kizárólag kedvéért hívja egyszerű funkciót.

Ennek bizonyításához hozzon létre statikus módszert az osztályra ShopProduct.amely automatikusan létrehozza az objektumok példányait ShopProduct.. C az SQLite használatával határozza meg az asztalt termékek. A következőképpen:

Az asztaltermékek létrehozása (ID INTEGER PRIMPY gomb AutoIncrement, Írja be a szöveget, a vezetéknevet, a főnév szöveget, a cím szövegét, az úszást, az INT, PLAYLGENGTH INT, PLAYLGENGTH INT, KEDVEZMÉNYT

Most hozzon létre egy módszert getinstance ()amely átadja a vonalazonosítót és a PDO típusú objektumot. Azokat az adatbázis táblázatból történő kivonására használják, amely alapján a típusobjektumot ezután kialakítják. ShopProduct.visszatért a hívási programba.

Ezeket a módszereket hozzáadhatjuk az osztályhoz ShopProduct.amelyet a korábbi anyagokban hoztak létre nekünk. Ahogy valószínűleg tudod, a PDO-t PHP adatobjektumként (PHP adatobjektumok) dekódolják. A PDO-osztály egy univerzális felületet biztosít a különböző adatbázis-alkalmazásokhoz.

// osztály ShopProduct Private $ id \u003d 0; Public Function Setid ($ ID) ($ ID) ($ ID -\u003e id \u003d $ ID;) // ... Nyilvános statikus funkció Getinstance ($ ID, PDO $ PDO) ($ STMT \u003d $ PDO-\u003e előkészítés ("Válassza ki a * termékeket Ahol ID \u003d? "); $ Eredmény \u003d $ STMT-\u003e Végrehajtás (Array ($ ID)); $ Row \u003d $ stmt-\u003e Fetch (), ha (üres ($ sor)) Sor ["Type"] \u003d\u003d "könyv") ($ termék \u003d új könyvespermék ($ sor ["cím"], $ sor ["firstname"], $ sor ["mainname"], $ sor ["ár"] , $ sor ["számok"]);) más, ha ($ sor ["típusa"] \u003d\u003d "CD") ($ termék \u003d új CDProduct ($ sor ["Cím"], $ sor ["firstname"], $ Sor ["mainname"], $ sor ["ár"], $ sor ["playltength"]);) más ($ termék \u003d új shopproduct ($ sor ["cím"], $ sor ["firstname"], $ sor ["mainname"], $ sor ["ár"]);) $ Product-\u003e setid ($ sor [ID "]); $ Product-\u003e SetDiscount ($ sor [" kedvezmény "]); vissza $ termék ;) // ...

Ahogy látható, a módszer getinstance () Visszaadja az objektumtípust ShopProduct., és elég "okos" ahhoz, hogy a mező értékén alapuljon típus Hozzon létre egy objektumot a kívánt jellemzőkkel.

Különösen csökkentem a hibakezelési kódot, hogy a példa egyszerűbb legyen. Például az aktuális változata ezt a kódot, akkor nem lehet túl bizakodó, és feltételezik, hogy a továbbított PDO objektumok inicializálása, és csatlakozik a szükséges adatbázis.

Valójában valószínűleg egy olyan ORDO-objektumot kötünk egy olyan osztályban, amely garantálja az ilyen viselkedést. Visszatérünk erre a kérdésre a jövőbeli anyagok egyikében.

Módszer getinstance () Hasznosabb az osztály összefüggésében, mint az objektum kontextusában. Könnyűvé teszi az adatbázisban lévő adatokat az objektumhoz, és erre nincs szükségünk a típusú objektum külön példányára ShopProduct..

Ez a módszer nem használ semmilyen olyan módszert vagy tulajdonságot, amely az objektum különálló példányát igényli, így nincs ok arra, hogy nem állapítsa meg statikusnak. Ezután a helyes OEM-objektummal rendelkezünk, ezt a módszert bármilyen alkalmazási helyre hívhatjuk.

$ dsn \u003d "sqlite: //home/bob/projects/products.db"; $ PDO \u003d Új PDO ($ DSN, NULL, NULL); $ Pdo-\u003e setatitribute (PDO :: attr_errmode, pdo :: errmode_exception); $ Obj \u003d ShopProduct :: Getinstance (1, $ PDO);

Az ilyen módszerek "gyár "ként működnek, mivel" nyers "anyagokat (például az adatbázis-karakterláncból vagy konfigurációs fájlból származó adatokat) és az objektumok létrehozásához használjuk őket.

A "gyár" kifejezés olyan kódra utal, amely az objektumok példányainak létrehozására szolgál. Az ilyen "gyárak" példáival tovább találkozunk veled.

Állandó tulajdonságok

Egyes tulajdonságok nem változhatnak. Például olyan elemeket, mint a hibakódok vagy a programállapotkódok általában manuálisan vannak beállítva az osztályokban. Bár nyilvánosan hozzáférhetőnek és statikusnak kell lenniük, az ügyfélkód nem tudja megváltoztatni őket.

Ehhez az osztályon belüli állandó tulajdonságokat határozhatja meg. A globális konstansokhoz hasonlóan az osztályállandók nem módosíthatók, miután azonosították őket. Az állandó tulajdonság kulcsszó segítségével nyilatkozik const..

A hagyományos tulajdonságokkal ellentétben a dollárjel nem kerül az állandó tulajdonság neve előtt. Az elfogadott megállapodás szerint gyakran csak nagybetűkből álló neveket írnak elő, mint a következő példában:

Osztályú shopproduct (CONST elérhető \u003d 0; const out_of_stock \u003d 1; // ...

Az állandó tulajdonságok csak az elemi típushoz kapcsolódó értékeket tartalmazhatnak. Állandó nem rendelhető objektumhoz.

A statikus tulajdonságokkal együtt az állandó tulajdonságokhoz való hozzáférés az osztályon keresztül történik, és nem az objektum példányán keresztül. Ahogy állandóan egy dollár aláírása nélkül határozható meg, azért, hogy hozzáférjen, szintén nem kell-e valamilyen szimbólumot használnia.

Nyomtatás ShopProduct :: elérhető;

A kijelölt értékre való állandó hozzárendelés kísérlete a szintaktikai elemzés szakaszában hibát eredményez.

A konstansokat akkor kell használni, ha az ingatlannak hozzáférhetőnek kell lennie az osztály minden példányához, és ha az ingatlanértéket rögzíteni kell és változatlan.

Teljesítem ezt a cikket, és ezután beszélünk.

Tetszett az anyag, és szeretnék köszönetet mondani?
Csak részesedjen meg barátaival és kollégáival!