CLASSE CONSTRUCTEUR DE TABLEAU HTML EN PHP (REVU ET CORRIGÉ)

Commentaire de marm0tte le 22/02/2011 23:22:24

SAlut.
D'accord avec phpAnonyme.
De plus j'ai veux deux choses qui me dérange beaucoup :
- les balises HTML en minuscule, histoire de suivre les standards.
- nomme tes variables soit tout en anglais, soit tout en français mais ne mélange pas. "MaNewString"....

Bonne continuation

Commentaire de demonstorm le 23/02/2011 11:11:41

Merci pour toutes ces remarques, je suis en BTS je le rappelle : ca ne fais que 4 moi que j'ai compris la notion d'objet c'est pas encore ultra clair pour moi...

De plus il ne me reste pas énormément de temps avant la fin de mon stage du coup je suis allé au plus rapide mais une mise a jour est prévu pour corriger un peu cela.

au final un objet tableau aura donc comme attribut un header et sera un manager d'objets de type ligne qui seront eux même des managers de colonnes

un objet colonne (appartenat donc à une ligne) contiendront des strings

pour ce qui est des noms de variables en franglais c'est une idée de mon prof qui nous a appris a faire comme ca pour reconnaitre nos objets...

corrigez moi si je me trompe...

enfin je le répète, je reste ouvert à tous conseils et toutes remarques! :)

Commentaire de Morphinof le 23/02/2011 12:19:15

C'est paradoxal de dire que le php est pas ton langage de predilection mais plutot le C# et que la notion d'objet est encore obscure vu que le C# est un langage objet et le php le deviens petit a petit mais bon ^^

Pour le nom des variables je prefere choisir anglais comme ca tout le monde peu comprendre mais bon le principal c'est que ce soit coherent quelque soit la langue.

Sinon pour ta conception elle est a mon avis trop lourde meme si elle est plutot coherente, en effet si tu cree un objet qui contient une une liste d'objet ligne contenant lui meme une liste d'objet colone et que tu t'en sert que pour ca l'interet est limite.
Si sa s'applique a plusieurs type d'objets different la ca pourrai etre bien mais a ta place je me simplifirait la vie et je ferais un objet Tableau qui contient un tableau associatif du genre :

private $tab = array( tableau_de_ligne(tableau_de_colones()) );

Il te suffira de le parcourir correctement pour generer ton tableau html, c'est bien moins lourd et ca aura le meme effet pour moins de travail.

Bonne continuation !

Commentaire de fenoril le 23/02/2011 13:13:14

Salut !

C'est toujours sympa d'automatiser un peu les codages, bonne idée de fainéant, donc de codeur...

Je par ailleurs particulièrement d'accord avec morphinof, pour la POO et la forme basée sur un tableau php (on va souvent tirer les infos d'une bdd, et donc on a une mise en correspondance assez facile à faire en amont).

A ajouter aux critiques, les balises html center et font color que tu as choisi sont dépréciées et en cours de disparition.

La critique seule n'étant pas le but, deux idées pour régler le problème :
Soit que ces fonctions (center et fontcolor)envoient des span avec un style : Reste souple d'utilisation, mais pas parfait côté séparation contenu/mise en forme.
Soit que ces fonctions envoient des span avec des classes définies dans un css : Plus limitant (car il faut une classe par couleur), mais plus respectueux de la séparation.

Amicalement,

Commentaire de demonstorm le 23/02/2011 16:15:36

Coucou tout le monde, je viens de me pencher sur une mise à jour mais cela ne fonctionne pas...

<?php

