How to pull null check into function in typescript

Question

I have some code where I have several functions that need to null check an object then do stuff with it, or throw an error if it's null, like so:

interface SomeObject {
    doThingOne: () => string;
    doThingTwo: () => string;
}

let object: SomeObject | null; 

function doThingOne() {
  if(!object) {
    throw new Error('Object is null!');
  }
  // Typescript knows that object is not null, so it's fine with accessing its properties/methods
  return object.doThingOne();
}

function doThingTwo() {
  if(!object) {
    throw new Error('Object is null!');
  }
  return object.doThingTwo();
}

I'd like to pull out the null check into a function to reduce the duplicated code, like so:

interface SomeObject {
    doThingOne: () => string;
    doThingTwo: () => string;
}

let object: SomeObject | null; 

function requireObject() {
  if(!object) {
    throw new Error('Object is null!');
  }
}

function doThingOne() {
  requireObject();
  // Typescript no longer knows that object is defined, so it gets mad at the next line
  return object.doThingOne();
}

function doThingTwo() {
  requireObject();
  return object.doThingTwo();
}

However, when I do so, typescript is no longer aware that after the check, object definitely exists. Is there a clean way to do this?

This question seems similar, but wouldn't actually let me save on much code repetition as I'd still need to set up an if

This is very confusing, I'm not entire sure what you're asking, also when does doThingOne/doThingTwo extend object into a method? And why use a seperate function? What is the goal? Could you make a minimal, reproducible example? https://stackoverflow.com/help/minimal-reproducible-example — insyri, Dec 15 '21 at 14:20
I'm just trying to reduce repetition. `object`, if it exists, is of a type that has some methods on it. The issue's the same regardless of if I want to call `object.doThingOne()` or use `object.someProperty`. — StephenTG, Dec 15 '21 at 14:27
Here's a code example with errors on the preferred approach: https://www.typescriptlang.org/play?#code/JYOwLgpgTgZghgYwgAgMoHsC2EDyAjAKwgTGQG8AoZa5AE3QBUALUAcxxAgC5kAKASmQBeAHzIAzmChsA3FRr1mbBgHd0PAcLGTpIVnIC+FCgBsIpdIWJgeGbPiIlkAH2QgAriZMzkFGO5ASYHQQOkYWPQ4ITUpqYBheAEJLRzBBWJowJih0FTcIPIBRKByoXgByB2tkYHE3TxNE8v45aiNqKHN3KFCU6wA6RQj2TgFDY39AsGDQoeU1GPl4pL6SdPlqLJy8ziKS9DLKqyda+q8mlvl25E6wbt7jsEHw+fQxiiM-AKCQm4gAR3cwE6VRIiziCWSj3WNGQW1y+T2pQqoNIpw852arWQRk+kx+sxekU4ACZwX9AcDcI8BPJbvdkKsnnNidFLnjvtNfizWKp0GSYRSgSCafw6V0eozHs8lHo+e8DEA — StephenTG, Dec 15 '21 at 14:35
There's no way to have a function call like `requireObject()` affect the state of arbitrary in-scope values. You can an [assertion function](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions) to get similar results but you need to pass in the guarded thing as an argument, like `requireObject(object)`. See [here](https://tsplay.dev/wX2BDm). If this approach meets your needs I can write up an answer, otherwise the answer is basically "no, you can't do this" which I *could* write up as an answer, I suppose, maybe. Let me know. — jcalz, Dec 15 '21 at 19:05
@jcalz Assertion functions seem like just what I'm looking for! — StephenTG, Dec 15 '21 at 19:39

score 6 · Accepted Answer · answered Dec 15 '21 at 21:43

There's no way to write requireObject() and have that affect the type of object, since the compiler does not see requireObject() as related to object in any way. (If the compiler could manage all possible state changes due to mutation of closed-over variables inside functions, that would be great, but it's just not computationally feasible. See microsoft/TypeScript#9998 for the general problem.)

What you can do is pass object into requireObject() and annotate that requireObject() is an assertion function. Assertion functions must be implemented as void-returning (so they don't return anything), and the annotated return type is an "assertion predicate" of the form asserts x is Y (where x is the name of one of the function parameters) or just asserts x if you want to say that x is truthy.

So that gives us:

function requireObject(x: any): asserts x {
  if (!x) {
    throw new Error('something is falsy here');
  }
}

And now we can do this without error:

let object: SomeObject | null;

function doThingOne() {
  requireObject(object);
  return object.doThingOne(); // okay
}

function doThingTwo() {
  requireObject(object);
  return object.doThingTwo(); // okay
}

Playground link to code

score 2 · Answer 2 · answered Dec 15 '21 at 15:00

You could use the ! operator to tell the compiler that object will definitely contain a value.

return object!.doThingOne();

I try to avoid that sort of thing. It's easy to get into trouble later on. Instead, I would define the requireObject function to always return an object.

function requireObject(): object {
    if (!object) {
        throw new Error('Object is null!');
    }
    return object;
}

You can then call it like this:

object = requireObject();

Since requireObject always returns an object type, the compiler will know that at that point object is not null.

The only problem now is, because object is actually a TypeScript type, the code is a little confusing. It should work (I haven't actually tried it), but you may want to consider naming the variable something else.

How to pull null check into function in typescript

2 Answers2