What are the pros and cons of replacing a list of conditionals(if/switch/ternary operators) with a predicate list?

Recently I've come across with a school of thought that advocates replacing conditionals(if/switch/ternary operators, same below) with something else(polymorphism, strategy, visitor, etc).

As I'd like to learn by trying new approaches, I've then revised some of my Javascript codes and immediately found a relevant case, which is basically the following list of ifs(which is essentially the same as a switch/nested ternary operators):

function checkResult(input) {
    if (isCond1Met(input)) return result1;
    if (isCond2Met(input)) return result2;
    if (isCond3Met(input)) return result3;
    // More conditionals here...
    if (isCondNMet(input)) return resultN;
    return defaultResult;
};

Shortly after I've come up with trying a predicate list instead.

Assuming that checkResult always return a String(which applies to my specific case), the above list of ifs can be replaced with a list of predicates(it uses arrow function and find which are ES6+ features though):

var resultConds = {
    result1: isCond1Met,
    result2: isCond2Met,
    result3: isCond3Met,
    // More mappings here...
    resultN: isCondNMet
};
var results = Object.keys(resultConds);

function checkResult(input) {
    return results.find(result => resultConds[result](input)) || defaultResult;
};

(On a side note: Whether checkResult should take resultConds and defaultResult as arguments should be a relatively minor issue here, same below)

If the above assumption doesn't hold, the list of predicates can be changed into this instead:

var conds = [
    isCond1Met,
    isCond2Met,
    isCond3Met,
    // More predicates here...
    isCondNMet
];
var results = [
    result1,
    result2,
    result3,
    // More results here...
    resultN
];

function checkResult(input) {
    return results[conds.findIndex(cond => cond(input))] || defaultResult;
};

A bigger refactoring maybe this:

var condResults = {
    cond1: result1,
    cond2: result2,
    cond3: result3,
    // More mappings here...
    condN: resultN,
};
var conds = Object.keys(condResults);

function checkResult(input) {
    return condResults[conds.find(cond => isCondMet[cond](input))] || defaultResult;
};

I'd like to ask what're the pros and cons(preferably with relevant experience and explanations) of replacing a list of conditionals with a predicate list, at least in such cases(e.g.: input validation check returning a non boolean result based on a list of conditionals)?

For instance, which approach generally leads to probably better:

• Testability(like unit testing)
• Scalability(when there are more and more conditionals/predicates)
• Readability(for those being familiar with both approaches to ensure sufficiently fair comparisons)
• Usability/Reusability(avoiding/reducing code duplications)
• Flexibility(for example, when the internal lower level logic for validating inputs changes drastically while preserving the same external higher level behavior)
• Memory footprint/Time performance(specific to Javascript)
• Etc

Also, if you think the predicate list approach can be improved, please feel free to demonstrate the pros and cons of that improved approach.

Edit: As @Bergi mentioned that Javascript objects are unordered, the ES6+ Maps may be a better choice :)