class Tableau
{
private $_Header="";
private $_DebutTab="<table>";
private $_FinTab="</table>";
private $_MonTableau="";
private $_MesLignes= array();

public function Tableau($MonHeader, $nbcols)
{
$_Header = '<th colspan="'.$nbcols.'">'.$MonHeader.'</th>';
}

public function AjouterLigne($MesValeursRecues)
{
$UneLigne = new Ligne($MesValeursRecues);
array_push($_MesLignes, $UneLigne);
}

public function Finalize()
{
$_MonTableau=$_DebutTab;
foreach ($_MesLignes as &$LigneEnCours)
{
$_MonTableau.=$LigneEnCours->Finalize();
}
$_MonTableau.=$_FinTab;
}

public function Show()
{
echo $_MonTableau;
}

public function Resultat()
{
return $_MonTableau;
}
}



class Ligne
{
private $_MaLigne="";
private $_DebLigne="<tr>";
private $_FinLigne="</tr>";
private $_MesColonnes=array();

public function Ligne($MesColonnesRecues)
{
foreach ($MesColonnesRecues as &$UneColonne)
{
$NouvelleColonne = new Colonne($UneColonne);
array_push($_MesColonnes, $NouvelleColonne);
}
}

public function Finalize()
{
$_Maligne=$_DebLigne;
foreach($_MesColonnes as &$ColonneEnCours)
{
$_Maligne.=$ColonneEnCours->Finalize();
}
$_Maligne.=$_FinLigne;

return $_MaLigne;
}
}

class Colonne
{
private $_MaColonne="";
private $_DebutCol="<td>";
private $_FinCol="</td>";

public function Colonne($MaColonneRecue)
{
$_MaColonne=$_DebutCol.$MaColonneRecue.$_FinCol;
}

public function Finalize()
{
return $_MaColonne;
}
}

?>

Ça c'est le fichier à inclure...

et voila un exemple de son utilisation :


<?php

echo'<br>D&eacute;but MonTableau<br>';
$UnHeader = "Mon Tableau";
$UnHeaderColSpan = 3;


$UnTableau = new Tableau($UnHeader, $UnHeaderColSpan);
$arrLigne1 = array("Ligne1 Colonne1", "Ligne1 Colonne2", "Ligne1 Colonne3");
$UnTableau->AjouterLigne($arrLigne1);
$arrLigne2 = array("Ligne2 Colonne1", "Ligne2 Colonne2");
$UnTableau->AjouterLigne($arrLigne2);
$UnTableau->Finalize();
$UnTableau->Show();
echo'<br>Fin MonTableau';

?>


Le tableau ne s'affiche pas, aurais je oublié quelque chose?

Commentaire de Morphinof le 23/02/2011 16:36:08

Desole j'ai copie coller et c'est $this->_MaColonne; pas $this->$_MaColonne; ^^ Je precise aussi que c'est la premiere erreur que j'ai vu j'ai pas pousse plus loin

Commentaire de MagicGilles le 23/02/2011 17:09:31

Hum un petit détail en passant. En php 5 le constructeur s'appelle __construct. C'est juste pour la cohérence de ton code.
Je vois que tu fais du html donc pourquoi ne pas étendre une classe HtmlElement, une classe HtmlAttribut et une classe HtmlNode. Un peu à la façon de DomDocument (en plus light).
Tu peux aussi créer une interface renderable avec render (pour retourner le html sous forme de chaine) et __toString (qui appelle implicitement render). ça aurait le mérite de rendre réutilisable les classes créant du html.
Enfin c'est juste quelques idées comme ça en l'air

Commentaire de demonstorm le 23/02/2011 17:13:01

Oula MAGICGilles, je suis pas sur d'arriver à faire ca... :/

Commentaire de MagicGilles le 23/02/2011 17:52:46

Pour répondre à ta question.
class A
{
private $montexte = 'bla';
function mafonction($mavariable)
     {
     $this->montexte = $mavariable;//affectation

     echo $this->montexte; //affichage
     }
}

Commentaire de demonstorm le 24/02/2011 11:30:59

Hello tout le monde, je ne comprend pas pour quoi mais la page ne m'affiche que le header du tableau...

<?php

