blocks|key|1520098|text|在类定义中，$this指的是当前对象，而self指的是当前类。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1520099|有必要使用self引用类元素，使用$this引用对象元素。|1520100|self::STAT+//+refer+to+a+constant+value
self::$stat+//+static+variable
$this->stat+//+refer+to+an+object+variable++|code-block|syntax|javascript|1520101|entityMap^0|6|5|K|4|0|5|4|H|5|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|N|$]]

Inside a class definition, <code>$this</code> refers to the current object, while <code>self</code> refers to the current class.

It is necessary to refer to a class element using <code>self</code>, and refer to an object element using <code>$this</code>.

<pre><code>self::STAT // refer to a constant value
self::$stat // static variable
$this-&gt;stat // refer to an object variable 
</code></pre>

blocks|key|1520017|text|我认为问题不在于是否可以通过调用ClassName::staticMember来调用类的静态成员。问题是使用self::classmember和$this->classmember有什么不同。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1520018|例如，无论您使用self::还是$this->，以下两个示例都可以正常工作|1520019|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;
++++}
}|code-block|syntax|javascript|1520020|entityMap^0|G|N|1I|H|20|I|0|8|6|G|7|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]|$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|V|8|@$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|N|$]]

I believe the question was not whether you can call the static member of the class by calling <code>ClassName::staticMember</code>. The question was what's the difference between using <code>self::classmember</code> and <code>$this-&gt;classmember</code>.
For example, both of the following examples work without any errors, whether you use <code>self::</code> or <code>$this-&gt;</code>
<pre><code>class Person{
 private $name;
 private $address;

 public function __construct($new_name,$new_address){
 $this-&gt;name = $new_name;
 $this-&gt;address = $new_address;
 }
}

class Person{
 private $name;
 private $address;
 public function __construct($new_name,$new_address){
 self::$name = $new_name;
 self::$address = $new_address;
 }
}
</code></pre>

blocks|key|1735483|text|self指的是当前类(在其中被调用)，|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1735484|$this指的是当前对象。您可以使用static而不是self。|1735485|请参见示例：|1735486|class+ParentClass+{
++++function+test()+{
++++++++self::which();++++//+Outputs+'parent'
++++++++$this->which();+++//+Outputs+'child'
++++}

++++function+which()+{
++++++++echo+'parent';
++++}
}

class+ChildClass+extends+ParentClass+{
++++function+which()+{
++++++++echo+'child';
++++}
}

$obj+=+new+ChildClass();
$obj->test();|code-block|syntax|javascript|1735487|输出：|1735488|+parent
+child|1735489|entityMap^0|0|4|0|0|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|11|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|12|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|13|8|@]|D|@]|E|$M|N]]|$1|S|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|T|$]]

<code>self</code> refers to the current class (in which it is called),
<code>$this</code> refers to the current object.
You can use static instead of self.
See the example:
<pre><code>class ParentClass {
 function test() {
 self::which(); // Outputs 'parent'
 $this-&gt;which(); // Outputs 'child'
 }

 function which() {
 echo 'parent';
 }
}

class ChildClass extends ParentClass {
 function which() {
 echo 'child';
 }
}

$obj = new ChildClass();
$obj-&gt;test();
</code></pre>
Output:
<pre><code> parent
 child
</code></pre>

blocks|key|1520276|text|这是一个小的基准测试(repl.it上的7.2.24)：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1520277|++++++++++++Speed+(in+seconds)++Percentage
$this->+++++0.91760206222534++++100
self::++++++1.0047659873962+++++109.49909865716
static::++++0.98066782951355++++106.87288857386|code-block|syntax|javascript|1520278|4000000次运行的结果。结论:这并不重要。下面是我使用的代码：|1520279|<?php

class+Foo
{
++public+function+calling_this()+{+$this->called();+}
++public+function+calling_self()+{+self::called();+}
++public+function+calling_static()+{+static::called();+}
++public+static+function+called()+{}
}

$foo+=+new+Foo();
$n+=+4000000;
$times+=+[];

//+warmup
for+($i+=+0;+$i+<+$n;+$i%2B%2B)+{+$foo->calling_this();+}
for+($i+=+0;+$i+<+$n;+$i%2B%2B)+{+$foo->calling_self();+}
for+($i+=+0;+$i+<+$n;+$i%2B%2B)+{+$foo->calling_static();+}

