Intersection with `any` type

Question

[EDIT] This question is indeed duplicate; see @jcalz's answer on the linked post :)

Related discussion on TS github: Allowing narrow from any

---

playground

When I do { a: any } & { a: number }, TypeScript resolves it to { a: any }. However, considering the meaning of intersection type, I think it should be { a: number }, as only values in number type are actually in the intersection of those two types. So I'm not sure about the rationale behind this behavior - maybe it's because any is treated specially?

Answer 1

Type intersection

When you intersect two types using T1 & T2, the resulting type has of all the properties in T1, as well as all of those in T2.

If you change your example slightly, to use string instead of any:

type AType = { a: string } & { a: number }

declare const a: AType
a.a // type: string & number

we see that a.a has the combination of the properties of string and number.

In your example, you might expect it to say that a.a was of type any & number, but that's just the same as any.

Type intersection with any

When a type (e.g. number) is intersected with any, any behaves as a subtype (a narrower type, with all the properties of number plus some more). You could say that any extends number. This leads us to the same behaviour as we see below:

type T1 = { a: number, b: number }
type T2 = { a: number }

type Intersection = T1 & T2 // T1 is a subtype of T2, so we get T1

Admittedly, this is unintuitive from the perspective that we expect any to be a wider (more permissive) type, rather than a narrower one. It is a special case.

You would see your expected behaviour if you used {} (the most permissive type) rather than any, because {} adds no properties to number.

Answer 2

It's because you are using any at first place which is supertype of number, what you using is type checking of any and number, so means it can be anything, which means it's any!

So any override the number type as it's supertype of number...

In typescript, always use specific type, if not sure about the type, use any...

So putting check for any is exactly like not putting any type check at all...

This is exact words from typescript team for any...

Any

We may need to describe the type of variables that we do not know when we are writing an application. These values may come from dynamic content, e.g. from the user or a 3rd party library. In these cases, we want to opt-out of type-checking and let the values pass through compile-time checks. To do so, we label these with the any type:

let notSure: any = 4;
notSure = "maybe a string instead";
notSure = false; // okay, definitely a boolean

The any type is a powerful way to work with existing JavaScript, allowing you to gradually opt-in and opt-out of type-checking during compilation. You might expect Object to play a similar role, as it does in other languages. But variables of type Object only allow you to assign any value to them - you can’t call arbitrary methods on them, even ones that actually exist:

let notSure: any = 4;
notSure.ifItExists(); // okay, ifItExists might exist at runtime
notSure.toFixed(); // okay, toFixed exists (but the compiler doesn't check)

let prettySure: Object = 4;
prettySure.toFixed(); // Error: Property 'toFixed' doesn't exist on type 'Object'

The any type is also handy if you know some part of the type, but perhaps not all of it. For example, you may have an array but the array has a mix of different types:

let list: any[] = [1, true, "free"];

list[1] = 100;