blocks|key|658479|text|主要原因是您不需要键入那么多内容。比方说，您可以将它们用于ORM记录，并充当隐式setter/getter：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|658480|使用__call()|offset|length|style|CODE|658481|$user+=+new+User();
$user->setName("Foo+Bar");
$user->setAge(42);
$user->save();|code-block|syntax|javascript|658482|使用__set()|658483|$user->name+=+"Foo+Bar";
$user->age+=+42;|658484|它映射到一个简单的数组：|658485|array(
++++"name"+=>+"Foo+Bar",
++++"age"++=>+42
)|658486|将这样的数组写入数据库要比进行大量手动调用来收集所有需要的信息容易得多。与公共成员相比，__set()和__get()还有另一个优势:您可以验证/格式化数据。|658487|entityMap^0|0|2|8|0|0|2|7|0|0|0|0|18|7|1G|7|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|Z|8|@$D|10|E|11|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|12|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|13|8|@$D|14|E|15|F|G]]|9|@]|A|$]]|$1|O|3|P|5|J|7|16|8|@]|9|@]|A|$K|L]]|$1|Q|3|R|5|6|7|17|8|@]|9|@]|A|$]]|$1|S|3|T|5|J|7|18|8|@]|9|@]|A|$K|L]]|$1|U|3|V|5|6|7|19|8|@$D|1A|E|1B|F|G]|$D|1C|E|1D|F|G]]|9|@]|A|$]]|$1|W|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|X|$]]

The main reason is that you do not need to type as much. You could use them for, say, an ORM record and act as implicit setters/getters:

using <code>__call()</code>:

<pre><code>$user = new User();
$user-&gt;setName("Foo Bar");
$user-&gt;setAge(42);
$user-&gt;save();
</code></pre>

using <code>__set()</code>:

<pre><code>$user-&gt;name = "Foo Bar";
$user-&gt;age = 42;
</code></pre>

which maps to a simple array:

<pre><code>array(
 "name" =&gt; "Foo Bar",
 "age" =&gt; 42
)
</code></pre>

It is much easier to write such an array to the database than doing a lot of manual calls to collect all needed information. <code>__set()</code> and <code>__get()</code> have another advantage over public members: You are able to validate/format your data.

blocks|key|658565|text|__call()|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|CODE|entityRanges|data|658566|我见过它用于实现行为，就像通过可插拔接口向类添加额外的函数一样。|658567|伪代码如下：|658568|$method+=+function($self)+{};
$events->register('object.method',+$method);
$entity->method();+//+$method($this);|code-block|syntax|javascript|658569|它还使得编写大多数类似的函数变得更容易，比如在ORM中。例如：|658570|$entity->setName('foo');+//+set+column+name+to+'foo'|658571|__get()/__set()|658572|我主要看到它被用来包装对私有变量的访问。|658573|ORM是脑海中浮现的最好的例子：|658574|$entity->name+=+'foo';+//+set+column+name+to+'foo'|658575|entityMap^0|0|8|0|8|0|0|0|0|0|0|0|F|0|F|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|D]]|E|@]|F|$]]|$1|G|3|H|5|6|7|18|8|@]|E|@]|F|$]]|$1|I|3|J|5|6|7|19|8|@]|E|@]|F|$]]|$1|K|3|L|5|M|7|1A|8|@]|E|@]|F|$N|O]]|$1|P|3|Q|5|6|7|1B|8|@]|E|@]|F|$]]|$1|R|3|S|5|M|7|1C|8|@]|E|@]|F|$N|O]]|$1|T|3|U|5|6|7|1D|8|@$9|1E|A|1F|B|C]|$9|1G|A|1H|B|D]]|E|@]|F|$]]|$1|V|3|W|5|6|7|1I|8|@]|E|@]|F|$]]|$1|X|3|Y|5|6|7|1J|8|@]|E|@]|F|$]]|$1|Z|3|10|5|M|7|1K|8|@]|E|@]|F|$N|O]]|$1|11|3|-4|5|6|7|1L|8|@]|E|@]|F|$]]]|12|$]]

<code>__call()</code>

I've seen it used to implement behaviors, as in add extra functions to a class through a pluginable interface.

Pseudo-code like so:

<pre><code>$method = function($self) {};
$events-&gt;register('object.method', $method);
$entity-&gt;method(); // $method($this);
</code></pre>

It also makes it easier to write mostly similar functions, such as in ORMs. e.g.:

