为什么任何可以分配给 TypeScript 中的每种类型

Question

This is a philosophical question about the type structure in TypeScript.

Let's take look at the following short snippet ( available as a playground here ).

function f(): string {
    if (Math.random() > 0.5) {
        return 'a real string';
    }
    var x: any = null;
    // Why does this type check?
    return x;
}

const myString = f();
// myString has type string
// not string | any, not string | undefined, not string | null
// so I expect it to really be a string
console.log(myString.length);
// -> TypeError: null is not an object (evaluating myString.length)

In short, my question is why does this example compile with all possible strictness flags enabled?

The documentation on any states that any is used to "describe the type of variables that we do not know". For this reason, it makes sense that all types can be assigned to any , however, why can any be assigned to all other types?

By its very nature, objects with type any have unknown properties, so why can they be marshaled into other types (like string ) with no warning? Does this not defeat the purpose of explicitly tagging things with types when we know the compiler is not enforcing their contents?

For example, let's say that I want to define a function that unequivocally returns a string (not null , not undefined , not number , but exactly string ). Is there a way to get the TypeScript compiler to enforce that every codepath that returns from that function returns a string? My preconception is that the example above should be doing that, and that we should see an error like any is not assignable to type string , but we do not.

Answer 1

The documentation on any states that any is used to "describe the type of variables that we do not know"

Since TypeScript 3.0, you should use unknown to describe such types instead.

any is an artifact from the past, and you shouldn't be using it except for rare edge cases where you cannot use unknown . There are a few (arcane) ones.

Solution

function f(): string {
    if (Math.random() > 0.5) {
        return 'a real string';
    }
    var x: unknown = null;
    return x; // Compile-time error: "Type 'unknown' is not assignable to type 'string'.(2322)"
}