Bu ne zaman kendini kendine kullanmal─▒?


Al─▒nan cevaba git


PHP 5ÔÇÖte, self ve ile aras─▒ndaki fark $this nedir?

Ne zaman uygun olur?


1942









Cevap say─▒s─▒n─▒ say: 22






K─▒sa cevap

$this Ge├žerli nesneye ba┼čvurmak i├žin kullan─▒n . self Mevcut s─▒n─▒fa at─▒fta bulunmak i├žin kullan─▒n . Ba┼čka bir deyi┼čle, $this->member statik olmayan ├╝yeler self::$member i├žin kullan─▒n , statik ├╝yeler i├žin kullan─▒n .

Tam cevap

─░┼čte bir ├Ârnek , do─čru kullan─▒m─▒ $this ve self sigara statik 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();
?>
 

Burada bir ├Ârnek , yanl─▒┼č kullan─▒m─▒ $this ve self d─▒┼č─▒ statik 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 polimorfizm 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();
?>
 

Burada, ├╝ye i┼člevler i├žin kullanarak polimorfik davran─▒┼č─▒ bast─▒rman─▒n bir ├Ârne─či 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();
?>
 

Buradaki d├╝┼č├╝nce, ge├žerli nesnenin t├╝r├╝ ne olursa olsun ├╝ye i┼člevini $this->foo() ├ža─č─▒r─▒r foo() . Nesne ise, type X ├ža─č─▒r─▒r X::foo() . Nesne varsa, type Y ├ža─č─▒r─▒r Y::foo() . Ancak ├Âz :: foo () X::foo() ile her zaman denir.

G├Ânderen http://www.phpbuilder.com/board/showthread.php?t=10354489 :

by http://board.phpbuilder.com/member.php?145249-laserlight


1662







Kendini anahtar kelime , en az─▒ndan sizi statik ├╝yelere k─▒s─▒tlayacak ┼čekilde de─čil, yaln─▒zca 'ge├žerli s─▒n─▒fa' DE─×─░LD─░R . Statik olmayan bir ├╝ye ba─člam─▒nda , ge├žerli nesne i├žin self vtable (vtable'daki wiki'ye bak─▒n─▒z ) atlaman─▒n bir yolunu da sa─člar . parent::methodName() Bir i┼člevin ebeveyn s├╝r├╝m├╝n├╝ ├ža─č─▒rmak i├žin kullanabildi─činiz gibi self::methodName() , bir y├Ântemin ge├žerli s─▒n─▒flar─▒n─▒n uygulamas─▒n─▒ ├ža─č─▒rmak i├žin de arayabilirsiniz.

 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 ├ž─▒kacakt─▒r:

Merhaba, ben Ludwig in geek
elveda.

sayHello() $this i┼čaret├žiyi kullan─▒r , b├Âylece vtable ├ža─čr─▒l─▒r Geek::getTitle() . sayGoodbye() kullan─▒r self::getTitle() , bu y├╝zden vtable kullan─▒lmaz ve Person::getTitle() denir. Her iki durumda da, somutla┼čt─▒r─▒lm─▒┼č bir nesnenin y├Ântemiyle ilgileniyoruz $this ve ├ža─čr─▒lan i┼člevler i├žindeki i┼čaret├žiye eri┼čiyoruz .


736







KULLANMAYIN self:: , kullan─▒n static::

Benli─čin ba┼čka bir y├Ân├╝ daha var: S├Âylemeye de─čer. Can s─▒k─▒c─▒ bi├žimde self:: , uygulama noktas─▒ndaki de─čil, uygulama noktas─▒ndaki 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 Person::status() ararsak "Ki┼či canl─▒" g├Ârece─čiz. ┼×imdi, bundan miras alan bir s─▒n─▒f olu┼čturdu─čumuzda ne olaca─č─▒n─▒ d├╝┼č├╝n├╝n:

 class Deceased extends Person
{

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

}
 

├ça─čr─▒n─▒n Deceased::status() "Ki┼či ├Âlm├╝┼č" oldu─čunu g├Ârmeyi bekleriz, ancak g├Âr├╝┼čme self::getStatus() tan─▒mland─▒─č─▒nda orijinal y├Ântem tan─▒m─▒n─▒ i├žerdi─činden, g├Ârd├╝─č├╝m├╝z ┼čey "Ki┼či canl─▒d─▒r" d─▒r .

PHP 5.3'├╝n bir ├ž├Âz├╝m├╝ var. static:: ├ž├Âz├╝n├╝rl├╝k operat├Âr├╝ uygular denir s─▒n─▒f─▒n kapsam─▒na ka├ž─▒n─▒lmazd─▒r s├Âyleyerek bir fantezi yolu olan "ge├ž statik ba─člama". ├çizgi de─či┼čtirin status() etmek static::getStatus() ve sonu├žlar─▒ ne bekledi─činiz vard─▒r. PHP'nin eski s├╝r├╝mlerinde, bunu yapmak i├žin bir tortu bulman─▒z gerekecektir.

PHP Dok├╝manlar─▒na Bak─▒nhttp://php.net/manual/en/language.oop5.late-static-bindings.php

Yani soruyu cevaplamad─▒─č─▒m gibi cevaplamak i├žin ...