class Tableau
{
private $_Header='';
private $_DebutTab='<table border=';
private $_FinTab='</table>';
private $_MonTableau='';
private $_MesLignes= array();

public function Tableau($MonHeader, $nbcols, $border)
{
$this->_DebutTab .= $border;
$this->_DebutTab .= '>';

$this->_Header = '<tr><th colspan='.$nbcols.'>';
$this->_Header .= $MonHeader;
$this->_Header .='</th></tr>';//on construit notre header
}

public function AjouterLigne($MesValeursRecues)
{
$UneLigne = new Ligne($MesValeursRecues);//on créé une ligne avec pour argument(s) un tableau de valeur(s)
array_push($this->_MesLignes, $UneLigne);//on ajoute cette ligne au tableau de lignes
}

public function Finalize()
{
$this->_MonTableau=$this->_DebutTab;//on commence a construire notre tableau
$this->_MonTableau.=$this->_Header;//on ajoute le header
foreach ($this->_MesLignes as $LigneEnCours) //pour chaque ligne dans le tableau de ligne(s)
{
$this->_MonTableau.=$LigneEnCours->Finalize();//on ajoute à notre tableau la ligne en cours constituée
}
$this->_MonTableau.=$this->_FinTab;//on ferme notre tableau
}

public function PrintMesLignes()
{
print_r($this->_MesLignes);
}

public function Show()
{
echo $this->_MonTableau;//affiche le tableau
}

public function Resultat()
{
return $this->_MonTableau;//renvoi le tableau
}

public function ShowCode()
{
printf(htmlentities($_MonTableau));
}
}



class Ligne
{
private $_MaLigne='';
private $_DebLigne='<tr>';
private $_FinLigne='</tr>';
private $_MesColonnes=array();

public function Ligne($MesColonnesRecues)//on attend un array de valeur(s)(chaque valeur deviendra une cellule
{
foreach ($MesColonnesRecues as $UneColonne) //pour chaque valeurs de l'array de valeur(s)
{
$NouvelleColonne = new Colonne($UneColonne[0], $UneColonne[1]);//on instancie une cellule avec pour argument la valeur en cours
array_push($this->_MesColonnes, $NouvelleColonne);//on ajoute cette cellule au tableau de cellules
}
}

public function PrintMesColonnes()
{
print_r($this->_MesColonnes);
}

public function Finalize()
{
$this->_Maligne=$this->_DebLigne;//on commence a construire notre ligne
foreach($this->_MesColonnes as $ColonneEnCours)//pour chaques cellules existante dans le tableau de cellules
{
$this->_Maligne.=$ColonneEnCours->Finalize();//on ajoute a notre ligne la cellule constituée
}
$this->_Maligne.=$this->_FinLigne;//on termine notre cellule on obtient alors <tr><td>contenu</td></tr>

return $this->_MaLigne;//on renvoi notre ligne constituée
}
}

class Colonne
{
private $_MaColonne='';
private $_DebutCol='<td colspan=';
private $_FinCol='</td>';

public function Colonne($MaColonneRecue)//on attend le contenu de la cellule
{
$this->_DebutCol .= (int)$MaColonneRecue[1];
$this->_DebutCol .= '>';
$this->_MaColonne = $this->_DebutCol;
$this->_MaColonne .= (string)$MaColonneRecue[0];
$this->_MaColonne .=$this->_FinCol;//on construit notre cellule <td>contenu</td>
}

public function Finalize()
{
return $this->_MaColonne;//on renvoi notre cellule constituée
}
}



?>

avec pour utilisation :

<?php

echo'<br>D&eacute;but MonTableau<br>';
$UnHeader = 'Mon Tableau';

$UnHeaderColSpan = 3;

$UnHeaderBorder = 2;


$UnTableau = new Tableau($UnHeader, $UnHeaderColSpan, $UnHeaderBorder);

$arrLigne1 = array(array('Ligne1 Colonne1', 1), array('Ligne1 Colonne2', 1), array('Ligne1 Colonne3', 1));

$UnTableau->AjouterLigne($arrLigne1);

$arrLigne2 = array(array('Ligne2 Colonne1', 2), array('Ligne Colonne2', 2));

