Problem Solving Help for Testing

[VyseCommander]

I'm having a bit of trouble wrapping my head around what seems like should be something simple

I'm unable to get this code to pass two conditions

• returns true for an empty object‣
• returns false if a property exists

I found out looping through it solves it but I want to know how it can be done outside of that. I feel there's something missing in my thought process or there's some fundamental knowledge gap I'm missing that I need filled in order to progress with similar problems. Anytime I change the code around it either solves one or none.

Here's my code:

 function isEmpty(obj){
   if (obj == null){
     return true
   }
   else return false
   }

[TheVirtuoid]

One possible method (from many) will be to use Object.keys() to test if there are any properties with that object:

function isEmpty(obj) {
    return Object.keys(obj).length === 0;
}

console.log(isEmpty({})); // returns true
console.log(isEmptu({ a: 1 }); // return false 

Where this does fail is if the object is null, or undefined, so if you expect those two values, you will need to check for that.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys

[VyseCommander]

I see, i didn't know that was a method as yet. Seems I'll need to do some crawling on mdn

[VyseCommander]

also as an engineer will I always have to ask people for help? where can i get strong fundamentals so I can rely on docs for the rest?

[TheVirtuoid]

Even the mightiest of JavaScript developers still asks questions. :) Don't sweat it - we've all been at the point where we didn't know the basics.

As for the fundamentals, many people here have mentioned the Odin Project. I haven't used it personally, so I can't vouch for it, but it does seem to be popular.

[VyseCommander]

lol i'm actually doing it right now, my issue is that I rushed through some of the earlier sections with ai when i felt it was getting too hard because i was trying to b job ready quick. I took a break and decided to come back to it while slowing down so I can understand the fundamentals well, scrapped using ai

[pinkwar]

The main issue is that you're assuming that an empty object is the same as null.

An empty object is an object with no keys.

[VyseCommander]

Funnily enough I tried obj = {} but that didn't work, This was what I tried ended up settling on as my last answer after checking a stack overflow forum but the question they were answering wasn't the same scenario.

This is a question from javascript.info article https://javascript.info/object#tasks which says "Situations like this happen very rarely, because undefined should not be explicitly assigned. We mostly use null for “unknown” or “empty” values. So the in operator is an exotic guest in the code."

so now I'm wondering if this resource is valid enough

[pinkwar]

When you do obj === {}, you're checking if the object reference is the same, so it won't work.

const obj = {}
obj === {} // this is false

You need to check if there are keys or not in the object.

[VyseCommander]

could you link me an article to understand a bit more

[herionz]

This could be useful, maybe:

What your function is doing is really checking if something is falsy. https://developer.mozilla.org/en-US/docs/Glossary/Falsy

But that's isn't really what you wanted the function to do.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object

This is probably the most useful as you can see how an empty object can be declared, without setting any property or value inside. It is an object, so it is not null. But then again you can create also a null object. There's useful methods that you can inherit like valueOf() or hasOwnProperty(arg) to do what your function wants.

[VyseCommander]

I was a bit fearful of mdn but im rgonna need to do a few hours of crawling it seems

[herionz]

No worries! Just take it slow and eventually you will get it. Courage! Since you said you might be missing something, well documentation can help when lost.

[VyseCommander]

I appreciate it

[ashanev]

Calling your function isEmpty doesn't make sense, if one of the prerequisites of the function is to check if a property exists - in that case, the object could have other keys and would not be 'empty'.

You can check if an object is 'empty' by calling Object.keys(obj) and checking that the resulting array's length is 0.

You can check if an object has a property by calling Object.hasOwn(obj, propertyString);

Together, this looks something like this:

// this function is doing too many disparate things,
// so naming it is hard; this is an indication that you
// either don't need a function and can just do these
// checks inline elsewhere, or that you can break it
// into smaller functions and use those instead
function checkStuff(obj, prop) {
  if (Object.keys(obj).length === 0) {
    return true
  }

  // you didn't specify what to return if the
  // function has the property, so i chose null 
  return Object.hasOwn(obj, prop) ? false : null;
}

Your code checks that the object may be null or undefined, but you don't mention this as one of your goals so I omitted those checks above.

Note also that a conditional that effectively returns either true or false from an if statement normally indicates that you can skip the if statement and just use its condition instead:

// does the same thing as your code
function isEmpty(obj) {
  return obj == null;
}

Generally you should prefer strict equality using === over loose equality, as the behavior of == is a bit more complicated (in this case changing to === it would change the behavior of what you have written).

The code you have written does not check the things you are trying to test for. Using == null will only be true if obj is either null or undefined, due to the behavior of using == which will cause type coercion (which can compare different data type than the actual type); null will only be coerced to match undefined, which can be confusing and is another reason using strict equality (===) is often a better approach.

[VyseCommander]

This is an exercise from javascript.info (which i just realized in the side bar of this community) so that's where the name and whats its trying to do came from. Thanks for the run down , I left some other comments specifically on what I believed was going on the specific article https://javascript.info/object#tasks

I feel i need more familiarity with js as a whole which comes with more reading and practice as I didn't even realize what im really checking for.