$this-> ge├žerli nesneyi (bir s─▒n─▒f─▒n ├Ârne─či) static:: belirtir , oysaki bir s─▒n─▒f─▒ belirtir


450


2011-07-24





Ger├žekten biz bahsederken bahsetti─činizi anlamak i├žin self kar┼č─▒ $this , asl─▒nda kavramsal ve pratik bir d├╝zeyde neler i├žine kazmak gerekir. Yan─▒tlar─▒n hi├žbirinin bunu uygun ┼čekilde yapt─▒─č─▒n─▒ hissetmiyorum, bu y├╝zden i┼čte benim giri┼čimim.

Bir s─▒n─▒f ve nesnenin ne oldu─ču hakk─▒nda konu┼čarak ba┼člayal─▒m .

S─▒n─▒flar ve Nesneler, Kavramsal Olarak

Peki, ne oldu─čunu bir s─▒n─▒f ? Bir├žok insan onu bir plan veya bir nesne i├žin bir ┼čablon olarak tan─▒mlar . Asl─▒nda, burada PHP'de S─▒n─▒flar Hakk─▒nda daha fazla bilgi edinebilirsiniz . Ve bir dereceye kadar ger├žekte olan bu. Bir s─▒n─▒fa bakal─▒m:

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

S├Âyleyebilece─činiz gibi, bu s─▒n─▒fta bir ├Âzellik ve ├ža─čr─▒lan $name bir y├Ântem (i┼člev) vard─▒r sayHello() .

O var ├žok dikkat etmek ├Ânemlidir s─▒n─▒f statik bir yap─▒d─▒r. Bu Person , bir kez tan─▒mland─▒─č─▒ zaman , s─▒n─▒f─▒n bakt─▒─č─▒n─▒z her yerde ayn─▒ oldu─ču anlam─▒na gelir .

├ľte yandan bir nesneye S─▒n─▒f ├Ârne─či denir . Bunun anlam─▒, s─▒n─▒f─▒n ÔÇťplan─▒n─▒ÔÇŁ ald─▒─č─▒m─▒z ve onu dinamik bir kopya yapmak i├žin kulland─▒─č─▒m─▒zd─▒r. Bu kopya ┼čimdi ├Âzellikle i├žinde depolanan de─či┼čkene ba─čl─▒d─▒r. Bu nedenle, bir ├Ârnekte yap─▒lan de─či┼čiklikler bu ├Ârnekte yereldir.

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

─░┼čleci kullanarak yeni bir s─▒n─▒f ├Ârne─či yarat─▒r─▒z new .

Bu nedenle, S─▒n─▒f─▒n k├╝resel bir yap─▒ oldu─čunu ve Nesnenin yerel bir yap─▒ oldu─čunu s├Âyl├╝yoruz. Komik -> s├Âzdizimi hakk─▒nda endi┼čelenme , birazdan bu konuya girece─čiz.

Konu┼čmam─▒z gereken bir di─čer ┼čey, bir ├Ârne─čin belirli bir s─▒n─▒f olup olmad─▒─č─▒n─▒ kontrol edebilmemizdir instanceof : $bob instanceof Person e─čer $bob ├Ârnek Person s─▒n─▒f veya ├žocu─ču kullan─▒larak yap─▒lm─▒┼čsa , bir boole d├Ând├╝r├╝r Person .

Devlet tan─▒m─▒

├ľyleyse bir s─▒n─▒f─▒n ger├žekte ne i├žerdi─čine bir bakal─▒m. Bir s─▒n─▒f─▒n i├žerdi─či 5 ├že┼čit "┼čey" vard─▒r:

  1. ├ľzellikler - Bunlar─▒ her ├Â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. Yani her ├Ârnek taraf─▒ndan asla kopyalanm─▒yorlar.

     class Foo {
        public static $bar = 1;
    }
     
  3. Y├Ântemler - Bunlar, her ├Ârne─čin i├žerece─či i┼člevlerdir (ve durumlarda ├žal─▒┼č─▒rlar).

     class Foo {
        public function bar() {}
    }
     
  4. Statik Y├Ântemler - Bunlar t├╝m s─▒n─▒fta payla┼č─▒lan fonksiyonlard─▒r. Onlar do de─čil ├Ârneklerinde, ancak bunun yerine sadece statik ├Âzelliklerine ├žal─▒┼č─▒rlar.

     class Foo {
        public static function bar() {}
    }
     
  5. Sabitler - S─▒n─▒f ├ž├Âz├╝lm├╝┼č sabitler. Burada daha derine inmek de─čil, b├╝t├╝nl├╝─č├╝ eklemek i├žin:

     class Foo {
        const BAR = 1;
    }
     

Bu y├╝zden, temel olarak, bilgilerin payla┼č─▒l─▒p payla┼č─▒lmad─▒─č─▒n─▒ (ve dolay─▒s─▒yla statik) veya (ve dolay─▒s─▒yla dinamik) olup olmad─▒─č─▒n─▒ belirleyen statik hakk─▒nda "ipu├žlar─▒" kullanarak s─▒n─▒f ve nesne konteynerine bilgi depolamaktay─▒z .

Devlet ve Y├Ântemler

