self (not $self) se réfère au type de la classe, où comme $this se réfère à l'actuelle instance de la classe. self est à utiliser dans les fonctions membres statiques pour vous permettre d'accéder membre statique des variables. $this est utilisé dans les fonctions membres non statiques, et est une référence à l'instance de la classe sur laquelle la fonction membre a été appelée.

parce que this est un objet, vous l'utilisez comme: $this->member

parce que self n'est pas un objet, c'est fondamentalement un type qui se réfère automatiquement à la classe courante, vous l'utilisez comme: self::member

$this-> est utilisé pour désigner une instance spécifique des variables (variables membres) ou des méthodes d'une classe.

Example: 
$derek = new Person();

$derek est maintenant une instance spécifique de personne. Chaque personne a un first_name et un last_name, mais $derek a un first_name et un last_name spécifiques (Derek Martin). Dans l'instance $ derek, nous pouvons nous référer à ceux comme $this - > first_name et $this->last_name

nom de classe:: est utilisé pour se référer à ce type de classe, et ses variables statiques, ses méthodes statiques. Si cela peut aider, vous pouvez mentalement remplacer le mot "statique" avec "partagé". Parce qu'ils sont partagés, ils ne peuvent pas se référer à $this, qui se réfère à une instance spécifique (non partagée). Les Variables statiques (c'est-à-dire static $db_connection) peuvent être partagées entre toutes les instances d'un type d'objet. Par exemple, tous les objets de la base de données partagent une seule connexion ($connection statique).

Exemple De Variables Statiques: Prétendre que nous avons un classe de base de données avec une variable à un seul membre: statique $ num_connections; Maintenant, mettez ceci dans le constructeur:

function __construct()
{
    if(!isset $num_connections || $num_connections==null)
    {
        $num_connections=0;
    }
    else
    {
        $num_connections++;
    }
}

tout comme les objets ont des constructeurs, ils ont aussi des destructeurs, qui sont exécutés lorsque l'objet meurt ou est désactivé:

function __destruct()
{
    $num_connections--;
}

chaque fois que nous créons une nouvelle instance, cela augmentera notre compteur de connexion d'un. Chaque fois que nous détruisons ou arrêtons d'utiliser une instance, cela diminuera le compteur de connexion d'un. Dans ce façon, nous pouvons surveiller le nombre d'instances de l'objet de base de données, nous avons utilisé avec:

echo DB::num_connections;

parce que $num_connections est statique (partagé), il reflétera le nombre total d'objets de base de données actifs. Vous avez peut-être vu cette technique utilisée pour partager des connexions de base de données entre toutes les instances d'une classe de base de données. Cela est fait parce que la création de la connexion de base de données prend beaucoup de temps, il est donc préférable d'en créer une seule, et de la partager (ceci s'appelle un Singleton Modèle.)

Les méthodes statiques

(C'est-à-dire public static View::format_phone_number ($digits)) peuvent être utilisées sans instanciation préalable d'un de ces objets (c'est-à-dire qu'elles ne se réfèrent pas en interne à $this).

Exemple De Méthode Statique:

public static function prettyName($first_name, $last_name)
{
    echo ucfirst($first_name).' '.ucfirst($last_name);
}

echo Person::prettyName($derek->first_name, $derek->last_name);

comme vous pouvez le voir, la fonction publique statique prettyName ne sait rien sur l'objet. C'est simplement de travailler avec les paramètres que vous passez, comme une fonction normale c'est pas partie d'un objet. Pourquoi s'embêter, alors, si nous pouvions juste l'avoir pas comme partie de l'objet?

1. premièrement, attacher des fonctions à des objets vous aide à garder les choses organisées, de sorte que vous savez où les trouver.
2. deuxièmement, il prévient les conflits de noms. Dans un grand projet, vous êtes susceptible d'avoir deux développeurs de créer des getName (). Si L'un crée un ClassName1::getName(), et l'autre crée ClassName2::getName(), ce n'est pas un problème du tout. Aucun conflit. Yay méthodes statiques!

SELF:: Si vous codez à l'extérieur de l'objet qui a la méthode statique à laquelle vous voulez faire référence, vous devez l'appeler en utilisant la vue nom de l'objet:: format_phone_number ($phone_number); Si vous êtes le codage à l'intérieur l'objet qui contient la méthode statique que vous souhaitez consulter, vous pouvez soit utiliser le nom de l'objet View:: format_phone_number ($pn), ou vous pouvez utiliser le self:: format_phone_number ($pn) raccourci

il en va de même pour les variables statiques: Exemple: View::templates_path rapport à soi::templates_path

dans la classe DB, si nous nous référions à une méthode statique d'un autre objet, nous utiliserions le nom de l'objet: exemple: Session:: getUsersOnline ();

mais si la classe DB voulait se référer à sa propre variable statique, il se dirait juste: Exemple: self::connexion;

Hope qui aide à clarifier les choses :)

à Partir de ce blog :

