Wherefore Art Thou

The Challenge:

The solution should return:

Some helpful links:

Global Object

Working With Objects

Standard Built-in Objects

Object Literals

Object.prototype.hasOwnProperty()

Object.keys()

Enumerability and Ownership of Properties

Array.prototype.every()

Starter Code:

What my solution should achieve:

1. Should create a function that checks which object in the first (collection) argument consisting of an array of objects has a key value pair which the second argument does not have, but the key value pairs that ARE present in the second argument are also present in the first.
2. Return the object from the first argument that contains the key value pair that is present in the second argument PLUS the key value pair that should be present in the second argument but is only present in the first.
3. My function should be able to filter out which object key value pair is present in the first argument and should be present in the second but is not. It should then include that object key value pair in the returned arr. It should also be able to determine which object in the first argument contains the object key value pair that is present in the second argument and include that in returned arr as well.

The helpful links provided hints as to which approach/methods I should take.

First, I knew I was dealing with an array of object literals in the first argument and an object literal in the second.

object literal: a list of zero or more pairs of property names and associated values of an object, enclosed in curly braces ({}). A property is an association between a name (or key) and a value.

Property names and associated values of an object, aka name value pairs, are also called key value pairs. An object property can refer to the name in the name value pair, or the key in the key value pair. It can also mean the complete name value pair/key value pair.

Example:

Second, I thought that I should create a new variable which stored an empty array that would eventually house the array of object(s) that were to be returned at the end of the function. I called this arr.

Then, based on the helpful links provided and that I was dealing with object literals, I thought that I should use the Object.keys() method.

Object.keys(): returns an array of an object’s non-inherited, non-prototype, enumerable properties, in the same order as a for in loop. Object.keys() returns an array of an object of which the properties directly belong to the object, not inherited through the prototype chain. Because the object’s properties are enumerable, this array of an object can be included in and visited by a for in loop or other similar iteration.

enumerable property: one that can be included in and visited by a for in loop, or a similar iteration of properties, like Object.keys(). If a property isn’t defined as enumerable, the loop will ignore that it is within the object.

Syntax:

Parameters:

obj: the object whose own enumerable properties are to be returned.

Object.keys() is a good method to use here because it works with arrays of objects and their enumerable properties.

Now let’s examine what I had thus far for the solution:

After declaring array arr and assigning the value of an empty array to it, I declared a new variable called keys to which I assigned the value Object.keys(source). I stored the key(s) present in the source argument in the variable keys.

Next I wanted to somehow store the collection argument in another variable, but filter out the objects which did not fit the criteria posed by the algorithm. In other words, filter out the object(s) in collection that don’t contain all the key value pairs present in the source argument, and return those that do contain them, as well as those that are present in collection and should be present in source but are not. So this is what I did next:

I reassigned arr by storing collection in its value.  Let’s break down what is happening inside the arr variable.

The .filter() method tests the obj parameter inherited from Object.keys(source) against each object in collection, removes the object(s) which don’t share keys present in source, and keys present in source are returned. The keys present in source that are returned are represented by keys.every(). Every source key is checked against each key in collection using the .every() method. Each key in collection is represented by the key parameter in the .every() method callback function. It inherits key from the filtered keys returned from collection.filter(). Next, the .every() method callback function returns the collection key that represents the key missing in source. This is represented by obj.hasOwnProperty(key). obj[key] === source[key] is also returned, and is true because obj === source. Since obj === source, obj[key] === source[key]. [key] refers to the collection key value pair that is strictly equal to source key value pair. Last, arr is returned at the end of the whatIsInAName() function containing the results from

Expected Outcome #1:

In collection, the keys present are first and last. In source, the key present is last. The only shared key value is Capulet. The key missing in source is first, so the object to be returned in arr is { first: “Tybalt”, last: “Capulet” }. Note: the key missing in source refers to both the key (property name) and its associated value Tybalt.

Expected Outcome #2:

In collection, the keys present are a and b. In source, the key present is a. The shared key value is 1.  The key missing in source is b, so the objects to be returned are { “a”: 1 }, { “a”: 1 }, { “a”: 1, “b”: 2 }.Note: the key missing in source refers to both the key (property name) and its associated value 2.

Expected Outcome #3:

In collection, the keys present are a, b, and c. In source, the keys present are a and b. The shared key values are 1 and 2. The key missing in source is c, so the objects to be returned are { “a”: 1, “b”: 2 }, { “a”: 1, “b”: 2, “c”: 2 }.Note: the key missing in source refers to both the key (property name) and its associated value 2.

Expected Outcome #4:

In collection, the keys present are a, b, and c. In source, the keys present are a and c. The shared key values are 1 and 2. The key missing in source is b, so the object to be returned is { “a”: 1, “b”: 2, “c”: 2 }. Note: the key missing in source refers to both the key (property name) and its associated value 2.

Solution:

Solution in ES6: