Soru Kendini ne zaman kullanmalıyım?


PHP 5'te, kullanım arasındaki fark nedir? self ve $this?

Her biri ne zaman uygun?


1777
2017-09-30 06:23


Menşei


olası kopyası Yeni kendiliğinden yeni durağan - Orangepill
Ne aradığını sormak istiyorum: cont A; $ this-> A ve öz :: A - mboullouz


Cevaplar:


Kısa cevap

kullanım $this akımına başvurmak   nesne. kullanım self başvurmak   mevcut sınıf. Başka bir deyişle,    $this->member Statik olmayan üyeler için   kullanım self::$member Statik üyeler için.

Tam cevap

İşte bir örnek doğru kullanımı $this ve self Statik olmayan ve statik üye değişkenler için:

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

İşte bir örnek yanlış kullanımı $this ve self Statik olmayan ve statik üye değişkenler için:

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

İşte bir örnek polimorfizmi ile $this üye işlevleri için:

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

İşte bir örnek polimorfik davranışı bastırmak kullanarak self üye işlevleri için:

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

Fikir şu: $this->foo() çağırır foo() ne olursa olsun üye işlevi, geçerli nesnenin tam türüdür. Nesne ise type X, bu yüzden> çağrılar X::foo(). Nesne ise type Y, çağırır Y::foo(). Ama> self :: foo () ile, X::foo() her zaman denir.

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

Tarafından http://board.phpbuilder.com/member.php?145249-laserlight


1512
2017-09-30 06:29



Bu cevap aşırı derecede basit. Diğer cevaplarda işaret edildiği gibi, self kapsam çözme operatörü ile kullanılır :: mevcut sınıfa başvurmak için; Bu hem statik hem de statik olmayan bağlamlarda yapılabilir. Ek olarak, kullanımı tamamen yasal $this Statik yöntemleri çağırmak (referans alanlarına değil). - Artefacto
Ayrıca, 5.3'ten daha büyükse statik :: yerine :: self kullanmayı düşünün. Aksi halde baş ağrısına neden olabilir, neden benim cevabımı aşağıda görebilirsiniz. - Sqoo
-1. Bu cevap yanıltıcı, daha fazla bilgi için diğer cevapları okuyun. - Pacerier
Aşırı basitleştirilebilir, ancak başımı patlatmadan temel seviyedeki soruma cevap verdi. Daha fazla yardımcı olacağımı düşündüğüm daha fazla bilgi aldım, ama şu an için sadece bu özniteliklerimi $ this-> özniteliğine ve sınıf sabitlerini self :: sabiti ile çarptığımı anlamaya çalışıyordum. Bu daha iyi anlamamı sağladı - MydKnight
Ne dersin $this::? - James


Anahtar kelime kendini yapar DEĞİL Sadece 'mevcut sınıfa' başvurunuz, en azından sizi statik üyelere kısıtlayacak şekilde değil. Statik olmayan bir üye kapsamında, self Ayrıca vtable atlamak için bir yol sağlarvtable konusuna bakın) geçerli nesne için. Tıpkı kullanabileceğin gibi parent::methodName() Bir fonksiyonun ebeveynlerinin versiyonunu aramak için self::methodName() Mevcut sınıfların bir yöntemin uygulanmasını çağırmak.

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

Bu çıkacak:

Merhaba, ben Ludwig in geek
     Ludwig gelen kişi veda

sayHello() kullanır $this işaretçi, vtable çağırmak için çağırılır Geek::getTitle(). sayGoodbye() kullanımları self::getTitle()Böylece vtable kullanılmaz ve Person::getTitle() denir. Her iki durumda da, örneklenmiş bir nesne yöntemi ile uğraşıyoruz ve $this çağrılan işlevler içinde işaretçi.


710
2017-07-27 18:00



