В PHP 5, в чем разница между использованием selfи $this?

Когда каждый уместен?

Короткий ответ

Используйте $thisдля ссылки на текущий объект. Используйте selfдля ссылки на текущий класс. Другими словами, используйте $this->memberдля нестатических элементов, используйте self::$memberдля статических элементов.

Полный ответ

Вот пример правильного использования $thisи selfдля нестатических и статических переменных-членов:

<?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();
?>

Вот пример неправильного использования $thisи selfдля нестатических и статических переменных-членов:

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

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

new X();
?>

Вот пример полиморфизма с $thisдля функций-членов:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        $this->foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Вот пример подавления полиморфного поведения с помощью selfфункций-членов:

<?php
class X {
    function foo() {
        echo 'X::foo()';
    }

    function bar() {
        self::foo();
    }
}

class Y extends X {
    function foo() {
        echo 'Y::foo()';
    }
}

$x = new Y();
$x->bar();
?>

Идея состоит в том, чтобы $this->foo()вызывать foo()функцию-член любого типа, который является точным типом текущего объекта. Если объект имеет type X, он таким образом вызывает X::foo(). Если объект имеет type Y, он вызывает Y::foo(). Но с self :: foo () X::foo()всегда вызывается.

С http://www.phpbuilder.com/board/showthread.php?t=10354489 :

Автор: http://board.phpbuilder.com/member.php?145249-laserlight

Ключевое слово self НЕ относится только к «текущему классу», по крайней мере не таким образом, чтобы ограничивать вас статическими членами. В контексте нестатического члена selfтакже предоставляет способ обхода vtable ( см. Wiki по vtable ) для текущего объекта. Точно так же, как вы можете использовать parent::methodName()для вызова родительской версии функции, вы также можете вызвать, self::methodName()чтобы вызвать текущую классовую реализацию метода.

class Person {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }

    public function getTitle() {
        return $this->getName()." the person";
    }

    public function sayHello() {
        echo "Hello, I'm ".$this->getTitle()."<br/>";
    }

    public function sayGoodbye() {
        echo "Goodbye from ".self::getTitle()."<br/>";
    }
}

class Geek extends Person {
    public function __construct($name) {
        parent::__construct($name);
    }

    public function getTitle() {
        return $this->getName()." the geek";
    }
}

$geekObj = new Geek("Ludwig");
$geekObj->sayHello();
$geekObj->sayGoodbye();

Это выведет:

Здравствуйте, я Людвиг гик
Прощай, Людвиг, человек

sayHello()использует $thisуказатель, поэтому vtable вызывается для вызова Geek::getTitle(). sayGoodbye()использует self::getTitle(), поэтому vtable не используется и Person::getTitle()называется. В обоих случаях мы имеем дело с методом экземпляра объекта и имеем доступ к $thisуказателю в вызываемых функциях.

НЕ ИСПОЛЬЗУЙТЕ self::, используйтеstatic::

Есть еще один аспект самости, который стоит упомянуть. Раздражающе self::относится к области действия в точке определения, а не в точке исполнения . Рассмотрим этот простой класс с двумя методами:

class Person
{

    public static function status()
    {
        self::getStatus();
    }

    protected static function getStatus()
    {
        echo "Person is alive";
    }

}

Если мы позвоним, Person::status()то увидим «Человек жив». Теперь рассмотрим, что происходит, когда мы создаем класс, который наследуется от этого:

class Deceased extends Person
{

    protected static function getStatus()
    {
        echo "Person is deceased";
    }

}

Вызов, который Deceased::status()мы ожидаем увидеть «Человек умер», однако мы видим «Человек жив», так как область действия содержит первоначальное определение метода, когда self::getStatus()был определен вызов .

PHP 5.3 имеет решение. то static::оператор реализует разрешение « в конце статической привязки» , который представляет собой причудливый способ сказать , что это связано с областью класса называется. Измените строку status()на static::getStatus()и вы получите ожидаемые результаты. В более старых версиях PHP вам нужно будет найти ключ для этого.

Смотрите PHP документацию

Так что ответить на вопрос не так, как задали ...

$this->ссылается на текущий объект (экземпляр класса), тогда как static::ссылается на класс

