Which coding style is more readable or preferable? [closed] - coding-style

Question

Closed. This question is opinion-based. It is not currently accepting answers.
Want to improve this question? Update the question so it can be answered with facts and citations by editing this post.
Closed 9 years ago.
Improve this question
In the below 2 ways, which method one has to prefer. I personally comfortable with method 2, the if-elseladder one. But my friend told, they invoke redundancy in coding., and he used to achieve that in many single if statements, like..
Examples:
if( cond1 && cond2 ){}
if(cond1 && cond3){}
if(cond3 && cond2){} etc..
Instead of.,
if(cond1)
{
}
else
{
if(cond3 && cond2)
{}
}
//Way 1
String str = cond1 && !cond2 && !cond3 ? "world" : "hello" ;
(cond1,cond2,cond3 -> aren't simple checks. say they itself contains many || and &&'s )
//Way 2
String str;
if (cond1)
{
if (cond2)
{
str = "hello";
}
else
{
if (cond3)
{
str = "hello";
}
else
{
str = "world";
}
}
}

Answer 1

String str;
if (cond1 && cond2) {
str = "hello";
} else if(cond1 && cond3) {
str = "hello";
} else if(cond1) {
str = "world";
}
This method is a bit inbetween the two. I am not a fan of the first method at all. But personally, this method seems a bit more clear than your second method and more readable, and it does the same thing.
This isn't to suggest that you should avoid nesting if statements. I'm merely suggesting that you should feel free to use compound if statements also. In my opinion, the contents of an if else block should be more than just more nested if or if else. If there is nothing inside your if block that's not in a nested if block, then your statement can be rewritten with compound if statements.
There's an alternate to my first method also.
String str;
if(cond1) {
if(cond2) {
//do stuff
} else if(cond3) {
//do stuff
} else {
//do stuff
}
}
This will check cond1 just once. It still has a purely nested if that can be rewritten as compound, but if you're concerned about performance (if cond1 is a particularly time-consuming check), this will check cond1 just once, and it still more readable than what you offered in the question originally (in my opinion). This difference is more subtle.
There's also this method.
bool flag1 = cond1;
bool flag2 = cond2;
bool flag3 = cond3;
String str;
if (flag1 && flag2) {
str = "hello";
} else if(flag1 && flag3) {
str = "hello";
} else if(flag1) {
str = "world";
}
In this method, you can make simple and short compound condition statements by using bool variables as flags. You can check any of the conditions as many times as you want (any time the condition may change, you need to flag1 = cond1 again, etc), without doing all the computing it may take to actually check the condition. You just check it once and save the result of the condition.

Answer 2

I have seen many different types of coding styles and from all that I have found, it all depends on the situation. There is not a universal standard, other than do not write un-readable code.
Your colleagues may desire a specific stylistic pattern and thus you follow that one.
To a moderately experienced programmer both are very readable and readability is very important for code, especially if it is going to be maintained by somebody else(which is eventually inevitable).
It is all what your goals are. If you want large if/else statements, I am not sure there is an inherent reason not too, other than it may eventually make unreadable code, depending on how it is implemented.