Orada PHP erişim yöntemleri için iki farklı yolu, ama ne fark eder?

$response->setParameter('foo', 'bar');

ve

sfConfig::set('foo', 'bar');

-> (büyüktür işareti ile çizgi ya da chevron) değişkenler fonksiyonlar için kullanılır varsayıyorum, ve :: (çift iki nokta üst üste) sınıflar için işlevler için kullanılır. Doğru mu?

=> atama operatörü tek bir dizi içinde veri atamak için kullanılır? Bu bir değişken oluşturmak veya değiştirmek için kullanılan = atama operatörünü aksine.

Sol tarafta bir nesne örneği, -> kullanın. Aksi takdirde, :: kullanın.

Bu demektir -> en çok kullanılan erişim örnek üyeleri (gerçi öyle de kullanılabilir erişim statik üyeleri, bu tür kullanımı önerilmez), :: genellikle kullanılan erişim statik üyeler (gerçi birkaç özel durumlarda, kullanılan erişim örnek üyeleri).

Genel :: kullanılan scope resolution, ve o olabilir ya da bir sınıf adı, parent, self veya (PHP 5.3) static kaldı. parent ifade eder kapsam üst sınıf nerede kullanılır; self ifade eder kapsam sınıfı nerede kullanılır; static ifade eder "denilen kapsam" late static bindings).

Kural :: ile bir ara örnek bir çağrı ise:

• hedef yöntemi olarak statik bildirilmedive
• arama sırasında uyumlu bir nesne bağlamı, bu doğru olması gerekir anlamı vardır:
  1. arama $this bulunduğu bir bağlam yapılır
  2. $this sınıf çağırılan yöntem veya bir alt sınıfıdır.

Örnek:

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

Çıkış:

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)