Чтобы по-настоящему понять, о чем мы говорим, когда говорим « selfпротив» $this, нам нужно действительно разобраться в том, что происходит на концептуальном и практическом уровне. Я не чувствую, что какой-либо из ответов делает это соответствующим образом, вот моя попытка.

Давайте начнем с разговора о том, что такое класс и объект .

Классы и объекты, концептуально

Итак, что это класс ? Многие люди определяют его как проект или шаблон для объекта. На самом деле, вы можете прочитать больше о классах в PHP здесь . И в какой-то степени это то, что есть на самом деле. Давайте посмотрим на класс:

class Person {
    public $name = 'my name';
    public function sayHello() {
        echo "Hello";
    }
}

Как вы можете заметить, в этом классе есть свойство, которое вызывается, и вызывается $nameметод (функция) sayHello().

Это очень важно отметить , что класс является статической структурой. Это означает, что Personкогда-то определенный класс всегда одинаков везде, где вы на него смотрите.

С другой стороны, объект - это то, что называется экземпляром класса. Это означает, что мы берем «план» класса и используем его для создания динамической копии. Эта копия теперь специально привязана к переменной, в которой она хранится. Поэтому любые изменения экземпляра являются локальными для этого экземпляра.

$bob = new Person;
$adam = new Person;
$bob->name = 'Bob';
echo $adam->name; // "my name"

Мы создаем новые экземпляры класса, используя newоператор.

Поэтому мы говорим, что класс - это глобальная структура, а объект - локальная структура. Не беспокойтесь об этом забавном ->синтаксисе, мы немного углубимся в это.

Еще одна вещь, о которой мы должны поговорить, это то, что мы можем проверить , является ли экземпляр instanceofконкретным классом: $bob instanceof Personкоторый возвращает логическое значение, если $bobэкземпляр был создан с использованием Personкласса или потомка Person.

Определение состояния

Итак, давайте немного углубимся в то, что на самом деле содержит класс. Есть 5 типов «вещей», которые содержит класс:

1. Свойства - Думайте о них как о переменных, которые будет содержать каждый экземпляр.

   class Foo {
       public $bar = 1;
   }

2. Статические свойства - Думайте о них как о переменных, которые используются на уровне класса. Это означает, что они никогда не копируются каждым экземпляром.

   class Foo {
       public static $bar = 1;
   }

3. Методы - это функции, которые каждый экземпляр будет содержать (и работать с экземплярами).

   class Foo {
       public function bar() {}
   }

4. Статические методы - это функции, которые являются общими для всего класса. Они работают не с экземплярами, а только со статическими свойствами.

   class Foo {
       public static function bar() {}
   }

5. Константы - класс разрешенных констант. Здесь не буду углубляться, но добавлю для полноты:

   class Foo {
       const BAR = 1;
   }

Таким образом, в основном, мы храним информацию о классе и контейнере объекта, используя «подсказки» о статических данных, которые определяют, является ли информация общей (и, следовательно, статической) или нет (и, следовательно, динамической).

Состояние и методы

Внутри метода экземпляр объекта представлен $thisпеременной. Текущее состояние этого объекта есть, и изменение (изменение) любого свойства приведет к изменению этого экземпляра (но не других).

Если метод вызывается статически, $thisпеременная не определена . Это потому, что нет никакого экземпляра, связанного со статическим вызовом.

Здесь интересно то, как выполняются статические звонки. Итак, давайте поговорим о том, как мы получаем доступ к состоянию:

Доступ к государству

Теперь, когда мы сохранили это состояние, нам нужно получить к нему доступ. Это может получить немного сложнее (или путь больше , чем немного), так что давайте разделить это на двух точек зрения: с внешней стороны экземпляра / класса (скажем , от обычного вызова функции или глобальной области видимости), так и внутри экземпляра / класс (изнутри метода объекта).

Снаружи экземпляра / класса

Снаружи экземпляра / класса наши правила довольно просты и предсказуемы. У нас есть два оператора, и каждый немедленно сообщает нам, имеем ли мы дело с экземпляром или классом static:

• ->- object-operator - всегда используется при доступе к экземпляру.

  $bob = new Person;
  echo $bob->name;

  Важно отметить, что вызов Person->fooне имеет смысла (поскольку Personэто класс, а не экземпляр). Следовательно, это ошибка разбора.

• ::- scope-resolution-operator - всегда используется для доступа к статическому свойству или методу Class.

  echo Foo::bar()

  Кроме того, мы можем вызвать статический метод для объекта таким же образом:

  echo $foo::bar()

  Это чрезвычайно важно отметить , что , когда мы делаем это снаружи , экземпляр объекта скрыт от bar()метода. Это означает, что это то же самое, что и бег:

  $class = get_class($foo);
  $class::bar();

Поэтому $thisне определяется в статическом вызове.

Изнутри экземпляра / класса

Здесь все немного меняется. Используются те же операторы, но их значение становится значительно размытым.

Объект-оператор -> по - прежнему используется для выполнения вызовов в состояние экземпляра объекта.

class Foo {
    public $a = 1;
    public function bar() {
        return $this->a;
    }
}

Вызов bar()метода $foo(экземпляра Foo) с использованием объекта-оператора: $foo->bar()приведет к версии экземпляра $a.

Так вот как мы ожидаем.

Смысл ::оператора хоть и меняется. Это зависит от контекста вызова текущей функции:

• В статическом контексте

  В статическом контексте любые вызовы, сделанные с использованием ::, также будут статическими. Давайте посмотрим на пример:

  class Foo {
      public function bar() {
          return Foo::baz();
      }
      public function baz() {
          return isset($this);
      }
  }

  Вызов Foo::bar()будет вызывать baz()метод статически и, следовательно $this, не будет заполнен. Стоит отметить, что в последних версиях PHP (5.3+) это вызовет E_STRICTошибку, потому что мы вызываем нестатические методы статически.

• В контексте экземпляра

  С другой стороны, в контексте экземпляра вызовы, выполняемые с использованием, ::зависят от получателя вызова (метода, который мы вызываем). Если метод определен как static, то он будет использовать статический вызов. Если это не так, он перешлет информацию об экземпляре.

  Итак, глядя на приведенный выше код, вызов $foo->bar()вернется true, поскольку «статический» вызов происходит внутри контекста экземпляра.

Есть смысл? Я так не думал. Это сбивает с толку.

Сокращенные Ключевые слова

Поскольку связывать все вместе, используя имена классов, довольно грязно, PHP предоставляет 3 основных «горячих» ключевых слова, чтобы облегчить определение области видимости.

• self- Это относится к текущему имени класса. Так self::baz()же, как и Foo::baz()внутри Fooкласса (любой метод на нем).

• parent - Это относится к родителю текущего класса.

• static- Это относится к названному классу. Благодаря наследованию дочерние классы могут переопределять методы и статические свойства. Поэтому вызов их с использованием staticвместо имени класса позволяет нам определить источник вызова, а не текущий уровень.

Примеры

Самый простой способ понять это - начать смотреть на некоторые примеры. Давайте выберем класс:

class Person {
    public static $number = 0;
    public $id = 0;
    public function __construct() {
        self::$number++;
        $this->id = self::$number;
    }
    public $name = "";
    public function getName() {
        return $this->name;
    }
    public function getId() {
        return $this->id;
    }
}

class Child extends Person {
    public $age = 0;
    public function __construct($age) {
        $this->age = $age;
        parent::__construct();
    }
    public function getName() {
        return 'child: ' . parent::getName();
    }
}

Теперь мы также смотрим на наследование здесь. На мгновение проигнорируйте, что это плохая объектная модель, но давайте посмотрим, что происходит, когда мы играем с этим:

$bob = new Person;
$bob->name = "Bob";
$adam = new Person;
$adam->name = "Adam";
$billy = new Child;
$billy->name = "Billy";
var_dump($bob->getId()); // 1
var_dump($adam->getId()); // 2
var_dump($billy->getId()); // 3

Таким образом, счетчик идентификаторов является общим для обоих экземпляров и дочерних элементов (потому что мы используем selfдля доступа к нему. Если бы мы использовали static, мы могли бы переопределить его в дочернем классе).

var_dump($bob->getName()); // Bob
var_dump($adam->getName()); // Adam
var_dump($billy->getName()); // child: Billy

Обратите внимание, что мы выполняем метод Person::getName() экземпляра каждый раз. Но мы используем это, parent::getName()чтобы сделать это в одном из случаев (дочерний случай). Это то, что делает этот подход мощным.

Слово предостережения № 1

Обратите внимание, что вызывающий контекст определяет, используется ли экземпляр. Следовательно:

