When working with JavaScript, it's common to encounter situations where you need to verify whether an object is empty—meaning it has no properties. This check can be especially important when validating data, working with APIs, or initializing application state.

In this article we'll explore several ways to check if a JavaScript object has no properties, such as using Object.keys.

We'll be including considerations for edge cases such as null, arrays, and symbol keys.

If you'd like to to know the best way to check for an empty string in JavaScript, you can check out that article here.

What Does It Mean for an Object to Be Empty?

An object is considered empty if it has no own enumerable properties. For example:

const obj = {}; // Empty object

Versus:

const obj = { name: "Walt" }; // Not empty

Note: We are not referring to objects that are null or undefined. An empty object must be a valid object and not contain any key-value pairs.

Method 1: Using Object.keys()

The most commonly used and readable method is to check the length of the keys array:

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

Why it works:

Object.keys() returns an array of the object's own enumerable property names. If the array length is zero, the object has no own properties.

Method 2: Using Object.entries() or Object.values()

These methods can be used similarly:

Object.entries(obj).length === 0
Object.values(obj).length === 0

They are functionally equivalent for this check but may be more relevant if you need keys and values together (Object.entries) or just the values (Object.values).

Method 3: Using Reflect.ownKeys() to Include Symbol Properties

Object.keys() does not include properties with Symbol keys. If you need a comprehensive check that includes both string and symbol keys, use Reflect.ownKeys():

function isTrulyEmpty(obj) {
  return Reflect.ownKeys(obj).length === 0;
}

Method 4: Using for...in with hasOwnProperty()

This is a more traditional method, which works across all environments:

function isEmpty(obj) {
  for (let key in obj) {
    if (obj.hasOwnProperty(key)) {
      return false;
    }
  }
  return true;
}

This approach checks for own enumerable properties while ignoring inherited ones.

Recommended Safe Approach

For production-level code, it’s best to include type checking to avoid runtime errors with null, arrays, or other non-object values:

function isObjectEmpty(obj) {
  return (
    obj &&
    typeof obj === 'object' &&
    !Array.isArray(obj) &&
    Reflect.ownKeys(obj).length === 0
  );
}

Why this is preferred:

• Ensures the input is a valid object
• Excludes arrays
• Accounts for both string and symbol keys
• Avoids common pitfalls like null values

Summary

Here’s a quick comparison of the most common methods:

Final Thoughts

Determining whether a JavaScript object is empty is a foundational task in development. While the simplest solution often works, it's important to consider edge cases—especially when building robust applications.

For most modern use cases, a utility function that checks type, avoids arrays, and includes symbol properties is the most reliable and future-proof approach.