Что является различием между:: (удвойте двоеточие), и-> (стрелка) в PHP?

:: используется в статическом контексте , т.е. когда какой-либо метод или свойство объявлено как статическое:

class Math {
    public static function sin($angle) {
        return ...;
    }
}

$result = Math::sin(123);

Кроме того, оператор :: (оператор разрешения области видимости, также известный как Паамайим Некудотаим ) используется в динамическом контексте, когда вы вызываете метод / свойство родительского класса:

class Rectangle {
     protected $x, $y;

     public function __construct($x, $y) {
         $this->x = $x;
         $this->y = $y;
     }
}

class Square extends Rectangle {
    public function __construct($x) {
        parent::__construct($x, $x);
    }
}

-> используется в динамическом контексте, т.е. когда вы имеете дело с некоторым экземпляром какого-то класса:

class Hello {
    public function say() {
       echo 'hello!';
    }
}

$h = new Hello();
$h->say();

Между прочим: я не думаю, что использование Symfony - хорошая идея, если у вас нет опыта ООП.

Оператор => используется для присвоения пар ключ-значение в ассоциативном массиве. Например:

$fruits = array(
  'Apple'  => 'Red',
  'Banana' => 'Yellow'
);

Это значение аналогично выражению foreach :

foreach ($fruits as $fruit => $color)
  echo "$fruit is $color in color.";

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

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

Как правило, :: используется для разрешения области , и он может иметь имя класса, родительский , self или (в PHP 5.3) static слева от него. parent относится к области суперкласса класса, в котором он используется; self относится к области класса, в котором он используется; static относится к «вызываемой области» (см. поздние статические привязки ).

Правило состоит в том, что вызов с :: является вызовом экземпляра тогда и только тогда, когда:

• целевой метод не объявлен как статический и
• существует совместимый объект контекст во время звонка, что означает, что они должны быть правдой:
  1. вызов выполняется из контекста, в котором существует $ this и
  2. класс $ this является либо классом вызываемого метода, либо его подклассом.

Пример:

class A {
    public function func_instance() {
        echo "in ", __METHOD__, "\n";
    }
    public function callDynamic() {
        echo "in ", __METHOD__, "\n";
        B::dyn();
    }

}

class B extends A {
    public static $prop_static = 'B::$prop_static value';
    public $prop_instance = 'B::$prop_instance value';

    public function func_instance() {
        echo "in ", __METHOD__, "\n";
        /* this is one exception where :: is required to access an
         * instance member.
         * The super implementation of func_instance is being
         * accessed here */
        parent::func_instance();
        A::func_instance(); //same as the statement above
    }

    public static function func_static() {
        echo "in ", __METHOD__, "\n";
    }

    public function __call($name, $arguments) {
        echo "in dynamic $name (__call)", "\n";
    }

    public static function __callStatic($name, $arguments) {
        echo "in dynamic $name (__callStatic)", "\n";
    }

}

echo 'B::$prop_static: ', B::$prop_static, "\n";
echo 'B::func_static(): ', B::func_static(), "\n";
$a = new A;
$b = new B;
echo '$b->prop_instance: ', $b->prop_instance, "\n";
//not recommended (static method called as instance method):
echo '$b->func_static(): ', $b->func_static(), "\n";

echo '$b->func_instance():', "\n", $b->func_instance(), "\n";

/* This is more tricky
 * in the first case, a static call is made because $this is an
 * instance of A, so B::dyn() is a method of an incompatible class
 */
echo '$a->dyn():', "\n", $a->callDynamic(), "\n";
/* in this case, an instance call is made because $this is an
 * instance of B (despite the fact we are in a method of A), so
 * B::dyn() is a method of a compatible class (namely, it's the
 * same class as the object's)
 */
echo '$b->dyn():', "\n", $b->callDynamic(), "\n";

Вывод:

B::$prop_static: B::$prop_static value
B::func_static(): in B::func_static

$b->prop_instance: B::$prop_instance value
$b->func_static(): in B::func_static

$b->func_instance():
in B::func_instance
in A::func_instance
in A::func_instance

$a->dyn():
in A::callDynamic
in dynamic dyn (__callStatic)

$b->dyn():
in A::callDynamic
in dynamic dyn (__call)

Разница между статическими и инстанцированными методами и свойствами кажется одним из самых больших препятствий для тех, кто только начинает осваивать ООП PHP в PHP 5.

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

Оператор arrow, наоборот, вызывает методы или свойства, которые из ссылки на экземпляр объекта.

Статические методы могут быть особенно полезны в объектных моделях, которые связаны с базой данных для методов create и delete, поскольку вы можете установить возвращаемое значение на id вставленной таблицы, а затем использовать конструктор для инстанцирования объекта по id строки.