Bir y├Ântemin i├žinde bir nesnenin ├Ârne─či $this de─či┼čken taraf─▒ndan temsil edilir . Bu nesnenin mevcut durumu oradad─▒r ve herhangi bir ├Âzelli─čin mutasyona u─čramas─▒ (de─či┼čmesi), bu ├Ârnekte (di─čerlerinde de─čil) bir de─či┼čikli─če neden olacakt─▒r.

Bir y├Ântem statik olarak adland─▒r─▒l─▒rsa, $this de─či┼čken tan─▒mlanmaz . Bunun nedeni, statik bir aramayla ili┼čkilendirilmi┼č bir ├Ârnek olmamas─▒d─▒r.

Buradaki ilgin├ž ┼čey, statik ├ža─čr─▒lar─▒n nas─▒l yap─▒ld─▒─č─▒d─▒r. ├ľyleyse devlete nas─▒l girdi─čimizi konu┼čal─▒m:

Devlete Eri┼čim

┼×imdi bu durumu kaydetti─čimiz i├žin, ona eri┼čmemiz gerekiyor. Bu biraz zor olabilir (veya bir bitden ├žok daha fazla), hadi bunu iki bak─▒┼č a├ž─▒s─▒na ay─▒ral─▒m: ├Ârne─čin / s─▒n─▒f─▒n d─▒┼č─▒ndan (normal bir i┼člev ├ža─čr─▒s─▒ndan veya genel kapsamdan) ve bir ├Ârne─čin i├žinde / class (nesne ├╝zerindeki bir y├Ântemin i├žinden).

├ľrnek / S─▒n─▒f─▒n D─▒┼č─▒ndan

Bir ├Ârnek / s─▒n─▒f─▒n d─▒┼č─▒ndan, kurallar─▒m─▒z olduk├ža basit ve tahmin edilebilirdir. ─░ki operat├Âr├╝m├╝z var ve her biri bize bir ├Ârnek veya s─▒n─▒f statikle u─čra┼č─▒yorsak derhal s├Âyler:

  • -> - object-operator - Bu, bir ├Ârne─če eri┼čirken daima kullan─▒l─▒r.

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

    ├ça─čr─▒n─▒n bir Person->foo anlam ifade etmedi─čine dikkat etmek ├Ânemlidir (├ž├╝nk├╝ Person bir s─▒n─▒f de─čil, bir s─▒n─▒f). Bu nedenle, bu bir ayr─▒┼čt─▒rma hatas─▒d─▒r.

  • :: - Ak─▒├ž ├ž├Âz├╝n├╝rl├╝─č├╝ i┼čleci - Bu her zaman bir S─▒n─▒f statik ├Âzelli─čine veya y├Ântemine eri┼čmek i├žin kullan─▒l─▒r.

     echo Foo::bar()
     

    Ek olarak, bir nesnede statik bir y├Ântemi de ayn─▒ ┼čekilde ├ža─č─▒rabiliriz:

     echo $foo::bar()
     

    Bunu d─▒┼čar─▒dan yapt─▒─č─▒m─▒zda , nesnenin ├Ârne─činin y├Ântemden gizli oldu─čunu not etmek son derece ├Ânemlidir . Yani ├žal─▒┼čan ile ayn─▒ oldu─ču anlam─▒na gelir: bar()

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

Bu nedenle, $this statik ├ža─čr─▒da tan─▒mlanmad─▒.

├ľrnek / S─▒n─▒f─▒n ─░├žinden

Burada i┼čler biraz de─či┼čiyor. Ayn─▒ operat├Ârler kullan─▒l─▒r, ancak anlamlar─▒ anlaml─▒ derecede bulan─▒kla┼č─▒r.

Nesne operat├Âr -> hala nesnenin ├Ârnek durumuna arama yapmak i├žin kullan─▒l─▒r.

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

Object-operat├Âr├╝n├╝ kullanarak bar() y├Ântemi $foo (├Ârne─čin ├Ârne─či Foo ) ├ža─č─▒rmak, $foo->bar() ├Ârne─čin s├╝r├╝m├╝yle sonu├žlan─▒r $a .

Demek istedi─čimiz bu.

Yine de :: operat├Âr├╝n anlam─▒ de─či┼čiyor. Ge├žerli i┼čleve yap─▒lan ├ža─čr─▒n─▒n i├žeri─čine ba─čl─▒d─▒r:

  • Statik bir ba─člamda

    Statik bir ba─člamda, yap─▒lan ├ža─čr─▒lar :: da statik olacakt─▒r. Bir ├Ârne─če bakal─▒m:

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

    Arama Foo::bar() arayacak baz() statik y├Ântemini ve dolay─▒s─▒yla $this edecek de─čil doldurulur. PHP'nin (5.3+) son s├╝r├╝mlerinde bunun bir E_STRICT hataya neden olaca─č─▒n─▒ , ├ž├╝nk├╝ statik olmayan y├Ântemleri statik olarak adland─▒rd─▒─č─▒m─▒z─▒ belirtmek gerekir .

  • Bir ├Ârnek ba─člam i├žinde

    ├ľte yandan, bir ├Ârnek ba─člam i├žinde, yap─▒lan aramalar :: araman─▒n al─▒c─▒s─▒na (arad─▒─č─▒m─▒z y├Ântem) ba─čl─▒d─▒r. Metot olarak tan─▒mlan─▒rsa static , statik bir ├ža─čr─▒ kullanacakt─▒r. De─čilse, ├Ârnek bilgisini iletir.

    B├Âylece, yukar─▒daki koda bakarak , "statik" ├ža─čr─▒ bir ├Ârnek ba─člam─▒n─▒n i├žinde ger├žekle┼čti─činden , ├ža─čr─▒ $foo->bar() geri d├Ânecektir true .

