De l'utilité des classes ?

[oranocha]

Bonjour,

J'explique mon cas ... Pour gagner du temps sur le moyen / long terme, j'ai envie de mettre en place un système qui me permettrait de "rapidifier" la création de formulaire.

Je voulais m'orienter vers la POO. Voici un cas très simple :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
class form {
  var $name
  var $action
  var $method
 
  function openForm($name, $action, $method) {
    echo "<form name=\"$name\" method=/"$method\" action=\"$action\">";
  }
 
  function closeForm() {
    echo "</form>";
  }
}

Quelle est l'utilité de faire cela alors que si je me limite à créer les fonctions, j'obtiendrai le même résultat :

Code :

1
2
3
4
5
6
7
8
 
function openForm($name, $action, $method) {
  echo "<form name=\"$name\" method=/"$method\" action=\"$action\">";
}
 
function closeForm() {
  echo "</form>";
}

Le but (quelle que soit la soluce choisie) étant que par la suite, je n'aurai qu'à taper le code ci-dessous pour que le système me crée un nouveau formulaire :

Code :

1
2
 
openForm(nomduformulaire, envoi.php, POST);

Et ceci pour qu'il le ferme :

Code :

1
2
 
closeForm();

Votre avis ?

[oranocha]

J'ajoute que mon post précédent est un exemple simpliste de ce que je veux faire ...

Le but final serait de pouvoir créer des formulaires complets facilement, par un tel système ...

[Mr N.]

Dans ton cas très simple, aucun intérêt. Si tu ne vois pas d'intéret à utiliser une solution, pas la peine d'investir du temps dessus.

[ouatmad]

bêh pour ce que tu veux faire, il faut dire qu'il n'y a pas de différence a utiliser les classes ou les fonctions. Sinon il faut dire que la POO offre d'enormes avantages notamment l'encapsulation, la reutilisabilité, etc ...
Si il te faut necessaire faire un choix, je te propose les classes

[genova]

Pour ton exemple, l'utilité serait serait que tes fonctions sont facilements reconnaissables, ainsi tu aurais :

Code :

1
2
3
$form = new form;
$form->open('nomduformulaire', 'envoi.php', 'POST');
$form->close();

En lisant ton code tu sais déjà qui sert à quoi.

La POO te permet aussi de jouer avec des constructeurs / destructeurs (PHP5), tu aurais donc tout simplement besoin de faire :

Code :

1
2
3
4
5
6
7
8
9
class form {
  function __construct($name, $action, $method) {
    echo "<form name=\"$name\" method=/"$method\" action=\"$action\">";
  }
 
  function __destruct() {
    echo "</form>";
  }
}

par conséquent simplement :
$form = new Form;

(__destruct() sera appelé à la fin de ton script. Si tu souhaites l'appeler avant, tu peux détruire l'objet simplement avec unset($form);)



De plus admettons que demain toi ou un autre développeur souhaite ajouter des possibilité à cette classe sans chercher partout où ajouter quoi, il suffirait de faire :

Code :

1
2
3
4
5
6
7
class input extends form
{
   function text($name, $value = '', $size = 30)
   {
      echo '<input type="text" name="' . $name . '" size="' . $size . '" value="' . $value . '" />';
   }
}

et ainsi tu pourrais faire :

Code :

1
2
3
4
$form = new input; // Ouverture du formulaire, avec l'appel du constructeur
$form->input('toto');
$form->input('titi');
unset($form); // Fermeture du formulaire, appel du destructeur

[oranocha]

Un grand merci pour cette grande explication ;-)

Ma question avait bien entendu un sens "ironique", ne conaissant pas encore suffisament les classes.

Je vois bien que ce système doit être utile mais pour reprendre ton dernier exemple, je pourrai tout aussi bien simplement créer une fonction :

Code :

1
2
3
4
5
 
function text($name, $value = '', $size = 30)
   {
      echo '<input type="text" name="' . $name . '" size="' . $size . '" value="' . $value . '" />';
   }

et faire un appel à celle-ci via text(nomdemoninput);

Ca donnerait tout de même le résultat voulu ... Et c'est la que je me demande si je dois me lancer dans la construction en classe ou simplement dans l'utilisation des fonctions ;-)

Merci en tout cas pour ces éclaircissements !

[Korko Fain]

non ça ne donnera pas la meme chose puisque justement, ce qu'on t'explique c'est qu'avec la classe, tu aura la balise <form> qui encadrera automatiquement ton input de pars l'heritage (le extends).

