Spirit 203

Good morning
I ask you to translate a long text whiche is a programmation tutorial
I isn't to win money and I don't speak a enough good english to translate it myself, because I want steady language. Does someone accept to translate it.
I would ask you not to transate text which is inside <code> ... </code> because there functions which can't be translated. There are { for pagination and I ask you not to delete it
Can someone do it, please ?

{{Pré requis}}: Maîtrise du PHP

Un objet est un format complexe de variable regroupant des variables et des fonctions. La programmation orientée objet s'éffectue en deux étapes: la définition des classes puis leur utilisation. Une fois la classe définie, il sera possible de créer une infinité d'objets du format de la classe définie.

Les fonctions d'une classe sont appelées les méthodes et les variables les propriétés

{{{I Définition des classes}}}

Définir une classe adopte la syntaxe suivante:

<code>
class nomObjet
{
var $variable1;
var $variable2;
...


function maFonction1()
{
...code
}

function maFonction2()
{

}

}

</code>

Il est possible d'attribuer une valeur par défaut. Le code dans la classe est alors
var $variable1 = valeur;

La définition de fonctions dans une classe est identique à celle de n'importe quelle fonction à la différence que lorsqu'elle fait référence à une variable de la classe, $variable doit être $this->variable. De même pour exécuter une fonction de la classe.
ex:

<code>
class client
{
var $aDitBonjour = false;


function direBonjour()
{
$this->message("Bonjour");
}

function message($message)
{
echo $message;
$this->aDitBonjour = true;
}

}
</code>

{{{II Utilisation d'un objet}}}

Attention: la classe est la définition d'un format de variable personnalisable. Le code n'est pas exécuté et il est impensable d'introduire le code suivant qui n'aurait aucun sens:

<code>
class client
{

for ($i=0; $i<5; $i++)
echo "$i\n";

}
</code>

Une fois la classe définie, il va falloir créer des variables objet du format de la classe définie. On crée un objet par le code suivant:

<code>
$objet = new client();
</code>

Il faut bien entendu avoir préalablement définit la classe client.
La variable $objet contient donc un objet. Pour accéder à une variable pour lui faire subir des modifications, il suffit d'entrer le code suivant:

<code>
$objet->variable1 = "Hello world";
</code>

Il est possible de lui faire subir les mêmes opérations qu'à une variable normale. De même pour exécuter une fonction:

<code>
$objet->maFonction();
</code>

Autant les méthodes une fois définies ne peuvent pas être modifiées, autant il est possible d'ajouter ou de supprimer des variables dans l'objet:

<code>
$objet->variable = "valeur"; //definition de variable

unset( $objet->variable ); //supressions
</code>

L'objet est unique, de sorte que s'il est enregistré dans une autre variable et qu'une modification lui est faite, elle sera visible pour les deux variables:

<code>
//Le code reprend l'ancien script

$objet = new client();
$objet2 = $objet;
$objet2->direBonjour();
echo $objet->aDitBonjour;

//affiche true
</code>

Pour dupliquer une variable, il faut donc entrer le code suivant:

<code>
$objet2 = clone $objet;
</code>

La nouvelle variable sera différente de l'ancienne mais aura les mêmes valeurs.

{{{III Les méthodes prédéfinies}}}

Il existe quelques méthodes pré-définies qui s'exécutent à des périodes de la vie de l'objet:

- __construct()

Cette méthode s'exécute lors de la création de l'objet. On entre alors les attributs potentiels de la fonction lors de sa création. Cette méthode est appelée "le constructeur"

- __destroy()

Cette méthode s'exécute au contraire au moment de la destruction de la variable. Elle est appelée "le destructeur".

Attention, ces deux méthodes sont précédées de deux underscores.
Voici un exemple utilisant les méthodes:

<code>

//Definition de la classe

class Humain
{
var $homme = false;
var $femme = false;

function __construct($type)
{
$this->$type = true;
}

function extremeOnction()
{
echo 'Amen';
}


function __destroy()
{
$this->extremeOnction();
}

}


//C'est un garçon !
$homme = new Humain("homme");

if ($homme->homme)
{
echo "C'est un homme";
}
elseif ($homme->femme)
{
echo "C'est une femme";
}

//mort de l'homme
unset($homme);


/*
La sortie sera

C'est un homme
Amen

*/

</code>

Sous php4, le constructeur avait pour nom celui de la classe. Sous php5, si la fonction __construct() n'est pas trouvée, l'interprêteur cherchera une méthode du même nom que la classe.

Il existe une dernière méthode qui s'exécute lors d'une duplication de l'objet. Son nom est __clone();


Il est possible de faire hériter une classe des propriétés et méthodes d'une autre classe. Ex:

<code>

class parent
{
var $varParent;

function functionParent()
{

}
}

class enfant extends parent
{
var $varEnfant;

function functionEnfant()
{

}
}

</code>

L'objet enfant bénéficiera des propriétés et des méthodes de la classe parent.

{{{IV Restriction d'accès}}}

Il est possible depuis PHP5 d'empêcher d'accéder à une variable par un autre biais que celui d'une méthode de l'objet. Il suffit de remplacer var par private lors de la définition de la variable. De même avec une méthode:

<code>
class CompteEnBanque
{

private $argent = 0;

private function ajouterArgent($valeur)
{
$this->argent += $valeur;
}

function gagnerArgent($valeur)
{
$this->ajouterArgent($valeur);
}
}


$compte = new CompteEnBanque()

//les actions suivantes sont impossibles:

$compte->argent = 3000;
$compte->ajouterArgent(3000);

//l'action suivante est possible

$compte->gagnerArgent(3000);

</code>

En effet, il faut gagner de l'argent avant d'en ajouter à la banque (quoique...)

Attention: ce code retournera un message d'erreur si il est exécuté sous PHP5 ou une version ultérieure

{{{V La gestion des erreurs}}}

Une classe de gestion des erreurs nommée Exception est gracieusement mise à votre disposition par l'interpréteur php. Voici un exemple d'utilisation

<code>
class Humain
{
var $age;

function __construct($combien)
{
$this->age = $combien;

try
{
if ($this->age<0)
throw new Exception('Un peu jeune')
if ($this->age>200)
throw new Exception('Un peu vieux')
}
catch (Exception $e)
{
echo $e->getMessage();
exit();
}
}

}

//Retournera un message d'erreur
$humain = new Humain(700);
$humain = new Humain(-3);

//Sans erreur
$humain = new Humain(16);
</code>


{{{Quelques fonctions intégrées}}}

Voici quelques fonctions en relation avec la programmation orientée objet qui peuvent vous être utiles.

- class_exists( {string} )

Vérifie qu'une classe existe. Renvoie une valeur booleenne.
ex:
<code>
if( class_exists('myClass')
$var = new myClass();
</code>

- get_class_methods( {class} )

Retourne les méthodes d'une classe sous forme de tableau.
ex:
<code>
$maClasse = new Classe();
$methods = get_class_methods( $maClasse );
print_r($methods);
</code>

- get_class_vars( {class} )

Retourne les variables ainsi que leurs valeurs par défaut sous forme de tableau
ex:
<code>
$maClasse = new Classe();
$methods = get_class_vars( $maClasse );
print_r($methods);
</code>