Mant─▒kl─▒ olmak? ├ľyle d├╝┼č├╝nmedim. Kafa kar─▒┼čt─▒r─▒c─▒.

K─▒sayol Anahtar Kelimeler

S─▒n─▒f adlar─▒n─▒ kullanarak her ┼čeyi birbirine ba─člamak olduk├ža kirli oldu─čundan, PHP, kapsam ├ž├Âz├╝mlemesini kolayla┼čt─▒rmak i├žin 3 temel "k─▒sayol" anahtar s├Âzc├╝─č├╝ sa─člar.

  • self - Bu, ge├žerli s─▒n─▒f ad─▒n─▒ ifade eder. Yani s─▒n─▒f i├žindeki self::baz() ile ayn─▒d─▒r (├╝zerinde herhangi bir y├Ântem). Foo::baz() Foo

  • parent - Bu, ge├žerli s─▒n─▒f─▒n ebeveyni anlam─▒na gelir.

  • static - Bu, aranan s─▒n─▒fa at─▒fta bulunur. Kal─▒t─▒m sayesinde, alt s─▒n─▒flar y├Ântemleri ve statik ├Âzellikleri ge├žersiz k─▒labilir. Bu y├╝zden onlar─▒ static bir s─▒n─▒f ismi yerine kullanarak ├ža─č─▒rmak, mevcut seviyeden ziyade araman─▒n nereden geldi─čini ├ž├Âzmemizi sa─člar.

├ľrnekler

Bunu anlaman─▒n en kolay yolu, baz─▒ ├Ârneklere bakmaya ba┼člamakt─▒r. Bir s─▒n─▒f 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 burada da mirasa bak─▒yoruz. Bir an i├žin bunun k├Ât├╝ bir nesne modeli oldu─čunu g├Âz ard─▒ edin, ancak bununla oynad─▒─č─▒m─▒zda neler oldu─čuna bir 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
 

Bu y├╝zden kimlik sayac─▒ hem ├Ârnekler hem de ├žocuklar aras─▒nda payla┼č─▒l─▒r (├ž├╝nk├╝ self ona eri┼čmek i├žin kullan─▒yoruz . Kullan─▒rsak static , onu bir ├žocuk s─▒n─▒f─▒nda ge├žersiz k─▒labilirdik).

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

Person::getName() ├ľrnek y├Ântemi her seferinde uygulad─▒─č─▒m─▒z─▒ unutmay─▒n . Fakat bunu parent::getName() vakalardan birinde (├žocuk vaka) yapmak i├žin kullan─▒yoruz. Bu, bu yakla┼č─▒m─▒ g├╝├žl├╝ k─▒lan ┼čeydir.

Dikkatli Kelime # 1

├ça─čr─▒ i├žeri─činin, bir ├Ârne─čin kullan─▒l─▒p kullan─▒lmayaca─č─▒n─▒ belirleyen ┼čey oldu─čuna dikkat edin. Bu nedenle:

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

Her zaman do─čru de─čil .

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

┼×imdi buras─▒ ger├žekten garip. Farkl─▒ bir s─▒n─▒f diyoruz, ancak $this bu Foo::isFoo() y├Ânteme iletilen ├Ârne─či $bar .

Bu, her t├╝rl├╝ hataya ve kavramsal WTF-ery'ye neden olabilir. ├çok ka├ž─▒narak ├Âneririm Yani :: bu ├╝├ž sanal "kestirme" anahtar kelimeler d─▒┼č─▒nda bir ┼čey ├╝zerinde ├Ârnek y├Ântemleri i├žinden operat├Âr├╝ ( static , self ve parent ).

Dikkatli Kelime # 2

Statik y├Ântemlerin ve ├Âzelliklerin herkes taraf─▒ndan payla┼č─▒ld─▒─č─▒n─▒ unutmay─▒n. Bu onlar─▒ temelde k├╝resel de─či┼čkenler yapar. D├╝nya ile birlikte gelen t├╝m ayn─▒ problemlerle. Bu y├╝zden, ger├žekten k├╝resel olma konusunda rahat olmad─▒─č─▒n─▒z s├╝rece, bilgileri statik y├Ântemlerde / ├Âzelliklerde saklamakta teredd├╝tl├╝ olaca─č─▒m.

Dikkatli Kelime # 3

