filter-and-sort language comparison

filter-and-sort.coffee

fields = ['firstName', 'middleName', 'lastName', 'suffix']
names  = [
    { firstName: 'Diane',      middleName: 'Tanya ', lastName: ' Douglas', suffix: ''   },
    { firstName: 'Jon ',       middleName: '',       lastName: ' Watson',  suffix: ''   },
    { firstName: ' Michelle ', middleName: '',       lastName: ' Ajuria',  suffix: ''   },
    { firstName: 'Elliot ',    middleName: '',       lastName: 'Gray ',    suffix: 'III'},
    { firstName: ' Jason ',    middleName: '',       lastName: 'Doran',    suffix: ''   }]

# drop superfluous spaces and empty name parts (i.e. if there is no middle name, get rid of it)
names.every (name) ->
    for own key, val of name
        name[key] = val.replace(/^\s+|\s+$/g, '')
        delete(name[key]) if not name[key].length

# drop records with last names starting with 'W'
names = names.filter (name) -> !/^w/i.test(name.lastName)

# sort descending by last name (names closer to Z first)
names = names.sort (a, b) -> (a.lastName < b.lastName) ? -1 : 1

# build an array where each value corresponds to a person's full name (i.e. Diane Tanya Douglas)
names = names.map (name) ->
    for own key, val of name
        val
names = names.map (name) -> name.join ' '

# print names one per line (use portable line break -- i.e. line break of the current OS)
console.log names.join "\n"

filter-and-sort.groovy

def fields = ['firstName', 'middleName', 'lastName', 'suffix']
def names  = [
[firstName:  'Diane'     , middleName: 'Tanya ' , lastName:   ' Douglas', suffix:   ''     ],
[middleName: ''          , firstName:  'Jon '   , lastName:   ' Watson' , suffix:   ''     ],
[firstName:  ' Michelle ', lastName:   ' Ajuria', middleName: ''        , suffix:   ''     ],
[firstName:  'Elliot '   , suffix:     'III'    , middleName: ''        , lastName: 'Gray '],
[firstName:  ' Jason '   , middleName: ''       , lastName:   'Doran'   , suffix:   ''     ]]

// drop superfluous spaces and empty name parts (i.e. if there is no middle name, get rid of it)
names.eachWithIndex {it, i ->
  it.each{it.value = it.value.trim()}
  it.each{if (it.value.isEmpty()) it.remove()}
}

// drop records where last name starts with 'W' and sort descending by last name
names = names.findAll {! (it.lastName ==~ /(?i)^[w].*/)}
names.sort { a,b-> if (a.lastName == b.lastName) 0 ; a.lastName > b.lastName ? -1: 1 }

// print full names one per line ignoring empty name parts (i.e. if middle name is empty, get rid of it)
names = names.collect {name ->
  fields.inject([]) {parts, field -> if (name[field]) parts << name[field]; parts}
}

names.each { println it.join(' ') }

filter-and-sort.js

;(function(){
var fields = ['firstName', 'middleName', 'lastName', 'suffix'],
    names  = [
    {'firstName': 'Diane ',     'middleName': 'Tanya ', 'lastName': ' Douglas', 'suffix': ''   },
    {'firstName': 'Jon ',       'middleName': '',       'lastName': ' Watson',  'suffix': ''   },
    {'firstName': ' Michelle ', 'middleName': '',       'lastName': ' Ajuria',  'suffix': ''   },
    {'firstName': 'Elliot ',    'middleName': '',       'lastName': 'Gray ',    'suffix': 'II' },
    {'firstName': ' Jason ',    'middleName': '',       'lastName': 'Doran',    'suffix': ''   }];

    // drop superfluous spaces and empty name parts (i.e. if there is no middle name, get rid of it)
    for (var i in names) {
        var name = names[i];
        for (var field in name) {
            names[i][field] = name[field].replace(/^\s+|\s+$/g, '');
            if (name[field].length === 0) { delete(names[i][field]); }
        }
    }

    // drop records with last names starting with 'W'
    for (var name in names) {
        if (/^w/i.test(names[name].lastName)) { delete(names[name]); }
    }

    // sort descending by last name (names closer to Z first)
    names.sort(function(a, b){
        if (a.lastName === b.lastName) return 0;
        return (a.lastName > b.lastName) ? -1 : 1;
    });

    // build an array where each value corresponds to a person's full name (i.e. Diane Tanya Douglas)
    for (var i in names) {
        var name = names[i], full = [];
        for (var j = 0; j < fields.length; ++j) {
            var field = fields[j];
            if (name.hasOwnProperty(field)) { full.push(name[field]) }
        }
        names[i] = full.join(' ');
    }

    // print names one per line (use portable line break -- i.e. line break of the current OS)
    console.log(names.join("\n"));
})();