$start+=+microtime(true);
for+($i+=+0;+$i+<+$n;+$i%2B%2B)+{+$foo->calling_this();+}
$times["this"]+=+microtime(true)-$start;

$start+=+microtime(true);
for+($i+=+0;+$i+<+$n;+$i%2B%2B)+{+$foo->calling_self();+}
$times["self"]+=+microtime(true)-$start;

$start+=+microtime(true);
for+($i+=+0;+$i+<+$n;+$i%2B%2B)+{+$foo->calling_static();+}
$times["static"]+=+microtime(true)-$start;

$min+=+min($times);
echo+$times["this"]+.+"\t"+.+($times["this"]+/+$min)*100+.+"\n";
echo+$times["self"]+.+"\t"+.+($times["self"]+/+$min)*100+.+"\n";
echo+$times["static"]+.+"\t"+.+($times["static"]+/+$min)*100+.+"\n";|1520280|entityMap|0|LINK|mutability|MUTABLE|url|https://repl.it/repls/FewUnacceptableObservatory^0|B|7|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

Here is a small benchmark (7.2.24 on <a href="https://repl.it/repls/FewUnacceptableObservatory" rel="nofollow noreferrer">repl.it</a>):
<pre><code> Speed (in seconds) Percentage
$this-&gt; 0.91760206222534 100
self:: 1.0047659873962 109.49909865716
static:: 0.98066782951355 106.87288857386
</code></pre>
Results for 4 000 000 runs. Conclusion: it doesn't matter. And here is the code I used:
<pre><code>&lt;?php

class Foo
{
 public function calling_this() { $this-&gt;called(); }
 public function calling_self() { self::called(); }
 public function calling_static() { static::called(); }
 public static function called() {}
}

$foo = new Foo();
$n = 4000000;
$times = [];

// warmup
for ($i = 0; $i &lt; $n; $i++) { $foo-&gt;calling_this(); }
for ($i = 0; $i &lt; $n; $i++) { $foo-&gt;calling_self(); }
for ($i = 0; $i &lt; $n; $i++) { $foo-&gt;calling_static(); }

$start = microtime(true);
for ($i = 0; $i &lt; $n; $i++) { $foo-&gt;calling_this(); }
$times[&quot;this&quot;] = microtime(true)-$start;

$start = microtime(true);
for ($i = 0; $i &lt; $n; $i++) { $foo-&gt;calling_self(); }
$times[&quot;self&quot;] = microtime(true)-$start;

$start = microtime(true);
for ($i = 0; $i &lt; $n; $i++) { $foo-&gt;calling_static(); }
$times[&quot;static&quot;] = microtime(true)-$start;

$min = min($times);
echo $times[&quot;this&quot;] . &quot;\t&quot; . ($times[&quot;this&quot;] / $min)*100 . &quot;\n&quot;;
echo $times[&quot;self&quot;] . &quot;\t&quot; . ($times[&quot;self&quot;] / $min)*100 . &quot;\n&quot;;
echo $times[&quot;static&quot;] . &quot;\t&quot; . ($times[&quot;static&quot;] / $min)*100 . &quot;\n&quot;;
</code></pre>

blocks|key|1735083|text|当self与::操作符一起使用时，它引用当前类，这可以在静态和非静态上下文中完成。$this指的是对象本身。此外，使用$this调用静态方法(但不引用字段)是完全合法的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1735084|entityMap^0|1|4|6|2|15|5|1N|5|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

When <code>self</code> is used with the <code>::</code> operator it refers to the current class, which can be done both in static and non-static contexts. <code>$this</code> refers to the object itself. In addition, it is perfectly legal to use <code>$this</code> to call static methods (but not to refer to fields).

blocks|key|1520141|text|$this指的是当前类对象，self指的是当前类(不是object)。类是对象的蓝图。所以你定义了一个类，但是你构造了对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1520142|因此，换句话说，使用self+for+static和this+for+none-static+members+or+methods。|1520143|此外，在子/父场景中，self+/+parent主要用于标识子和父类成员和方法。|1520144|entityMap^0|0|5|E|4|0|A|F|Q|13|0|B|D|0^^$0|@$1|2|3|4|5|6|7|L|8|@$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|J|3|-4|5|6|7|Y|8|@]|D|@]|E|$]]]|K|$]]

