Share
Pe măsură ce aplicațiile PHP devin din ce în ce mai complexe, poate fi ușor să se încheie cu o mizerie încurcată de cod care face ca întreținerea să fie aproape imposibilă. Aplicarea conceptului de aplicații la nivel secundar poate contribui la atenuarea unor dificultăți în întreținerea aplicațiilor complexe.
Programarea înclinată este practica de a păstra diferite componente, idei sau limbi separate unul de celălalt.
În dezvoltarea de front-end, marcarea pe niveluri ar fi folosită foi de stil externe și JavaScript.
Prin conectarea la un fișier CSS mai degrabă decât prin încorporarea stilurilor în marcajul HTML, devine mai ușor să schimbați
formatarea site-urilor web, deoarece acum toate informațiile de stil sunt stocate convenabil într-un singur loc, separate
de la marcarea documentului. Și mai multe pagini HTML pot trage în exact același fișier CSS, întregul site
pot fi actualizate cu stil prin schimbarea pur și simplu a unei linii de CSS.
În dezvoltarea back-end, se aplică aceleași reguli, dar avem de-a face cu diferite componente. În termeni generali, suntem
la trei niveluri: Bază de date (stocarea și recuperarea datelor), Afaceri
(prelucrarea și prelucrarea datelor) și Prezentare (modul în care sunt afișate datele).
S-ar putea să nu fie imediat evident, dar separarea aplicațiilor dvs. într-o structură delimitată va avea un imens
impact asupra capacității codului dvs. de a schimba în viitor. De exemplu, dacă aveți un sistem de bloguri înființat și
devine necesar să creați un feed RSS pentru blog, o aplicație adecvată în mod corespunzător vă permite să pur și simplu
configurați un șablon RSS, apoi apelați baza de date și funcțiile de afaceri pe care le-ați scris deja.
Pe de altă parte, dacă clientul dvs. a decis brusc că PostgreSQL a fost o alegere mai bună pentru organizarea lor
decât MySQL, va trebui doar să rescrieți funcțiile bazei de date, toate fără să atingeți afacerea sau
logica de prezentare a aplicației.
În ceea ce privește reutilizarea, ați putea avea mai multe funcționalități de bază de date (suport pentru MySQL, PostgreSQL și
Oracle, de exemplu), care ar putea fi ușor abandonate în noile implementări ale aplicației dvs. folosind doar câteva
linii de cod într-un singur loc, în loc să editați mai multe linii ale codului dvs. în mai multe funcții.
Pentru a începe, hai să facem o sarcină destul de simplă - trageți titlul și textul corpului unei intrări dintr-o bază de date,
creând o versiune prescurtată a intrării și plasând datele în marcaj HTML - și vizitați-o
în întregime în mod greșit. În următorul cod, vom scrie o funcție pentru a ne realiza pe toți
sarcini:
Accentsconagua
funcția displayEntry () $ entryDisp = NULL; // Obțineți informațiile din baza de date $ sql = "SELECT title, entry FROM entries WHERE page =" blog ""; $ r = mysql_query ($ sql) sau muri (mysql_error ()); în timp ce ($ entry = mysql_fetch_assoc ($ r)) $ title = $ intrare ['titlu']; $ text = $ intrare ['intrare']; // Crearea previzualizării textului $ textArray = explode (", $ text); $ preview = NULL; pentru ($ i = 0; $ i<24; $i++) $preview .= $textArray[$i] ."; $preview .= $textArray[24] . '… '; // Format the entries $entryDisp .= << titlu $ $ previzualizare
ENTRY_DISPLAY; return $ entryDisp; Acest cod emite marcaj HTML de-a lungul acestor linii:
Intrarea One
Aceasta este descrierea scurtă a primei intrări. Afișează primele 25 de cuvinte ale intrării și apoi trasează cu o elipsă ...
Intrare Două
Aceasta este descrierea scurtă a primei intrări. Afișează primele 25 de cuvinte ale intrării și apoi trasează cu o elipsă ...
Deși acest lucru ar putea părea logic, de fapt este într-adevăr nedorit. Să trecem peste ceea ce face asta
codificați o abordare mai puțin optimă.
Slabă lizibilitate-Acest cod este diluat. Scopul său, deși documentat în comentarii
(un fel de), este greu de discernut. Dacă ați scris acest lucru, ați revenit la el în șase luni, nu ar fi instantaneu
clar ce se întâmplă, ceea ce înseamnă că câteva secunde / minute pierdute încercând să interpreteze propriul cod.
Prea îngustă în focalizare-Această funcție este compromisă de specificul acesteia: interogarea bazei de date funcționează numai pentru un tip de intrare;
crearea de previzualizare a textului este codificată greu în funcție; formatarea este specifică tipului de intrare
fiind afișat. Pentru a crea o implementare puțin diferită a acestei funcționalități, ne-ar fi obligați să o facem
creați oa doua funcție care părea aproape exact aceeași, chiar dacă tot ce trebuia să schimbăm era numărul de
cuvinte în previzualizarea textului.
Lipsa scalabilității-Acest lucru este foarte strâns legat de ideea de a fi prea îngust în focalizare; dacă vrem să adăugăm mai multe funcționalități (cum ar fi
ca o legătură sau o imagine), funcția noastră va deveni mai mare și mai dificil de gestionat. Și dacă vrem să adăugăm
condiții care afectează modul în care este afișată o intrare? Este ușor de văzut cum programarea de genul asta permite codul
devin repede și nu se poate controla.
Aceasta este problema care provoacă toate problemele menționate mai sus.
Prin combinarea tuturor celor trei logice
tipuri, ajungem la o încurcătură îngustă, dezordonată, greu de administrat, aproape imposibil de reutilizat.
Imaginați-vă o aplicație în care a fost construit fiecare tip de afișaj (feed RSS, previzualizare de intrare, afișare de intrare completă etc.)
o funcție ca cea de mai sus, cu accesul la baza de date, logica de afaceri și logica de prezentare, toate scrise împreună.
Acum, imaginați-vă că pe site există nouă pagini, toate având propriile funcții de afișare și previzualizare a intrărilor.
Chiar dacă presupunem că aplicația este foarte simplă și că există doar două funcții pe fiecare pagină de site, suntem încă
privind aproape douăzeci de funcții care vor trebui actualizate dacă schimbările devin necesare.
Pentru a îmbunătăți codul de mai sus, vom răspândi diferitele noastre tipuri de logică în mai multe funcții. Dacă se face bine, noi
ar trebui să se încheie cu un set de funcții extrem de refolosibile, ușor de înțeles, care stack pentru a efectua o varietate de sarcini.
Pentru a începe, vom planifica funcționalitatea necesară pentru a obține o idee mai bună
cum ar trebui construit:
După cum puteți vedea, planul nostru identifică în mod clar o bază de date, o afacere și o prezentare de nivel. Putem acum
scrieți funcții pentru a îndeplini fiecare dintre acești pași cu ușurință.
Pentru a obține informații din baza de date, vom scrie o funcție foarte simplă. Pentru a încuraja codarea bună
practica, voi folosi extensia mysqli, dar
Nu mă voi concentra pe cum funcționează. Dacă nu îl folosiți deja, vă încurajez să explorați mysqli sau a
extensie similară (adică PDO) pentru a vă proteja interogările MySQL împotriva
injecții.
Deci să mergem direct în cod:
funcția getDataFromDB ($ page) / * * Conectarea la un server MySQL * / $ mysqli = mysqli nou ('localhost', 'user', 'password', 'world'); dacă (mysqli_connect_errno ()) printf ("Conectarea a eșuat:% s \ n", mysqli_connect_error ()); Ieșire; / * * Creați o instrucțiune pregătită pentru tragerea tuturor intrărilor dintr-o pagină * / if ($ stmt = $ mysqli-> prepare ('SELECT title, entry FROM WHERE page =?' array dimensional pentru a stoca * informațiile din fiecare intrare * / $ entries = array (); / * * Legați parametrul trecut la interogare, extrageți datele și plasați-l în intrările $ array pentru utilizarea ulterioară * / $ stmt-> bind_param ("s", pagina $); $ Stmt-> execute (); $ stmt-> bind_result ($ titlu, $ intrare); în timp ce ($ stmt-> fetch ()) $ entries [] = array ('title' => $ title, 'entry' => $ entry); / * * Distruge setul de rezultate și eliberează memoria folosită pentru el * / $ stmt-> close (); / * * Închideți conexiunea * / $ mysqli-> close (); / * * Returnați matricea * / returnează $ intrările; Dacă defalcați ceea ce face această funcție, suntem doar cererea
două coloane (titlu și intrare) din tabelul (intrările), apoi stocarea fiecărei intrări
într-o matrice asociativă multidimensională, care este valoarea de returnare a
funcţie. Transmitem un parametru, pagina de pagini, pentru a putea determina ce pagină suntem
grabbing informații pentru. În acest mod, am creat acum o funcție care va funcționa
pentru fiecare pagină a site-ului nostru (cu condiția ca toate să aibă un câmp "titlu" și "intrare").
Observați că funcția noastră nu face nimic mâner datele; pur și simplu acționează
ca un curier, apucând informațiile pe care le cerem și trecând-o la orice
vine în continuare. Acest lucru este important, pentru că dacă ar fi făcut ceva mai mult, am fi în
tărâmul logicii de afaceri.
Răspunsul scurt este că permite baza de date
abstracție, ceea ce înseamnă, în esență, că datele ar putea fi migrate din MySQL
într-un alt format de bază de date, cum ar fi PostgreSQL sau Oracle, toate fără
schimbarea funcțiilor de prelucrare a datelor (nivelul de activitate), deoarece producția ar fi
totuși pur și simplu să fie o matrice multidimensională asociativă care conține intrări cu a
titlul și coloana de intrare, indiferent de tipul de bază de date pe care îl folosim.
Cu datele încărcate în matricea noastră, putem începe să preluăm informațiile
conform scopurilor noastre. În acest exemplu, încercăm să creăm o previzualizare a intrărilor. În
primul exemplu, lungimea previzualizării a fost codificată greu în funcție,
pe care am decis că este o practică proastă. În această funcție, vom trece doi parametri
la codul nostru: textul de procesat și numărul de cuvinte pe care dorim să le afișăm ca
previzualizarea noastră.
Să începem prin examinarea funcției:
functie createTextPreview ($ text, $ length = 25) / * * Sparge textul in spatii si creeaza variabila preview * / $ words = explode (", $ text); $ preview = NULL; buclă pentru a adăuga cuvinte la variabila preview * / if ($ length < count($words)) for($i=0; $i<$length; $i++) $preview .= $words[$i] ."; // Add the space back in between words $preview .= $words[$length] . '… '; // Ellipsis to indicate preview else /* * If the entry isn't as long as the specified preview length, simply * return the whole entry. */ $preview = $text; /* * Return the preview */ return $preview; În funcția de mai sus, pur și simplu verificăm numărul de cuvinte furnizate
intrarea este mai mare decât numărul de cuvinte pe care doriți să le afișăm în previzualizarea noastră, atunci
adăugați cuvinte la variabila de previzualizare nou creată unul câte unul până când ne atingem
ținta lungime, la care punct vom adăuga o elipsă și reveni previzualizare $.
La fel ca în baza noastră de date, păstrăm codul în limitele
nivel de afaceri. Tot ce facem este crearea unei previzualizări de text; nu este
interacțiunea cu baza de date și niciun element de prezentare, cum ar fi HTML
marcare.
În cele din urmă, trebuie să afișăm datele pe care le-am recuperat și le-am procesat. Pentru noi
în scopuri, vom fi afișate cu un marcaj HTML extrem de simplu:
Ideea din spatele acestui cod este simplă: mai întâi, încărcați înregistrările utilizând
funcția de bază de date, apoi buclele prin intrări, scurtarea textului de intrare
folosind funcția de previzualizare și apoi plasând titlul și previzualizarea intrării în
prezentare grafică.
Acum, pentru a schimba aspectul previzualizărilor de intrare, doar două linii de
Codul HTML trebuie ajustat. Acesta este un strigăt mai puțin confuz decât originalul
care a manipulat toate cele trei niveluri.
Aș dori să subliniez faptul că exemplul de mai sus este foarte simplu și este destinat doar să
demonstrează conceptul de programare graduată. Ideea este că prin păstrarea
diferite tipuri de logica de programare separate, puteți crește foarte mult
lizibilitatea și mentenabilitatea codului dvs..
NOTĂ: Există un articol minunat
pe TheDailyWTF.com, discutând despre utilizarea și utilizarea greșită a designului de software pe etape și
comentariu minunat pe
articol care prezintă opinii diferite. Aplicațiile pe mai multe niveluri sunt extrem de utile, dar și ușor de utilizat
înțelegeți greșit și complicați-vă, așa că amintiți-vă să planificați cu atenție software-ul înainte de construire pentru a evita provocarea
mai multe probleme decât soluționați.
Aveți gânduri în privința aplicațiilor cu niveluri diferite? Ce măsuri faceți
maximizați ușurința întreținerii și modificările viitoare ale codului pe care îl scrieți? Lasa-ne
știți în comentarii!