[oranocha]

Envoyé par Korko Fain

non ça ne donnera pas la meme chose puisque justement, ce qu'on t'explique c'est qu'avec la classe, tu aura la balise <form> qui encadrera automatiquement ton input de pars l'heritage (le extends).

Donc ... Si je crée ma classe Form (comme indiquée dans l'autre post) de cette façon :

Code :

1
2
3
4
5
6
7
8
9
10
 
class form {
  function __construct($name, $action, $method) {
    echo "<form name=\"$name\" method=/"$method\" action=\"$action\">";
  }
 
  function __destruct() {
    echo "</form>";
  }
}

et que je crée une classe input de cette manière :

Code :

1
2
3
4
5
6
7
8
 
class input extends form
{
   function text($name, $value = '', $size = 30)
   {
      echo '<input type="text" name="' . $name . '" size="' . $size . '" value="' . $value . '" />';
   }
}

je ne suis pas obligé d'instancier la class form mais je peux simplement faire :

Code :

1
2
3
4
 
$form = new input; // Ouverture du formulaire, avec l'appel du constructeur
$form->input('toto');
unset($form);

Pour que mon formulaire soit créé avec </form> à la fin ?
Ou dois-je tout de même instancier la classe form +/- de cette façon :

Code :

1
2
3
 
$form = new form;
$form->open('nomduformulaire', 'envoi.php', 'POST');

Merci encore.

[genova]

Effectivement tu peux utiliser des fonctions, pour ce que tu veux faire ça aurait le même effet visuel. Cependant la façon de penser est différente, en programmant en POO tu considères les éléments comme des objets. Ainsi ton formulaire est un objet, ta connexion à la base de donnée est un objet, etc ...

Pourquoi préférer l'objet aux fonctions ? Pour ces raisons principalement :

• La POO te permet une meilleure lisibilité du code. Ainsi tu vois facilement que $db->coucou() est une fonction qui fait quelque chose sur ta base de donnée, $template->bonjour() une fonction liée à ton template.
• La POO te donne de nombreux outils supplémentaires, par exemple :
  • Les constructeurs / destructeurs, pour donner un exemple avec une classe de base de donnée :
    
    Code :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    class Database
    {
    	function __construct($server, $login, $password, $dbname)
    	{
    		// Tu fais ici ta connexion à la base de donnée
    		mysql_connect(...);
    	}
     
    	function query($sql)
    	{
    		mysql_query(...);
    	}
     
    	function __destruct()
    	{
    		mysql_close();
    	}
    }

    ce qui est plus clair et automatique.
  • La POO te permet de créer des propriétés (des variables locales à ton objet), par exemple :
    
    Code :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    class Database
    {
    	private $count = 0;
     
    	function __construct($server, $login, $password, $dbname)
    	{
    		// Tu fais ici ta connexion à la base de donnée
    		mysql_connect(...);
    	}
     
    	function query($sql)
    	{
    		mysql_query(...);
     
    		// on incrémente $count à chaque requète
    		$this->count++;
    	}
     
    	// Retourne le nombre de requètes executées (utile pour le debug, etc ..)
    	function total_query()
    	{
    		return ($this->count);
    	}
     
    	function __destruct()
    	{
    		mysql_close();
    	}
    }

    Code :

    1
    2
    3
    4
    $db = new Database('localhost', 'root', '', 'nomDeMaBaseDeDonnee');
    $db->query('SELECT * ...');
    $db->query('INSERT etc ...');
    echo 'Nombre total de requêtes : ' . $db->total_query();

  • La POO te permet d'étendre tes classes (par exemple tu fais une classe Livre pour un gestionnaire de bibliothèque, si tu souhaites définir des méthodes (fonctions) uniquement pour les manga tu pourras faire
    
    Code :

    1
    2
    3
    4
    5
    6
    7
    8
    9
    class Livre
    {
       // Plein de fonctions liées aux livres
    }
     
    class Manga extends
    {
    	// Cette classe contient les méthodes (fonctions) de la classe Livre, ainsi que les nouvelles méthodes ajoutées
    }

    avec tout ce qu'implique l'héritage : la surcharge de fonction (le fait que si tu créé une fonction ayant le même nom dans Livre et Manga, la fonction de Manga écrasera celle de Livre - très pratique), surcharge de propriétés, etc etc ..

Au début tu auras du mal a voir l'intérêt de la POO (pour avoir eu le même raisonnement que toi au début - a savoir "mais à quoi sert la POO alors que je peux le faire avec des fonctions ?" - je peux te garantir que pour peu que tu t'intéresse un minimum à la POO tu vas pas tarder à être converti et à tout faire en POO



Pour répondre à ta question sur le formulaire, ce qui se trouve dans la fonction [b]__construct()[b] est appelé automatiquement lors de l'instance de l'objet ($form = new Form('paramètres').

[oranocha]

Encore un super gd merci ;-)

Je crois que je vais m'y mettre et essayer de découvrir un max. sur la POO car j'avoue que j'avais laissé cela très loin derrière moi :-)

[Korko Fain]

Ta classe input héritant de la classe form, lorsque tu appel la classe input (son constructeur), automatiquement, tu appel le constructeur de la classe parent. De meme pour le destructeur. Mais le constructeur parent nécéssitant des paramètres, je te conseil de l'appeler explicitement dans la classe fille :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
<?php
 
class Form
{
	public function __construct($name, $action, $method)
	{
		echo "<form name=\"$name\" method=\"$method\" action=\"$action\">";
	}
 
	public function __destruct()
	{
		echo "</form>";
	}
}
 
class Input extends Form
{
	public function __construct($name, $action, $method)
	{
		parent::__construct($name, $action, $method);
	}
 
	function text($name, $value = '', $size = 30)
	{
		echo '<input type="text" name="' . $name . '" size="' . $size . '" value="' . $value . '" />';
	}
}
 
$form = new Input('form1', '#', 'GET');
$form->text('toto');
 
?>

Retour :

Code :

1
2
3
<form name="form1" method="GET" action="#">
<input type="text" name="toto" size="30" value="" />
</form>

[Asmodean]

J'ai une petite question...

Je vous vois parler de méthodes __construct() , mais pourquoi vous n'utilisez pas la forme classique qui est d'appelé le constructeur par le nom de la class?

genre:

Code :

1
2
3
4
5
6
7
8
 
class Form{
 
	function Form()
	{
	}
 
}

[Korko Fain]

Car appeler le constructeur du nom de la classe est, comme le fait de faire précéder les variables de la classe par le mot "var", la syntaxe de classes de PHP4.

PHP5 à changer cela en créant les méthodes magiques __construct, __destruct et j'en passe. Et en remplace "var" par des mots précisant les droits de la variable (public, private, protected)

[Asmodean]

Envoyé par Korko Fain

Car appeler le constructeur du nom de la classe est, comme le fait de faire précéder les variables de la classe par le mot "var", la syntaxe de classes de PHP4.

PHP5 à changer cela en créant les méthodes magiques __construct, __destruct et j'en passe. Et en remplace "var" par des mots précisant les droits de la variable (public, private, protected)

C'est pas tant a php4 que je me refèrais mais à tous les autres langages de programmation. Mais c'est toujours bon à savoir. Merci de l'info.

[Korko Fain]

Toutes les fonctions commençant par __ sont ce qu'on appel des méthodes magiques (tu n'a pas a les appeler explicitement) :
__construct
__destruct
__get
__set
__unset
__call
__toString

