npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2024 – Pkg Stats / Ryan Hefner

object-match-maker

v2.1.3

Published

Create an object using data from two other objects. Get and update what you want.

Downloads

3

Readme

Documentation

object-match-maker

Create an object using data from two other objects. Get what you want from either objects and update what you want from either object. Returns a promise.

Node from developer:

Don’t Forget

Leave a star on github. Fork if necessary.

Install

npm install object-match-maker --save

const {ObjectMatchMaker} = require('object-match-maker');

File Structure

object-match-maker/
./index
./test/
./package.json
./README.md

Testing

node test test_1

Test from test_1 through test_8. And I added test_51 for kicks. Do not forget the underscore. If you don't add a test argument, it will default to test_51.

Syntax

ObjectMatchMaker(
obj = [{}, {}], 
output_type=2, 
get_values_from = 0, 
this_is_the_rest = 0, 
keys_to_update=[])
.then(res => {
   		 console.log(res, ' from ', arg)
})
  • obj is an array of the two objects that you want to work with.
  • output_type - by default, OMM (object-match_maker) will output an array and an object. You can decide which one you want to work with by simply adding a second argument of 0 or 1 respectfully. 0 is to return an array, 1 is to return an object. 2 or any other values, including empty, is to return both. . Examples below.
  • get_values_from - which element you want to get the value from. If you want to get the value from the first object or the second object. Examples below.
  • this_is_the_rest - OMM mostly focus on similarities. The differences are largely disregarded. If you want the difference, regardless if it matches both objects or not, then you will apply a 0 or 1 to state where the rest of the data are coming from. Examples below.
  • keys_to_update - just in case you may want to go deeper into the object to update specific keys instead of updating everything. This_is_the_rest and keys_to_update makes OMM very powerful and useful.

Uses Cases

Below, I will explain how to use each argument.

  • Object a and an object b have different first level keys.
  • Except for “ab”. There is a key “ab” on both objects.
  • Very important. Because, most of the use cases are going to show you how to use Object Oriented to help create a new object that updates ab.

let a = {
    aa: {
        aaa: 1,
        aab: 2, 
        aac: 3
    }, 
    ab: {
        aaa: 4,
        aab: 5, 
        aac: 6
    }, 
    ac: {
        aaa: 7,
        aab: 8, 
        aac: 9
    }, 
}
let b = {
    ba: {
        aaa: 10,
        aab: 11, 
        aac: 12
    }, 
    ab: {
        aaa: 13,
        aab: 14, 
        aac: 15
    }, 
    bc: {
        aaa: 16,
        aab: 17, 
        aac: 18
    }, 
}

Case 1: argument 1, obj

node test test_1

  • Imagine, object A was a newly created object.
  • object B was coming from the database.
  • And you do not want to override what is already on the database.
  • You simply wanted to add the new data (a) to the existing data (b).

Here's the solution:

let c = ObjectMatchMaker([a,b])

console.log(c) 

output: 
[ [ { aaa: 13, aab: 14, aac: 15 },
    { aaa: 1, aab: 2, aac: 3 },
    { aaa: 7, aab: 8, aac: 9 } ],
  { ab: { aaa: 13, aab: 14, aac: 15 },
    aa: { aaa: 1, aab: 2, aac: 3 },
    ac: { aaa: 7, aab: 8, aac: 9 } } 
]

case 2: argument 2, outputting an array only.

node test test_2

Do not panic.

  • You just output the solution as an object and as an array.
  • If you only want the object, you will simply add a second argument of 1
  • and if you wanted only the array, you will add a second parameter of 0
  • If you want both, you may leave it empty or add a second parameter of 2.

Let's run it again with a second argument of 0. This should output an array instead of array and object.


let c = ObjectMatchMaker([a,b],0)

console.log(c) 

output: 
[ { aaa: 13, aab: 14, aac: 15 },
  { aaa: 1, aab: 2, aac: 3 },
  { aaa: 7, aab: 8, aac: 9 } ]

case 3: output an object only.

node test test_3

  • Let's say you wanted to output an object instead of an array.
  • You will simply add a second argument of 1.

let c = ObjectMatchMaker([a,b],1)

console.log(c) 

output: 
{ ab: { aaa: 13, aab: 14, aac: 15 },
  aa: { aaa: 1, aab: 2, aac: 3 },
  ac: { aaa: 7, aab: 8, aac: 9 } } 

I implemented this feature because I found myself needing either an object or an array. Depending on the circumstances. Hopefully, this feature will also help you.

Understanding the result

  • The result, object c, should contain
  • ab from object b.
  • aa from object a
  • ac from object a This is because object a is the new object and you may:
  • Not want to override ab from object b.
  • Object b may have additional information that object cannot pocess yet.
  • Such as created_at.
  • Or current_status.
  • Or view_count
  • Etc.

However, overriding object b should be your choice. Not mine. Therefore, I have implemented ways to override values from an object.

Case 4: get_values_from object “b”

From test script, run: node test test_4

Now, lets say, you only wanted to update object b. And you do not want to add new keys to it.

  • This will mean that you will only take keys that match object a and object b.
  • The rest of the keys from object that does not match object b will be disregarded.
  • Remember, before you have took from b and add to a.
  • This time, you will only take from a to update b.
  • The rest of a, that does not match b, should be set aside.

For this solution, you will have to add a third argument of 0 or 1.


let c = ObjectMatchMaker([a,b],1,1)

console.log(c) 

