$ thisでselfを使用する場合

StackOverflow https://stackoverflow.com/questions/151969

  •  02-07-2019
  •  | 
  •  

質問

PHP 5では、 self と $ this の使用の違いは何ですか？

それぞれが適切なのはいつですか

役に立ちましたか？

解決

簡単な回答

  

$ this を使用して、現在の   オブジェクト。 self を使用して、   現在のクラス。言い換えると、   非静的メンバーの場合は $ this-＆gt; member 、   静的メンバーには self :: $ member を使用します。

完全な回答

非静的および静的メンバー変数に対する $ this および self の正しい使用例は次のとおりです。

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

非静的および静的メンバー変数に対する $ this および self の誤った使用例は次のとおりです。

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

メンバー関数の $ this を使用した polymorphism の例を次に示します。

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

以下は、メンバー関数に 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();
?>
  

アイデアは、 $ this-＆gt; foo（）が現在のオブジェクトの正確な型が何であれ foo（）メンバー関数を呼び出すというものです。オブジェクトが type X の場合、 X :: foo（）を呼び出します。オブジェクトが type Y の場合、 Y :: foo（）を呼び出します。ただし、self :: foo（）では、 X :: foo（）が常に呼び出されます。

http://www.phpbuilder.com/board/showthread.phpから？t = 10354489 ：

http://board.phpbuilder.com/member.php?145249-laserlightによって

他のヒント

キーワードselfは、少なくとも「現在のクラス」を NOT 参照せず、少なくとも静的メンバーに制限する方法ではありません。非静的メンバーのコンテキスト内で、 self はvtable（現在のオブジェクトについては、vtableのwikiを参照）。 parent :: methodName（）を使用して関数の親バージョンを呼び出すことができるように、 self :: methodName（）を呼び出して現在のクラスの実装を呼び出すことができますメソッドの。

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

これにより出力されます：

  

こんにちは、オタクのルートヴィヒです
     ルートヴィヒ人からさようなら

sayHello（）は $ this ポインターを使用するため、vtableが呼び出されて Geek :: getTitle（）を呼び出します。 sayGoodbye（）は self :: getTitle（）を使用するため、vtableは使用されず、 Person :: getTitle（）が呼び出されます。どちらの場合も、インスタンス化されたオブジェクトのメソッドを処理しており、呼び出された関数内の $ this ポインターにアクセスできます。

self :: は使用せず、 static ::

を使用します

自己には別の側面があります::言及する価値があります。迷惑なことに self :: は、実行時点ではなく定義時点のスコープを参照しています。 2つのメソッドを持つこの単純なクラスを考えてみましょう：

class Person
{

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

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

}

Person :: status（）を呼び出すと、「Person is alive」が表示されます。 。次に、これを継承するクラスを作成するとどうなるかを考えます。

class Deceased extends Person
{

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

}

Deceased :: status（）を呼び出すと、＆quot; Person is deceased＆quot;が表示されます。しかし、私たちが見るのは「人は生きている」ということです。 self :: getStatus（）の呼び出しが定義されたとき、スコープには元のメソッド定義が含まれているため。

PHP 5.3には解決策があります。 static :: 解決演算子は、「遅延静的バインディング」を実装します。これは、呼び出されたクラスのスコープにバインドされていると言うのに凝った方法です。 status（）の行を static :: getStatus（）に変更すると、結果は予想どおりです。 PHPの古いバージョンでは、これを行うには手がかりを見つける必要があります。

PHPドキュメント

を参照

では、質問に答えるのではなく...

$ this-＆gt; は現在のオブジェクト（クラスのインスタンス）を参照しますが、 static :: はクラスを参照します

self 対 $ this について話すときに何を話しているのかを本当に理解するには、概念的かつ実用的なレベル。私は答えのどれもこれを適切に行うとは本当に感じていないので、ここに私の試みがあります。

クラスとオブジェクトが何であるかについて話を始めましょう。

概念的にクラスとオブジェクト

では、クラスとは とは何ですか？多くの人々はそれをオブジェクトの青写真またはテンプレートとして定義しています。実際には、 PHPのクラスについてはこちらをご覧ください。 。そして、ある程度までそれは実際にそうです。クラスを見てみましょう：

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

おわかりのように、そのクラスには $ name というプロパティと、 sayHello（）というメソッド（関数）があります。

