Creating a TypeScript class without using the prototype method

Question

Creating a TypeScript class without using the prototype method

Recently delving into TypeScript and encountering a perplexing issue for which I can't seem to locate a satisfactory explanation...

Let's suppose I have a function:

function test() {
    function localAccessMethod() {
        console.log('I am only accessible from inside the function :)');
    }

    this.exposedMethod = function () {
        console.log('I can access local method :P');

        localAccessMethod();
    }
}

Now, the task at hand is to transform this function into a TypeScript class. Up until now, my progress is as follows:

class test {

    constructor: {}

    exposedMethod() {
        console.log('I can access local method :P');

        localAccessMethod();
    }

}

The challenge lies in defining that local function within the TypeScript class without exposing it through the prototype or .this. Is there a way to achieve this?

Alternatively, how should I modify the source code to comply with TypeScript conventions? I aim to create a function that is accessible to all class methods only, without being exposed...

typescript

Answer 1

Answer №1

To restrict access, utilize the private static keywords:

class Example
{
  private static restrictedMethod()
  {
    console.log('You can only access me from within this function :)');
  }

  publicMethod()
  {
    console.log('I have access to the local method :P');
    Example.restrictedMethod();
  }
}

Answer 2

To restrict access, utilize the private static keywords:

class Example
{
  private static restrictedMethod()
  {
    console.log('You can only access me from within this function :)');
  }

  publicMethod()
  {
    console.log('I have access to the local method :P');
    Example.restrictedMethod();
  }
}

Answer 3

Answer №2

In JavaScript, even private/protected members/methods are exposed, as only the compiler enforces visibility.

You have several options to work around this:

(1) Keep the "inner" function inside the main function:

export class test {
    constructor() {}

    exposedMethod() {
        console.log('I can access local method :P');

        function localAccessMethod() {
            console.log('I am only accessible from inside the function :)');
        }

        localAccessMethod();
    }
}

(2) If this is a module, place the inner function at the top level of the module and do not export it:

function localAccessMethod() {
    console.log('I am only accessible from inside the function :)');
}

export class test {
    constructor() {}

    exposedMethod() {
        console.log('I can access local method :P');

        localAccessMethod();
    }
}

(3) If you are not using modules, enclose the code in a namespace and export only the class:

namespace wrapping {
    function localAccessMethod() {
        console.log('I am only accessible from inside the function :)');
    }

    export class test {
        constructor() {}

        exposedMethod() {
            console.log('I can access local method :P');

            localAccessMethod();
        }
    }
}

Answer 4

In JavaScript, even private/protected members/methods are exposed, as only the compiler enforces visibility.

You have several options to work around this:

(1) Keep the "inner" function inside the main function:

export class test {
    constructor() {}

    exposedMethod() {
        console.log('I can access local method :P');

        function localAccessMethod() {
            console.log('I am only accessible from inside the function :)');
        }

        localAccessMethod();
    }
}

(2) If this is a module, place the inner function at the top level of the module and do not export it:

function localAccessMethod() {
    console.log('I am only accessible from inside the function :)');
}

export class test {
    constructor() {}

    exposedMethod() {
        console.log('I can access local method :P');

        localAccessMethod();
    }
}

(3) If you are not using modules, enclose the code in a namespace and export only the class:

namespace wrapping {
    function localAccessMethod() {
        console.log('I am only accessible from inside the function :)');
    }

    export class test {
        constructor() {}

        exposedMethod() {
            console.log('I can access local method :P');

            localAccessMethod();
        }
    }
}

Creating a TypeScript class without using the prototype method

Answer №1

Answer №2

Similar questions

What are some methods for retrieving RTK Query data beyond the confines of a component?

Guide on creating a server-side middleware in Next.js

Arranging Data in AngularJS based on Selected Filter Criteria

In TypeScript, how does "number" differ from "Number"?

Ways to develop a dynamic Promise-returning Function

Using useState to initialize a long value

Using Material UI with React and TypeScript

The JavaScript code is executing before the SPFX Web Part has finished loading on the SharePoint page

Best practices for organizing API Services using TypeScript and Next.js Server Actions

Update the TypeScript definitions in the index.d.ts file using the npm command, by overriding it with the reference types

Guide on incorporating external .d.ts files for a module

Ionic Vue is throwing an error indicating that a property is not found on the type '{ $route(currentRoute: any): void; }'

Upon deployment, Angular encounters issues with routing to lazy loaded modules

Utilizing Angular Components Across Various Layers: A Guide

What is the reason `addEventListener` does not work with a class method?

Preserving ES6 syntax while transpiling using Typescript

Exploring the power of Prosemirror with NextJS through Tiptap v2

HTML not updating after a change in properties

Using Typescript: Defining a function parameter that can be either of two interfaces

Creating an instance of a class using a class decorator, with or without the 'new'