Genel olarak, Ge├ž Statik Ciltleme olarak bilinenleri kullanmak static yerine kullanmak isteyeceksiniz self . Ama ayn─▒ ┼čey olmad─▒klar─▒na dikkat edin, bu nedenle "her zaman static yerine kullanmak her zaman self ├žok k─▒sa g├Âr├╝┼čl├╝yd├╝. Bunun yerine, yapmak istedi─činiz ├ža─čr─▒y─▒ d├╝┼č├╝n├╝n ve d├╝┼č├╝n├╝n ve ├žocuk s─▒n─▒flar─▒n─▒n bu statik ├ž├Âz├╝m├╝ ge├žersiz k─▒lmas─▒n─▒ isteyip istemedi─činizi d├╝┼č├╝n├╝n aramak.

TL / DR

├çok k├Ât├╝, geri d├Ân ve oku. ├çok uzun olabilir, ama o kadar uzun ├ž├╝nk├╝ bu karma┼č─▒k bir konu

TL / DR # 2

Tamam iyi. K─▒sacas─▒, bir s─▒n─▒f i├žindeki ge├žerli s─▒n─▒f ad─▒na self ba┼čvurmak i├žin kullan─▒l─▒r , burada ge├žerli nesne ├Ârne─čini ifade eder . Bu bir kopyala / yap─▒┼čt─▒r k─▒sayol oldu─čunu unutmay─▒n. Bunu g├╝venli bir ┼čekilde s─▒n─▒f ad─▒n─▒zla de─či┼čtirebilirsiniz; Ancak , vaktinden ├Ânce belirlenemeyen dinamik bir de─či┼čken (ve hatta sizin s─▒n─▒f─▒n─▒z olmayabilir). $this self $this

TL / DR # 3

E─čer nesne-operat├Âr├╝ kullan─▒l─▒yorsa ( -> ), o zaman bir ├Ârnekle u─čra┼čt─▒─č─▒n─▒z─▒ her zaman bilirsiniz. Kapsam ├ž├Âz├╝n├╝rl├╝─č├╝ i┼čleci kullan─▒l─▒yorsa ( :: ), ba─člam hakk─▒nda daha fazla bilgiye ihtiyac─▒n─▒z vard─▒r (zaten bir nesne ba─člam─▒nda m─▒y─▒z? Bir nesnenin d─▒┼č─▒nda m─▒y─▒z? Vb.).


242







self ($ self de─čil) , s─▒n─▒f─▒n ge├žerli ├Ârne─čini ifade etti─či ┼čekilde s─▒n─▒f t├╝r├╝n├╝ $this ifade eder . statik ├╝ye de─či┼čkenlerine eri┼čmenize izin vermek i├žin statik ├╝ye i┼člevlerinde kullan─▒m i├žindir. statik olmayan ├╝ye i┼člevlerinde kullan─▒l─▒r ve ├╝ye i┼člevinin ├ža─čr─▒ld─▒─č─▒ s─▒n─▒f─▒n ├Ârne─čine bir ba┼čvuru yapar. self $this

├ç├╝nk├╝ this bir nesne, onu ┼č├Âyle kullan─▒yorsunuz: $this->member

├ç├╝nk├╝ self bir nesne de─čil, otomatik olarak ge├žerli s─▒n─▒fa ba┼čvuran bir t├╝r temelde, bunu gibi kullan─▒n: self::member


115







$this-> Bir s─▒n─▒f─▒n de─či┼čkenlerinin (├╝ye de─či┼čkenleri) veya y├Ântemlerinin belirli bir ├Ârne─čini ifade etmek i├žin kullan─▒l─▒r.

 Example: 
$derek = new Person();
 

$ derek ┼čimdi belirli bir Person ├Ârne─čidir. Her insan─▒n bir ilk ad─▒ ve bir soyad─▒ vard─▒r, fakat $ derek'in bir ilk ad─▒ ve soyad─▒ vard─▒r (Derek Martin). $ Derek ├Ârne─činde, $ this-> first_name ve $ this-> last_name olanlar─▒na ba┼čvurabiliriz.

ClassName ::, bu s─▒n─▒f tipine ve statik de─či┼čkenlerine, statik y├Ântemlere g├Ânderme yapmak i├žin kullan─▒l─▒r. Yard─▒m ederse, zihinsel olarak "statik" kelimesini "payla┼č─▒lan" ile de─či┼čtirebilirsiniz. Payla┼č─▒ld─▒klar─▒ i├žin, $ bunu ifade edemezler; bu, belirli bir ├Ârne─če (payla┼č─▒lmayan) at─▒fta bulunur. Statik De─či┼čkenler (yani 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─▒s─▒).

Statik De─či┼čkenler ├ľrnek: Tek bir ├╝ye de─či┼čkenli bir veritaban─▒ s─▒n─▒f─▒m─▒z varm─▒┼č gibi davran─▒n: static $ num_connections; ┼×imdi, bunu yap─▒c─▒ya koyun:

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

Nesnelerin yap─▒c─▒lar─▒ oldu─ču gibi, nesnenin ├Âld├╝─č├╝ veya mutsuz oldu─ču durumlarda y├╝r├╝t├╝len y─▒k─▒c─▒lar─▒ da vard─▒r:

 function __destruct()
{
    $num_connections--;
}
 

