Welcome to day 7. We're over half way through! I hope you've enjoyed learning
about a few of these awesome modules on ForgeBox. Want to say thanks for some
of these modules? Make sure to star the repos on GitHub!
Now, on to today's module: cfcollection.
cfcollection
Functional Programming
Functional programming can make your code more expressive. Take these two examples:
1 2 3 4 5 |
var newUsers = [];for ( var user in oldUsers ) { arrayAppend( newUsers, user.username );}return newUsers; |
This is pretty succienct code, but you have to read it all to know what it is doing. It is transforming an array of users in to an array of usernames.
Now, take a look at the map equivalent:
1 2 3 |
return collect( users ).map( function( user ) { return user.username;} ).get(); |
The biggest benefit here is that map has semantics where a for loop does not.
When you see map, you know you are getting an array back the same length as
the source array with every item transformed in some way. With a for loop,
you just have to read the loop to figure out what it is doing.
With cfcollection, this can be taken further into an even higher level function:
1 |
return collect( users ).pluck( "username" ).get(); |
pluck has further semantics of being a map that returns a property off of the
objects passed in. These semantics keep your code clean and make chaining methods
a more expressive way to program. cfcollection includes many of these expressive,
chainable methods to help make reading your code flow.
Futher semantic methods can clean your code up even more:
1 2 3 4 5 6 7 |
return collect( users ) .filter( function( user ) { return user.isActive; } ) .reduce( function( total, user ) { return total + user.salary; }, 0 ); |
1 2 3 |
return collect( users ) .where( "isActive", true ) .sum( "salary" ); |
A quick note about performance. A concern many people have when getting in to
a more functional pipeline style of programming as seen here is that we are now
looping multiple times over the same collection instead of one time with a for
loop. That is true, but in most cases it doesn't matter. The time added to loop
over your collection multiple times most likely pales in comparison to, for
exampe, your database queries. The right approach is to focus on correct, clean
code first. Then measure and fix where the measurements tell you to. Don't
just fix where you think the problem is. Remember:
make it work, make it right, make it fast.
Member Functions Everywhere!
This section could also have been labelled CFEngine compatibility. cfcollection is tested on Adobe ColdFusion (ACF) 10, 11, and 2016 as well as Lucee 4 and 5. This means that even if you are on ACF 10 and don't have member functions or need to support multiple engines (like a module!) you can have them through cfcollection.
Mixins
Mixins are a super neat feature of cfcollection powered by WireBox! Any component managed through WireBox can have a any number of files mixed in when creating an instance of the component. This lets you extend components with arbitrary functionality. Take this example:
1 2 3 4 5 6 |
// config/ColdBox.cfcmoduleSettings = { cfcollection = { mixinLocations = "/app/includes/macros/CFCollectionMacros" }}; |
1 2 3 4 5 6 7 8 |
<!--- includes/mixins/CFCollectionMixins ---><cfscript>function triple() { return this.map( function( item ) { return item * 3; } );}</cfscript> |
1 2 3 4 5 6 7 8 9 |
// handlers/main.cfcproperty name="collect" inject="collect@CFCollection";function index( event, rc, prc ) { var nums = collect( [ 1, 2, 3, 4, 5 ] ); event.renderData( nums.triple().get() ); // [ 3, 6, 9, 12, 15 ]} |
The biggest benefit here is that you don't need every collection method added to the cfcollection core. You can add your own pipeline functions directly in to your collections. Whether this is your favorite utility that's not in the core, or a utility specific to a project, this lets you stay in the expressive, functional pipeline world no matter what your use case.
Wrap Up
cfcollection is basically an automatic install in all my CFML projects now a days. The consistent member functions, the expressive pipelines, and the ability to mix my own methods in make it invaluable for keeping my code readable and clean.
Add Your Comment