Оператор разрешения области видимости (::)

Оператор разрешения области видимости (также называемый "Paamayim Nekudotayim") или просто "двойное двоеточие" - это лексема, позволяющая обращаться к статическим свойствам, константам и перегруженным свойствам или методам класса.

При обращении к этим элементам извне класса, необходимо использовать имя этого класса.

Начиная с версии PHP 5.3.0, стало возможным обратиться к классу с помощью переменной. Значение переменной не должно быть ключевым словом (например, self, parent или static).

"Paamayim Nekudotayim" на первый взгляд может показаться странным словосочетанием для обозначения двойного двоеточия. Однако, во время создания Zend Engine версии 0.5 (который входил в PHP3), команда Zend выбрала именно это обозначение. Оно на самом деле значит "двойное двоеточие" - на иврите!

Пример #1 Использование :: вне объявления класса

<?php
class MyClass {
    const 
CONST_VALUE 'Значение константы';
}

$classname 'MyClass';
echo 
$classname::CONST_VALUE// Начиная с версии PHP 5.3.0

echo MyClass::CONST_VALUE;
?>

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

Пример #2 Использование :: внутри объявления класса

<?php
class OtherClass extends MyClass
{
    public static 
$my_static 'статическая переменная';

    public static function 
doubleColon() {
        echo 
parent::CONST_VALUE "\n";
        echo 
self::$my_static "\n";
    }
}

$classname 'OtherClass';
echo 
$classname::doubleColon(); // Начиная с версии PHP 5.3.0

OtherClass::doubleColon();
?>

Когда дочерний класс перегружает методы, объявленные в классе-родителе, PHP не будет осуществлять автоматический вызов методов, принадлежащих классу-родителю. Этот функционал возлагается на метод, перегружаемый в дочернем классе. Данное правило распространяется на конструкторы и деструкторы, перегруженные и "магические" методы.

Пример #3 Обращение к методу в родительском классе

<?php
class MyClass
{
    protected function 
myFunc() {
        echo 
"MyClass::myFunc()\n";
    }
}

class 
OtherClass extends MyClass
{
    
// Перекрываем родительское определение
    
public function myFunc()
    {
        
// Но все еще вызываем родительскую функцию
        
parent::myFunc();
        echo 
"OtherClass::myFunc()\n";
    }
}

$class = new OtherClass();
$class->myFunc();
?>

См. также некоторые примеры статических вызовов.

Коментарии

You use 'self' to access this class, 'parent' - to access parent class, and what will you do to access a parent of the parent? Or to access the very root class of deep class hierarchy? The answer is to use classnames. That'll work just like 'parent'. Here's an example to explain what I mean. Following code

<?php
class A
{
    protected 
$x 'A';
    public function 
f()
    {
        return 
'['.$this->x.']';
    }
}

class 
extends A
{
    protected 
$x 'B';
    public function 
f()
    {
        return 
'{'.$this->x.'}';
    }
}

class 
extends B
{
    protected 
$x 'C';
    public function 
f()
    {
        return 
'('.$this->x.')'.parent::f().B::f().A::f();
    }
}

$a = new A();
$b = new B();
$c = new C();

print 
$a->f().'<br/>';
print 
$b->f().'<br/>';
print 
$c->f().'<br/>';
?>

will output 

[A] -- {B} -- (C){C}{C}[C]
2006-01-27 05:57:07
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
Little static trick to go around php strict standards ...
Function caller founds an object from which it was called, so that static method can alter it, replacement for $this in static function but without strict warnings :)

<?php

error_reporting
(E_ALL E_STRICT);

function 
caller () {
 
$backtrace debug_backtrace();
 
$object = isset($backtrace[0]['object']) ? $backtrace[0]['object'] : null;
 
$k 1;
       
  while (isset(
$backtrace[$k]) && (!isset($backtrace[$k]['object']) || $object === $backtrace[$k]['object']))
   
$k++;

  return isset(
$backtrace[$k]['object']) ? $backtrace[$k]['object'] : null;
}