class Foo {
    public function isFoo() {
        return $this instanceof Foo;
    }
}

Это не всегда так.

class Bar {
    public function doSomething() {
        return Foo::isFoo();
    }
}
$b = new Bar;
var_dump($b->doSomething()); // bool(false)

Теперь это действительно странно здесь. Мы вызываем другой класс, но экземпляр, $thisкоторый передается Foo::isFoo()методу, является экземпляром класса $bar.

Это может вызвать всевозможные ошибки и концептуальные WTF-еры. Поэтому я настоятельно рекомендую избегать ::оператора внутри методов экземпляра на что - либо , кроме этих трех виртуальных «укороченных» ключевых слов ( static, selfи parent).

Слово предостережения № 2

Обратите внимание, что статические методы и свойства доступны всем. Это делает их в основном глобальными переменными. С такими же проблемами, которые идут с глобалами. Так что я бы не решался хранить информацию в статических методах / свойствах, если вы не уверены, что она действительно глобальная.

Слово предостережения № 3

В общем, вы захотите использовать то, что известно как Late-Static-Binding, используя staticвместо self. Но обратите внимание, что это не одно и то же, поэтому выражение «всегда использовать staticвместо selfдействительно недальновидно». Вместо этого остановитесь и подумайте о вызове, который вы хотите сделать, и подумайте, хотите ли вы, чтобы дочерние классы могли переопределять это статическое разрешение. вызов.

TL / DR

Жаль, вернись и прочитай это. Это может быть слишком долго, но это так долго, потому что это сложная тема

TL / DR # 2

Хорошо. Короче говоря, selfиспользуется для ссылки на текущее имя класса внутри класса, где as $thisссылается на текущий экземпляр объекта . Обратите внимание, что selfэто ярлык копирования / вставки. Вы можете смело заменить его своим именем класса, и оно будет работать нормально. Но $thisэто динамическая переменная, которая не может быть определена заранее (и может даже не быть вашим классом).

TL / DR # 3

Если используется объект-оператор ( ->), то вы всегда знаете, что имеете дело с экземпляром. Если используется оператор scope-resolution-operator ( ::), вам нужно больше информации о контексте (мы уже в объект-контексте? Мы вне объекта? И т. Д.).

self(не $ self) относится к типу класса, где as $thisотносится к текущему экземпляру класса. selfпредназначен для использования в статических функциях-членах, чтобы позволить вам получить доступ к статическим переменным-членам. $thisиспользуется в нестатических функциях-членах и является ссылкой на экземпляр класса, для которого была вызвана функция-член.

Поскольку thisэто объект, вы используете его как:$this->member

Поскольку selfэто не объект, это в основном тип, который автоматически ссылается на текущий класс, вы используете его следующим образом:self::member

$this-> используется для ссылки на конкретный экземпляр переменных класса (переменных-членов) или методов.

Example: 
$derek = new Person();

$ derek теперь является конкретным экземпляром Person. У каждого персонажа есть имя и фамилия, но у $ derek есть конкретные имя и фамилия (Дерек Мартин). Внутри экземпляра $ derek мы можем ссылаться на них как $ this-> first_name и $ this-> last_name

ClassName :: используется для ссылки на этот тип класса и его статические переменные, статические методы. Если это поможет, вы можете мысленно заменить слово «статический» на «общий». Поскольку они являются общими, они не могут ссылаться на $ this, что относится к конкретному экземпляру (не общему). Статические переменные (то есть static $ db_connection) могут быть общими для всех экземпляров типа объекта. Например, все объекты базы данных совместно используют одно соединение (статическое соединение $).

Пример статических переменных: представьте, что у нас есть класс базы данных с одной переменной-членом: static $ num_connections; Теперь поместите это в конструктор:

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

Так же, как объекты имеют конструкторы, они также имеют деструкторы, которые выполняются, когда объект умирает или не устанавливается:

function __destruct()
{
    $num_connections--;
}

Каждый раз, когда мы создаем новый экземпляр, он увеличивает счетчик подключений на единицу. Каждый раз, когда мы уничтожаем или прекращаем использовать экземпляр, он уменьшает счетчик соединений на единицу. Таким образом, мы можем отслеживать количество экземпляров объекта базы данных, с которым мы используем:

echo DB::num_connections;

