One of my biggest bugbears with TypeScript is the fact that it piles all methods (regardless of the access modifier) to the prototype.

Example

class Example {
    public getString(): string {
        return "Hello World";
    }

    private getNumber(): number {
        return 123;
    }
}

As we know, the access modifiers are only checked at pilation, thus ignored by the emitted JavaScript. One way JavaScript developers have learned to mitigate this is to use closures (okay, we know there are performance penalties to pay with closures, but I believe there are cases where closures are absolutely necessary).

Example

var Example = (function () {
    function Example() {
        this.getString = function () {
            return "Hello World";
        }

        var getNumber = function() {
            return 123;
        }
    }

    return Example;
})();

The above example respects the public/private access.

I've worked out that by using lambda syntax we can declare public closure methods within TypeScript.

Example

class Example {
    getString = (): string => {
        return "Hello World";
    }
}

It's not particularly pretty, but it works.

What I would like to know is: How would I declare private closures in TypeScript?

Example

class Example {

    // TypeScript doesn't like this!
    var getNumber = (): number => {
        return 123;
    }
}

See more on this bugbear here:

One of my biggest bugbears with TypeScript is the fact that it piles all methods (regardless of the access modifier) to the prototype.

Example

class Example {
    public getString(): string {
        return "Hello World";
    }

    private getNumber(): number {
        return 123;
    }
}

As we know, the access modifiers are only checked at pilation, thus ignored by the emitted JavaScript. One way JavaScript developers have learned to mitigate this is to use closures (okay, we know there are performance penalties to pay with closures, but I believe there are cases where closures are absolutely necessary).

Example

var Example = (function () {
    function Example() {
        this.getString = function () {
            return "Hello World";
        }

        var getNumber = function() {
            return 123;
        }
    }

    return Example;
})();

The above example respects the public/private access.

I've worked out that by using lambda syntax we can declare public closure methods within TypeScript.

Example

class Example {
    getString = (): string => {
        return "Hello World";
    }
}

It's not particularly pretty, but it works.

What I would like to know is: How would I declare private closures in TypeScript?

Example

class Example {

    // TypeScript doesn't like this!
    var getNumber = (): number => {
        return 123;
    }
}

See more on this bugbear here: https://github./Microsoft/TypeScript/issues/2940

• javascript
• typescript
• closures

• 1 This seems like a non-issue to me. You can't use private functions in other classes in typescript, so why does this bug you? Are you trying to hide the functions from JS devs who will investigate the methods of an object in the console? If so, just prefix them with an underscore and if they use those functions then that's their own fault. – David Sherret Commented Jun 17, 2015 at 13:59
• @DavidSherret you've got my point. I guess I e from the classical OOP where you are expected to provide correct levels of access to methods, so that 3rd party devs know exactly what they can/can't do. I wish I could do this cleanly with JavaScript, but the only real solution is to use closures. I don't like the idea of something being private in one language, and then public the moment it piles. Whilst I understand TypeScript's motivations in this respect, I still see the fact that TypeScript cannot create closure based classes as a limitation. – Matthew Layton Commented Jun 18, 2015 at 10:53
• @DavidSherret - also, you're right that it's another dev's fault if they use functionality not intended for their use, but I'd rather get the response "You've written a bulletproof API", rather than "Due to the number of leaky abstractions in your API, it's leaking like a sift!" – Matthew Layton Commented Jun 18, 2015 at 10:56
• I definitely understand the concern if it is a library that will be used by JS devs—to clarify, for typescript devs it's a non-issue. Personally, I think sacrificing code clarity and simplicity is not worth it in order to get over the limitations of JS. Using the underscore prefix is for sure not perfect, but to me clean simple code is of higher importance than pletely preventing someone from accessing undocumented methods and properties. – David Sherret Commented Jun 18, 2015 at 14:57
• ...JS is just terrible in this regard, but I do agree that it would be nice for typescript to have the option of piling the code in this way, though that might be a lot of work for them to implement :/ – David Sherret Commented Jun 18, 2015 at 14:58

2 Answers 2

TypeScript brings types and accessors to ES6 (and it checks both statically). The class keyword in TypeScript is the standard class keyword from ES6. There are no private closures in ES6 classes. This syntax is not valid in ES6:

class Example {
    var v = /* ... */; // invalid in ES6
}

If you need to declare a closure that encapsulates variables, you should use the classic JavaScript way. I strongly suggest to takes advantage of the TS interfaces:

interface NamedObject {
    getName(): string;
}

let createNamedObject = function (name = 'John'): NamedObject {
    return {
        getName: function () {
            return name;
        }
    };
};

let obj: NamedObject = createNamedObject();

If you really want to make class methods with closures, you can do this:

class BadPerformance {
    public getName: () => string;

    constructor(name = 'John') {
        this.getName = () => {
            return name;
        };
    }
}

As we know, the access modifiers are only checked at pilation, thus ignored by the emitted JavaScript.

That's because privacy in this context is privacy of the API from other developer. If you want them to know that the method is private - provide them with a .d.ts file so their editor can know that or don't document it in the API Documentation.

In JavaScript the documentation is often regarded as the API.

What I would like to know is: How would I declare private closures in TypeScript?

You can create functions in the constructor which would declare them on the instance and not on the prototype. This would allow you to use a closure - it also goes against prototypical inheritance and the nature of TypeScript and JavaScript.