blocks|key|1311700|text|就我个人而言，我不喜欢这个成语。如果需要的话，我更喜欢有一个很长的参数列表。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1311701|问题是，我不能通过查看函数签名来知道数组不能接受的元素。最重要的是，实现几乎不会检查是否有任何键无法识别，所以如果我错误地拼写了数组键，我就不会收到任何警告。|1311702|更好的替代方法是传递一个配置对象。至少，IDE可以提供有关可用配置对象的提示，并且可以将计算出的缺少选项的默认值从您向配置对象中的getter显示的构造函数中移出。一种显而易见的替代方法是为几个配置选项提供setter；尽管这对每个选项所需的setter没有帮助，但不能提供默认值。|1311703|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Personally, I dislike that idiom. I prefer to have a long parameter list instead, if necessary.

The problem is that I can't know the elements the array can't take by looking at the function signature. On top of that, the implementations almost never check if there's any key that's not recognized, so if I mispell an array key, I get no warning.

A better alternative would be passing a configuration object. At least, there the IDE can provide me hints on the available configuration objects and the calculated default values for missing options can be moved away from the constructor you show to the getters in the configuration object. The obvious alternative is to provide setters for the several configuration options; though this doesn't help for the required ones for each no default can be provided.

blocks|key|2098851|text|我非常喜欢“选项数组”的设计模式。如果PHP支持Python的参数扩展，那么我会同意使用长参数列表。但是我发现foo(1,+2,+'something',+true,+23,+array(4),+$bar);真的很难读。当需要设置的参数超过3到4个时，我通常会使用数组……|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2098852|为了“清理”构造函数，我建议创建一个受保护的方法来访问配置变量(最好是在基类中)：|2098853|abstract+class+Configurable+{
++++protected+$options+=+array();
++++protected+$requiredOptions+=+array();

++++public+function+__construct(array+$options+=+array())+{
++++++++$this->options+=+$options;
++++++++foreach+($this->requiredOptions+as+$option)+{
++++++++++++if+(!isset($this->options[$option]))+{
++++++++++++++++throw+new+InvalidArgumentException('Required+argument+[$'.$option.']+was+not+set');
++++++++++++}
++++++++}
++++}

++++protected+function+_getOption($key,+$default+=+null)+{
++++++++return+isset($this->options[$key])+?+$this->options[$key]+:+$default;
++++}
}|code-block|syntax|javascript|2098854|然后，在您的类中，可以重载requireOptions数组来定义需要设置的内容|2098855|class+Foo+extends+Configurable+{
++++protected+$requiredOptions+=+array(
++++++++'db',
++++++++'foo',
++++);

++++public+function+__construct(array+$options+=+array())+{
++++++++parent::__construct($options);
++++++++if+($this->_getOption('bar',+false))+{
++++++++++++//Do+Something
++++++++}
++++}
}|2098856|有一件事。如果执行此操作，请记录所需的选项。这将使那些关注你的人的生活变得容易得多。|BOLD|2098857|entityMap^0|1J|1D|0|0|0|0|0|5|11|0^^$0|@$1|2|3|4|5|6|7|V|8|@$9|W|A|X|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Y|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Z|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|10|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|11|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|12|8|@$9|13|A|14|B|S]]|D|@]|E|$]]|$1|T|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|U|$]]

I very much like the design pattern of "options arrays". If PHP supported Python's argument expansion, then I would agree to go with a long parameter list. But I just find <code>foo(1, 2, 'something', true, 23, array(4), $bar);</code> to be REALLY un-readable. I typically will use arrays when there are more than about 3 or 4 parameters that need to be set...

What I would suggest to "clean up" the constructor, is create a protected method for accessing config vars (preferably in a base class):

<pre><code>abstract class Configurable {
 protected $options = array();
 protected $requiredOptions = array();

 public function __construct(array $options = array()) {
 $this-&gt;options = $options;
 foreach ($this-&gt;requiredOptions as $option) {
 if (!isset($this-&gt;options[$option])) {
 throw new InvalidArgumentException('Required argument [$'.$option.'] was not set');
 }
 }
 }

 protected function _getOption($key, $default = null) {
 return isset($this-&gt;options[$key]) ? $this-&gt;options[$key] : $default;
 }
}
</code></pre>

Then, in your class, you can overload the requireOptions array to define things that need to be set

<pre><code>class Foo extends Configurable {
 protected $requiredOptions = array(
 'db',
 'foo',
 );

 public function __construct(array $options = array()) {
 parent::__construct($options);
 if ($this-&gt;_getOption('bar', false)) {
 //Do Something
 }
 }
}
</code></pre>

One thing. If you do this, PLEASE document the options required. It will make life a lot easier for those that follow you.

blocks|key|3506717|text|我发现当有很多可选参数时，使用数组作为参数会很有帮助。通常我会使用array_merge将传递的数组与"defaults“数组合并。不需要检查。如果您有必需的参数，可以使用array_diff_key来确定是否缺少任何必需的参数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3506718|function+params($p_array)+{
++++static+$default_vals+=+array('p1'=>1,+'p2'=>null,+'p3'=>'xyz');
++++static+$rqd_params+=+array('p1'=>null,+'p3'=>null);
++++//+check+for+missing+required+params
++++$missing_params+=+array_diff_key($rqd_params,+$p_array);
++++if+(+count($missing_params)>0+)+{
+++++++//return+an+error+(i.e.+missing+fields)
+++++++return+array_keys($missing_params);
++++}
++++//+Merge+passed+params+and+override+defaults
++++$p_array+=+array_merge($default_vals,+$p_array);
}|code-block|syntax|javascript|3506719|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I find using arrays as parameters to be helpful when there are a lot of optional parameters. Usually I'll use an array_merge to merge the passed array with the "defaults" array. No checking required. If you have required parameters, you can use array_diff_key to determine if any required parameters are missing.

<pre><code>function params($p_array) {
 static $default_vals = array('p1'=&gt;1, 'p2'=&gt;null, 'p3'=&gt;'xyz');
 static $rqd_params = array('p1'=&gt;null, 'p3'=&gt;null);
 // check for missing required params
 $missing_params = array_diff_key($rqd_params, $p_array);
 if ( count($missing_params)&gt;0 ) {
 //return an error (i.e. missing fields)
 return array_keys($missing_params);
 }
 // Merge passed params and override defaults
 $p_array = array_merge($default_vals, $p_array);
}
</code></pre>

I often see this idiom when reading php code:

<pre><code>public function __construct($config)
{
 if (array_key_exists('options', $config)) {
 ...
 }
 if (array_key_exists('driver_options', $config)) {
 ...
 }
}
</code></pre>

Here I am concern with the way the parameter is used.
If I were in lisp I would do:

<pre><code>(defun ct (&amp;key options driver_options) 
 (do-something-with-option-and-driver_option))
</code></pre>

But since I am in PHP I would rather have a constructor that take a list of parameter and let them be null if there a not require.

So what do you guys think about having an array as parameter in other to do some initialization-or-whatever?

In other to answer you have to take in account the point of view of the user of the function and the designer of the API.

Passing an array for setting variable

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

在阅读php代码时，我经常看到这个成语：public function __construct($config){    if (array_key_exists('options', $config)) {       ...    }    if (array_key_exists('driver_options'...

问传递用于设置变量的数组
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问传递用于设置变量的数组EN