Поскольку $ num_connections является статическим (общим), оно будет отражать общее количество активных объектов базы данных. Возможно, вы видели этот метод, используемый для совместного использования соединений с базой данных среди всех экземпляров класса базы данных. Это сделано потому, что создание соединения с базой данных занимает много времени, поэтому лучше всего создать только одно и поделиться им (это называется Singleton Pattern).

Статические методы (т. Е. Открытый статический View :: format_phone_number ($ digits)) могут использоваться БЕЗ первого создания экземпляра одного из этих объектов (т. Е. Они внутренне не ссылаются на $ this).

Пример статического метода:

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

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

Как видите, публичная статическая функция prettyName ничего не знает об объекте. Он просто работает с параметрами, которые вы передаете, как обычная функция, которая не является частью объекта. Зачем тогда беспокоиться, если бы мы могли иметь это не как часть объекта?

1. Во-первых, прикрепление функций к объектам помогает вам упорядочить вещи, чтобы вы знали, где их найти.
2. Во-вторых, это предотвращает конфликты имен. В большом проекте у вас, скорее всего, есть два разработчика, создающих функции getName (). Если один создает ClassName1 :: getName (), а другой создает ClassName2 :: getName (), это не проблема. Нет конфликта Yay статические методы!

SELF :: Если вы кодируете вне объекта, у которого есть статический метод, на который вы хотите сослаться, вы должны вызвать его, используя имя объекта View :: format_phone_number ($ phone_number); Если вы кодирование внутри объекта , который имеет статический метод , который вы хотите обратиться, вы можете либо использовать имя View :: format_phone_number объекта ($ Pn), или вы можете использовать автоматический :: format_phone_number ($ Pn) ярлык

То же самое касается статических переменных: Пример: View :: templates_path и self :: templates_path

Внутри класса DB, если бы мы ссылались на статический метод какого-либо другого объекта, мы бы использовали имя объекта: Пример: Session :: getUsersOnline ();

Но если бы класс DB хотел ссылаться на свою статическую переменную, он просто сказал бы: Self: Example: self :: connection;

Надеюсь, что это поможет прояснить ситуацию :)

Из этого сообщения в блоге :

• self относится к текущему классу
• self может использоваться для вызова статических функций и ссылки на статические переменные-члены
• self может использоваться внутри статических функций
• self также может отключить полиморфное поведение, минуя vtable
• $this ссылается на текущий объект
• $this может использоваться для вызова статических функций
• $thisне должен использоваться для вызова статических переменных-членов. Используйте selfвместо этого.
• $this не может использоваться внутри статических функций

В PHP вы используете ключевое слово self для доступа к статическим свойствам и методам.

Проблема в том, что вы можете заменить $this->method()на что self::method()угодно, независимо от того method(), объявлено ли оно статическим или нет. Так какой из них вы должны использовать?

Рассмотрим этот код:

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();

В этом примере self::who()всегда будет выводиться «parent», в то время как $this->who()будет зависеть от того, какой класс имеет объект.

Теперь мы можем видеть, что self ссылается на класс, в котором он вызывается, а $thisссылается на класс текущего объекта .

Таким образом, вы должны использовать self только тогда, когда $thisон недоступен или когда вы не хотите, чтобы классы-потомки перезаписывали текущий метод.

Внутри определения класса $thisссылается на текущий объект, а selfссылается на текущий класс.

Необходимо ссылаться на элемент класса с помощью selfи ссылаться на элемент объекта с помощью $this.

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

Вот пример правильного использования $ this и self для нестатических и статических переменных-членов:

<?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();
?> 

По данным http://www.php.net/manual/en/language.oop5.static.php нет $self. Существует только $thisдля ссылки на текущий экземпляр класса (объект) и self, которые можно использовать для ссылки на статические члены класса. Различие между экземпляром объекта и классом вступает здесь в игру.

Я считаю, что вопрос был не в том, можно ли вызвать статический член класса, позвонив ClassName::staticMember. Вопрос был в чем разница между использованием self::classmemberи $this->classmember.

Например, оба следующих примера работают без ошибок, используете ли вы self::или$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;
    }
}

self ссылается на текущий класс (в котором он называется),

$thisссылается на текущий объект. Вы можете использовать статические вместо себя. Смотрите пример:

    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();

Вывод: родительский ребенок