$UnTableau->AjouterLigne($arrLigne2);

$UnTableau->Finalize();

$UnTableau->Show();

echo'<br>Fin MonTableau';
echo'<br><br>';

$UnTableau->ShowCode();

?>

Du coup je me suis dit que j'allais afficher le code html créé et donc dans la class Tableau j'ai créé la fonction ShowCode()

mais je ne comprend pas elle ne semble pas fonctionner(rien à l'ecran, même pas le code concernant le header de mon tableau(qui lui apparemment fonctionne))


Help me, pleaase help me, je deviens fououououououuuuu... (sur l'air de "Love me")

Commentaire de Morphinof le 24/02/2011 23:58:07

Hum.
public function ShowCode()
{
printf(htmlentities($_MonTableau));
}

$this->$_MonTableau ? :)

Commentaire de Morphinof le 25/02/2011 09:34:08

Mince encore le copier coller foireux ^^ $this->_MonTableau et pas $this->$_MonTableau :p

Commentaire de Morphinof le 25/02/2011 10:52:01

Selon le libelle et sans lire le code ca viens de la :
foreach ($this->_MesLignes as $LigneEnCours => $value)

LigneEnCours n'est pas un objet Ligne et du coup tu peux pas appeller ta fonction surment parce que LigneEnCours est soit une chaine soit un entier qui correspond a l'index as cause de l'utilisation de as ton objet ligne est dans $value.

Je peux pas lire ton code je suis sur un truc mais si ca marche toujours pas apres ca je regarderai

Commentaire de Morphinof le 25/02/2011 12:22:17

Tu peux m'envoyer ta source que je puisse tester ?

Commentaire de alain04 le 28/02/2011 05:09:53

Waouhhh ! je dois être en retard d'une génération. Tant qu'à vouloir faire un tableau HTML (si j'ai bien compris)c'est pas plus simple et plus rapide de baliser ... en HTML?

Commentaire de demonstorm le 28/02/2011 10:56:49

Voila terminé, source mise a jour!
Merci à Phpanonyme, Marm0te et Fenoril pour leurs conseils
et merci à Morphinof(ce pseudo serait il un petit clin d'½il évoquant la notion de Polymorphisme?) pour avoir pris le temps de me donner des conseil, de m'orienter vers certaines idées, m'avoir apporter pas mal de réponses...

Alain04 => C'est jamais très joli (mais quand même un peu plus facile pour les neos) de mettre du html dans du php (personnellement si je connais une façon systématique de séparer php de html (autre que par le principe de CSS+TPL+PHP) je le ferais...

L'intérêt de ce code (même si un peu lourd a utiliser (pas forcement compliqué, mais vachement répetitif) et de pouvoir générer un tableau sans html (principe d'objet oblige, la classe tabconstruct est entièrement réutilisable)


BJ33 => pour le htmlentities j'avais corrigé cela courant la semaine dernière mais merci d'y avoir pensé... Pour ce qui est de l'éditeur je n'en utilise pas, je tourne avec NP++ même si j'aimerai utiliser un éditeur qui m'assisterait un peu plus...

Commentaire de bj33 le 28/02/2011 13:25:51

salut

<<même si j'aimerai utiliser un éditeur qui m'assisterait un peu plus...

NP++ comme beaucoup de débutants. mais il y a bien mieux, netbeans, par exemple, ou encore mieux, zend studio mais là, bien sur, il faut payer. Mais netbeans est plus qu'éfficace et gratuit, et il gére aussi le java, c, c++, etc. presque aussi éfficace que zs, alors.

<<private $_DebutTab='<table border=';

ce border, çà fait désordre;) c'est aux css de gérer çà. a la limite un style=""

et perso, j'ai coder des classes pour générer des tableaux à la volée mais avec des méthodes statiques et des classes abstraites...si tu manques d'inspiration, n'hésite pas.

Commentaire de bj33 le 28/02/2011 14:08:31

<<Pour abstraite je ne l'utilise jamais, car je n'ai jamais compris le DP de la fabrique abstraite ni même son utilité

classe abstraite, pas design pattern ;)

