Méthylbro - Tag - POO

Gestion des utilisateurs avec PHP

Méthylbro — Mon, 12 May 2008 10:44:00 +0200

Cela fait quelques jours que je n'ai pas posté de billet. Il faut dire qu'en ce moment je suis un peu pris par mes examens qui commencent cette semaine.

Là ; je fait un rapide billet pour demander un avis général sur un script que j'écris depuis ces derniers jours. Il s'agit d'une librairie en php permettant de gérer facilement des groupes d'utilisateurs et de leurs attribuer des droits.

IUM User Manager

Pour le moment je ne donnerais pas d'explications ou de documentation. Ca viendras dans les jours à venir. Néanmoins je serais ravis que les plus aguéris me fasse remonter leur point de vue et leurs critiques.

PS: Après les exams c'est promis, je me remet dans la rédaction de tutoriels.

Introduction à la POO avec PHP - Partie 6

Méthylbro — Sat, 19 Apr 2008 06:30:00 +0200

Si vous avez suivis tous mes billets sur la POO avec PHP de cette semaine (voir le billet Introduction à la POO avec PHP) ; vous devez maintenant être en mesure d’écrire vos premières classes. De définir vos premiers objets. Bref ; d’entrer dans le monde de la Programmation Orienté Objet.

Aujourd’hui suite et fin de cette série de billet. Aujourd’hui ; cours pratique. Créons notre classe Stylo !

Exemple

Maintenant ; vous avez en main tous les clés pour comprendre le détail de ma classe d’exemple.


class Stylo {

  static private $niveau_encre_max = 100;
  static private $niveau_encre_min = 25;

  private $niveau_encre;
  protected $couleur_normale = '#000000';
  protected $couleur_fin = '#C0C0C0';
  public $statut;

  private function peutEcrire() {
    if (!$this->statut) {
      $result = false;
    } elseif ($this->niveau_encre<=0) {
      $result = false;
    } else {
      $result = true;
    }
    return $result;
  }

  public function __construct() {
    $this->statut = false;
    $this->niveau_encre = self::$niveau_encre_max;
  }

  public function click() {
    if ($this->statut) {
      $this->statut = false;
    } else {
      $this->statut = true;
    }
  }
 
  public function ecrire($texte) {
    if ($this->peutEcrire()) {
      echo '<p style="color:'.$this->couleur_normale.'">';
      $nb_caracteres = strlen($texte);
      $texte = htmlentities($texte);
      $texte = str_split($texte);
      $i = 0;
      while($this->peutEcrire() && $i<=$nb_caracteres) {
        if ($this->niveau_encre==self::$niveau_encre_min) {
          $format = '<span style="color:'.$this->couleur_fin.'">%s';
        } else {
          $format = "%s";
        }
        printf($format, $texte[$i]);
        $i++;
        $this->niveau_encre --;
      }
      if ($this->niveau_encre<=self::$niveau_encre_min) {
        echo "</span>";
      }
      echo "</p>\n";
    }
  }

}
 
$monBic = new Stylo();
$monBic->ecrire(‘Essayez d\’écrire sans enlever le capuchon…’) ;
$monBic->click() ;
$monBic->ecrire(‘Un premier paragraphe.’) ;
$monBic->ecrire(‘Un second paragraphe qui n\’iras pas jusque au bout car mon stylo va certainement manquer d’encre.’);

$monBic->click() ;

Conclusion

La plupart des développeurs qui ne développent pas encore en POO expliquent souvent que ; pour qu'il leur est plus "naturel" de concevoir et de lire un code procédural.

C’est une fausse excuse. Sur un projet de taille un peu conséquente ; il sera plus facile de manipuler des objets et des entités logique. Ainsi que plus facile à écrire ; et à naviguer au sein de ces entités. Que de se retrouver au milieu d’une foule de procédures ; complexifiant le code ; et très souvent même consommant trop de ressources.

De plus ; l’exemple utilisé dans cet article démontre bien que ; grâce au concept objet ; vous pouvez intégrer absolument tous les cas que vous aurez à traiter. Et ce ; en quelques minutes.

Introduction à la POO avec PHP - Partie 5

Méthylbro — Fri, 18 Apr 2008 00:29:00 +0200

A l’heure ou le premier billet de cette série commence à être référencé (google) ; nous allons voir le dernier concept que vous devez connaitre avant de pouvoir commencer à écrire vos propres classes.

Et comme promis lundi ; demain vous devrez être en mesure d’écrire votre première classe ! Et nous verrons ca ensemble.

Les concepts généraux de la POO (suite)

Le Constructeur

Le moteur objet de PHP implémente toute une série de méthodes dites « magiques » (__construct(), __destruct(), __sleep(), __serialize(), __call() …). Ici nous allons parler de __construct() : le constructeur.