クラスは静的な構造であることに注意することは非常に重要です。つまり、クラス Person は、一度定義されると、どこを見ても常に同じです。

一方、オブジェクトはクラスのインスタンスと呼ばれるものです。つまり、「青写真」を取得するということです。クラスの、それを使用して動的コピーを作成します。このコピーは、保存されている変数に明確に関連付けられています。したがって、インスタンスへの変更は、そのインスタンスに対してローカルです。

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

new 演算子を使用して、クラスの新しいインスタンスを作成します。

したがって、クラスはグローバル構造であり、オブジェクトはローカル構造であると言います。面白い-＆gt; 構文について心配する必要はありません。もう少し詳しく説明します。

もう1つ話すべきことは、インスタンスが特定のクラスの instanceof であるかどうかをチェックできることです： $ bob instanceof Person $ bob インスタンスが Person クラス、または Person の子を使用して作成された場合、ブール値を返します。

状態の定義

では、クラスに実際に含まれているものを少し掘り下げてみましょう。 「もの」には5種類あります。クラスに含まれるもの：

  1. プロパティ-これらは各インスタンスに含まれる変数と考えてください。

    class Foo {
    public $bar = 1;
}

  2. 静的プロパティ-これらはクラスレベルで共有される変数と考えてください。つまり、各インスタンスによってコピーされることはありません。

    class Foo {
    public static $bar = 1;
}

  3. メソッド-これらは、各インスタンスに含まれる（およびインスタンスで動作する）関数です。

    class Foo {
    public function bar() {}
}

  4. 静的メソッド-これらはクラス全体で共有される関数です。それらはインスタンスに対しては動作しませんが、代わりに静的プロパティのみに対して動作します。

    class Foo {
    public static function bar() {}
}

  5. 定数-クラスが解決した定数。ここでは詳しく説明しませんが、完全を期すために追加します。

    class Foo {
    const BAR = 1;
}

つまり、基本的に、「ヒント」を使用してクラスとオブジェクトコンテナに関する情報を保存します。情報が共有されている（したがって静的）か共有されていない（したがって動的）かを識別する static について。

状態とメソッド

メソッドの内部では、オブジェクトのインスタンスは $ this 変数で表されます。そのオブジェクトの現在の状態はそこにあり、プロパティを変更（変更）すると、そのインスタンスが変更されます（他のインスタンスは変更されません）。

メソッドが静的に呼び出される場合、 $ this 変数は定義されていません。これは、静的呼び出しに関連付けられたインスタンスがないためです。

ここで興味深いのは、静的呼び出しがどのように行われるかです。状態にアクセスする方法について話しましょう：

アクセス状態

その状態を保存したら、アクセスする必要があります。これには少し注意が必要です（または方法）。これを2つの視点に分割します：インスタンス/クラスの外側から（たとえば、通常の関数呼び出しまたはグローバルスコープから）、インスタンス/クラスの内側から（オブジェクトのメソッド内から）。

インスタンス/クラスの外部から

インスタンス/クラスの外側から見ると、ルールは非常にシンプルで予測可能です。 2つの演算子があり、それぞれがインスタンスまたはクラスstaticを処理しているかどうかをすぐに通知します。

  • -＆gt; - object-operator -これは、インスタンスにアクセスするときに常に使用されます。

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

    Person-＆gt; foo の呼び出しは意味をなさないことに注意することが重要です（ Person はインスタンスではなくクラスであるため）。したがって、それは解析エラーです。

  • :: - scope-resolution-operator -これは、クラスの静的プロパティまたはメソッドへのアクセスに常に使用されます。

    echo Foo::bar()

    さらに、同じ方法でオブジェクトの静的メソッドを呼び出すことができます：

    echo $foo::bar()

    非常に重要なのは、外部からこれを行うと、オブジェクトのインスタンスが bar（）メソッドで非表示になることです。実行とまったく同じであることを意味します：

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

したがって、 $ this は静的呼び出しで定義されていません。

インスタンス/クラスの内部から

ここで少し変更があります。同じ演算子が使用されますが、それらの意味はかなりあいまいになります。

object-operator -＆gt; は、オブジェクトのインスタンス状態の呼び出しに引き続き使用されます。

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

object-operatorを使用して、 $ foo （ Foo のインスタンス）で bar（）メソッドを呼び出す： $ foo -＆gt; bar（）は、インスタンスのバージョンの $ a になります。