Bu cevap, istisna olmaktan ziyade genel bir kuralla başlarsanız daha da iyi olur. Teknik bir uzmanlık değil, bir tarz meselesi. Bu, self :: ve $ this-> arasındaki fark hakkında gördüğüm en iyi örnektir, ancak bunu önce bir fikri onaylamadan saklamak bir utançtır. - adjwilli
@adjwilli: Neden bu kötü tarz? OP'nin beklentisi (tez) ilk onaylanmadığı (antitez) ve sonra da açıklama sentez olarak verilirse bilinci yükseltmez mi? - hakre
"Mevcut dersi" gerçekten sorunlu buluyorum. Bu kelime birleşimi hem "sınıf" olarak anlaşılabilir self "/" sınıf tanımı, "nesnenin sınıfı" nın yanı sıra "gerçekte bir parçası" (aslında nesnenin sınıfı) static). - Jakumi
Ne dersin $this::? - James


KULLANMAYIN self::, kullan static::

Kendinin bir başka yönü daha vardır: söz etmeye değer. can sıkıcı biçimde self:: Yürütme noktasında değil, tanım noktasında kapsamı ifade eder.. Bu basit sınıfı iki yöntemle düşünün:

class Person
{

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

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

}

Eğer ararsak Person::status() "Kişi yaşıyor" göreceğiz. Şimdi bundan miras alan bir sınıf yaptığımızda neler olduğunu düşünün:

class Deceased extends Person
{

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

}

çağrı Deceased::status() "Kişi öldü" görmeyi beklerdik ancak ne zaman gördüğümüz "Kişi yaşıyor" şeklindedir. self::getStatus() tanımlandı.

PHP 5.3 bir çözüm var. static:: Çözünürlük operatörü, adı geçen sınıfın kapsamına bağlı olduğunu söylemenin süslü bir yolu olan "geç statik bağlama" uygular. Satırı değiştirin status() için static::getStatus() ve sonuçlar beklediğiniz gibi. PHP'nin eski sürümlerinde bunu yapmak için bir kludge bulmanız gerekecektir.

Görmek PHP Belgeleri

Yani soruyu sorulan soruya cevap vermek ...

$this-> mevcut nesneyi (bir sınıfın bir örneğini) ifade eder, static::bir sınıfa atıfta bulunur


429
2017-07-24 15:08



Sınıf sabitleri için ne dersiniz? - Kevin Bond
Sanırım aynı gider - Sqoo
"Called Deceased :: status ()" Beklenen kişi "görmeyi bekleriz". Hayır. Bu, statik bir işlev çağrısıdır, böylece hiçbir polimorfizm yoktur. - cquezel
@jasondavis teşekkürler, İngilizce kullanmayı denedim ve polimorfizm gibi terimlerden kaçındım. Bu cevap normalde sadece bir bilgisayar bilimcinin anlayacağı bir şekilde ifade ediliyor, PHP bilgisayar bilimcilerine yönelik bir dil değil! - Sqoo
Örnek bana kafa karıştırıcı geliyor: Görüyorum getStatus Bir sınıf için değil, bir sınıf örneğini çağırırdım. - Jānis Elmeris


Konuştuğumuzda neden bahsettiğimizi gerçekten anlamak için self e karşı $thisAslında, kavramsal ve pratik düzeyde neler olup bittiğini araştırmalıyız. Bu cevapların hiçbirini uygun şekilde yapmadığını hissediyorum, işte benim denemem.

Ne hakkında konuşarak başlayalım sınıf ve bir nesne olduğunu.

Sınıflar ve Nesneler, Kavramsal

Ne olmuş yani olduğu bir sınıf? Bir çok insan bunu taslak ya da şablon bir nesne için. Aslında, daha fazla okuyabilirsiniz Burada PHP Sınıfları Hakkında. Ve bir dereceye kadar gerçekte öyle. Bir sınıfa bakalım:

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

Anlatabileceğin gibi, bu sınıfta bir mülk var. $name ve adlandırılan bir yöntem (işlev) sayHello().

Onun çok not etmek önemli sınıf statik bir yapıdır. Bu sınıfın anlamı PersonTanımlandığında, her baktığınız her zaman aynıdır.