<pre><code>$entity-&gt;setName('foo'); // set column name to 'foo'
</code></pre>

<code>__get()/__set()</code>

I've mostly seen it used to wrap access to private variables.

ORMs are the best example that comes to mind:

<pre><code>$entity-&gt;name = 'foo'; // set column name to 'foo'
</code></pre>

blocks|key|2561461|text|因为魔术方法可以在重复的任务中节省大量的编码，比如定义成员，填充它们，然后检索它们--而不是做那些无聊的，冗长的工作，你可以使用上面提到的3种方法来缩短编写所有这些代码的时间。如果需要，我可以提供几个例子，它们可以在网上的各种教程中找到。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2561462|我不知道这是否是普遍的共识，但通常应该适用-在适当的地方使用。如果你发现自己在做重复的任务(定义成员，填充成员，获取成员，调用X个稍有不同的函数)-神奇的方法可能会帮助你。|2561463|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Since magic methods can save you a LOT of coding when it comes to repetitive tasks like defining members, populating them and then retrieving them - instead of doing that boring, long piece of work, you can use mentioned 3 methods to shorten the time to code all that. If needed, I can provide a few examples tho they can be found in various tutorials over the net.

I don't know if it's general consensus, but the usual should apply - use where appropriate. If you find yourself to do repetitive task (define member, populate member, get member, call X functions that differ slightly) - magic methods might help you.

blocks|key|2278562|text|一种常见的模式是为客户端提供单个句柄，并根据命名约定或配置将调用代理到封装的对象或单例。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2278563|class+db
{
++++static+private+$instance+=+null;

++++static+public+function+getInstance()
++++{
++++++++if(+self::$instance+==+NULL+)
++++++++++++self::$instance+=+new+db;

++++++++return+self::$instance;
++++}

++++function+fetch()
++++{
++++++++echo+"I'm+fetching\n";
++++}
}

class+dataHandler
{
++++function+__call($name,+$argv)
++++{
++++++++if(+substr($name,+0,+4)+==+'data'+)
++++++++{
++++++++++++$fn+=+substr($name,+4);
++++++++++++db::getInstance()->$fn($argv);
++++++++}
++++}
}

$dh+=+new+dataHandler;
$dh->datafetch('foo',+'bar');|code-block|syntax|javascript|2278564|可以使用相同的原则来驱动相同功能的不同后端，而不必更改驱动程序。|2278565|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

One common pattern is to have a single handle for your clients and proxy the calls to encapsulated objects or singletons based on naming conventions or configurations.

<pre><code>class db
{
 static private $instance = null;

 static public function getInstance()
 {
 if( self::$instance == NULL )
 self::$instance = new db;

 return self::$instance;
 }

 function fetch()
 {
 echo "I'm fetching\n";
 }
}

class dataHandler
{
 function __call($name, $argv)
 {
 if( substr($name, 0, 4) == 'data' )
 {
 $fn = substr($name, 4);
 db::getInstance()-&gt;$fn($argv);
 }
 }
}

$dh = new dataHandler;
$dh-&gt;datafetch('foo', 'bar');
</code></pre>

Same principles can be used to drive different backends of the same functionality without having to change the driver.

blocks|key|2561540|text|它允许你这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2561541|class+myclass+{
++++private+$propertybag;

++++public+function+__get($name)+{
++++++++if(isset($this->propertybag[$name])+{return+$this->propertybag[$name];}
++++++++throw+new+Exception("Unknown+property+"+.+(string)+$name);
++++}

+}|code-block|syntax|javascript|2561542|然后，您可以在一行中从SQL查询填充$propertybag，而不是一个接一个地设置一大堆属性。|offset|length|style|CODE|2561543|此外，它还允许您拥有特定的属性，这些属性是只读的(即不允许通过__set()修改)。例如，可能对ID字段有用。|2561544|此外，您还可以将代码放入__get()和__set()中，这样您就可以做一些比获取或设置单个变量更复杂的事情。例如，如果您有一个storeID字段，您可能还想提供一个storeName属性。您可以通过交叉引用查找在__get()中实现它，因此您可能不需要将名称实际存储在类中。当然，不希望在__get()中实现storeName。|2561545|有很多可能性。|2561546|当然，使用魔法方法也有一些缺点。对我来说，最大的问题是你失去了IDE中的自动完成功能。这对你可能重要，也可能无关紧要。|2561547|entityMap^0|0|0|I|C|0|V|7|0|C|7|K|7|1S|7|2B|9|2Z|7|41|7|4B|9|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@$I|12|J|13|K|L]]|9|@]|A|$]]|$1|O|3|P|5|6|7|14|8|@$I|15|J|16|K|L]|$I|17|J|18|K|L]|$I|19|J|1A|K|L]|$I|1B|J|1C|K|L]|$I|1D|J|1E|K|L]|$I|1F|J|1G|K|L]|$I|1H|J|1I|K|L]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1J|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1K|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|V|$]]