<code>$this</code> refers to the current class object, and <code>self</code> refers to the current class (Not object). The class is the blueprint of the object. So you define a class, but you construct objects.
So in other words, use <code>self for static</code> and <code>this for none-static members or methods</code>.
Also in a child/parent scenario, <code>self / parent</code> is mostly used to identify child and parent class members and methods.

blocks|key|1735276|text|另外，因为$this::还没有被讨论过。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1735277|仅出于提供信息的目的，在PHP5.3中，当处理实例化的对象以获取当前作用域值时，可以像这样使用$this::，而不是使用static::。|1735278|http://ideone.com/7etRHy|1735279|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|code-block|syntax|javascript|1735280|使用上面的代码并不是常见的或推荐的做法，而只是为了说明它的用法，并且更像是一种“你知道吗？”关于原始发帖者的问题。|1735281|它还表示$object::CONSTANT的用法，例如echo+$foo::NAME;，而不是$this::NAME;|1735282|entityMap|0|LINK|mutability|MUTABLE|url^0|5|7|0|1B|7|1O|8|0|0|O|0|0|0|0|4|H|R|G|1B|C|0^^$0|@$1|2|3|4|5|6|7|Z|8|@$9|10|A|11|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|12|8|@$9|13|A|14|B|C]|$9|15|A|16|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|17|8|@]|D|@$9|18|A|19|1|1A]]|E|$]]|$1|J|3|K|5|L|7|1B|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1C|8|@]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|C]|$9|1I|A|1J|B|C]]|D|@]|E|$]]|$1|S|3|-4|5|6|7|1K|8|@]|D|@]|E|$]]]|T|$U|$5|V|W|X|E|$Y|I]]]]

Additionally since <code>$this::</code> has not been discussed yet.

For informational purposes only, as of PHP 5.3 when dealing with instantiated objects to get the current scope value, as opposed to using <code>static::</code>, one can alternatively use <code>$this::</code> like so.

<a href="http://ideone.com/7etRHy" rel="noreferrer">http://ideone.com/7etRHy</a>

<pre><code>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-&gt;getStaticName(); //outputs Foo
$bar-&gt;getStaticName(); //outputs FooBar
$foo-&gt;getStaticName(); //outputs FooBar
</code></pre>

Using the code above is not common or recommended practice, but is simply to illustrate its usage, and is to act as more of a "Did you know?" in reference to the original poster's question.

It also represents the usage of <code>$object::CONSTANT</code> for example <code>echo $foo::NAME;</code> as opposed to <code>$this::NAME;</code>

blocks|key|1520062|text|如果您想调用类的方法而不创建该类的对象/实例，则使用self，从而节省RAM+(有时使用self实现此目的)。换句话说，它实际上是静态地调用一个方法。将this用于对象透视图。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1520063|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Random-access_memory^0|Q|4|24|4|Z|3|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]]|D|@$9|S|A|T|1|U]]|E|$]]|$1|F|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Use <code>self</code> if you want to call a method of a class without creating an object/instance of that class, thus saving <a href="http://en.wikipedia.org/wiki/Random-access_memory" rel="nofollow noreferrer">RAM</a> (sometimes use self for that purpose). In other words, it is actually calling a method statically. Use <code>this</code> for object perspective.

blocks|key|1520326|text|根据php.net的说法，在这种情况下有三个特殊的关键字：self，parent和static。它们用于从类定义内部访问属性或方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1520327|另一方面，$this用于调用任何类的实例和方法，只要该类是可访问的。|1520328|entityMap^0|T|4|Y|6|15|6|0|5|5|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|I|$]]

According to php.net there are three special keywords in this context: <code>self</code>, <code>parent</code> and <code>static</code>. They are used to access properties or methods from inside the class definition.

<code>$this</code>, on the other hand, is used to call an instance and methods of any class as long as that class is accessible.

In PHP 5, what is the difference between using <code>self</code> and <code>$this</code>?

When is each appropriate?

When should I use 'self' over '$this'?

在PHP5中，使用self和$this有什么不同什么时候是合适的？

问什么时候我应该使用'self‘而不是'$this'？
EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候我应该使用'self‘而不是'$this'？EN

回答 9

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问什么时候我应该使用'self‘而不是'$this'？
EN