Öte yandan bir nesne ne denir? örnek bir sınıfın Bunun anlamı, sınıfın "blueprint" ini alıp dinamik bir kopyasını yapmak için kullanıyoruz. Bu kopya şu anda içerdiği değişkene özel olarak bağlı. Bu nedenle, herhangi bir değişiklik örnek bu örneğe yereldir.

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

Yeni oluşturuyoruz örnekleri kullanarak bir sınıfın new Şebeke.

Bu nedenle, bir Sınıfın küresel bir yapı olduğunu ve bir Nesnenin yerel bir yapı olduğunu söylüyoruz. Bu komik hakkında endişelenme -> sözdizimi, biraz içine gireceğiz.

Konuşmamız gereken başka bir şey, yapabileceğimiz Kontrol bir örnek ise instanceof belirli bir sınıf: $bob instanceof Person eğer bir boole döndürürse $bob örnek kullanılarak yapıldı Person sınıf, veya bir çocuk Person.

Tanımlama Durumu

Öyleyse, bir sınıfın gerçekten içerdiği şeylere bir bakalım. Bir sınıfın içerdiği 5 tür "şey" vardır:

  1. Özellikleri - Bunları her bir örneğin içereceği değişkenler olarak düşünün.

    class Foo {
        public $bar = 1;
    }
    
  2. Statik Özellikler - Bunları sınıf düzeyinde paylaşılan değişkenler olarak düşünün. Her bir örnek tarafından asla kopyalanmadıkları anlamına gelir.

    class Foo {
        public static $bar = 1;
    }
    
  3. Yöntemler - Bunlar her örneğin içereceği işlevlerdir (ve örnekler üzerinde çalışır).

    class Foo {
        public function bar() {}
    }
    
  4. Statik Yöntemler - Bunlar, tüm sınıf boyunca paylaşılan işlevlerdir. Onlar yapar değil Örnekler üzerinde çalışır, ancak bunun yerine yalnızca statik özellikler üzerinde çalışır.

    class Foo {
        public static function bar() {}
    }
    
  5. Sabitler - Sınıf çözülmüş sabitler. Burada daha derine inme, ama tamlığı ekleyerek:

    class Foo {
        const BAR = 1;
    }
    

Temel olarak, "ipuçlarını" kullanarak sınıf ve nesne kapsayıcısı hakkında bilgi saklıyoruz statik bilginin paylaşılıp paylaşılmadığını (ve dolayısıyla statik) ya da olmadığını (ve dolayısıyla dinamik) tanımlar.

Devlet ve Yöntemler

Bir yöntemin içinde, bir nesnenin örneği tarafından temsil edilir. $thisdeğişken. Bu nesnenin mevcut durumu oradadır ve herhangi bir özelliği mutasyona uğratmak (değiştirmek), o örnekte bir değişikliğe yol açacaktır (ancak diğerleri değil).

Bir yöntem statik olarak adlandırılırsa, $this değişken Tanımlanmadı. Bunun nedeni, statik bir aramayla ilişkili bir örnek olmamasıdır.

Buradaki ilginç şey, statik çağrıların nasıl yapıldığıdır. O zaman devlete nasıl erişeceğimiz hakkında konuşalım:

Devlete Erişim

Yani şimdi bu durumu sakladık, ona erişmemiz gerekiyor. Bu biraz zor olabilir (veya yol bir bitten fazla), bu yüzden bunu iki bakış açısına bölelim: bir örnek / sınıfın dışından (normal bir işlev çağrısından veya global kapsamdan) ve bir örnek / sınıfın içinden (bir yöntem içinde nesne).

Bir Örnek / Sınıf Dışında

