Quickly filter an object by keys

1. Use var myKeys = Object.keys(myObject) to get the keys.

2. Check if a myString exist in the array myKeys using native

   var matchingKey = myKeys.indexOf(myString) !== -1
   

   Processing an array? Use this:

   var matchingKeys = myKeys.filter(function(key){ return key.indexOf(myString) !== -1 });
   

3. Get the value using myObject[matchingKey].

   Processing an array? Use this:

   var matchingValues = matchingKeys .map(function(key){ return myObject[key] });
   

4. No need to check array-boundaries or sizes. It's 100% boundary-safe.

I think that the more important questions you need to be asking yourself wrt your code are:

1. What am I really trying to accomplish? (Answering this question will ultimately resolve your uncertainty related to whether you need to create a new object every time or, maybe, modify in place etc.)
2. Am I using the right data-structure for the task? Look, you've built your data-structure from hash-tables, each with a single key! Not only that, the same key repeats in every such hash-table! What would you lose if you used just the value from that hash-table instead of the entire hash-table?
3. This has become a mantra, but it is as true as ever: Make It Work, Make It Right, Make It Fast. Do not optimize unless the profiler tells you to. And most certainly not before you are absolutely confident that you made it right.

As an example of how your data-structure could've been made different such as to allow you to make filtering more straightforward:

var types = {
    'integer':   'int', 
    'character': 'char',
    'float':     'float',
    'double':    'double',
    'string':    'str', 
    'boolean':   'bool'
};

function filterTypes(accepted) {
    var result = {};
    for (var type in types)
        if (accepted.indexOf(type) > -1) 
            result[type] = types[type];
    return result;
}
// filterTypes(['integer', 'float', 'double']);
// { integer: 'int',
//   float: 'float',
//   double: 'double' }

And this is all there is to it. I would also question the purpose of these types in JavaScript, but I assumed they aren't to be implemented in JavaScript, just some kind of labels for some other programming language.

Note, additionally, that since the types hash-table is relatively small, there is no point of copying the keys to check against into another hash-table (to achieve faster lookup instead of indexOf). With this number of types indexOf will most likely outperform hash-table lookup, even more importantly. It offers a simpler solution, which works with acceptable speed.

1. unfiltered || (!unfiltered && keys[key]) is redundant you can just do unfiltered || keys[key]

2. You will run into false positives for any property set on Object.prototype such as "toString" or "valueOf" (for instance consider {valueOf: 1})

3. keys[key] is not a sufficent as it will miss any falsey value (NaN, null, false, 0, "", etc). You should use either the in operation or hasOwnProperty

4. This can be done considerably faster (and more accurately) by iterating the keep array instead of the properties on obj (lets you get around a Object.keys call)

This is how I would go about it

// Avoid issues with `{hasOwnProperty: 5}`
var hasOwnProperty = ({}).hasOwnProperty;
function filterByKeys(obj, keep) {
    if (!(Ext.isObject(obj) && keep)) {
        return Ext.clone(obj);
    }

    var result = {};
    for (var i = 0, len = keep.length; i < len; i++) {
        var key = keep[i];
        if (hasOwnProperty.call(obj, key)) {
            result[key] = obj[key];
        }
    }

    return result;
};