{ ab: { aaa: 4, aab: 5, aac: 6 },
  ba: { aaa: 10, aab: 11, aac: 12 },
  bc: { aaa: 16, aab: 17, aac: 18 } }

As you can see, ab is coming from object a. And ba, and bc is coming from object b.

  • This argument is called, get_values_from.
  • This is because we are getting values from B and we are updating B with object A.
  • and we are disregarding the keys that do not match B.

Case 5: get_values_from object a

node test test_5

Instead of getting values from b, you may want to get value from a. Therefore, you will turn the third argument into a 0, instead of 1

  • Object-match-maker actually returned a promise.
  • Therefore, you can use "then" statement.
  • This will run, after your object has been resolved.
ObjectMatchMaker([a, b], 0,0).then(output => 
    console.log(output)
)

[ { aaa: 13, aab: 14, aac: 15 },
  { aaa: 1, aab: 2, aac: 3 },
  { aaa: 7, aab: 8, aac: 9 } ]

6 this_is_the_rest

From test script, run: node test test_6

  • argument 4 is called, "this_is_the_rest" because it gets the rest of the keys, regardless if they matches.
  • But, you have to tell it, where to get the rest of the keys from.
  • Object a or b.
  • based on the position of the first argument.
  • Therefore, you will enter a 0 or 1.
ObjectMatchMaker([a, b], 1,0, 0).then(output => 
    console.log(output)
)

{ ab: { aaa: 13, aab: 14, aac: 15 },
  aa: { aaa: 1, aab: 2, aac: 3 },
  ac: { aaa: 7, aab: 8, aac: 9 } }
  • In this instance, case 6 does not have a significant difference.
  • Because we are getting values from 0 and we want the rest of 0.
  • We already have the rest of 0. Because we are getting values from 0.
  • But, in case 7, you will see a big difference.

7 this_is_the_rest

node test test_7

If you wanted to get the key /value pair from object A, and get the rest of the values from B, You will add a fourth argument of 1

This make OMM very powerful. Here's why.

  • Imagine, object C is meant to include all of object A and all of Object B.
  • But, you want object A to be updated with keys that match object B.
  • Hence., the existing data from the database will remain the same, but I want to add new data.

You can simply make object C includes data from A and B and update the data. let's run this.

ObjectMatchMaker([a, b], 1,0, 1).then(output => 
    console.log(output)
)

{ ab: { aaa: 13, aab: 14, aac: 15 },
  aa: { aaa: 1, aab: 2, aac: 3 },
  ac: { aaa: 7, aab: 8, aac: 9 },
  ba: { aaa: 10, aab: 11, aac: 12 },
  bc: { aaa: 16, aab: 17, aac: 18 } }
  • First, notice we have 5 keys and not 6.

  • That is because AB was updated. And it was updated by AB from object B.

  • And also notice that all of the keys are blend into 1.

  • This is because we are getting already getting all the values from object and we said, we also want values from object b.

    8 keys_to_update

node test test_8

  • This is my favorite feature because we can update particular second level keys.
  • Let's say, you do not want to update everything that matches a and b.
  • You only wanted to update a few keys.
  • For example, lets say, I want to update a key called updated_at, product_status.
  • And every other 2nd level keys should not be updated.
  • In this case, you will add a fifth argument that contains an array of the keys that must be updated.
let test_8 =[ [a, b], 1,0, 1, ['aaa', 'aac']]

ObjectMatchMaker(...test_8).then(res => {
    console.log(res)

})

output:

{ ab: { aaa: 4, aab: 14, aac: 6 },
  aa: { aaa: 1, aab: 2, aac: 3 },
  ac: { aaa: 7, aab: 8, aac: 9 },
  ba: { aaa: 10, aab: 11, aac: 12 },
  bc: { aaa: 16, aab: 17, aac: 18 } } 

Play with it. Have fun with it. I am pretty sure, you will find what you want from it. Good luck.

Full Test Script

const {ObjectMatchMaker, omm} = require('./index');

let a = {
   aa: {
       aaa: 1,
       aab: 2,
       aac: 3
   },
   ab: {
       aaa: 4,
       aab: 5,
       aac: 6
   },
   ac: {
       aaa: 7,
       aab: 8,
       aac: 9
   },
}
let b = {
   ba: {
       aaa: 10,
       aab: 11,
       aac: 12
   },
   ab: {
       aaa: 13,
       aab: 14,
       aac: 15
   },
   bc: {
       aaa: 16,
       aab: 17,
       aac: 18
   },
}


let test_51 =[ [a, b], 0,0, 1, ['aaa', 'aac']]
let test_1 =[ [a, b]]
let test_2 =[ [a, b], 0]
let test_3 =[ [a, b], 1]
let test_4 =[ [a, b], 1,1]
let test_5 =[ [a, b], 0,0]
let test_6 =[ [a, b], 1,0, 0]
let test_7 =[ [a, b], 1,0, 1]
let test_8 =[ [a, b], 1,0, 1, ['aaa', 'aac']]

let object = {
   test_1, test_2, test_3, test_4, test_5, test_6, test_7, test_8, test_51
}



let arg = process.argv.slice(2)[0]

if(!arg){
   arg = 'test_51'
   console.log('you must include test detail from test_1 to test_8. Do not forget the underscores. Therefore, I am outputting a test file but it is not the exact one you are looking for')
}

ObjectMatchMaker(...object[arg]).then(res => {
   console.log(res, ' from ', arg)

})

Change Log

2.1.3

  • Added bullet list for readability

2.1.2

  • include change log
  • update README.md, fix some grammar.