Open
Description
Search Terms
unknown type guard
Related: #24439 (comment), #25172
Suggestion
Currently, only a very limited set of type guards are able to narrow the new unknown
type:
- Array.isArray (because it is a typeguard for
arg is any[]
) and probably some more in the lib files - instanceof
- self-written typeguards
However to make working with unknown types less awkward, I'd like to see a couple of other constructs being able to narrow the unknown
type:
let x: unknown;
// Direct equality should narrow to the type we compare to
x === "1"; // should narrow x to string or the literal "1" type, similar for other types aswell
// All these should narrow x to {prop: any}
"prop" in x;
x.prop != null;
x.prop !== undefined;
typeof x.prop !== "undefined";
// typeof should work on properties of the unknown variable
typeof x.prop === "string"; // should narrow x to {prop: string}
Use Cases
Make unknown
easier to work with!
// before, very verbose!
const x: unknown = undefined!;
function hasProp1(x: any): x is {prop1: any} {
return "prop1" in x;
}
function hasProp2(x: any): x is {prop2: any} {
return "prop2" in x;
}
// imagine doing this for many more properties
if (hasProp1(x)) {
x.prop1;
if (hasProp2(x)) {
x.prop2;
}
}
// ===========
// after, much more concise and less overhead
const x: unknown = undefined!;
if ("prop1" in x) {
x.prop1;
if ("prop2" in x) {
x.prop2;
}
}
Checklist
My suggestion meets these guidelines:
- This wouldn't be a breaking change in existing TypeScript / JavaScript codeThis wouldn't change the runtime behavior of existing JavaScript codeThis could be implemented without emitting different JS based on the types of the expressionsThis isn't a runtime feature (e.g. new expression-level syntax)
Metadata
Metadata
Assignees
Labels
Type
Projects
Milestone
Relationships
Development
No branches or pull requests
Activity
mattmccutchen commentedon Jul 17, 2018
The use of
in
is covered by #21732. Shall we add the other checks for a property (comparison to undefined, typeof) to #21732 and call this a duplicate of #21732 + #25172?AlCalzone commentedon Jul 17, 2018
Sure, why not!
in
operator as type guard which asserts property existence #21732AlCalzone commentedon Jul 19, 2018
And one more thing:
ghost commentedon Jul 24, 2018
At the least, at
typeof foo === "object"
it should narrow toobject
. Currently remainsunknown
and the following fails:mhegazy commentedon Jul 27, 2018
Similar requests in #10715, #25172, and #21732
unknown
types #26078simonbuchan commentedon Aug 21, 2018
I was hoping
unknown
would let me have type-safe data-loading, e.g.:This to me would be a better match to TS for what #26078 wants, but I wouldn't complain about adding quick-fixes to add the missing checks!
(remember that
typeof u === "object"
should actually narrow toobject | null
- Thanks javascript!)w0rp commentedon Sep 12, 2018
I would like it if type guards with
unknown
worked a little more like this.I think the type promotion ought to work like so, if at all possible.
typeof unknown === 'object'
->object | null
(object | null) !== null
->object
'foo' in object
->{foo: unknown}
typeof {foo: unknown}.foo === 'string'
->{foo: string}
22 remaining items