Bir vakanın / sınıfın dışından, kurallarımız oldukça basit ve öngörülebilir. İki operatörümüz var ve bir örnekle veya bir sınıfa ait statik ile uğraşırsak her biri bize derhal bildirir:

  • -> - nesne operatör - Bir örneğe eriştiğimizde bu her zaman kullanılır.

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

    Bu çağrıyı not etmek önemlidir Person->foo mantıklı değil Person bir sınıftır, bir örnek değildir. Bu nedenle, bu bir ayrıştırma hatasıdır.

  • :: - kapsamı çözünürlüklü operatörü - Bu her zaman bir Sınıf statik özellik veya yönteme erişmek için kullanılır.

    echo Foo::bar()
    

    Ek olarak, bir nesnedeki statik yöntemi de aynı şekilde çağırabiliriz:

    echo $foo::bar()
    

    Onun son derece Bunu yaptığımızda şunu unutmamak önemlidir dışarıdan, nesnenin örneği bar() yöntem. Bu koşu ile tam olarak aynı anlamı:

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

Bu nedenle, $this statik aramada tanımlanmadı.

Bir Örnek / Sınıf İçinden

Burada işler biraz değişiyor. Aynı operatörler kullanılır, ancak anlamları önemli ölçüde bulanıklaşır.

nesne operatör  -> nesnenin örnek durumuna çağrı yapmak için kullanılır.

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