Ne zaman yeni bir ├Ârnek yaratsak, ba─člant─▒ say─▒m─▒z─▒ birer birer art─▒racakt─▒r. Bir ├Ârne─či kullanmay─▒ her b─▒rakt─▒─č─▒m─▒zda veya durdurdu─č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┼č─▒lan) oldu─čundan, toplam etkin veritaban─▒ nesnesi say─▒s─▒n─▒ yans─▒t─▒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─▒ olu┼čturmak uzun zaman ald─▒─č─▒ndan, sadece bir tane olu┼čturup payla┼čmas─▒ en iyisidir, ├ž├╝nk├╝ buna Singleton Pattern denir.

Statik Y├Ântemler (yani genel statik View :: format_phone_number ($ basamak)), bu nesnelerden birini ilk kez ba┼člatmadan (yani, $ 'a ba┼čvurmazlar) OLMADAN kullan─▒labilir.

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├Ârd├╝─č├╝n├╝z gibi, genel statik i┼člev olan prettyName, nesne hakk─▒nda hi├žbir ┼čey bilmiyor. Sadece bir nesnenin par├žas─▒ olmayan normal bir fonksiyon gibi, girdi─činiz parametrelerle ├žal─▒┼č─▒yor. ├ľyleyse neden onu bir nesnenin par├žas─▒ olarak g├Âremiyorsak, rahats─▒z etsin?

  1. ─░lk olarak, i┼člevlerin nesnelere eklenmesi i┼čleri d├╝zenli tutman─▒za 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┼člevleri olu┼čturmas─▒na neden olabilirsiniz. Biri bir ClassName1 :: getName () olu┼čtururken, di─čeri ClassName2 :: getName () olu┼čturursa, hi├ž sorun olmaz. ├çat─▒┼čma yok. Yay statik y├Ântemler!

SELF :: Ba┼čvurmak istedi─činiz statik metoda sahip nesnenin d─▒┼č─▒nda kodlama yap─▒yorsan─▒z, nesneyi View :: format_phone_number ($ phone_number) ad─▒n─▒ kullanarak ├ža─č─▒rmal─▒s─▒n─▒z; E─čer kodlama yap─▒yorsan─▒z i├žine sen olabilir ba┼čvurmak isteyen statik y├Ântem vard─▒r nesne ya nesnenin ad─▒ G├Âr├╝nt├╝le :: format_phone_number ($ pn) kullan─▒n VEYA kendini :: format_phone_number ($ pn) kullanabilece─činiz k─▒sayol

Ayn─▒s─▒ statik de─či┼čkenler i├žin de ge├žerlidir: ├ľrnek: View :: templates_path versus self :: templates_path

DB s─▒n─▒f─▒n─▒n i├žinde, ba┼čka bir nesnenin statik y├Ântemine at─▒fta bulunsayd─▒k , nesnenin ad─▒n─▒ kullan─▒rd─▒k: ├ľrnek: Session :: getUsersOnline ();

Fakat e─čer DB s─▒n─▒f─▒ kendi statik de─či┼čkenine at─▒fta bulunmak istiyorsa, sadece self derdi: ├ľrnek: self :: connection;

Her ┼čeyi a├ž─▒kl─▒─ča kavu┼čturmaya yard─▒mc─▒ olan umar─▒m :)


96







G├Ânderen bu blog yay─▒n─▒nda :

  • self ge├žerli s─▒n─▒fa at─▒fta bulunur
  • self statik fonksiyonlar─▒ ├ža─č─▒rmak ve statik ├╝ye de─či┼čkenleri referans olarak kullanmak i├žin kullan─▒labilir
  • self statik fonksiyonlar─▒n i├žinde kullan─▒labilir
  • self vtable atlayarak da polimorfik davran─▒┼č─▒ kapatabilir
  • $this ge├žerli nesneyi ifade eder
  • $this statik i┼člevleri ├ža─č─▒rmak i├žin kullan─▒labilir
  • $this statik ├╝ye de─či┼čkenlerini ├ža─č─▒rmak i├žin kullan─▒lmamal─▒d─▒r. Yerine self kullan─▒n.
  • $this statik i┼člevlerin i├žinde kullan─▒lamaz

29







PHP'de, statik ├Âzelliklere ve y├Ântemlere eri┼čmek i├žin self anahtar s├Âzc├╝─č├╝n├╝ kullan─▒rs─▒n─▒z.

Sorun, statik ilan edilip edilmedi─čine bak─▒lmaks─▒z─▒n $this->method() , self::method() herhangi bir yerle de─či┼čtirebilirsiniz method() . Hangisini kullanmal─▒s─▒n?

Bu kodu g├Âz ├Ân├╝nde bulundurun:

 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 'parent' ├ž─▒kt─▒s─▒n─▒ al─▒rken $this->who() , nesnenin hangi s─▒n─▒fa ba─čl─▒ oldu─čunu g├Âsterir.

┼×imdi, ├Âz├╝n ├ža─čr─▒ld─▒─č─▒ s─▒n─▒f─▒, mevcut nesnenin s─▒n─▒f─▒n─▒ $this ifade etti─čini g├Ârebiliriz .

Bu nedenle, kendini yaln─▒zca $this uygun olmad─▒─č─▒nda veya alt s─▒n─▒flar─▒n ge├žerli y├Ântemin ├╝zerine yazmas─▒na izin vermek istemedi─činiz zaman kullanmal─▒s─▒n─▒z.


25







