typeof a === "object" does not type the object as Object

[Roaders]

Code

function doStuff(a: any) {

    if (typeof a === "object") {
        a //why isn't a typed as Object here?
    }
}

example here

Expected behavior:
in the if statement a should be typed as Object and give code completion suggestions for object (like hasOwnProperty).

Actual behavior:
a is still typed as any and no object based code completion suggestions are given.

[MrAndersen1]

The specification for typeof says that lots of things gives "object".
Some examples that do are null, arrays, dates, Math, regex etc.
Many of witch the user does not expect to have when they used such a guard.
Regardless, even if you remove null, you cannot be sure "a" has things like hasOwnProperty.
Consider:
var a = Object.create(null);
Here typeof a is "object" but it does not have "hasOwnProperty".
So typing it as any and therefore not giving completions sounds reasonable to me.

[ikokostya]

@Roaders You can found answer in handbook http://www.typescriptlang.org/docs/handbook/advanced-types.html (see typeof type guards section)

These typeof type guards are recognized in two different forms: typeof v === "typename" and typeof v !== "typename", where "typename" must be "number", "string", "boolean", or "symbol".

However, you can achieve desired result using type guards:

function isObject(obj: any): obj is object {
    return typeof obj === 'object';
}

function doStuff(a: any) {
    if (isObject(a)) {
        a // a has `object` type here
    }
}

More information about object type can be found at wiki https://github.com/Microsoft/TypeScript/wiki/What%27s-new-in-TypeScript#object-type

[ahejlsberg]

why isn't a typed as Object here?

Because lots of perfectly valid code would become an error if we did. For example, typeof a === "object" is true for an array, but all of the methods of Array<T> would disappear if we narrowed the type to Object. In general, we only narrow any to a specific type when we know that it is the exact type of the object (as is the case only for number, string, boolean, and symbol).

[Roaders]

Ok, thanks for the replies. I will obviously close this.

What is the recommended way of checking that an item is actually a non-primitive that will have hasOwnProperty for example?

[jcalz]

Just running into this; the type guard you should use is something like:

function isObject<T>(t: T): t is T & object {
  return (typeof t === 'object') && (t !== null);
}

You need to eliminate null, because even though typeof null === 'object', null is not assignable to the type object. In other words, the OP should be a request that typeof t === 'object' narrow to object | null, not just object.

Unfortunately even if TypeScript could automatically narrow a variable x where typeof x === 'object' from T to T & (object | null) (or from any to object | null) you would run into the following problem when you try to eliminate the null yourself:

function oops<T>(t: T): T {
  if (typeof x === 'object') {
    // even if this narrowed to (T & (object | null)), which it doesn't
    if (t !== null) {
      // here t is still T & (object | null) !!
      return new Proxy(t, {}); // so error here 🙁
    }
  }
  return t;
}

which is why I think the type guard above is the best bet here.

---

Also, not sure why @ahejlsberg's comment about narrowing from Array<T> to object would apply to an intersection (Array<T> & object would be equivalent to Array<T>, wouldn't it?) but I'm guessing that narrowing by eliminating union constituents and narrowing by intersection are done separately. Oh well.