Share
Comme les applications PHP deviennent de plus en plus complexes, il peut être facile de se retrouver avec un fouillis de code qui rend la maintenance presque impossible. L'application du concept d'applications à plusieurs niveaux peut aider à atténuer certaines des difficultés liées à la maintenance d'applications complexes..
La programmation par niveaux est la pratique qui consiste à garder différents composants, idées ou langages séparés les uns des autres.
Dans le développement frontal, le balisage à plusieurs niveaux utiliserait des feuilles de style externes et JavaScript.
En liant à un fichier CSS plutôt qu'en incorporant des styles dans votre balise HTML, il devient plus facile de changer le
mise en forme de vos sites Web, car toutes les informations de style sont désormais stockées de manière pratique au même endroit, séparées
à partir du balisage du document. Et plusieurs pages HTML peuvent extraire exactement le même fichier CSS, votre site entier
peut être mis à jour en changeant simplement une ligne de CSS.
En développement back-end, les mêmes règles s'appliquent, mais nous traitons avec des composants différents. En termes généraux, nous sommes
regardant à trois niveaux: le Base de données (stocker et récupérer des données), Affaires
(traitement et traitement des données), et Présentation (comment les données sont affichées).
Cela n’est peut-être pas immédiatement évident, mais séparer vos applications en une structure à plusieurs niveaux aura un impact considérable.
impact sur la capacité de votre code à changer dans le futur. Par exemple, si vous avez un système de blogging configuré, et
il devient nécessaire de créer un flux RSS pour le blog, une application correctement hiérarchisée vous permettrait simplement
configurer un modèle RSS, puis appeler la base de données et les fonctions métier que vous avez déjà écrites.
À l'opposé, si votre client décidait soudain que PostgreSQL était un meilleur choix pour son organisation
que MySQL, il vous suffirait de réécrire les fonctions de votre base de données, le tout sans toucher à l'entreprise ou
logique de présentation de l'application.
En termes de capacité de réutilisation, vous pouvez avoir plusieurs fonctionnalités de base de données (prenant en charge MySQL, PostgreSQL et
Oracle, par exemple), qui pourraient facilement être insérés dans les nouveaux déploiements de votre application en utilisant seulement quelques-uns
lignes de code en un seul endroit, plutôt que de modifier plusieurs lignes de votre code à travers plusieurs fonctions.
Pour commencer, prenons une tâche assez simple: extraire le titre et le corps d'une entrée d'une base de données.,
créer une version abrégée de l'entrée et placer les données dans un balisage HTML - et s'y prendre dans
tout à fait le mauvais sens. Dans le code suivant, nous allons écrire une fonction pour effectuer tous nos
les tâches:
Accentsconagua
fonction displayEntry () $ entryDisp = NULL; // Récupère les informations de la base de données $ sql = "SELECT titre, entrée FROM entrées WHERE page =" blog ""; $ r = mysql_query ($ sql) ou die (mysql_error ()); while ($ entry = mysql_fetch_assoc ($ r)) $ title = $ entry ['title']; $ text = $ entry ['entry']; // Créer l'aperçu du texte $ textArray = explode (", $ text); $ preview = NULL; pour ($ i = 0; $ i<24; $i++) $preview .= $textArray[$i] ."; $preview .= $textArray[24] . '… '; // Format the entries $entryDisp .= << $ title aperçu $
ENTRY_DISPLAY; return $ entryDisp; Ce code génère un balisage HTML selon ces lignes:
Entrée un
Ceci est la description abrégée de l'entrée numéro un. Il affiche les 25 premiers mots de l'entrée puis se termine par des points de suspension…
Entrée deux
Ceci est la description abrégée de l'entrée numéro deux. Il affiche les 25 premiers mots de l'entrée puis se termine par des points de suspension…
Bien que cela puisse sembler logique, cela n’est vraiment pas souhaitable. Voyons ce qui fait cela
coder une approche moins qu'optimale.
Mauvaise lisibilité-Ce code est dilué. Son but, bien que documenté dans les commentaires
(en quelque sorte), est difficile à discerner. Si vous avez écrit cela, puis y êtes revenu dans six mois, il ne serait pas instantanément
clarifier ce qui se passait, ce qui signifie quelques secondes / minutes perdues à essayer d'interpréter votre propre code.
Focus trop étroit-Cette fonction est paralysée par sa spécificité: la requête de base de données ne fonctionne que pour un seul type d’entrée;
la création de l'aperçu du texte est codée en dur dans la fonction; le formatage est spécifique au type d'entrée
être affiché. Afin de créer une implémentation légèrement différente de cette fonctionnalité, nous serions obligés de
créer une seconde fonction qui ressemblait presque exactement à la même chose, même si tout ce que nous avions besoin de changer était le nombre de
mots dans l'aperçu du texte.
Manque d'évolutivité-Ceci est assez étroitement lié à l’idée d’une focalisation trop étroite; si nous voulons ajouter plus de fonctionnalités (telles que
en tant que lien ou image), notre fonction deviendra plus grande et plus difficile à gérer. Et si on veut ajouter
conditions qui affectent l'affichage d'une entrée? Il est facile de voir comment une telle programmation permet au code de
devenir rapidement tentaculaire et ingérable.
C’est le problème majeur qui cause tous les problèmes susmentionnés..
En combinant les trois de notre logique
les types, nous nous retrouvons avec un enchevêtrement de code étroit, désordonné, difficile à gérer, et presque impossible.
Imaginez une application dans laquelle chaque type d’affichage (flux RSS, aperçu de l’entrée, affichage complet de l’entrée, etc.) a été construit avec
une fonction comme celle ci-dessus, avec l'accès à la base de données, la logique métier et la logique de présentation tous écrits ensemble.
Maintenant, imaginez qu'il y a neuf pages sur le site, qui ont toutes leurs propres fonctions d'affichage et de prévisualisation..
Même si nous supposons que l'application est très simple et qu'il n'y a que deux fonctions par page de site, nous sommes toujours
regardant presque vingt fonctions qui devront être mises à jour si des changements deviennent nécessaires.
Pour améliorer le code ci-dessus, nous allons répartir nos différents types de logique sur plusieurs fonctions. Si cela est fait correctement, nous
devrait aboutir à un ensemble de fonctions hautement réutilisables et faciles à comprendre qui s'empilent pour effectuer diverses tâches.
Pour commencer, nous allons planifier les fonctionnalités nécessaires pour avoir une meilleure idée de
comment il devrait être construit:
Comme vous pouvez le voir, notre plan identifie clairement un niveau base de données, entreprise et présentation. Nous pouvons maintenant
écrire des fonctions pour accomplir chacune de ces étapes avec une relative facilité.
Pour obtenir des informations de la base de données, nous allons écrire une fonction très simple. Encourager un bon codage
pratique, je vais utiliser l'extension mysqli, mais
Je ne vais pas me concentrer sur la façon dont cela fonctionne. Si vous ne l'utilisez pas déjà, je vous encourage à explorer mysqli ou un
extension similaire (PDO) pour sécuriser vos requêtes MySQL contre
attaques par injection.
Alors sautons directement dans le code:
function getDataFromDB ($ page) / * * Se connecter à un serveur MySQL * / $ mysqli = new mysqli ('localhost', 'user', 'password', 'world'); if (mysqli_connect_errno ()) printf ("La connexion a échoué:% s \ n", mysqli_connect_error ()); sortie; / * * Créez une instruction préparée pour extraire toutes les entrées d'une page * / if ($ stmt = $ mysqli-> prepare ('SELECT titre, entrée FROM entrées WHERE page =?')) / * * Créer une multi- tableau dimensionnel pour stocker * les informations de chaque entrée * / $ entries = array (); / * * Lie le paramètre passé à la requête, récupère les données et les place * dans les entrées $ du tableau pour une utilisation ultérieure * / $ stmt-> bind_param ("s", $ page); $ stmt-> execute (); $ stmt-> bind_result ($ title, $ entry); while ($ stmt-> fetch ()) $ entrées [] = tableau ('titre' => $ titre, 'entrée' => $ entrée); / * * Détruit le jeu de résultats et libère la mémoire utilisée * / $ stmt-> close (); / * * Ferme la connexion * / $ mysqli-> close (); / * * Retourne le tableau * / return $ entries; Si vous décomposez ce que cette fonction fait, nous demandons littéralement
deux colonnes (titre et entrée) de notre tableau (entrées), puis stockage de chaque entrée
dans un tableau associatif multidimensionnel, qui est la valeur de retour de la
une fonction. Nous passons un paramètre, $ page, afin que nous puissions déterminer quelle page nous sommes
saisir des informations pour. Ce faisant, nous avons maintenant créé une fonction qui fonctionnera
pour chaque page de notre site (à condition qu'ils aient tous un champ "titre" et "entrée").
Notez que notre fonction ne fait rien pour manipuler les données; il s'agit simplement
en tant que courrier, saisir les informations que nous demandons et les transmettre à tout
vient ensuite. C’est important, car s’il faisait quelque chose de plus, nous serions dans le
royaume de la logique d'entreprise.
La réponse courte est que cela permet aux bases de données
abstraction, ce qui signifie essentiellement que les données peuvent être migrées à partir de MySQL
dans un autre format de base de données, tel que PostgreSQL ou Oracle, le tout sans
changer les fonctions de traitement des données (niveau métier), car la sortie
toujours tout simplement être un tableau associatif multidimensionnel contenant des entrées avec un
colonne titre et entrée, peu importe le type de base de données utilisée.
Avec les données chargées dans notre tableau, nous pouvons commencer à traiter les informations pour
convenir à nos fins. Dans cet exemple, nous essayons de créer un aperçu de l'entrée. Dans
Dans le premier exemple, la longueur de l'aperçu était codée en dur dans la fonction.,
que nous avons décidé est une mauvaise pratique. Dans cette fonction, nous allons passer deux paramètres
à notre code: le texte à traiter et le nombre de mots que nous voulons afficher comme
notre aperçu.
Commençons par regarder la fonction:
function createTextPreview ($ text, $ length = 25) / * * Séparez le texte des espaces et créez la variable de prévisualisation * / $ mots = exploser (", $ text); $ preview = NULL; / * * Exécuter un boucle pour ajouter des mots à la variable de prévisualisation * / 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; Dans la fonction ci-dessus, nous vérifions simplement que le nombre de mots du mot fourni
l’entrée est supérieure au nombre de mots que nous voulons montrer dans notre aperçu, puis
ajouter des mots à la variable de prévisualisation $ nouvellement créée un à la fois jusqu'à ce que nous frappons notre
longueur cible, auquel nous ajoutons des points de suspension et retournons $ preview.
Tout comme dans notre niveau base de données, nous gardons le code dans les limites de la
niveau entreprise. Nous ne faisons que créer un aperçu du texte. il n'y a pas
interaction avec la base de données, et aucun élément de présentation tel que HTML
balisage.
Enfin, nous devons afficher les données que nous avons récupérées et traitées. Pour notre
nous allons l'afficher avec un balisage HTML extrêmement simple:
L’idée de ce code est simple: d’abord, chargez les entrées à l’aide de notre
fonction de base de données, puis parcourez les entrées en raccourcissant le texte
en utilisant notre fonction de prévisualisation, puis en plaçant le titre et l'entrée de prévisualisation dans
balisage de présentation.
Pour modifier la présentation des aperçus d’entrée, il ne reste que deux lignes de
HTML doit être ajusté. C'est un cri beaucoup moins déroutant que l'original
fonction qui a géré les trois niveaux.
Je voudrais souligner que l’exemple ci-dessus est très basique et n’a pour but que de
démontrer le concept de programmation à plusieurs niveaux. L’idée est qu’en gardant le
différents types de logique de programmation séparés, vous pouvez considérablement augmenter la
lisibilité et maintenabilité de votre code.
NOTE: Il y a un bon article
sur TheDailyWTF.com discutant de l’utilisation et de la mauvaise utilisation de la conception logicielle hiérarchisée, et
merveilleux commentaire sur le
article qui présente des opinions divergentes. Les applications à plusieurs niveaux sont extrêmement utiles, mais aussi faciles à utiliser.
incompréhension et complication excessive, pensez donc à bien planifier votre logiciel avant de le construire pour éviter de causer
plus de problèmes que vous ne résolvez.
Avez-vous des idées sur les applications à plusieurs niveaux? Quelles mesures prenez-vous pour
maximiser la facilité de maintenance et les modifications futures du code que vous écrivez? Laissez-nous
savoir dans les commentaires!