Çağırıyor bar() üzerinde yöntem $foo (bir örneği Foonesne-operatörünü kullanarak: $foo->bar() örneğinin sürümüyle sonuçlanacak $a.

Yani böyle bekleriz.

Anlamı :: operatör olsa da değişiklikler. Mevcut işleve yapılan çağrı bağlamına bağlıdır:

  • Statik bir bağlamda

    Statik bir bağlamda, yapılan tüm çağrılar :: ayrıca statik olacak. Bir örneğe bakalım:

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

    çağrı Foo::bar() arayacak baz() yöntem statik ve dolayısıyla $this irade değil nüfuslu olmak. PHP'nin (5.3+) son sürümlerinde bu durumun E_STRICT hata, statik olmayan yöntemleri statik olarak çağırdığımızdan.

  • Bir örnek bağlamda

    Diğer bir örnek bağlamda, yapılan aramalar :: aramanın alıcısına bağlıdır (aradığımız yöntem). Yöntem şöyle tanımlanırsa staticDaha sonra statik bir çağrı kullanacaktır. Değilse, örnek bilgilerini iletir.

    Yani, yukarıdaki kodlara bakarak $foo->bar() dönecek true"statik" çağrı bir örnek içeriğin içinde gerçekleştiği için.

Mantıklı olmak? Öyle düşünmemiştim. Kafa karıştırıcı.

Kısa Anahtar Kelimeler

Sınıf isimlerini kullanarak her şeyi birbirine bağlayacağınız için, PHP'nin kapsamı daha kolay anlaşılır hale getirmek için 3 temel "kısayol" anahtar kelimesi vardır.

  • self - Bu geçerli sınıf adını ifade eder. Yani self::baz() aynıdır Foo::baz() içinde Foo sınıf (üzerinde herhangi bir yöntem).

  • parent - Bu, mevcut sınıfın ebeveyne başvurur.

  • static - Bu çağrılan sınıfa atıfta bulunur. Mirastan dolayı, çocuk sınıfları yöntemleri ve statik özellikleri geçersiz kılabilir. Yani onları kullanarak çağırıyor static Bir sınıf adı yerine, mevcut seviyeden ziyade aramanın nereden geldiğini çözmemize izin verir.

Örnekler

Bunu anlamanın en kolay yolu, bazı örneklere bakmaktır. Bir ders seçelim:

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

Şimdi, biz de burada mirasa bakıyoruz. Bir an için bunun kötü bir nesne modeli olduğunu göz ardı edin, ama bununla oynadığımızda neler olduğuna bakalım:

$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

Yani kimlik sayacı her iki örnekte ve çocuklarda paylaşılıyor (çünkü kullanıyoruz self erişmek için Eğer kullansaydık staticbunu bir çocuk sınıfında geçersiz kılabiliriz).

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

Yürütüyor olduğumuzu unutmayın. Person::getName()  örnek her seferinde yöntem. Ama biz kullanıyoruz parent::getName() vakalardan birinde (çocuk davası) yapmak. Bu yaklaşımı güçlü kılan şey budur.

Dikkatli Söz 1

Çağırma içeriği, bir örneğin kullanılıp kullanılmadığını belirleyen şeydir. Bu nedenle:

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

Değil her zaman doğru.

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

Şimdi öyle Gerçekten mi Burada garip. Farklı bir sınıf arıyoruz, ama $this bu geçer Foo::isFoo() yöntem örneğidir $bar.

Bu, her türlü hataya ve kavramsal WTF-ery'ye neden olabilir. Bu yüzden, :: Bu üç sanal "kısa yol" anahtar kelimesi dışında örnek yöntemlerden operatör (static, self, ve parent).

Dikkat # 2 kelimesi

Statik yöntemlerin ve özelliklerin herkes tarafından paylaşıldığını unutmayın. Bu onları temelde küresel değişkenler yapar. Dünyadaki tüm problemler ile birlikte. Bu yüzden, gerçekten küresel olmamanızdan emin değilseniz, bilgiyi statik yöntemlerle / mülklerde depolamakta gerçekten çekinirim.

Dikkat # 3 kelimesi

Genelde Late-Static-Binding olarak bilinen şeyi kullanmak isteyeceksiniz. static yerine self. Ama aynı şeylerin aynı olmadıklarına dikkat edin. static yerine self çok kısa görüşlü. Bunun yerine, çocuk sınıflarının bunu geçersiz kılabileceğini düşünmek için düşünmek ve düşünmek istediğiniz aramayı düşünün ve düşünün. statik çözümlendi aramak.

TL / DR

Çok kötü, geri dön ve oku. Çok uzun olabilir, ama bu kadar uzun çünkü bu karmaşık bir konu

TL / DR # 2

Tamam iyi. Kısacası, self referans vermek için kullanılır geçerli sınıf adıbir sınıfta, $this geçerli nesneyi ifade eder örnek. Bunu not et self bir kopya / yapıştır kısa yoldur. Bunu sınıf adınızla güvenle değiştirebilirsiniz ve iyi çalışır. Fakat $this zamanın ötesinde belirlenemeyen dinamik bir değişkendir (ve hatta sınıfınız olmayabilir).

TL / DR # 3

Nesne operatörü kullanılıyorsa (->), o zaman sen her zaman Bir örnekle uğraştığını biliyorum. Kapsam özüm-işleç kullanılırsa (::), bağlam hakkında daha fazla bilgiye ihtiyacınız var (zaten bir nesne bağlamında mıyız? Bir nesnenin dışında mıyız? vb.).


228
2018-06-10 15:21



Dikkat # 1 kelimesi: $ statik bir yöntem çağrıldığında bu tanımlanmayacaktır: 3v4l.org/9kr0e - Mark Achée
İyi... $this "Sıkı Standartlar" ı izlerseniz ve statik olarak tanımlanmayan yöntemleri statik olarak çağırmazsanız tanımlanmayacaktır. Burada açıkladığınız sonucu görüyorum: 3v4l.org/WeHVM Anlaştık, gerçekten garip. - Mark Achée
Uzun açıklamayı tamamen okuduktan sonra, tekrar vurgulamak için tekrar yukarı kaydırmayı hissettim. Şaka yapıyorum, bunu reddettim: D. Teşekkürler bu çok yararlı. - Mr_Green
self :: $ property ve self :: property arasındaki fark hakkında net bir açıklama eklemek hoş olurdu; Bence bu oldukça kafa karıştırıcı. - Tommaso Barbugli
WoC 1. farklı davranır PHP 7'den beri Foo::isFoo() statik olarak adlandırılır, $this tanımlanmayacak. Bu benim düşüncemde daha sezgisel bir davranış. -- Bir diğeri farklı sonuç eğer verilirse Bar uzanmak Foo. Sonra arama Foo::isFoo() aslında örnek bağlamında olurdu (PHP7'ye özgü değil). - Kontrollfreak


