In TypeScript, how to express a not-null condition will be true after a statement is called?

Question

I have a class that employs lazy initialisation.

class LazyWorker {
    private state: string | undefined;

    lazyInit() {
        if (this.state === undefined) {
            //A lot of statements here
            //That are guaranteed to initialise the this.state property
            this.state = 'aaa'

            //I don't want to repeat those statements...
            //DRY principle, right? 
        }
    }

    doSomething() {
        this.lazyInit();

        this.state.startsWith('doSomething');
    }

    doSomethingElse() {
        this.lazyInit();

        this.state.endsWith('doSomethingElse');
    }
}

Unfortunately, in the doSomething methods, the compiler complains that this.state might be undefined.

I can hack around compiler complaining by defining the property the following way, but it is inelegant and might give the false impression that the property is never undefined.

class LazyWorker {
    private state: string = undefined as any as string;

Any elegant way around it?

Answer 1

If state is generally not undefined you might consider removing the undefined from the type and using a definite assignment assertion:

class LazyWorker {
    private state!: string;
    // ...
}

Another option is to use a not null assertion every time you access state:

class LazyWorker {
    private state: string | undefined;

    initializeState() {
        //A lot of statements here
        //That are guaranteed to initialise the this.state property
        this.state = 'aaa'

        //I don't want to repeat those statements...
        //DRY principle, right? 
    }

    doSomething() {
        this.initializeState();

        this.state!.startsWith('doSomething');
    }

    doSomethingElse() {
        this.initializeState();

        this.state!.endsWith('doSomethingElse');
    }
}

Both of these options are not type save and can cause run-time errors.

Typescript does not support custom assertion functions, it only supports type guards, which require an if to work as expected, but only for public properties. We can get this to work, but I'm not sure if it's not overkill:

class LazyWorker {
    state: string | undefined;

    initializeState(): this is this & { state: string } {
        //A lot of statements here
        //That are guaranteed to initialise the this.state property
        this.state = 'aaa'

        //I don't want to repeat those statements...
        //DRY principle, right? 
        return true;
    }

    doSomething() {
        if(!this.initializeState()) return;

        this.state.startsWith('doSomething');
    }

    doSomethingElse() {
        if(!this.initializeState()) return;

        this.state.endsWith('doSomethingElse');
    }
}

Answer 2

1. use non-null assertion (exclamation mark)

this.state!.startsWith('doSomething');

2. If possible, find a why to initialize state in the constructor

  private state: string;

  constructor() {
    this.state = 'aaa'
  }

Typescript is still new, and still require these kind of tweak to make it work properly.

For this matter, I think your suggested method is good as well, and in any case - don’t let TypeScript slow you down