http://fr2.php.net/manual/fr/language.oop5.php

et tu est plus a l'aise avec csharp!?

Commentaire de bj33 le 28/02/2011 15:52:29

class SqueletteXhtml implements ISqueletteXhtml {
private static $_doctypeTrans = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">';
   private static $_doctypeStrict = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">';

public static function table(array $tab_params, $contenu) {
$tp = '<table ';
foreach ($tab_params as $k => $v) {
if (end($tab_params) == $v)
$tp .= $k.'="'.$v.'"';
else $tp .= $k.'="'.$v.'" ';
}
$tp .= '>'.chr(10);
$tp .= $contenu;
$tp .= self::ferme('table');
     return $tp;
   }
}

là, je fais,

include_once 'SqueletteXhtml.php';

SqueletteXhtml::table(...) ou SqueletteXhtml::$_doctypeTrans

çà permet de se servir des méthodes de classes n'importe où, y compris hors de la classe et ce à plusieurs niveaux d'imbrication. très pratique.
ce n'est pas la seule utilité des méthodes et variables statiques mais s'en est une.

un design pattern fabrique, c'est par exemple,

final class Fabrique {
private static $_instance = null;
private $_namespace;

/**
* constructeur protege pour empecher une instanciation directe
*/
protected function __construct() {}

/**
* retourne une instance de la classe en tenant compte du namespace
*
* @param $namespace
* @return object
*/
public static function getInstance($namespace = null) {
if (is_null(self::$_instance)) {
self::$_instance = new self;
}
self::$_instance->_namespace = $namespace;
return self::$_instance;
}

public function __call($methodes,$arguments) {
$classe = ucfirst(strtolower($this->_namespace.$methodes));
if (class_exists($classe,false)) {
$retourClasse = new ReflectionClass($classe);
if ($retourClasse->isInstantiable() && $retourClasse->hasMethod('__construct')) {
return $retourClasse->newInstanceArgs($arguments);
} else {
throw new Format_Generique('La classe '.$classe.' n\'est pas instanciable');
}
} else {
throw new Format_Generique('La classe '.$classe.' est introuvable');
}
}
}

ne mélange pas tout;) une classe abstraite,

abstract class NettoyageFormulaire {
protected static function nettoie($variable) {
if (get_magic_quotes_gpc()) {
stripslashes($variable);
}
$variable = trim(strip_tags($variable));
return $variable;
}
}

et là, je fais,

include_once 'NettoyageFormulaire.php';

NettoyageFormulaire::nettoie()

une classe abstraite çà peut aussi être çà,

abstract class Chemin {
const CHEMIN_CLASSES = 'classes/';
const CHEMIN_FONCTIONS_UTILITAIRES = 'classes/utilitaires/fonctions/';
const CHEMIN_INC = 'includes/';
}

pour accéder au facilement aux paramètres de config sans contraintes ou les fixer. çà vient en bossant, t'inquiete pas. ce ne sont que des exemples, cherche les tutos de malaman, admin du réseau cs, ce sont les meilleurs.

Commentaire de demonstorm le 28/02/2011 16:11:56

Je vais voir ca, merci! :)

Commentaire de demonstorm le 02/03/2011 10:11:58

Serait il possible que vous notiez ma source afin d'avoir une petite idée de ce qu'elle peut valoir?

Ps: Je compte la présenter comme Application Professionnelle pour mes oraux du BTS (on doit en présenter 5 au minimum (7 au maximum) et on est interrogé sur 1 seule)

Commentaire de demonstorm le 07/03/2011 14:17:34

enfin faut se dire aussi qu'à moins d'être un petit génie ca n'aurai pas pu être parfait dès le premier code posté! :/

Après je ne connais pas énormément de DP (2 en fait : Singleton et Polymorphisme)...