{"id":35,"date":"2017-05-31T19:16:00","date_gmt":"2017-05-31T19:16:00","guid":{"rendered":""},"modified":"2019-03-12T20:10:16","modified_gmt":"2019-03-12T20:10:16","slug":"do-not-use-boolean-parameters","status":"publish","type":"post","link":"https:\/\/ntlx.org\/de\/2017\/05\/do-not-use-boolean-parameters.html","title":{"rendered":"Do Not Use Boolean Parameters"},"content":{"rendered":"

I’m absolutely serious, don’t do it. “But hey”, one may ask, “what’s wrong with boolean parameters?” That’s what I got asked recently when I did a code review. And to all of you who have the same question in mind, here is my answer.
There is only one reason to use a boolean parameter in a function interface, and that’s when it’s the only parameter – in a setter function (and even there one could argue to not use it).<\/p>\n

Unreadable Function Calls<\/h2>\n

Let’s take a look at a first example:
<\/p>\n

\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12<\/pre>\n<\/td>\n
\n
#include <iostream><\/span>
#include \"concat.h\"<\/span>
#include <string><\/span>
#include <vector><\/span>

int<\/span> main<\/span> ()
{
    Concat concat;
    std::<\/span>vector<<\/span>const<\/span> std::<\/span>string><\/span> values {\"Line One\"<\/span>, \"Line Two\"<\/span>, \"Line Three\"<\/span>};
    std::<\/span>cout <<<\/span> concat.concatVector(values, false<\/span>, true<\/span>);
    return<\/span> 0<\/span>;
}
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
In line 10 you can see a call to the function concatVector which seems to be used to concat all the values of a vector to a single string. But what are those 2 boolean parameters passed? To find out what they are used for you have to take a look at the declaration of that function. (Or, depending on the IDE you are using, at least hover over the function call to see the names of that parameters, while hoping the names are speaking) Here is the corresponding header file:
<\/p>\n
\n\n\n\n
\n
1
2
3
4
5
6
7<\/pre>\n<\/td>\n
\n
#include <vector><\/span>
class<\/span> Concat<\/span> {
    public:<\/span>
        const<\/span> std::<\/span>string concatVector(const<\/span> std::<\/span>vector<<\/span>const<\/span> std::<\/span>string><\/span> strings, const<\/span> bool<\/span> unixStyle, const<\/span> bool<\/span> endWithNewline);
    private:<\/span>
        const<\/span> std::<\/span>string newLine(const<\/span> bool<\/span> unixStyle);
};
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Okay. Now we know the first one is used to tell the function if it should use unix-style new lines to separate the strings or DOS-style new lines. The second one tells if the string should end with a newline. Took already some time, and it will take that time again when you want to understand it a week later, because you won’t remember at least the order of those parameters.
One first step towards better readability of that code would be to store the parameters first to local variables, so the reader of the code knows what they are used for.
<\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14<\/pre>\n<\/td>\n
\n
#include <iostream><\/span>
#include \"concat.h\"<\/span>
#include <string><\/span>
#include <vector><\/span>

int<\/span> main<\/span> ()
{
    Concat concat;
    std::<\/span>vector<<\/span>const<\/span> std::<\/span>string><\/span> values {\"Line One\"<\/span>, \"Line Two\"<\/span>, \"Line Three\"<\/span>};
    bool<\/span> useUnixStyle =<\/span> false<\/span>;
    bool<\/span> endWithNewLine =<\/span> true<\/span>;
    std::<\/span>cout <<<\/span> concat.concatVector(values, useUnixStyle, endWithNewLine);
    return<\/span> 0<\/span>;
}
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Okay, now we can at least understand what the code does, without visiting the header or implementation of that function. Great.<\/p>\n
Even better would be to make them member of the Concat class, so the user of the class is forced to explicitly spell the usage in the client code:
<\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14<\/pre>\n<\/td>\n
\n
#include <iostream><\/span>
#include \"concat.h\"<\/span>
#include <string><\/span>
#include <vector><\/span>

int<\/span> main<\/span> ()
{
    Concat concat;
    std::<\/span>vector<<\/span>const<\/span> std::<\/span>string><\/span> values {\"Line One\"<\/span>, \"Line Two\"<\/span>, \"Line Three\"<\/span>};
    concat.setUseUnixStyle(false<\/span>);
    concat.setEndWithNewline(true<\/span>);
    std::<\/span>cout <<<\/span> concat.concatVector(values);
    return<\/span> 0<\/span>;
}
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
That way, you even can specify suitable defaults for that boolean parameters without setting them in the function definition (which you also shouldn’t do, but that’s a separate topic).
<\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11<\/pre>\n<\/td>\n
\n
#include <vector><\/span>
class<\/span> Concat<\/span> {
    public:<\/span>
        const<\/span> std::<\/span>string concatVector(const<\/span> std::<\/span>vector<<\/span>const<\/span> std::<\/span>string>&<\/span> strings);
        void<\/span> setUseUnixStyle<\/span>(bool<\/span> _useUnixStyle){useUnixStyle =<\/span> _useUnixStyle;};
        void<\/span> setEndWithNewline<\/span>(bool<\/span> _endWithNewline){endWithNewline =<\/span> _endWithNewline;};
    private:<\/span>
        const<\/span> std::<\/span>string newLine();
        bool<\/span> useUnixStyle {false<\/span>};
        bool<\/span> endWithNewline {false<\/span>};
};
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
<\/p>\n
Multi-purpose functions<\/h2>\n
Often, boolean parameters are used to specify the behaviour of a function. This indicates that the function in question may serve multiple purposes, which functions should never do. Hence, often it is useful to split those functions up in separate ones, each fulfilling one purpose. This results in a cleaner interface of the functions as well as easier to understand function implementations.
Here is the current implementation of the Concat class.
<\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23<\/pre>\n<\/td>\n
\n
#include <string><\/span>
#include <sstream><\/span>
#include \"concat.h\"<\/span>

const<\/span> std::<\/span>string Concat::<\/span>concatVector(const<\/span> std::<\/span>vector<<\/span>const<\/span> std::<\/span>string>&<\/span> strings)
{
    std::<\/span>stringstream str;
    for<\/span> (std::<\/span>vector<<\/span>const<\/span> std::<\/span>string>::<\/span>const_iterator it =<\/span> strings.begin(); it !=<\/span> strings.end(); ++<\/span>it) {
        if<\/span> (it !=<\/span> strings.begin())
            str <<<\/span> newLine();
        str <<<\/span> *<\/span>it;
    }
    if<\/span> (endWithNewline)
        str <<<\/span> newLine();
    return<\/span> str.str();
}

const<\/span> std::<\/span>string Concat::<\/span>newLine() {
    if<\/span> (useUnixStyle)
        return<\/span> \"<\/span>n<\/span>\"<\/span>;
    else<\/span>
        return<\/span> \"<\/span>rn<\/span>\"<\/span>;
}
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
We now split it up into two separate functions concatVectorWithNewlineEnding and concatVectorWithoutNewlineEnding (one might come up with better function names).
<\/p>\n
\n\n\n\n
\n
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40<\/pre>\n<\/td>\n
\n
#include <string><\/span>
#include <sstream><\/span>
#include \"concat.h\"<\/span>

const<\/span> std::<\/span>string Concat::<\/span>concatVector(const<\/span> std::<\/span>vector<<\/span>const<\/span> std::<\/span>string>&<\/span> strings)
{
    if<\/span> (endWithNewline)
        return<\/span> concatVectorWithNewlineEnding(strings);
    return<\/span> concatVectorWithoutNewlineEnding<\/span>(strings);
}

const<\/span> std::<\/span>string Concat::<\/span>concatVectorWithNewlineEnding(const<\/span> std::<\/span>vector<<\/span>const<\/span> std::<\/span>string>&<\/span> strings)
{
    const<\/span> auto<\/span>&<\/span> concatWithoutNewline =<\/span> concatVectorWithoutNewlineEnding(strings);
    return<\/span> appendNewline<\/span>(concatWithoutNewline);
}

const<\/span> std::<\/span>string Concat::<\/span>concatVectorWithoutNewlineEnding(const<\/span> std::<\/span>vector<<\/span>const<\/span> std::<\/span>string>&<\/span> strings)
{
    std::<\/span>stringstream str;
    for<\/span> (std::<\/span>vector<<\/span>const<\/span> std::<\/span>string>::<\/span>const_iterator it =<\/span> strings.begin(); it !=<\/span> strings.end(); ++<\/span>it) {
        if<\/span> (it !=<\/span> strings.begin())
            str <<<\/span> newLine();
        str <<<\/span> *<\/span>it;
    }
    return<\/span> str.str();
}

const<\/span> std::<\/span>string Concat::<\/span>appendNewline(const<\/span> std::<\/span>string&<\/span> string)
{
    std::<\/span>string str(string);
    return<\/span> str.append(newLine());
}

const<\/span> std::<\/span>string Concat::<\/span>newLine() {
    if<\/span> (useUnixStyle)
        return<\/span> \"<\/span>n<\/span>\"<\/span>;
    else<\/span>
        return<\/span> \"<\/span>rn<\/span>\"<\/span>;
}
<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
Now we have separate functions, each serving one purpose only, which play well together. Even though we generated more code now than in the beginning, it is much more readable and every function does exactly what its name promises.<\/p>\n
Summary<\/h2>\n
Here are the main reasons not to use boolean parameters in your functions:<\/div>\n
\n
    \n
  1. Code which uses your function is easier to read if you find a different way than boolean parameters<\/li>\n
  2. Boolean parameters indicate functions with more than one purpose, which you should split up whenever possible<\/li>\n<\/ol>\n
    I used a simple example to show how you can improve such code. One can imagine, the effect gets even bigger in a huge code base with long and unreadable functions (and a high amount of function parameters).<\/div>\n<\/div>","protected":false},"excerpt":{"rendered":"I’m absolutely serious, don’t do it. “But hey”, one may ask, “what’s wrong with boolean parameters?” That’s what I got asked recently when I did a code review. And to all of you who have the same question in mind, here is my answer.There is only one reason to use a boolean parameter in a… Artikel ansehen<\/a>","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[],"tags":[5],"_links":{"self":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/35"}],"collection":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/comments?post=35"}],"version-history":[{"count":1,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/35\/revisions"}],"predecessor-version":[{"id":71,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/posts\/35\/revisions\/71"}],"wp:attachment":[{"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/media?parent=35"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/categories?post=35"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/ntlx.org\/de\/wp-json\/wp\/v2\/tags?post=35"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}