だから私たちはそれを期待しています。

:: 演算子の意味は変わりますが。現在の関数の呼び出しのコンテキストに依存します：

  • 静的コンテキスト内

    静的コンテキスト内では、 :: を使用して行われた呼び出しもすべて静的です。例を見てみましょう：

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

    Foo :: bar（）を呼び出すと、 baz（）メソッドが静的に呼び出されるため、 $ this は を入力します。 PHPの最近のバージョン（5.3以降）では、非静的メソッドを静的に呼び出しているため、 E_STRICT エラーが発生することに注意してください。

  • インスタンスコンテキスト内

    一方、

    インスタンスコンテキスト内では、 :: を使用して行われた呼び出しは、呼び出しの受信者（呼び出しているメソッド）に依存します。メソッドが static として定義されている場合、メソッドは静的呼び出しを使用します。そうでない場合、インスタンス情報を転送します。

    したがって、上記のコードを見ると、 $ foo-＆gt; bar（）を呼び出すと、 true が返されます。呼び出しはインスタンスコンテキスト内で発生します。

理にかなっていますか？そうは思わなかった。紛らわしいです。

ショートカットキーワード

クラス名を使用してすべてを結び付けるのはかなり汚いため、PHPは3つの基本的な「ショートカット」を提供しますスコープ解決を容易にするキーワード。

  • self -これは現在のクラス名を指します。したがって、 self :: baz（）は、 Foo クラス内の Foo :: baz（）と同じです（その上の任意のメソッド）。

  • parent -これは現在のクラスの親を指します。

  • static -これは呼び出されたクラスを指します。継承のおかげで、子クラスはメソッドと静的プロパティをオーバーライドできます。したがって、クラス名の代わりに static を使用して呼び出すと、現在のレベルではなく、呼び出し元を解決できます。

例

これを理解する最も簡単な方法は、いくつかの例を見てみることです。クラスを選びましょう：

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

self （$ selfではない）はクラスの type を参照します。 $ this は現在のインスタンスクラスの。 self は、静的メンバー関数で使用して、静的メンバー変数にアクセスできるようにします。 $ this は非静的メンバー関数で使用され、メンバー関数が呼び出されたクラスのインスタンスへの参照です。

this はオブジェクトなので、次のように使用します。 $ this-＆gt; member

self はオブジェクトではないため、基本的に現在のクラスを自動的に参照する型であり、次のように使用します： self :: member

$ this-＆gt; は、クラスの変数（メンバー変数）またはメソッドの特定のインスタンスを参照するために使用されます。

Example: 
$derek = new Person();

$ derekは、Personの特定のインスタンスになりました。 すべてのPersonにはfirst_nameとlast_nameがありますが、$ derekには特定のfirst_nameとlast_nameがあります（Derek Martin）。 $ derekインスタンス内では、これらを$ this-＆gt; first_nameおよび$ this-＆gt; last_nameとして参照できます

ClassName ::は、そのタイプのクラス、およびその静的変数、静的メソッドを参照するために使用されます。役立つ場合は、「静的」という言葉を精神的に置き換えることができます。 「共有」で。共有されているため、特定のインスタンス（共有されていない）を参照する$ thisを参照できません。静的変数（つまり、静的$ db_connection）は、オブジェクトのタイプのすべてのインスタンス間で共有できます。たとえば、すべてのデータベースオブジェクトは単一の接続（静的な$ connection）を共有します。

静的変数の例： 単一のメンバー変数を持つデータベースクラスがあるとします：static $ num_connections; 次に、これをコンストラクターに配置します。

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

オブジェクトにはコンストラクターがあるだけでなく、デストラクタもあります。デストラクタは、オブジェクトが消滅するか設定解除されるときに実行されます。

function __destruct()
{
    $num_connections--;
}

新しいインスタンスを作成するたびに、接続カウンタが1つ増えます。インスタンスを破棄または使用を停止するたびに、接続カウンターが1つ減少します。このようにして、使用中のデータベースオブジェクトのインスタンスの数を監視できます。

echo DB::num_connections;

$ num_connectionsは静的（共有）であるため、アクティブなデータベースオブジェクトの総数を反映します。この手法は、データベースクラスのすべてのインスタンス間でデータベース接続を共有するために使用されることがあります。これはデータベース接続の作成に時間がかかるためです。1つだけを作成して共有することをお勧めします（これはシングルトンパターンと呼ばれます）。