class 
{

  public 
$data 'Empty';
 
  function 
set_data () {
   
b::set();
  }

}

class 
{

  static function 
set () {
   
// $this->data = 'Data from B !';
    // using this in static function throws a warning ...
   
caller()->data 'Data from B !';
  }

}

$a = new a();
$a->set_data();
echo 
$a->data;

?>

Outputs: Data from B !

No warnings or errors !
2009-01-24 17:15:12
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
For the 'late static binding' topic I published a code below, that demonstrates a trick for how to setting variable value in the late class, and print that in the parent (or the parent's parent, etc.) class.

<?php

class cA
{
   
/**
     * Test property for using direct default value
     */
   
protected static $item 'Foo';
   
   
/**
     * Test property for using indirect default value
     */
   
protected static $other 'cA';
   
    public static function 
method()
    {
        print 
self::$item."\r\n"// It prints 'Foo' on everyway... :(
       
print self::$other."\r\n"// We just think that, this one prints 'cA' only, but... :)
   
}
   
    public static function 
setOther($val)
    {
       
self::$other $val// Set a value in this scope.
   
}
}

class 
cB extends cA
{
   
/**
     * Test property with redefined default value
     */
   
protected static $item 'Bar';
   
    public static function 
setOther($val)
    {
       
self::$other $val;
    }
}

class 
cC extends cA
{
   
/**
     * Test property with redefined default value
     */
   
protected static $item 'Tango';
   
    public static function 
method()
    {
        print 
self::$item."\r\n"// It prints 'Foo' on everyway... :(
       
print self::$other."\r\n"// We just think that, this one prints 'cA' only, but... :)
   
}
   
   
/**
     * Now we drop redeclaring the setOther() method, use cA with 'self::' just for fun.
     */
}

class 
cD extends cA
{
   
/**
     * Test property with redefined default value
     */
   
protected static $item 'Foxtrot';
   
   
/**
     * Now we drop redeclaring all methods to complete this issue.
     */
}

cB::setOther('cB'); // It's cB::method()!
cB::method(); // It's cA::method()!
cC::setOther('cC'); // It's cA::method()!
cC::method(); // It's cC::method()!
cD::setOther('cD'); // It's cA::method()!
cD::method(); // It's cA::method()!

/**
 * Results: ->
 * Foo
 * cB
 * Tango
 * cC
 * Foo
 * cD
 * 
 * What the hell?! :)
 */

?>
2009-02-03 11:54:02
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
Well, a "swiss knife" couple of code lines to call parent method. The only limit is you can't use it with "by reference" parameters.
Main advantage you dont need to know the "actual" signature of your super class, you just need to know which arguments do you need

<?php
class someclass extends some superclass {
// usable for constructors
 
function __construct($ineedthisone) {
 
$args=func_get_args(); 
 
/* $args will contain any argument passed to __construct.   
  * Your formal argument doesnt influence the way func_get_args() works
  */
 
call_user_func_array(array('parent',__FUNCTION__),$args);
 }
// but this is not for __construct only
 
function anyMethod() {
 
$args=func_get_args();
 
call_user_func_array(array('parent',__FUNCTION__),$args);
 }
 
// Note: php 5.3.0 will even let you do
 
function anyMethod() {
 
//Needs php >=5.3.x
 
call_user_func_array(array('parent',__FUNCTION__),func_get_args());
 }

}
?>
2009-06-02 09:38:46
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
It's worth noting, that the mentioned variable can also be an object instance. This appears to be the easiest way to refer to a static function as high in the inheritance hierarchy as possible, as seen from the instance. I've encountered some odd behavior while using static::something() inside a non-static method.

See the following example code:

<?php
class FooClass {
    public function 
testSelf() {
        return 
self::t();
    }

    public function 
testThis() {
        return 
$this::t();
    }

    public static function 
t() {
        return 
'FooClass';
    }

    function 
__toString() {
        return 
'FooClass';
    }
}

class 
BarClass extends FooClass {
    public static function 
t() {
        return 
'BarClass';
    }

}

$obj = new BarClass();
print_r(Array(
   
$obj->testSelf(), $obj->testThis(),
));
?>

which outputs:

<pre>
Array
(
    [0] => FooClass
    [1] => BarClass
)
</pre>

As you can see, __toString has no effect on any of this. Just in case you were wondering if perhaps this was the way it's done.
2009-11-09 09:24:52
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
Автор:
A class constant, class property (static), and class function (static) can all share the same name and be accessed using the double-colon.

<?php

class {

    public static 
$B '1'# Static class variable.

   
const '2'# Class constant.
   
   
public static function B() { # Static class function.
       
return '3';
    }
   
}

echo 
A::$B A::A::B(); # Outputs: 123
?>
2009-12-05 22:58:15
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
As of php 5.3.0, you can use 'static' as scope value as in below example (add flexibility to inheritance mechanism compared to 'self' keyword...)

<?php

class {
    const 
'constA';
    public function 
m() {
        echo static::
C;
    }
}

class 
extends {
    const 
'constB';
}

$b = new B();
$b->m();

// output: constB
?>
2010-05-05 16:50:18
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
It seems as though you can use more than the class name to reference the static variables, constants, and static functions of a class definition from outside that class using the :: . The language appears to allow you to use the object itself. 

For example:
class horse 
{
   static $props = {'order'=>'mammal'};
}
$animal = new horse();
echo $animal::$props['order'];

// yields 'mammal'

This does not appear to be documented but I see it as an important convenience in the language. I would like to see it documented and supported as valid. 

If it weren't supported officially, the alternative would seem to be messy, something like this:

$animalClass = get_class($animal);
echo $animalClass::$props['order'];
2013-09-15 23:29:24
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
Just found out that using the class name may also work to call similar function of anchestor class.

<?php

class Anchestor {
   
   public 
$Prefix '';

   private 
$_string 'Bar';
    public function 
Foo() {
        return 
$this->Prefix.$this->_string;
    }
}

class 
MyParent extends Anchestor {
    public function 
Foo() {
         
$this->Prefix null;
        return 
parent::Foo().'Baz';
    }
}

class 
Child extends MyParent {
    public function 
Foo() {
       
$this->Prefix 'Foo';
        return 
Anchestor::Foo();
    }
}

$c = new Child();
echo 
$c->Foo(); //return FooBar, because Prefix, as in Anchestor::Foo()

?>

The Child class calls at Anchestor::Foo(), and therefore MyParent::Foo() is never run.
2013-10-03 16:25:19
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
In PHP, you use the self keyword to access static properties and methods.

The problem is that you can replace $this->method() with self::method() anywhere, regardless if method() is declared static or not. So which one should you use?

Consider this 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();
In this example, self::who() will always output ‘parent’, while $this->who() will depend on what class the object has.

Now we can see that self refers to the class in which it is called, while $this refers to the class of the current object.

So, you should use self only when $this is not available, or when you don’t want to allow descendant classes to overwrite the current method.
2017-05-15 21:36:22
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html
<?php
/**
*access a constant from outside a class
*/
class Foo{
    public const 
"Constant A";
}
echo 
Foo::A;
echo 
"\n";

/**
*access a constant within its own class 
*/

class Bar{
    public const 
"Constant A";
    public function 
abc(){
        echo 
self::A;
        echo 
"\n";
    }
}

$obj = new Bar;
$obj->abc();

/**
*access a constant within her child class
*/

class Baz extends Bar{
    public function 
abc(){
        echo 
parent::A;
    }
}
$obj = new Baz;
$obj->abc();

//Static property and static method also follows this principle.
2024-01-15 16:43:32
http://php5.kiev.ua/manual/ru/language.oop5.paamayim-nekudotayim.html

    Поддержать сайт на родительском проекте КГБ