self ($ self değil) tip sınıf, nerede $this geçerli kasteder örnek sınıfın. self Statik üye değişkenlerine erişebilmeniz için statik üye fonksiyonlarında kullanım içindir. $this statik olmayan üye işlevlerinde kullanılır ve üye işlevinin çağrıldığı sınıfın örneğine başvurulur.

Çünkü this bir nesne, onu şöyle kullanıyorsun: $this->member

Çünkü self bir nesne değildir, temel olarak geçerli sınıfa otomatik olarak başvuran bir türdür. self::member


109
2017-09-30 07:26





$this-> bir sınıfın değişkenlerinin (üye değişkenleri) veya yöntemlerinin belirli bir örneğine başvurmak için kullanılır.

Example: 
$derek = new Person();

$ derek şimdi Kişinin belirli bir örneğidir. Her Kişinin bir first_name ve bir last_name vardır, ancak $ derek belirli bir first_name ve last_name (Derek Martin) vardır. $ Derek örneğinin içinde bunlara $ this-> first_name ve $ this-> last_name olarak bakabiliriz.

ClassName ::, bu sınıf türüne ve onun statik değişkenlerine, statik yöntemlerine başvurmak için kullanılır. Eğer yardımcı olursa "mental" kelimesini "paylaşımlı" ile zihinsel olarak değiştirebilirsiniz. Paylaşıldıklarından, belirli bir örneğe (paylaşılmayan) başvuran $ 'a başvuramazlar. Statik Değişkenler (örn. Statik $ db_connection), bir nesne türünün tüm örnekleri arasında paylaşılabilir. Örneğin, tüm veritabanı nesneleri tek bir bağlantıyı paylaşır (statik $ bağlantı).

Statik Değişkenler Örneği: Tek bir üye değişkeni olan bir veritabanı sınıfımız olduğunu varsayalım: statik $ num_connections; Şimdi bunu kurucunun içine koy:

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

Nesnelerin kurucuları olduğu gibi, nesneler öldüğünde veya yanlış olduğunda çalıştırılan yıkıcılar da vardır:

function __destruct()
{
    $num_connections--;
}

Her yeni bir örnek oluşturduğumuzda, bağlantı sayacımız bir artırılacaktır. Bir örneği kullanarak her defasında ya da durduğumuzda, bağlantı sayacını bir azaltacaktır. Bu şekilde, kullanımda olan veritabanı nesnesinin örnek sayısını izleyebiliriz:

echo DB::num_connections;

$ Num_connections statik (paylaşılmış) olduğundan, aktif veritabanı nesnelerinin toplam sayısını yansıtacaktır. Bir veritabanı sınıfının tüm örnekleri arasında veritabanı bağlantılarını paylaşmak için kullanılan bu tekniği görmüş olabilirsiniz. Bu, veritabanı bağlantısının oluşturulması uzun sürdüğü için yapılır, bu yüzden sadece bir tane oluşturup paylaşmanız en iyisidir (buna Singleton Kalıbı denir).

Statik Yöntemler (yani, genel statik View :: format_phone_number ($ digit)), bu nesnelerden birisini ilk kez oluşturmadan kullanılabilir (yani, bunlar dahili olarak buna değinmez).

Statik Yöntem Örneği:

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

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

Görebildiğiniz gibi, public statik işlevi prettyName nesne hakkında hiçbir şey bilmiyor. Sadece bir nesnenin parçası olmayan normal bir işlev gibi, girdiğiniz parametrelerle çalışıyor. Neden rahatsız ediyorsun, eğer nesnenin bir parçası olarak olmasaydık?

  1. Öncelikle, fonksiyonları nesnelere eklemek, işleri organize etmenize yardımcı olur, böylece onları nerede bulacağınızı bilirsiniz.
  2. İkincisi, adlandırma çakışmalarını önler. Büyük bir projede, iki geliştiricinin getName () işlevlerini oluşturması muhtemeldir. Bir ClassName1 :: getName () oluşturur ve diğeri ClassName2 :: getName () oluşturursa, hiç sorun değil. Çatışma yok. Yay statik yöntemleri!

