PHP 5.4.36 Released

Les classes : class

Une classe est une collection de variables et de fonctions qui fonctionnent avec ces variables. Les variables sont définies par l'élément var et les fonctions par function. Une classe est définie en utilisant la syntaxe suivante :

<?php
class Panier {
    
// Eléments de notre panier
    
var $items;

    
// Ajout de $num articles de type $artnr au panier

    
function add_item($artnr$num) {
        
$this->items[$artnr] += $num;
    }

    
// Suppression de $num articles du type $artnr du panier

    
function remove_item($artnr$num) {
        if (
$this->items[$artnr] > $num) {
            
$this->items[$artnr] -= $num;
            return 
true;
        } elseif (
$this->items[$artnr] == $num) {
            unset(
$this->items[$artnr]);
            return 
true;
        } else {
            return 
false;
        }
    }
}
?>

L'exemple ci-dessus définit la classe Panier qui est composée d'un tableau associatif contenant les articles du panier et de deux fonctions, une pour ajouter et une pour enlever des éléments au panier.

Avertissement

Vous NE POUVEZ PAS couper la définition d'une classe en plusieurs fichiers. De la même façon, vous NE POUVEZ PAS couper la définition d'une classe en de multiples blocs, à moins que la coupure ne soit à l'intérieur de la déclaration d'une méthode. Ce qui suit ne fonctionnera pas :

<?php
class test {
?>
<?php
    
function test() {
        print 
'OK';
    }
}
?>

Néanmoins, ce qui suit est autorisé :

<?php
class test {
    function 
test() {
        
?>
        <?php
        
print 'OK';
    }
}
?>

Les notes suivantes ne sont valables que pour PHP 4.

Attention

Le nom stdClass est utilisé en interne par Zend et ne doit pas être utilisé. Vous ne pouvez pas nommer une classe stdClass en PHP.

Attention

Les noms de fonctions __sleep et __wakeup sont magiques en PHP. Vous ne pouvez pas utiliser ces noms de fonctions dans vos classes, à moins que vous ne souhaitiez utiliser la magie qui y est associée.

Attention

PHP se réserve l'usage de tous les noms de fonctions commençant par __, pour sa propre magie. Il est vivement recommandé de ne pas utiliser des noms de fonctions commençant par __, à moins que vous ne souhaitiez utiliser la magie qui y est associée.

En PHP 4, seuls les initialiseurs constants pour les variables var sont autorisés. Utilisez les constructeurs pour les initialisations variables, ou utilisant des expressions.

<?php
/* Aucune de ces syntaxes ne fonctionnera en PHP 4 */
class Panier {
    var 
$date_du_jour date("d/m/Y");
    var 
$name $firstname;
    var 
$owner 'Fred ' 'Jones';
    var 
$items = array("DVD""Télé","Magnétoscope");
}
/* Voici comment cela doit se faire désormais. */
class Panier {
    var 
$date_du_jour;
    var 
$name;
    var 
$owner;
    var 
$items;
    function 
Panier() {
        
$this->date_du_jour date("d/m/Y");
        
$this->name $GLOBALS['firstname'];
        
/* etc. */
    
}
}
?>

Les classes forment un type de variable. Pour créer une variable du type désiré, vous devez utiliser l'opérateur new.

<?php
$cart 
= new Panier;
$cart->add_item("10"1);

$another_cart = new Panier;
$another_cart->add_item("0815"3);
?>

L'instruction ci-dessus crée l'objet $cart et $another_cart de la classe Panier. La fonction add_idem() de l'objet $cart est appelée afin d'ajouter l'article numéro 10 dans $cart. Trois articles numéro 0815 sont ajoutés au panier $another_cart.

$cart et $another_cart disposent des fonctions add_item(), remove_item() et de la variable items. Ce sont des fonctions et variables distinctes. Vous pouvez vous représenter les objets comme des dossiers sur votre disque dur. Vous pouvez avoir deux fichiers lisez-moi.txt sur votre disque dur, tant qu'ils ne sont pas dans le même répertoire. De même que vous devez alors taper le chemin complet jusqu'au fichier, vous devez spécifier le nom complet de la méthode avant de l'employer : en termes PHP, le dossier racine est l'espace de nom global, et le séparateur de dossier est ->. Par exemple, les noms $cart->items et $another_cart->items représentent deux variables distinctes. Notez que le nom de la variable est alors $cart->items, et non pas $cart->$items : il n'y a qu'un seul signe $ dans un nom de variable.

<?php
// correct, le signe $ est unique
$cart->items  = array("10" => 1);

// incorrect, car $cart->$items devient $cart->""
$cart->$items = array("10" => 1);

// correct, mais risque de ne pas se comporter comme prévu
// $cart->$myvar devient $cart->items
$myvar 'items';
$cart->$myvar = array("10" => 1);  
?>

