Question

have the following function on my collection:

getFiltered: function (status, city) {
        return this.filter(function (trainer) {
            return ((status === null) ? trainer : trainer.get("TrainerStatusName") === status) &&
                    ((city === null) ? trainer : trainer.get('City') === city);
        });
    }

What is is best way to deal with nullable params passed in i.e. if city it null then ignore filter/fetch all and if status is null then ignore filter/fetch all

The code above works, but curious about alternatives

Answer 1

Ok, first off, I’m a little confused by your question; the title says its about handling “nullable” parameters, but your code looks like it is dealing with “special case” parameters (specifically “all”) … except for the case of trainer being null, but I don’t think that is even possible when iterating through a Backbone collection.

* * Edit * *
OP updated the question, so the above is no longer relevant. I’ve also updated my answer accordingly.

In any case, there’s nothing at all wrong or unusual about your code; ternary operators are a standard way of handling one-off special cases. If you’re looking for alternative ideas though, here’s one that uses an extra function to DRY out (eliminate the duplication of) your code:

function matchesOrAll(expected, actual) {
    return expected === null || expected === actual;
}

getFiltered: function (status, city) {
    return this.filter(function (trainer) {
        return matchesOrAll(status, trainer.get("TrainerStatusName") &&
               matchesOrAll(city, trainer.get("City"));
}

* * Edit * *

Now that we’re talking about null and not “all”, it’s worth pointing out that there is a better pattern for simpler cases of nulls/undefined. If you were just filtering cities, for instance, the code could just be:

getFiltered: function (expectedCity) {
    return this.filter(function (currentCity) {
        return expectedCity === (currentCity || expectedCity);
}

In other words, you could take advantage of Javascript’s “truthiness”, and the fact that disjunctive (ie. ||) booleans expressions return the first truthy value. This eliminates the need for a ternary, and many libraries use this pattern to fill in un-provided arguments; for instance, here’s a line from jQuery that sets the “target” argument to a new object if none is provided:

target = arguments[1] || {};

Unfortunately though, when you’re dealing with properties/attributes of things (eg. trainer.get('foo')) instead of just objects directly (eg. trainer), there’s no good shortcut you can use (other than making a function).