Lorsque vous créer une nouvelle instance de classe (voir le paragraphe « classe et instance de classe) ; vous pouvez dores et déjà exécuter des opérations. Par exemple ; instancier des propriétés avec les valeurs de votre choix. Bien entendu ; il n’est pas interdit de passer des paramètres à cette méthode.

Pour illustrer ; nous allons définir la couleur de notre stylo lors de sa création :


class Stylo {
  private $niveau_encre ;
  private $couleur ;
  private $statut ;

  function __construct($couleur) {
    // la propriété $couleur de l’instance de classe concerné
    // prendra la valeur passé en paramètre au constructeur.
    $this->couleur = $couleur;
  }
}
// Nous allons créer un nouvel objet de type Stylo ;
// avec en paramètre sa couleur.
$monStyloNoir = new Stylo(‘#000000’) ;

En php4 ; le constructeur ne sera pas appelé de la même manière. Il ne devra pas s’appeler __construct(), il devra porter le même nom que celui que vous avez donné à votre classe.

Introduction à la POO avec PHP - Partie 4

Méthylbro — Thu, 17 Apr 2008 06:30:00 +0200

Un article par jour pendant une semaine. Je m’y tiens autant que faire ce peut à ce rythme. Aujourd’hui donc ; 4éme jour. Et voici la suite de notre série de billets consacré à la Programmation Orienté Object avec PHP.

Les concepts généraux de la POO (suite)

Les éléments Statiques

Un élément statique ; sera le même pour toutes les instances d’une même classe. Il peut aussi bien être une propriété ou une méthode. Et sera défini comme statique par le mot clé static. C’est en fait exactement le même principe que les variables statique au sein des fonctions ; sauf qu’ici cela s’applique aussi à vos classes.

Les propriétés statique

Si vous définissez une propriété comme statique ; elle aura toujours la même valeur ; quelle que soit les instances de votre classe. Et vous pourrez même la modifier ou la lire sans passer par l’une de ses instances.

Pour accéder ces propriétés statiques ; il est conseillé d’utiliser l’opérateur de résolution de portée.
Pour plus d’informations : http://fr.php.net/manual/fr/language.oop5.paamayim-nekudotayim.php.

Dans notre exemple ; si je définis la propriété Stylo ::couleur comme statique ; l’effet sera le suivant :


Class Stylo {
  static public $couleur ;
}
// Je crée un stylo ; puis je met la couleur à FF00FF
$stylo1 = new Stylo() ;
$stylo1->couleur = ‘#FF00FF’ ;
// Je crée un autre stylo ; puis je change la couleur pour 00FFFF
$stylo2 = new Stylo() ;
$stylo2->couleur = ‘#00FFFF’ ;
// J’affiche la couleur des deux stylos.
echo $stylo1->couleur ; // Affiche #00FFFF
echo $stylo2->couleur ; // Affiche #00FFFF
// Je change encore une fois la couleur
Stylo::couleur = ‘#000000’;
echo $stylo1->couleur ; // Affiche #000000
echo $stylo2->couleur ; // Affiche #000000

Les méthodes statique

Les méthodes statiques sont utilisées généralement pour définir plus d’un constructeur. Nous ne attarderons pas plus dessus dans cet article. Sachez simplement qu’elles existent.

Introduction à la POO avec PHP - Partie 3

Méthylbro — Wed, 16 Apr 2008 06:00:00 +0200

Vous le savez ; depuis lundi je m’efforce de faire découvrir à ceux qui ne le connaissent pas le monde le la Programmation Orienté Objet (voir ce billet). Une série de billet à l’occasion de la sortie cette semaine de la nouvelle version de Titaxium.

Lundi : Introduction
Mardi : Les Concepts Généraux de la POO

Aujourd’hui ; troisième Opus.

Les concepts généraux de la POO (suite)

Porté des éléments

Il est possible de contrôler la visibilité des éléments de votre classe au sein de votre code. Pour ce faire nous allons découvrir de nouveaux mots clés.

Si vous avez déjà pu lire du code source PHP écris avec de la POO ; vous avez sans doutes vu apparaitre des mots comme « public », « private » ou encore « protected ».

Ces mots clé sont utilisés pour définir la visibilité de vos éléments. J’entends par éléments ; les propriétés et les méthodes de votre classe. L’intérêt est de pouvoir limiter l’accès à ces éléments en fonction de l’endroit dans le code ou vous en faites appel.

Vous pouvez restreindre la visibilité de vos éléments selon les trois niveaux suivant :

Public

De n’importe où cet élément sera visible. A n’importe quel moment dans votre programme vous pourrez venir utiliser un élément défini comme public.


class Stylo {
  public $niveau_encre = 1;
}
$unStylo = new Stylo();
echo $unStylo->niveau_encre; // Affiche 1

$unStylo->niveau_encre = 0;
echo $unStylo->niveau_encre; // Affiche 0

Private

Si vous choisissez cette option ; votre élément ne sera visible uniquement par votre classe. De la même manière que ; dans un développement procédural ; vous déclarez (par défaut) et utilisez une variable au sein d’une fonction. Cette variable ne sera visible et utilisable uniquement au sein de votre fonction ; et pour une utilisation de celle-ci.

class Stylo { private $niveau_encre = 1; function test() { echo $this->niveau_encre ; } }

$unStylo = new Stylo(); echo $unStylo->niveau_encre; // Affiche l’erreur : // Cannot Access private property $unStylo->test() ; // Affiche 1

Protected

Ce type de visibilité est associé aux concepts d’héritages et de polymorphisme que nous ne traiterons pas dans cet article.

Par défaut en PHP ; tous vos éléments prendront la visibilité public.

Introduction à la POO avec PHP - Partie 2

Méthylbro — Tue, 15 Apr 2008 06:30:00 +0200

La programmation orientée objet (POO) ou programmation par objet, est un paradigme de programmation informatique qui consiste en la définition et l'assemblage de briques logicielles appelées objet ; un objet représente un concept, une idée ou toute entité du monde physique, comme une voiture, une personne ou encore une page d'un livre.

http://fr.wikipedia.org/wiki/Programmation_orientée_objet

Ou bien d'un simple stylo !
Comme promis (Introduction à la POO avec PHP - Partie 1) ; voici la deuxième partie de cette série de billets dédiés à la Programmation Orienté Objet avec PHP.

Les concepts généraux de la POO

Classe et instance de classe

Comme vous pouvez l’imaginer ; avant de pouvoir utiliser un objet ; nous allons devoir définir le type de cet objet.

C’est à ce niveau que la compréhension risque d’être la moins évidente et la plus difficile. Il va falloir distinguer le type d’un objet (entier, réel, booléen etc) de l’objet lui-même (33, 3.14, true etc).

Lorsque nous définirons le type d’un objet ; nous parlerons de classes. Lorsque nous utiliserons ses classes pour créer et manipuler des objets nous parlerons d’instances de classes.

Pour illustrer ; je vais reprendre mon exemple des stylos. La classe sera le schéma pour un stylo. Comme un de plan de fabrication, ou d’utilisation. Tandis que l’instance de cette classe sera techniquement le stylo. Donc ; pour le même schéma ; pour la même classe ; vous pouvez avoir plusieurs stylos ; plusieurs objets ou instances de classe.

En php définir une classe est aussi simple que de définir une fonction :


class Stylo {
  // définition des propriétés
  // définition des méthodes
}

Une fois la classe définie ; vous pouvez très bien créer un nouvel objet ; une nouvelle instance de votre classe. Pour ce faire ; en php on utilise l’opérateur new.

// $myClassInstance est un nouvel objet de type Stylo $myClassInstance = new Stylo() ;

Les propriétés

Les propriétés sont des variables associés aux instances de vos classes (ceci est une généralité. Nous verrons plus loin que des cas spécifiques sont possibles ; notamment avec le mot clé static).

Par exemple ; si nous considérons une entité de type Personne. Chaque personnes possède un nom ; un prénom et une date de naissance. Et bien ces informations seront des propriétés de la classe Personne. Chaque instance de Personne possédera donc un nom ; un prénom et une date de naissance.

Si je reprends mon exemple du stylo ; chaque stylo aura comme propriété un niveau d’encre ; une couleur ; et un statut pour savoir si ma mine est sortie ou capuchée. La définition de ma classe Stylo prendra donc la forme suivante :


class Stylo {
  var $niveau_encre ;
  var $couleur ;
  var $statut ;
  // définition des méthodes
}

Le mot clés var n’est plus utilisé depuis php5. Cependant il a été conservé pour une compatibilité avec php4. Il est utilisé ici ; juste pour que vous sachiez qu’il existe et pour que vous ne soyez pas surpris si un jour vous le rencontrez.

Les méthodes

Les méthodes sont des procédures et/ou des fonctions associées aux instances de vos classes. De la même façon que les propriétés ; nous verrons plus loin que cette affirmation est une généralité assujettie à des exceptions.

Au sein de vos méthodes ; vous pouvez faire appel aux autres éléments (méthodes et ou propriétés) de votre instance de classe à l’aide de l’objet $this. Qui est en fait une référence vers l’instance de classe concernée.

Par exemple ; nous allons créer une méthode qui renvoie vrai si le niveau d’encre est suffisant pour écrire ; et faux le cas contraire. Vous allez voir que ; a part la possibilité d’accéder aux propriétés de l’objet en cours ; rien ne change comparativement aux fonctions que vous connaissez.

class Stylo { $niveau_encre ; $couleur ; $statut ; function peutEcrire() { if ($this->niveau_encre<=0) { $result = false; } else { $result = true ; } return $result ; } }