It allows you to do things like this:

<pre><code>class myclass {
 private $propertybag;

 public function __get($name) {
 if(isset($this-&gt;propertybag[$name]) {return $this-&gt;propertybag[$name];}
 throw new Exception("Unknown property " . (string) $name);
 }

 }
</code></pre>

Then you can populate <code>$propertybag</code> from a SQL query in a single line, rather than setting a whole bunch of properties one by one.

Also, it allows you to have specific properties which are read-only (ie don't allow them to be modified via <code>__set()</code>). Maybe useful for an ID field, for example.

Also, you can put code into <code>__get()</code> and <code>__set()</code>, so you can do something more complex than just getting or setting a single variable. For example, if you have a <code>storeID</code> field, you may also want to provide a <code>storeName</code> property. You could implement that in <code>__get()</code> via a cross-reference lookup, so you may not need the name actually to be stored in the class. And of course <code>storeName</code> would not want to be implemented in <code>__get()</code>.

Lots of possibilities there.

There are of course some down-sides of using magic methods. The biggest one for me is the fact that you lose the auto-complete functionality in your IDE. This may or may not matter to you.

blocks|key|4353499|text|只要您愿意，只要魔术属性/方法被记录在案；除非使用非常抽象的代码层，例如在开发ORM时，否则应该避免未记录的魔术。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4353500|抽象层可接受的|4353501|/**
+*+DB+backed+model+base+class.
+*/
class+Model+{
++++protected+$attributes+=+[];

++++function+__get($name)+{
++++++++return+@$this->attributes[$name];
++++}
}|code-block|syntax|javascript|4353502|文档化时可接受|offset|length|style|BOLD|4353503|/**
+*+User+model+backed+by+DB+tables.
+*+@property-read+string+$first_name
+*+@property-read+string+$last_name
+*/
class+UserModel+extends+Model+{

}|4353504|懒惰和不可接受(在使用ORM时很常见)|4353505|/**
+*+This+class+is+magical+and+awesome+and+I+am+a+lazy+shithead!
+*/
class+UserModel+extends+WhoCaresWhenEverythingIsMagical+{

}|4353506|entityMap^0|0|0|0|0|3|0|0|0|J|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]]|9|@]|A|$]]|$1|O|3|P|5|F|7|12|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|13|8|@$K|14|L|15|M|N]]|9|@]|A|$]]|$1|S|3|T|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

Whenever you'd like, as long as the magic properties/methods are documented; undocumented magic should be avoided unless working with a very abstract layer of code, such as when developing an ORM.

acceptable at an abstract layer

<pre><code>/**
 * DB backed model base class.
 */
class Model {
 protected $attributes = [];

 function __get($name) {
 return @$this-&gt;attributes[$name];
 }
}
</code></pre>

acceptable when documented

<pre><code>/**
 * User model backed by DB tables.
 * @property-read string $first_name
 * @property-read string $last_name
 */
class UserModel extends Model {

}
</code></pre>

lazy and unacceptable (and common when using ORMs)

<pre><code>/**
 * This class is magical and awesome and I am a lazy shithead!
 */
class UserModel extends WhoCaresWhenEverythingIsMagical {

}
</code></pre>

I've generally tried to stay away from PHP's magic methods because they seem to obfuscate an object's public interface. That said, they seem to be used more and more, at least, in the code I've read, so I have to ask: is there any consensus on when to use them? Are there any common patterns for using these three magic methods?

Practical applications of PHP magic methods - __get, __set, and __call

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我通常尽量避免使用PHP的魔术方法，因为它们似乎混淆了对象的公共接口。也就是说，它们似乎越来越多地被使用，至少在我读过的代码中是这样，所以我不得不问:在什么时候使用它们有什么共识吗？使用这三种神奇方法有什么共同的模式吗？

问PHP魔术方法的实际应用- get、set和__call
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问PHP魔术方法的实际应用- __get、__set和__callEN