Why is there not a built-in method in JavaScript to check if an object is a plain object?

You can check the type and the instance of an object this way:

var a = new Date();
console.log(typeof a);
console.log(a instanceof Date);

var b = "Hello";
console.log(typeof b);
console.log(b instanceof Date);

Updated according to the comments from the OP:

let arr = [1, 2, true, 4, {
    "abc": 123
  },
  6, 7, {
    "def": 456
  },
  9, [10], {}, "[object Object]"
];
arr.forEach(function(v) {
  if (typeof v == "object" && !(v instanceof Array) && v != null)
    console.log("Object Found");
  else
    ; // console.log("Na");
});

The above code snippets outputs thrice Object Found.

Relying on [object Object] string representation is inaccurate. This behaviour may be changed for any objects with:

let o = { toString: () => '...' };
('' + o) !== '[object Object]'

var a = [];
a.toString = () => '[object Object]';
('' + a) === '[object Object]';

The most solid way to check if a value is a plain object is

let o = {}
Object.getPrototypeOf(o) === Object.prototype

And considering that constructor property wasn't tampered, the most straightforward way to check if a value is a plain object is

let o = {}
o.constructor === Object

This covers all POJOs constructed from Object and doesn't cover Object.create(null, { ... }) or any child classes (including built-ins like RegExp or Array):

Object.create(null).constructor !== Object
[].constructor !== Object
(new class {}).constructor !== Object

One of the possible reasons why there is no dedicated method to check for object plainness is because a restriction to use only {} objects is not practical. This makes very little sense in the context of JS. This prevents the use of any class instances or relatively 'plain' objects (Object.create({}, ...)).

This would require the hack in order for desired non-plain objects to pass the check:

Object.assign({}, (new class {})).constructor === Object

In most cases of object checking 'everything which is not forbidden is allowed' principle pays off (with extra caution regarding infamous null inconsistency).

Applying the above to this case, a safe and concise condition to filter non-array objects is

o && typeof o === 'object' && !Array.isArray(o)

And a condition to filter objects that are not built-ins (functions, Array, RegExp, etc) is

o && (o.constructor === Object || !/\[native code\]/.test(o.constructor))

Just for the sake of further documenting different ways:

One way I can think of:

JSON.stringify(testValue)[0] === '{';

Keep in mind that objects with circular references cannot be stringified. However, if you are certain that all testValues cannot have circular references, you have yourself a way to check against Null, Arrays, and any primitive value to ensure that you have an Object.

I suggest that if you plan on using this throughout your code though, that you define a helper function that actually implements it, in case you find that this does not work as you expect and end up having to change the way you check it.