filter-and-sort.php

<?php
$fields  = array('firstName', 'middleName', 'lastName', 'suffix');
$names[] = array('firstName' => 'Diane ',     'middleName' => 'Tanya ', 'lastName' => ' Douglas', 'suffix' => '');
$names[] = array('firstName' => 'Jon ',       'middleName' => '',       'lastName' => ' Watson',  'suffix' => '');
$names[] = array('firstName' => ' Michelle ', 'middleName' => '',       'lastName' => ' Ajuria',  'suffix' => '');
$names[] = array('firstName' => 'Elliot ',    'middleName' => '',       'lastName' => 'Gray ',    'suffix' => 'II');
$names[] = array('firstName' => ' Jason ',    'middleName' => '',       'lastName' => 'Doran',    'suffix' => '');

// drop superfluous spaces and empty name parts (i.e. if there is no middle name, get rid of it)
$names = array_map(function($name) {
    return array_map(function($part){ return trim($part); }, $name);
}, $names);

// drop records with last names starting with 'W'
$names = array_filter($names, function($name) {
    return !preg_match('/^[w]/iu', $name['lastName']);
});

// sort descending by last name (names closer to Z first)
usort($names, function($a, $b){ return strcmp($b['lastName'], $a['lastName']); });

// build an array where each value corresponds to a person's full name (i.e. Diane Tanya Douglas)
$names = array_map(function($name) use($fields) {
    return array_reduce($fields, function($parts, $field) use($name) {
        if (!empty($name[$field])) $parts[] = $name[$field]; return $parts;
    }, array());
}, $names);

// print names one per line (use portable line break -- i.e. line break of the current OS)
foreach ($names as $name) { echo join(' ', $name), PHP_EOL; }

filter-and-sort.rb

fields = [:firstName, :middleName, :lastName, :suffix]
names  = [
{firstName:  'Diane'     , middleName: 'Tanya ' , lastName:   ' Douglas', suffix:   ''     },
{middleName: ''          , firstName:  'Jon '   , lastName:   ' Watson' , suffix:   ''     },
{firstName:  ' Michelle ', lastName:   ' Ajuria', middleName: ''        , suffix:   ''     },
{firstName:  'Elliot '   , suffix:     'III'    , middleName: ''        , lastName: 'Gray '},
{firstName:  ' Jason '   , middleName: ''       , lastName:   'Doran'   , suffix:   ''     }]

# trim superfluous spaces
names.each     {|name| name.each_pair {|key, val| name[key] = val.strip}}

# drop records where last name starts with 'W'
names.reject!  {|name| name[:lastName].match(/^w/i)}

# sort descending by last name
names.sort_by! {|name| name[:lastName]}.reverse!

# print full names one per line ignoring empty name parts (i.e. if middle name is empty, get rid of it)
names.collect! do |name|
  fields.inject([]) {|parts, field| parts << name[field] unless name[field].empty?; parts}
end

names.each {|name| puts name.join ' '}

filter-and-sort.scala

import scala.collection.mutable.Map
val fields = List("firstName", "middleName", "lastName", "suffix")
var names  = List(
    Map("firstName"  -> "Diane"     , "middleName" -> "Tanya " , "lastName"   -> " Douglas", "suffix"   -> ""     ),
    Map("middleName" -> ""          , "firstName"  -> "Jon "   , "lastName"   -> " Watson" , "suffix"   -> ""     ),
    Map("firstName"  -> " Michelle ", "lastName"   -> " Ajuria", "middleName" -> ""        , "suffix"   -> ""     ),
    Map("firstName"  -> "Elliot "   , "suffix"     -> "III"    , "middleName" -> ""        , "lastName" -> "Gray "),
    Map("firstName"  -> " Jason "   , "middleName" -> ""       , "lastName"   -> "Doran"   , "suffix"   -> ""     ))

// trim superfluous spaces
names foreach { name => name foreach {case (key, value) => name(key) = value.trim() } }

// drop records where last name starts with 'W'
names = names filterNot { _("lastName").startsWith("W")}

// sort descending by last name
names = names sortWith  { (e1, e2) => (e1("lastName") compareTo e2("lastName")) < 0 } reverse

// print full names one per line ignoring empty name parts (i.e. if middle name is empty, get rid of it)
names foreach           { name =>
    var record:List[String] = Nil
    for(field <- fields reverse) if (name(field).length > 0) record = name(field) :: record
    println(record.mkString(" "))
}