Bir s─▒n─▒f tan─▒m─▒nda, $ this, ge├žerli nesneye kar┼č─▒l─▒k gelirken, self ise ge├žerli s─▒n─▒fa i┼čaret eder.

Kendini kullanarak bir s─▒n─▒f ├Â─česine ve $ this kullanarak bir nesne ├Â─česine ba┼čvurmak gerekir.

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

21







Statik olmayan ve statik ├╝ye de─či┼čkenler i├žin $ this ve self kullan─▒m─▒n─▒n bir ├Ârne─či:

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

20







Http://www.php.net/manual/tr/language.oop5.static.php 'a g├Âre hi├žbir yok $self . Sadece $this bir s─▒n─▒f─▒n statik ├╝yelerine g├Ânderme yapmak i├žin kullan─▒labilecek s─▒n─▒f─▒n (nesnesinin) ge├žerli ├Ârne─čine ve ├Âz├╝ne ba┼čvurmak i├žin vard─▒r. Bir nesne ├Ârne─či ile s─▒n─▒f aras─▒ndaki fark burada devreye giriyor.


20







Bence soru, s─▒n─▒f─▒n statik ├╝yesini ├ža─č─▒rarak arayabilir misiniz diye de─čildi ClassName::staticMember . Soru self::classmember ve kullanma aras─▒ndaki fark neydi $this->classmember .

├ľrne─čin, a┼ča─č─▒daki ├Ârneklerin her ikisi de, kullansan─▒z self:: da kullanmasan─▒z da , hatas─▒z ├žal─▒┼č─▒r. $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;
    }
}
 

15


2009-05-18





self Mevcut s─▒n─▒f─▒ (hangi adda oldu─ču) ifade eder,

$this ge├žerli nesneyi ifade eder. Kendini yerine statik kullanabilirsiniz. ├ľrne─če bak─▒n─▒z:

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

├ç─▒kt─▒: ebeveyn ├žocuk


15







  • ─░┼čaret├ži $ this, ge├žerli nesneye i┼čaret eder.
  • "Statik" s─▒n─▒f de─čeri, ge├žerli nesneyi ifade eder.
  • "Self" s─▒n─▒f de─čeri, i├žinde tan─▒mland─▒─č─▒ tam s─▒n─▒f─▒ ifade eder.
  • "Parent" s─▒n─▒f de─čeri, i├žinde tan─▒mland─▒─č─▒ tam s─▒n─▒f─▒n ebeveynine kar┼č─▒l─▒k gelir.

A┼č─▒r─▒ y├╝klenmeyi g├Âsteren a┼ča─č─▒daki ├Ârne─če bak─▒n.

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

Mevcut s─▒n─▒fa at─▒f yapmak istedi─činiz ├žo─ču zaman, bu y├╝zden static ya da kullan─▒n $this . Bununla birlikte, ihtiyac─▒n─▒z olan zamanlar vard─▒r, self ├ž├╝nk├╝ ne olursa olsun, orijinal s─▒n─▒f─▒ istedi─činizde kullan─▒n. (├çok, ├çok nadir)


14







Burada kimse performanslardan bahsetmedi─činden, yapt─▒─č─▒m k├╝├ž├╝k bir kriter (5.6):

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

Bunlar 2 000 000 ├žal─▒┼čman─▒n sonu├žlar─▒ ve i┼čte kulland─▒─č─▒m kod:

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

14


2015-05-31





Ne zaman self birlikte kullan─▒l─▒r :: operat├Âr statik ve statik olmayan ba─člamlarda hem yap─▒labilir ak─▒m s─▒n─▒f─▒na kar┼č─▒l─▒k gelir. $this nesnenin kendisine at─▒fta bulunur. Ek olarak, $this statik y├Ântemleri ├ža─č─▒rmak i├žin kullanmak tamamen yasald─▒r (ancak alanlara at─▒fta bulunmamak).


13







$this ge├žerli s─▒n─▒f nesnesini self ifade eder, ge├žerli s─▒n─▒fa i┼čaret eder (Nesne de─čil). S─▒n─▒f, nesnenin plan─▒d─▒r. Yani bir s─▒n─▒f tan─▒mlars─▒n─▒z, ancak nesneler yapars─▒n─▒z.

Yani ba┼čka bir deyi┼čle, self for static ve kullan─▒n this for none-static members or methods .

Ayr─▒ca ├žocuk / ebeveyn senaryosunda self / parent ├žo─čunlukla ├žocuk ve ebeveyn s─▒n─▒f ├╝yelerini ve y├Ântemlerini tan─▒mlamak i├žin kullan─▒l─▒r.


7







Ek $this:: olarak hen├╝z g├Âr├╝┼č├╝lmedi.

Bilgilendirme amac─▒yla, PHP 5.3'ten itibaren, ge├žerli kapsam de─čerini elde etmek i├žin somutla┼čt─▒r─▒lm─▒┼č nesnelerle u─čra┼č─▒rken, kullanmak yerine static:: , alternatif olarak kullanabilirsiniz $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
 

Yukar─▒daki kodu kullanmak yayg─▒n de─čildir veya ├Ânerilen bir uygulama de─čildir, ancak kullan─▒m─▒n─▒ a├ž─▒klamak i├žindir ve ÔÇťBiliyor muydunuz?ÔÇŁ Gibi davranmakt─▒r. Orijinal posterin sorusuna at─▒fta bulunarak.