• self renvoie à la classe actuelle
• self peut être utilisé pour appeler des fonctions statiques et de référence des variables statiques
• self peut être utilisé à l'intérieur de fonctions statiques
• self peut également désactiver le comportement polymorphe en contournant le vtable
• $this fait référence à l'objet actuel
• $this peut être utilisé pour appeler des fonctions statiques
• $this ne doit pas être utilisé pour appeler des variables membres statiques. Utilisez self à la place.
• $this ne peut pas être utilisé à l'intérieur des fonctions statiques

en PHP, vous utilisez le mot-clé self pour accéder aux propriétés statiques et aux méthodes.

le problème est que vous pouvez remplacer $this->method() par self::method() n'importe où, peu importe si method() est déclaré statique ou non. Alors, qui devriez-vous utiliser?

considérez ce code:

class ParentClass {
    function test() {
        self::who();    // will output 'parent'
        $this->who();   // will output 'child'
    }

    function who() {
        echo 'parent';
    }
}

class ChildClass extends ParentClass {
    function who() {
        echo 'child';
    }
}

$obj = new ChildClass();
$obj->test();

dans cet exemple, self::who() produira toujours" parent", tandis que $this->who() dépendra de la classe de l'objet.

maintenant, nous pouvons voir que self se réfère à la classe dans laquelle il est appelé, tandis que $this se réfère à la classe de l'objet actuel .

ainsi, vous devriez utiliser self seulement quand $this n'est pas disponible, ou quand vous ne voulez pas permettre aux classes descendantes d'écraser la méthode actuelle.

dans la définition d'une classe, $renvoie à l'objet courant, tandis que self renvoie à la classe courante.

il est nécessaire de faire référence à un élément de classe en utilisant self, et de faire référence à un élément d'objet en utilisant $this.

self::STAT // refer to a constant value
self::$stat // static variable
$this->stat // refer to an object variable  

voici un exemple d'utilisation correcte de $this et self pour non-static et les variables statiques des membres:

<?php
class X {
    private $non_static_member = 1;
    private static $static_member = 2;

    function __construct() {
        echo $this->non_static_member . ' '
           . self::$static_member;
    }
}

new X();
?> 

selon http://www.php.net/manual/en/language.oop5.static.php il n'y a pas de $self . Il n'y a que $this , pour se référer à l'instance courante de la classe (l'objet), et le soi, qui peut être utilisé pour se référer aux membres statiques d'une classe. La différence entre une instance objet et une classe entre en jeu ici.

comme personne ici ne parlait de performances, voici un petit benchmark que j'ai fait (5.6):

 Name     | Time    | Percent  
----------|---------|---------  
 $this->  | 0.99163 | 106.23%  
 self::   | 0.96912 | 103.82%  
 static:: | 0.93348 | 100%

ce sont les résultats pour 2 000 000 de passages, et voici le code que j'ai utilisé:

<?php

require '../vendor/autoload.php';

// My small class to do benchmarks
// All it does is looping over every test x times and record the
//   time it takes using `microtime(true)`
// Then, the percentage is calculated, with 100% being the quickest
// Times are being rouned for outputting only, not to calculate the percentages
$b = new Tleb\Benchmark\Benchmark(2000000);

class Foo
{
    public function calling_this()
    {
        $this->called();
    }

    public function calling_self()
    {
        self::called();
    }

    public function calling_static()
    {
        static::called();
    }

    public static function called()
    {
    }
}

$b->add('$this->',  function () { $foo = new Foo; $foo->calling_this(); });
$b->add('self::',   function () { $foo = new Foo; $foo->calling_self(); });
$b->add('static::', function () { $foo = new Foo; $foo->calling_static(); });

$b->run();

self se rapporte à la classe courante (dans laquelle elle est appelée),

$this renvoie à l'objet courant. Vous pouvez utiliser statique au lieu de l'auto. Voir l'exemple:

    class ParentClass {
            function test() {
                    self::which();  // output 'parent'
                    $this->which(); // output 'child'
            }

            function which() {
                    echo 'parent';
            }
    }

    class ChildClass extends ParentClass {
            function which() {
                    echo 'child';
            }
    }

    $obj = new ChildClass();
    $obj->test();

sortie: parent enfant

je crois que la question n'était pas de savoir si vous pouvez appeler le membre statique de la classe en appelant ClassName::staticMember . La question était de savoir quelle était la différence entre self::classmember et $this->classmember .

pour par exemple, les deux exemples suivants fonctionnent sans aucune erreur, que vous utilisiez self:: ou $this->

class Person{
    private $name;
    private $address;

    public function __construct($new_name,$new_address){
        $this->name = $new_name;
        $this->address = $new_address;
    }
}

class Person{
    private $name;
    private $address;
    public function __construct($new_name,$new_address){
        self::$name = $new_name;
        self::$address = $new_address;
    }
}

