As a part of that system, I needed to provide detailed stats for certain situations, such as a list of all transactions that had a discount code used. At first, I had one method per drilldown, all of which shared 90% of the same code. I tried and I tried, but I couldn't work out a way to abstract out the changes.

The only changes in the code were that the number of items counted differed depending on the section. E.g. On the sandwich breakdown all units with a specific PLU counted, but on the discount one, only items that had a discount applied are counted.

As the criteria used changed with every drill down, and wasn't just a case of comparing a field to a value. Passing in the field to check and the expected outcome as strings wasn't going to cut it.

How To Solve It

My first option was a giant if/else statement, or a switch. Pass in a parameter or two to the function and run whatever filter was needed. While this could have worked, it couples the two functions far too tightly for my liking, and I'm putting logic that belongs in multiple functions into one.

Another option was to conditionally define a function filter which took multiple optional parameters and automatically run it in the drilldown. Again, while this would have worked it's not a very clean way to do it.

Enter lambda functions. By passing a function as a parameter, we can filter the data as selectively as we like. By default, $__filter will be null, so we can check if there is a filter to run at all. If there is a filter, run it and handle the response however you want.

Short Example

Imagine we're selling things online. We have a model that returns all of the transactions made by a specific customer. We want to use all of this data to generate statistics - some for all the transactions returned, and some only for items that match our filter.

You can be as generic or as specific with your filters as you like. For example, this one will only return data for items that have a price of over £5.

function over_five($__transaction_ids) {
        $filter = function($__item){
            return $__item->sale_price > 5;
        };
        $r = $this->_filter_data(
                model::get_transactions($__transaction__ids),
                $filter
        );
    }

While that's a nice simple example, we can also make things more complicated by passing in variables to be used in the function with use. You simply tell the lambda function that you want to use a variable that's in the current scope, and pass it into your new function.

function discounted($__transaction_ids, $__code) {
        $filter = function($__item) use ($__code){
            return $__item->discount_code == $__code;
        };
        $r = $this->_filter_data(
                model::get_transactions($__transaction__ids),
                $filter
        );
    }

Of course, the two filter functions are useless without the function that actually applies them to the data and gives us something back. This is a very contrived example, but hopefully it'll show how lambda functions can be used to filter out data we don't want.

function _filter_data($__transactions, $__filter){
        // Some stats that we're gonna collect about the data
        $r = array();
        $r['total_items'] = 0;
        $r['matching_items'] = 0;
        $r['transaction_count'] = 0;
        $r['items_to_output'] = array();

        foreach ($__transactions as $k => $transaction){
            foreach($transaction as $item){
                    // Anything that's done every iteration goes before
                    // we try and filter the data
                    $r['total_items']++;

                    // If we have a filter provided
                    if (!is_null($__filter)){

                        // We pass in our item, and if it doesn't pass
                        // the filter skip the rest of this iteration
                        if (!$__filter($item)){
                            continue;
                        }

                    }

                    // Everything that we need to do if it matches
                    // the filter gets done down here
                    $r['matching_items']++;
                    array_push($r['items_to_output'], $item);
            }

            $r['transaction_count']++;
        }
       return $r;
    }

Notes

It's important to note that this only works in PHP 5.3 onwards. In previous versions, you would either have to use if/else or conditionally defined functions.

Additionally, you could also do all of your filtering within mySQL itself. Unfortunately this wasn't possible in this situation, as the database contains massive amounts of data. Running 6 big queries on the same page when I could have run one generic one and filtered it wasn't an option

Related posts:

1. HowTo: Codeigniter Partial Library This assumes you have moved both the application and system...
2. Javascript Control Structures I stumbled across http://eloquentjavascript.net/ and decided to have a flick...
3. Working with DOMDocument Nowadays, most of the services we need to access programatically...

Author: john
Date: 2009-08-25 17:42:12 +0100 (Tue, 25 Aug 2009)
New Revision: 1999

Log:
Party Like Its r1999!

Added:
versatilia/prince/
versatilia/prince/Party-Like-Its-Revision-1999.mp3

No related posts.