À l'intérieur d'une définition de classe, vous ne savez pas le nom de la variable à partir duquel l'objet sera accessible dans le script. On ne peut prévoir que l'objet créé sera affecté à la variable $cart, $another_cart ou quelque chose d'autres. Donc, vous ne pouvez pas utiliser la syntaxe $cart->items. Mais pour pouvoir accéder aux méthodes et membres d'un objet, vous pouvez utiliser la variable spéciale $this, qui peut s'interpréter comme "moi-même", ou bien "l'objet courant". Par exemple, '$this->items[$artnr] += $num' peut se lire comme 'ajouter $num au compteur $artnr de mon propre tableau de compteur' ou bien 'ajouter $num au compteur $artnr du tableau de compteurs de l'objet courant'.

Note:

La pseudo-variable $this n'est pas toujours définie si la méthode dans laquelle elle est présente est appelée statiquement. Cependant, ceci n'est pas une règle stricte : $this est définie si une méthode est appelée statiquement depuis un autre objet. Dans ce cas, la valeur de $this vaut l'objet appelé. Ce comportement est illustré dans l'exemple ci-dessous :

<?php
class A
{
    function 
foo()
    {
        if (isset(
$this)) {
            echo 
'$this est défini (';
            echo 
get_class($this);
            echo 
")\n";
        } else {
            echo 
"\$this n'est pas défini.\n";
        }
    }
}

class 
B
{
    function 
bar()
    {
        
A::foo();
    }
}

$a = new A();
$a->foo();
A::foo();
$b = new B();
$b->bar();
B::bar();
?>

L'exemple ci-dessus va afficher :

$this est défini (a)
$this n'est pas défini.
$this est défini (b)
$this n'est pas défini.

Note:

Il y a des fonctions très pratiques pour gérer les classes et objets. Vous pouvez étudier le chapitre sur les fonctions de classes et objets.

add a note add a note

User Contributed Notes 4 notes

up
0
masonswolf at gmail dot com
2 years ago
You can invoke a class above its definitions in some cases, but there are very important exceptions to this behavior. If your class extends another class, and the interpreter doesn't see the extended class first, then it won't be added to the symbol table until the code has stepped through it in runtime. As a result, if you try to invoke it above the definition, you'll get a "class not found" fatal error.

And those suck.

So, to provide an example, the following will output a fatal error
<?php
Bar
::bar();
exit;

class
Bar extends Foo { } //will fatal because Foo not seen yet

class Foo {
    static function
bar() { echo 'yep, this is Foo::bar'; }
}
?>

However, THIS code will work just fine:
<?php
Bar
::bar();
exit;

class
Foo {
    static function
bar() { echo 'yep, this is Foo::bar'; }
}

class
Bar extends Foo { } //will work because Foo came first
?>

Notice that if you include a file containing the class you will extend, and then extend the class in the same file as its invocation, you can also get the class not found fatal. This happens even if the 'include' call happens before the child class's definition.

Eg. the following will also output a fatal error
<?php
include_once('file_with_foo.php');

Bar::bar();
exit;

class
Bar extends Foo { }
?>

Hope that clarifies things.
up
-1
anthonymccuen at yahoo dot com
1 year ago
You can also use "var" to declare multiple public instance variables like in C:

int main(int *argc, const char *argv[]) {
    int a, b, c, d, e, f;
   
    a = 50;
    // blah blah blah code here
    // ...
   
    return 0;
}

Same as PHP:

<?php
class MyClass {
    var
$myvar, $anotherVar, $something, $str;
}
?>
up
-3
boukeversteegh at gmail dot com
4 years ago
You can also instantiate objects using variables containing the name of the class:

<?php

$type
= 'Foo';
$foo   = new $type();

print_r( $foo );
/* Prints:
Foo Object
(
)
*/
?>

The following works as well:
<?php

$somefoo   
= new Foo();
$anotherfoo = new $somefoo();

# so you don't have to do:
$anotherfoo = new get_class( $somefoo)();
?>
up
-5
pov at fingerprint.fr
3 years ago
I just discovered a behaviour that has to be mentioned.

Let's consider the following file

<?php
Foo
::bar();
exit;

class
Foo {
  function
bar() { echo 'yep, this is Foo::bar'; }
}
?>

You may expect :
- an error on the Foo::bar call, because the class is not defined
- removing the code after the exit without side-effect

But it won't, and it will output the string !
It seems every class definition is executed at parse-time.

But without errors; if your file is
<?php
Foo
::bar();
exit;

class
Foo {
  function
bar() { echo 'yep, this is Foo::bar'; }
}
class
Foo {
  function
bar() { echo 'yep, this is another Foo::bar'; }
}
?>
it will still output the first string, not doing any "Already exiting class" error !

So if you intend preventing a double include by doing in an included file :
<?php
if (class_exists('Foo')) { return; }

class
Foo {
  static function
register() { ... }
}
Foo::register();
?>
the Foo::register method won't be called !

Very strange development choice; I suppose it is due to ascending compatibility.
Hope it can help...
To Top