• Указатель $thisна объект ссылается на текущий объект.
• Значение класса staticотносится к текущему объекту.
• Значение класса selfотносится к точному классу, в котором оно было определено.
• Значение класса parentотносится к родителю того класса, в котором он был определен.

Смотрите следующий пример, который показывает перегрузку.

<?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"

Большую часть времени вы хотите сослаться на текущий класс, поэтому вы используете staticили $this. Однако бывают случаи, когда вам нужно, self потому что вы хотите оригинальный класс, независимо от того, что его расширяет. (Очень, очень редко)

Поскольку никто здесь не говорил о выступлениях, вот небольшой тест, который я сделал (5.6):

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

Это результаты для 2 000 000 прогонов, и вот код, который я использовал:

<?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используется с ::оператором, он ссылается на текущий класс, что может быть сделано как в статическом, так и в нестатическом контексте. $thisотносится к самому объекту. Кроме того, совершенно законно использовать $thisдля вызова статических методов (но не для ссылки на поля).

Я столкнулся с тем же вопросом, и простой ответ:

• $this требует экземпляра класса
• self:: не

Всякий раз, когда вы используете статические методы или статические атрибуты и хотите вызывать их без создания экземпляра объекта класса, вам нужно использовать их self:для вызова, потому что $thisвсегда требуется создание объекта.

$thisссылается на текущий объект класса, selfссылается на текущий класс (не объект). Класс - это план объекта. Итак, вы определяете класс, но вы создаете объекты.

Другими словами, используйте self for staticи this for none-static members or methods.

также в дочернем / родительском сценарии self / parentчаще всего используются идентифицированные дочерние и родительские классные члены и методы.

Кроме того, так как $this::еще не обсуждался.

Только в информационных целях, начиная с PHP 5.3, когда имеешь дело с экземплярами объектов, чтобы получить текущее значение области, в отличие от использования static::, можно альтернативно использовать $this::подобное.

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

Использование приведенного выше кода не является общепринятой или рекомендуемой практикой, а просто иллюстрирует его использование и действует как «Знаете ли вы?» со ссылкой на оригинальный вопрос автора.

Это также представляет использование, $object::CONSTANTнапример, echo $foo::NAME;в отличие от$this::NAME;

Используйте, selfесли вы хотите вызвать метод класса без создания объекта / экземпляра этого класса, тем самым экономя ОЗУ (иногда для этой цели используйте self). Другими словами, это фактически вызывает метод статически. Используйте thisдля перспективы объекта.

Случай 1: использование selfможет использоваться для констант класса

 класс classA { 
     const FIXED_NUMBER = 4; 
     самостоятельно :: POUNDS_TO_KILOGRAMS
}

Если вы хотите вызвать его вне класса, используйте classA::POUNDS_TO_KILOGRAMSдля доступа к константам

Случай 2: для статических свойств

class classC {
     публичная функция __construct () { 
     самостоятельно :: $ _ счетчик ++; $ this-> num = self :: $ _ counter;
   }
}

По php.net есть три специальные ключевые слова в данном контексте: self, parentи static. Они используются для доступа к свойствам или методам из определения класса.

$thisс другой стороны, используется для вызова экземпляра и методов любого класса, если этот класс доступен.

self ::  keyword используется для текущего класса и в основном используется для доступа к статическим членам, методам и константам. Но в случае $ this вы не можете вызывать статический член, метод и функции.

Вы можете использовать ключевое слово self :: в другом классе и получать доступ к статическим членам, методам и константам. Когда это будет продолжаться от родительского класса и то же самое в случае $ этого ключевого слова. Вы можете получить доступ к нестатическим членам, методам и функциям в другом классе, когда он будет расширяться из родительского класса.

Код, приведенный ниже, является примером self :: и $ this ключевого слова. Просто скопируйте и вставьте код в ваш файл кода и посмотрите результат.

class cars{
    var $doors=4;   
    static $car_wheel=4;

  public function car_features(){
    echo $this->doors." Doors <br>";
    echo self::$car_wheel." Wheels <br>"; 
  }
}

class spec extends cars{
    function car_spec(){
        print(self::$car_wheel." Doors <br>");
        print($this->doors." Wheels <br>");
    }
}

/********Parent class output*********/

$car = new cars;
print_r($car->car_features());

echo "------------------------<br>";

/********Extend class from another class output**********/


$car_spec_show=new spec;

print($car_spec_show->car_spec());