renseigne toi elles sont intéréssantes

[goodpz]

Je vous vois parler de méthodes __construct() , mais pourquoi vous n'utilisez pas la forme classique qui est d'appelé le constructeur par le nom de la class?

La nouvelle dénomination "__construct" a été introduite dans php5 car les destructeurs ont fait leur arrivé. Comme ces derniers ne pouvaient pas être nommés "~Name" (comme en c++ par exemple), ils ont choisi "__destruct". D'où l'arrivée de "__construct" par souci de cohérence.

Il vaut mieux privilégier __construct, comme on peut le voir dans cet exemple, qui mélange l'ancienne et la nouvelle dénomination:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class A {
  function A() { echo __METHOD__; }
}
 
class B {
  function __construct() { echo __METHOD__; }
}
 
class C extends A {
  function __construct() {
    parent::__construct(); // affiche A::A()
  }
}
 
class D extends B {
  function __construct() {
    parent::B(); // Fatal error: Call to undefined method B::b()
  }
}
 
$c = new C;
$d = new D;

[Mr N.]

Envoyé par goodpz

Comme ces derniers ne pouvaient pas être nommés "~Name"

Pourquoi ?

[goodpz]

Pourquoi ?

Pour ne pas devoir ajouter un nouveau symbole à la grammaire de php et qui casse en plus la règle [_a-zA-Z] pour le début des noms des fonctions