What object is not an instance of Object?

    typeof v === "object"
    v !== null
    !(v instanceof Object)

What do we know about v?

The expressions tell us two things about v: It is an object, but it is not an instance of Object.

v is an object

The first two expressions use the typeof operator to ascertain that v is an object. The second expression is only needed because typeof has a bug and returns "object" for null [1]. Thus, v will have all of the characteristics of an object.

Remember that JavaScript has two kinds of values: primitives and objects [2]. Primitives are read-only – you can try to create or change properties, but those operations have no effect:

    > var str = "abc";

    > str.foo = 123;
    123
    > str.foo
    undefined

    > str.length
    3
    > str.length = 1;
    > str.length
    3

Primitives are also compared by value – the contents of a value determine whether it is equal to another value of the same type:

    > "abc" === "abc"
    true

In contrast, objects are mutable and compared by reference. Every object has its own identity. Even if they have the same content, two objects are only equal if they have the same identity:

    > new String("abc") === new String("abc")
    false
    > {} === {}
    false

    > var obj = {};
    > obj === obj
    true

v is not an instance of Object

The third expression tells us that v is not an instance of Object. But what does that mean? To check whether

    value instanceof type

holds, the instanceof operator looks at type.prototype and checks whether it is in the prototype chain of value. That is, if we were to implement instanceof ourselves, it would look like this (minus some error checks, such as for type being null):

    function myInstanceof(value, type) {
        return type.prototype.isPrototypeOf(value);
    }

Finding an object without a prototype

We must therefore find an object that does not have Object.prototype in its prototype chain. None of the built-in types fit the bill:

    > Object.prototype.isPrototypeOf({})
    true
    > Object.prototype.isPrototypeOf([])
    true
    > Object.prototype.isPrototypeOf(/abc/)
    true

We can, however, use Object.create to create on object that does not have any prototype, not even Object.prototype:

    > var obj = Object.create(null)
    undefined
    > Object.getPrototypeOf(obj)
    null
    > Object.prototype.isPrototypeOf(obj)
    false

obj does not have standard methods such as toString, but it is still an object, with properties and all the usual features. We have thus found our v:

    > obj instanceof Object
    false
    > typeof obj
    'object'

Another solution. Given that prototype chains must end somewhere, Object.prototype does not have a prototype, either:

    > Object.prototype instanceof Object
    false
    > typeof Object.prototype
    'object'

Kudos to @michaelasmith for this alternative answer. The objects in the prototype properties of other built-in types do have prototypes:

    > Object.getPrototypeOf(Date.prototype)
    {}