• le pointeur d'objet $ceci se réfère à l'objet courant.
• la valeur de classe" statique " se rapporte à l'objet courant.
• La classe de la valeur "auto" fait référence exacte de la classe qu'il a été défini.
• la valeur de classe" parent " se rapporte au parent de la classe exacte dans laquelle il a été défini.

voir l'exemple suivant qui montre une surcharge.

<?php

class A {

    public static function newStaticClass()
    {
        return new static;
    }

    public static function newSelfClass()
    {
        return new self;
    }

    public function newThisClass()
    {
        return new $this;
    }
}

class B extends A
{
    public function newParentClass()
    {
        return new parent;
    }
}


$b = new B;

var_dump($b::newStaticClass()); // B
var_dump($b::newSelfClass()); // A because self belongs to "A"
var_dump($b->newThisClass()); // B
var_dump($b->newParentClass()); // A


class C extends B
{
    public static function newSelfClass()
    {
        return new self;
    }
}


$c = new C;

var_dump($c::newStaticClass()); // C
var_dump($c::newSelfClass()); // C because self now points to "C" class
var_dump($c->newThisClass()); // C
var_dump($b->newParentClass()); // A because parent was defined *way back* in class "B"

la plupart du temps, vous voulez vous référer à la classe courante, c'est pourquoi vous utilisez static ou $this . Cependant, il ya des moments où vous besoin self parce que vous voulez la classe d'origine indépendamment de ce qui l'étend. (Très, très rarement)

quand self est utilisé avec l'opérateur :: il se réfère à la classe courante, qui peut être fait à la fois dans des contextes statiques et non statiques. $this se réfère à l'objet lui-même. En outre, il est parfaitement légal d'utiliser $this pour appeler des méthodes statiques (mais ne pas faire référence à des champs).

$this se rapporte à l'objet de la classe courante, self se rapporte à la classe courante (non à l'objet). La classe est le modèle de l'objet. Donc vous définissez une classe, mais vous construisez des objets.

donc, en d'autres termes, utilisez self for static et this for none-static members or methods .

aussi dans le scénario enfant / parent self / parent est principalement utilisé pour identifier les enfants et les parents membres de la classe et les méthodes.

en outre depuis $this:: n'a pas encore été discuté.

à titre d'information seulement, à partir de PHP 5.3 en traitant des objets instanciés pour obtenir la valeur de portée actuelle, par opposition à l'utilisation de static:: , on peut alternativement utiliser $this:: comme ainsi.

http://ideone.com/7etRHy

class Foo
{
    const NAME = 'Foo';

    //Always Foo::NAME (Foo) due to self
    protected static $staticName = self::NAME;

    public function __construct()
    {
        echo $this::NAME;
    }

    public function getStaticName()
    {
       echo $this::$staticName;
    }
}

class Bar extends Foo
{
    const NAME = 'FooBar';

    /**
     * override getStaticName to output Bar::NAME
     */
    public function getStaticName()
    {
        $this::$staticName = $this::NAME;
        parent::getStaticName();
    }
}

$foo = new Foo; //outputs Foo
$bar = new Bar; //outputs FooBar
$foo->getStaticName(); //outputs Foo
$bar->getStaticName(); //outputs FooBar
$foo->getStaticName(); //outputs FooBar

L'utilisation du code ci-dessus n'est pas une pratique courante ou recommandée, mais est simplement pour illustrer son utilisation, et d'agir plus comme un "le Saviez-vous?"en référence à la question de l'affiche originale.

il représente également l'usage de $object::CONSTANT par exemple echo $foo::NAME; par opposition à $this::NAME;

utiliser self si vous voulez appeler une méthode d'une classe sans créer un objet/instance de cette classe, donc sauvegarder RAM (parfois utiliser soi-même à cette fin). En d'autres termes, il appelle en fait une méthode statiquement. Utilisez this pour la perspective de l'objet.

Cas 1: L'utilisation de self peut être utilisée pour les constantes de classe

 class classA { 
     const FIXED_NUMBER = 4; 
     self::POUNDS_TO_KILOGRAMS
}

si vous voulez l'appeler en dehors de la classe, utilisez classA::POUNDS_TO_KILOGRAMS pour accéder aux constantes

Case 2: pour les propriétés statiques

class classC {
     public function __construct() { 
     self::$_counter++; $this->num = self::$_counter;
   }
}

j'ai rencontré la même question et la réponse simple est:

• $ce nécessite une instance de la classe
• self:: n'est pas

Chaque fois que vous utilisez méthodes statiques ou les attributs statiques et que vous voulez les appeler sans avoir un objet de la classe instanciée, vous devez utiliser self:: pour les appeler, car $this nécessite toujours que l'objet soit créé.

selon php.net il y a trois mots clés spéciaux dans ce contexte: self , parent et static . Ils sont utilisés pour accéder aux propriétés ou aux méthodes à partir de la définition de la classe.

$this , d'autre part, est utilisé pour appeler une instance et des méthodes de n'importe quelle classe aussi longtemps que cette classe est accessible.