Refactoring of PHP multi-parameter methods (code example)

Suppose we want to complete a function of saving articles. If we use functional programming, it will probably look like this:

<?php
function saveArticle($title, $content, $categoryId)
{
    // ...
}
?>

Each parameter represents an attribute, but it brings a problem. The parameter list will became very long. At this time, it would be a good idea to use object programming technology:

<?php
class Article
{
    var $title;
    var $content;
    var $categoryId;
    function save()
    {
        // ...
    }
}
?>

Here, the original method parameters are converted into attributes of the object, thus greatly reducing the number of method parameters. Most of the time, this method is good, but not all parameters are suitable to exist in the form of object attributes. The principle of differentiation is to see whether these parameters belong to the intrinsic attributes or external characteristics of the object. If they are not distinguished, they will all be converted into Object properties, which would make the object itself meaningless.

For example, our Article object also has a method named find. When using it, parameters such as limit, offset, order, etc. may be involved:

<?php
class Article
{
    var $title;
    var $content;
    var $categoryId;
    var $limit = 10;
    var $offset = 0;
    var $order = &#39;created DESC&#39;;
    function save()
    {
        // ...
    }
    function find($categoryId)
    {
        // ...
    }
}
?>

As shown above, Once we convert parameters such as limit, offset, and order into attributes of the object, the object itself becomes nondescript, because although title, content, and categoryId can be counted as intrinsic attributes of the object, limit, offset, and order are not. At best, they can only be regarded as external characteristics. The result of not distinguishing them is basically the beginning of a nightmare. Therefore, it is better to honestly put the external characteristics into the parameters of the method (more strictly speaking, the find method should be a static type method, but the text is a simple explanation, no need to go into detail):

<?php
class Article
{
    var $title;
    var $content;
    var $categoryId;
    function save()
    {
        // ...
    }
    function find($categoryId, $limit = 10, $offset = 0, $order = &#39;created DESC&#39;)
    {
        // ...
    }
}
?>
可惜如此一来又出现了文章开头所说的问题，find方法的参数太多了，缺乏可读性，所以还得重构：
<?php
class Article
{
    var $title;
    var $content;
    var $categoryId;
    function save()
    {
        // ...
    }
    function find($categoryId, $options = array())
    {
        $default = array(
            &#39;limit&#39; => 10,
            &#39;offset&#39; => 0,
            &#39;order&#39; => &#39;created DESC&#39;
        );
        $options = array_merge($default, (array)$options);
         // ...
    }
}
?>

Looks pretty good. You can use a method similar to the following when calling:

$article->find(123, array('limit' => 20));

Simply put, it uses array parameters to simulate an effect similar to keyword parameters. In this way If so, you can use the key names of the array to describe the function of the parameters, thereby increasing the readability of the code. Refactoring methods like this are widely used in projects such as CakePHP. If you understand it carefully, you can instinctively write highly readable code when writing code in the future.

Supplement: Compared to array_merge, using $options = $default; is also a good choice. In addition, if the logic of options is very complex, you can also use an array instead of an array to encapsulate the logical operations using a special object.

The above is the detailed content of Refactoring of PHP multi-parameter methods (code example). For more information, please follow other related articles on the PHP Chinese website!