KENDİNİ :: Kodlama yapıyorsanız dışında başvurmak istediğiniz statik yönteme sahip olan nesne, nesnenin adını View :: format_phone_number ($ phone_number) kullanarak çağırmanız gerekir; Kodlama yapıyorsanız içeride başvurmak istediğiniz statik yönteme sahip olan nesneyi ya nesnenin ismini kullan View :: format_phone_number ($ pn), VEYA self :: format_phone_number ($ pn) kısayolunu kullanabilirsiniz.

Aynı şey statik değişkenler için de geçerlidir: Örnek: Görünüm :: templates_path karşı self :: templates_path

DB sınıfının içinde, başka bir nesnenin statik bir yöntemine başvursaydık, nesnenin adını kullanırdık: Örnek: Oturum :: getUsersOnline ();

Ama eğer DB sınıfı kendi statik değişkenine başvurmak istiyorsa, sadece kendini ifade ederdi: Örnek: öz :: bağlantısı;

Umarım şeyleri temizlemeye yardımcı olur :)


93
2017-10-22 17:52



Metninizin ikinci paragrafında $ ronny var, ama yanılmadıkça $ derek olmalıydı. - James Skemp
Mükemmel cevap. Sadece bir statik özniteliğe başvururken, şunu belirtmek istiyorum. $ işaret. Örneğin self::$templates_path - henrywright


itibaren bu blog yazısı:

  • self mevcut sınıfa atıfta bulunur
  • self statik işlevleri çağırmak ve statik üye değişkenlerini referans almak için kullanılabilir
  • self statik fonksiyonların içinde kullanılabilir
  • self vtable bypass ederek polimorfik davranışı da kapatabilir
  • $this geçerli nesneyi ifade eder
  • $this statik fonksiyonları çağırmak için kullanılabilir
  • $this Statik üye değişkenlerini çağırmak için kullanılmamalıdır. kullanım self yerine.
  • $this Statik fonksiyonlarda kullanılamaz

27
2018-05-10 12:00





PHP'de, statik özelliklere ve yöntemlere erişmek için kendi anahtar sözcüğünü kullanırsınız.

Sorun şu ki değiştirebilirsin $this->method() ile self::method()her nerede olursa olsun, method() statik olarak bildirilmiş veya değil. Hangisini kullanmalıyım?

Bu kodu düşünün:

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

Bu örnekte, self::who() her zaman "ebeveyn" çıkacak, $this->who() nesnenin sahip olduğu sınıfa bağlı olacaktır.

Şimdi, kendinin çağrıldığı sınıfla ilgili olduğunu görebiliyoruz. $this ifade eder mevcut nesnenin sınıfı.

Yani, sadece $this mevcut değil veya alt sınıfların geçerli yöntemin üzerine yazmasına izin vermek istemediğinizde.


23
2017-12-29 13:20





Bir sınıf tanımının içinde, bu, geçerli nesneyi ifade eder;

Kendini kullanarak bir sınıf elemanına başvurmak ve bunu kullanarak bir nesne elemanına başvurmak gerekir.

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

19
2018-05-08 06:58





Statik olmayanlar için $ ve self'in doğru kullanımının bir örneği   ve statik üye değişkenleri:

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

17
2017-12-06 11:26





Göre http://www.php.net/manual/en/language.oop5.static.php yok $self. Sadece var $thissınıfın (örneğini) geçerli örneğine başvurmak için ve bir sınıfın statik üyelerine başvurmak için kullanılabilecek öz. Bir nesne örneği ve bir sınıf arasındaki fark burada devreye girer.


16
2017-09-30 06:29



Öneri: Asit üzerinde çalışırken bu cevabı okuyun. - a20