打字稿和（a，b）=> a + b

Question

The following code doesn't compile (and I understand why):

let x: number[] = [];

x = ((a, b) => a+b)(x, x);
x.push(0);

This, however, compiles (and I don't understand why):

let x: number[] = [],
    f = (a, b) => a+b;

x = f(x, x);
x.push(0);

Then, if you run it, it produces a TypeError at runtime, like one would expect.

Why does Typescript handle these two samples differently?

Answer 1

I guess I should make this an answer:

In this:

let x: number[] = [];
x = ((a, b) => a+b)(x, x);  // error
//             ~~~ <-- Operator '+' cannot be applied 
//                     to types 'number[]' and 'number[]'.
x.push(0);

The anonymous function (a, b) => a + b uses contextual typing to infer that both a and b are of type number[] , because you immediately apply it to parameters of that type. And since you can't use the + operator on two arrays, you get an error.

On the other hand, in this:

let x: number[] = [],
    f = (a, b) => a+b;  // f is (a: any, b: any) => any
x = f(x, x);
x.push(0);

The type of the value f is inferred by the compiler to be the type of (a, b) => a + b , and there are no contextual typing clues, since it is not being called at this point. Yes, you call f(x, x) later, but typing doesn't flow backwards like that in general (contextual typing itself is sort of a very limited backward flow of typing). After all, you could call f(x, x) and then f("hey", false) and then presumably the type of f would need to be some combination of both (a: number[], b: number[]) => any and (a: string, b: boolean) => string ? Or something else? Who knows. Instead, what actually happens is that the unannotated a and b parameters are inferred to be of type any . And since any effectively turns off the type system, a + b is not an error. The any type is insidious; it tends to spread silently from one location to another in your program, and if you're not careful it can show up in places you don't expect.

The best way to combat this kind of thing is to enable the --noImplicitAny compiler option , which warns you when the compiler infers a type of any for something. This way you should only have to worry about the any type when it has been explicitly written down in the code somewhere:

let x: number[] = [],
f = (a, b) => a+b;  // error
//   ~  ~ 
//      ^--- Parameter 'b' implicitly has an 'any' type.
//   ^------ Parameter 'a' implicitly has an 'any' type.

Now you can deal with that warning by deciding what you wanted a and b to be... presumably number :

let x: number[] = [],
f = (a: number, b: number) => a+b;  
x = f(x, x); // error
//    ~ <-- Argument of type 'number[]' is not assignable to parameter of type 'number'.

and then you will have to deal with trying to call f() on number[] arguments explicitly.

Okay, hope that helps. Good luck!