静的メソッド（つまりpublic static View :: format_phone_number（$ digits））は、それらのオブジェクトの1つを最初にインスタンス化することなく使用できます（つまり、内部で$ thisを参照しません）。

静的メソッドの例： 

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

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

ご覧のとおり、public static関数prettyNameはオブジェクトについて何も知りません。オブジェクトの一部ではない通常の関数のように、渡されたパラメーターを操作するだけです。それでは、なぜオブジェクトの一部としてではないのに気にするのですか？

  1. 最初に、オブジェクトに関数を添付すると、物事を整理しやすくなり、どこにあるかがわかります。
  2. 第二に、名前の競合を防ぎます。大きなプロジェクトでは、2人の開発者がgetName（）関数を作成する可能性があります。一方がClassName1 :: getName（）を作成し、もう一方がClassName2 :: getName（）を作成する場合、まったく問題ありません。競合なし。イェーイ静的メソッド！

SELF :: 参照したい静的メソッドを持つオブジェクトを外部でコーディングしている場合、オブジェクトの名前View :: format_phone_number（$ phone_number）;を使用して呼び出す必要があります。 参照したい静的メソッドを持つオブジェクトを inside コーディングしている場合、オブジェクトの名前View :: format_phone_number（$ pn）を使用するかどちらでも、またはself :: format_phone_number（$ pn）ショートカットを使用できます

静的変数についても同じことが言えます。 例： View :: templates_pathとself :: templates_path

DBクラス内で、他のオブジェクトの静的メソッドを参照する場合、オブジェクトの名前を使用します。 例： Session :: getUsersOnline（）;

ただし、DBクラスが独自の静的変数を参照したい場合は、単にselfと言います。 例： self :: connection;

問題を解決するのに役立つ希望：）

このブログ投稿から：

  
      
  • self は現在のクラスを指します
    •   
  • self を使用して、静的関数を呼び出し、静的メンバー変数を参照できます
    •   
  • self は静的関数内で使用できます
    •   
  • self は、vtableをバイパスすることで多態的な動作をオフにすることもできます
    •   
  • $ this は現在のオブジェクトを指します
    •   
  • $ this を使用して静的関数を呼び出すことができます
    •   
  • $ this は、静的メンバー変数を呼び出すために使用しないでください。代わりに self を使用してください。
    •   
  • $ this は静的関数内では使用できません
    •   

PHPでは、selfキーワードを使用して静的プロパティとメソッドにアクセスします。

問題は、 method（）<に関係なく、どこでも $ this-＆gt; method（）を self :: method（）に置き換えることができることです/ 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();

この例では、 self :: who（）は常に＆＃8216; parent＆＃8217;を出力しますが、 $ this-＆gt; who（）は依存しますオブジェクトのクラスについて。

これで、selfが呼び出されたクラスを参照し、 $ this が現在のオブジェクトのクラスを参照していることがわかります。

したがって、 $ this が利用できない場合、または現在のメソッドを子孫クラスに上書きさせたくない場合にのみselfを使用してください。

クラス定義の内部では、$ thisは現在のオブジェクトを参照し、selfは現在のクラスを参照します。

selfを使用してクラス要素を参照し、$ thisを使用してオブジェクト要素を参照する必要があります。

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

非静的な場合の$ thisおよびselfの正しい使用例   および静的メンバー変数：

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

http://www.php.net/manualによると/en/language.oop5.static.php には $ self はありません。クラスの現在のインスタンス（オブジェクト）を参照するための $ this と、クラスの静的メンバーを参照するために使用できるselfのみがあります。ここでは、オブジェクトインスタンスとクラスの違いが関係します。

self は、それが呼び出される現在のクラスを参照します。

$ this は現在のオブジェクトを参照します。 selfの代わりにstaticを使用できます。 例を参照してください：

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

出力：       親      子

  • 現在のオブジェクトを参照するオブジェクトポインター$ this。
  • クラス値＆quot; static＆quot;現在のオブジェクトを参照します。
  • クラス値＆quot; self＆quot;定義された正確なクラスを指します。
  • クラス値＆quot; parent＆quot ;;定義された正確なクラスの親を参照します。

