should refactor this if else

Question

someone gave me example about how to refactor if-else code.

function doSomething(a) {
    if (a === 'x') {
        doX();
    } else if (x === 'y') {
        doY();
    } else {
        doZ();
    }
}

it should refactored to:

function doSomething(a) {
    var lookup = {x: doX, y: doY}, def = doZ;
    (lookup[a] || def)();
}

but I said it is a bad example. the first piece of code is sample enough. I think it is ok to have those if-else. The second piece of code is not as clear as the first one.

then he gave me another example:

function rank(score) {
    var star
    if (score > 89) {
        star = 9
    } else if (score > 74 && score < 90) {
        star = 8
    } else if (score > 59 && score < 75) {
        star = 7
    } else if (score > 44 && score < 60) {
        star = 6
    } else if (score > 29 && score < 45) {
        star = 5
    } else if (score >10 && score < 30) {
        star = 4
    } else if (score > 8 && score < 11) {
        star = 3
    } else if (score > 6 && score < 9) {
        star = 2
    } else if (score < 7) {
        star = 1
    }
    return star
}  

I still though it is accepted. it is not big or complicated. easy to know what is doing. I will code like this just remove the condition after &&. I don't like to write so much if-else like this, but I cannot find a better way.

I asked he how to refacot it, he gave me the code he refactored.

function rank(score) {
    var ranges = {
        9: [90: Infinity],
        8: [75, 90],
        7: [60, 75],
        6: [45, 60],
        5: [30, 45],
        4: [11, 30],
        3: [9, 11],
        2: [7, 9],
        1: [-Infinity, 7]
    }
    var count = _.findKey(ranges, function(range) {
        return range[0] <= score && score < range[1]
    })
    return count >>> 0
}

I think the code refactored is more complicated then the origin code, easy to make mistake. and I don't like to use a hash map to refactor the if-else.

he said I should read some article about functional programming. they don't have if-else. they use pattern-matching and guard. I know litte about Scala and Haskell. I think pattern-matching just like switch statment. just more powerful.

I coped a piece of Haskell code from wiki:

describeLetter :: Char -> String
describeLetter c
   | c >= 'a' && c <= 'z' = "Lower case"
   | c >= 'A' && c <= 'Z' = "Upper case"
   | otherwise            = "Not an ASCII letter"

If I use Haskell to write this logic, I will write it like this, and I think it is similar to the origin code, not the code refactored by him.

My question is which code is better, the origin one or refactored one? why? or there is any other way to refactor this code?

Is it a good practice to use hash map to refactor if-else?

Thanks for your ansower!

Answer 1

I think the answer will depend on your situation.

If you're working on your own, pick the style you're more comfortable working with; after all, you are the one that's going to be (re-)reading your code — you need to be able to understand it fairly easily. I'd say if you can train yourself to understand hash maps at a glance, go for it, it'll save those precious taps on the keyboard.

If you're working in a professional environment, you have to understand that this code is not 'yours'. This code is going to be read by your colleagues and probably a number of your successors as well. You need to make sure your code is as readable and coherent as possible — if those extra 1-2 lines of code here and there make the entire program more readable, it's worth the investment. There's nothing worse than inheriting code from people that try to be 'too smart' when writing and end up with complex clumps of code that are barely readable, even by the author.

You'll also have to take into consideration the preference of your colleagues as well, perhaps there's even a guide to dictate how to write out these situations in code. In those cases, you should pick the preferred style opted for by the team — sometimes that may be the less readable version, but continuity will help ensure legibility as well.

Answer 2

All of this code for "refactoring", you just need to use switch, switch is faster than if else and most probably by all the other obscure code above.

more here - > Javascript switch vs. if...else if...else

P.S this is my personal opinion