打字稿功能怪异的空隙|| &&行为

Question

Why is returnObject causing an compilation TypeError returnObject2 isn't?

Normally, void || something void || something should return something while void && something should return void .

But in Typescript, it's the opposite that occurs.

var returnVoid = function(){};

var returnObject = function(){  //Typescript compilation TypeError. 
    //No best common type exists among return expressions.
    if(Math.random() < 0.5)
        return new Error();
    return returnVoid() || null; //always return null
}
var returnObject2 = function(){ //works
    if(Math.random() < 0.5)
        return new Error();
    return returnVoid() && null; //always return undefined
}

Note: TypeError occurs during the compilation, not in the runtime.

---

EDIT: I did another test. Shouldn't returnNum2 be () => number too considering (undefined || something) === something ? Note: Same behaviour for void 0 .

var returnNum = function(){ //() => number
    return undefined || 0; 
}

var returnVoid = function(){};

var returnNum2 = function(){ //() => void | number
    return returnVoid() || 0; 
}

Answer 1

It's been pointed out in comments, but I think in general you just need to understand that function(){} will return undefined , which has specified behavior for logical operators.

For undefined && somevalue , undefined will always be returned. For undefined || somevalue undefined || somevalue , somevalue will be evaluated and returned.

Here's a good reference for more information: http://www.javascriptkit.com/jsref/comparison_operators.shtml

EDIT: The question isn't about what is returned for the logical operation, but why typescript gives error TS2354: No best common type exists among return expressions. on compilation.

This does seem like an error, but may make sense in the context. If you replace the logical operators with just a call to returnVoid() only, you'll get the same error in both functions. Static typing allows the && operator to short-circuit entirely for typing, since something && null will never evaluate to a type, but something || null something || null could depending on what the something is.

Related to this, in typescript you cannot explicitly specify null or undefined as a return type for a function.

While I understand why this may be the case, I agree it is a little odd. It might be worth checking with the folks who make Typescript and filing a bug.

Answer 2

TypeScript doesn't special case expressions of the form undefined || T undefined || T or void || T void || T to be T because a) you shouldn't write that code (use the comma operator!) and b) it's not safe to write this code because return value contravariance means you're not guaranteed to have a falsy value just because you have a void-returning function reference.

Consider if you wrote code like this:

type callback = (arg: any) => void;

function doSomething(x: callback) {
    return x(10) || 'Hello, world!';
}

var x = [];
var add = (arg: any) => x.push(arg);
console.log(doSomething(add)); // Prints '1', not 'Hello, world!'