Ayr─▒ca kullan─▒m─▒n─▒ temsil eder $object::CONSTANT , ├Ârne─čin echo $foo::NAME; kar┼č─▒ $this::NAME;


7







Ayn─▒ soruyu ko┼čtum ve basit cevap:

  • $ this , s─▒n─▒f─▒n bir ├Ârne─čini gerektirir
  • ├Âz :: yok

Ne zaman statik y├Ântemler veya statik ├Âzellikler kullan─▒yorsan─▒z ve bunlar─▒ s─▒n─▒f─▒n nesnesine sahip olmadan ├ža─č─▒rmak istedi─činizde, onlar─▒ ├ža─č─▒rmak i├žin self :: kullanman─▒z gerekir, ├ž├╝nk├╝ $ bu her zaman nesnenin yarat─▒lmas─▒n─▒ gerektirir.


7


2018-05-19





self Bir s─▒n─▒f─▒n y├Ântemini o s─▒n─▒f─▒n bir nesnesini / ├Ârne─čini olu┼čturmadan ├ža─č─▒rmak istiyorsan─▒z kullan─▒n , b├Âylece RAM tasarrufu yap─▒n (bazen bu ama├ž i├žin kendini kullan─▒n). Ba┼čka bir deyi┼čle, asl─▒nda statik olarak bir y├Ântem ├ža─č─▒r─▒yor. this Nesne perspektifi i├žin kullan─▒n .


5







Durum 1: self S─▒n─▒f sabitleri i├žin kullan─▒m kullan─▒labilir

 classA s─▒n─▒f─▒ { 
     const FIXED_NUMBER = 4; 
     ├Âz :: POUNDS_TO_KILOGRAMS
}

S─▒n─▒f d─▒┼č─▒nda ├ža─č─▒rmak istiyorsan─▒z classA::POUNDS_TO_KILOGRAMS , sabitlere eri┼čmek i├žin kullan─▒n .

Durum 2: Statik ├Âzellikler i├žin

classC s─▒n─▒f─▒ {
     public i┼člev __construct () { 
     ├Âz :: $ _ saya├ž ++; $ this-> num = self :: $ _ counter;
   }
}

2







Php.net g├Âre orada bu ba─člamda ├╝├ž ├Âzel anahtar kelimeler: self , parent ve static . S─▒n─▒f tan─▒m─▒n─▒n i├žinden ├Âzelliklere veya y├Ântemlere eri┼čmek i├žin kullan─▒l─▒rlar.

$this ├ľte yandan, bu s─▒n─▒fa eri┼čilebilir oldu─ču s├╝rece herhangi bir s─▒n─▒f─▒n bir ├Ârne─čini ve y├Ântemlerini ├ža─č─▒rmak i├žin kullan─▒l─▒r.


1


2015-12-07

─░lgili yay─▒nlar


LinkedList Java'da ArrayList ├╝zerinden ne zaman kullan─▒l─▒r?

CouchDB, MongoDBÔÇÖde ne zaman kullan─▒l─▒r?

Bir dizi / dizi listesi ├╝zerinde ba─člant─▒l─▒ liste ne zaman kullan─▒l─▒r?

CoffeeScript, Ne zaman ya─č ok (=>) ok (->) ├╝zerinde ve tersi

RDL raporlar─▒nda RDLC ne zaman kullan─▒l─▒r?

If-else if-else anahtar─▒ ifadeleri ne zaman kullan─▒l─▒r ve bunun tersi [yinelenen]

Durumsuz oturum fasulye, durumsuz oturum fasulye ├╝zerinde ne zaman kullan─▒l─▒r?

─░mzas─▒z de─čerler imzal─▒ de─čerler ├╝zerinden ne zaman kullan─▒l─▒r?

─░plik NPM ├╝zerinden ne zaman kullan─▒l─▒r? Farkl─▒l─▒klar nedir?

JCR (i├žerik deposu) ne zaman di─čer se├ženeklerin ├╝zerinde kullan─▒l─▒r?

Etiketle ilgili di─čer sorular [php]


JQuery kullanarak bir a├ž─▒l─▒r listeden (se├žme kutusu) se├žilen metni al

Android'de 'Ba─člam' nedir?

Sadece iki komisyon aras─▒nda de─či┼čen dosya isimleri nas─▒l listelenir?

Bir APK dosyas─▒ndan kaynak kodunu alman─▒n bir yolu var m─▒?

Neden insanlar #! / Usr / bin / env python shebang'─▒ Python beti─činin ilk sat─▒r─▒na yazarlar?

V├╝cudun taray─▒c─▒ y├╝ksekli─činin% 100'├╝n├╝ al

Node.js'i nas─▒l g├╝ncellerim?

S├╝rekli bir ak─▒nt─▒ya nas─▒l 'grep' yap─▒l─▒r?

Jilet g├Âr├╝n├╝m motorunda @ karakterinden ka├ž─▒┼č

GitHub'ta bar─▒nd─▒r─▒lan harici JavaScript dosyas─▒n─▒ ba─člay─▒n ve y├╝r├╝t├╝n