オーバーロードを示す次の例を参照してください。

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

ほとんどの場合、現在のクラスを参照したいため、 static または $ this を使用します。ただし、何を拡張するかに関係なく元のクラスが必要なため、必要 自己になる場合があります。 （非常に、めったにありません）

ここで誰もパフォーマンスについて話していないので、ここに私がやった小さなベンチマークがあります（5.6）：

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

これらは2 000 000回の実行の結果です。使用したコードは次のとおりです。

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

質問は、 ClassName :: staticMember を呼び出してクラスの静的メンバーを呼び出すことができるかどうかではないと思います。質問は、 self :: classmember と $ this-＆gt; classmember を使用することの違いは何ですか。

たとえば、 self :: または $ this-＆gt;

のどちらを使用しても、次の例は両方ともエラーなしで機能します。 
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;
    }
}

：演算子で self を使用する場合、現在のクラスを参照します。これは、静的コンテキストと非静的コンテキストの両方で実行できます。 $ this はオブジェクト自体を指します。さらに、 $ this を使用して静的メソッドを呼び出すことは完全に合法です（ただし、フィールドを参照することはできません）。

$ this は現在のクラスオブジェクトを指し、 self は現在のクラス（オブジェクトではない）を指します。クラスはオブジェクトの青写真です。したがって、クラスを定義しますが、オブジェクトを構築します。

つまり、 staticにはself を使用し、非静的メンバーまたはメソッドにはthis を使用します。

子/親のシナリオでも self / parent は、主に子および親クラスのメンバーとメソッドを識別するために使用されます。

さらに、 $ this :: はまだ議論されていないため。

情報提供のみを目的として、PHP 5.3以降、インスタンス化されたオブジェクトを処理して現在のスコープ値を取得する場合、 static :: を使用する代わりに、 $ 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

上記のコードを使用することは一般的でも推奨されるプラクティスでもありませんが、その使用法を説明するためのものであり、「ご存知ですか？」元のポスターの質問を参照してください。

$ object :: CONSTANT の使用も表します。たとえば、 $ this :: NAME; <とは対照的に、 echo $ foo :: NAME; です。

同じ質問にぶつかりました。簡単な答えは次のとおりです。

  • $ this にはクラスのインスタンスが必要です
  • self :: はありません

静的メソッドまたは静的属性を使用しており、クラスのオブジェクトをインスタンス化せずにそれらを呼び出す場合は、必ず self :: <を使用する必要があります/ strong>を呼び出します。これは、 $ this で常にオブジェクトを作成する必要があるためです。

クラスのオブジェクト/インスタンスを作成せずにクラスのメソッドを呼び出し、 RAM （その目的でselfを使用する場合があります）。つまり、実際にはメソッドを静的に呼び出しています。オブジェクトのパースペクティブには this を使用します。

ケース1：クラス定数には self を使用できます

 class classA { 
     const FIXED_NUMBER = 4; 
     self::POUNDS_TO_KILOGRAMS
}

クラスの外部で呼び出す場合、 classA :: POUNDS_TO_KILOGRAMS を使用して定数にアクセスします

ケース2：静的プロパティの場合

class classC {
     public function __construct() { 
     self::
ケース1：クラス定数には self を使用できます



 class classA { 
     const FIXED_NUMBER = 4; 
     self::POUNDS_TO_KILOGRAMS
}




クラスの外部で呼び出す場合、 classA :: POUNDS_TO_KILOGRAMS を使用して定数にアクセスします



ケース2：静的プロパティの場合


<*>counter++; $this->num = self::
ケース1：クラス定数には self を使用できます



 class classA { 
     const FIXED_NUMBER = 4; 
     self::POUNDS_TO_KILOGRAMS
}




クラスの外部で呼び出す場合、 classA :: POUNDS_TO_KILOGRAMS を使用して定数にアクセスします



ケース2：静的プロパティの場合


<*>counter;
   }
}

php.netによると、このコンテキストには3つの特別なキーワードがあります： self 、 parent 、および static 。クラス定義内からプロパティまたはメソッドにアクセスするために使用されます。

一方、

$ this は、そのクラスがアクセス可能である限り、任意のクラスのインスタンスとメソッドを呼び出すために使用されます。

ライセンス： CC-BY-SA と 帰属
所属していません StackOverflow
scroll top