⌘K
Noting Found

View all related articles

What Are Access Modifiers In JavaScript

JavaScript 2 mins read

Table of Content

    Introduction

    Access modifiers are keywords used to specify the declared accessibility of a member or a type.

    Let's discuss how access modifiers i.e. variables and methods are declared and accessed as Private, Public and Privileged in JavaScript.

    What is Access Modifiers?

    An access modifier is a keyword that we can apply to a member of a class to control its access from the outside.

    The followings are the access modifiers in most of the object-oriented programs.

    public, private and protected.

    Public Access Modifiers

    By default, all members (properties, fields, methods, or functions) of classes are public accessible from outside the class.

    For example:

    1 
    2class Employee
    3{
    4 
    5 constructor(name: string)
    6 {
    7 this.employeeName = name
    8 }
    9 
    10 greet() {
    11 console.log(`Good Morning ${this.employeeName}`)
    12 }
    13 
    14}
    15 
    16let employee = new Employee('Ossama')
    17 
    18employee.greet()

    Explanation:

    • We Define a public property called employeeName, and it's accessible from outside the class.

    • make a constructor with parameter has default type of string

    • make a greet method to say Good Morning to the employee :)

    After that, we define a variable to store the new instance of the Employee class on it, and call the greet method after that.

    Output:

    Good Morning Ossama

    Private Access Modifiers

    Private members can not accessible from outside the class, and it can access only internally within the class.

    Let's add a private method and try to access it outside the class

    1class Employee
    2{
    3 constructor(name: string)
    4 {
    5 this.employeeName = name
    6 }
    7 
    8 greet() {
    9 console.log(`Good Morning ${this.employeeName}`)
    10 }
    11 
    12 private convertToString(num: number) {
    13 return num.toString()
    14 }
    15}
    16 
    17let employee = new Employee('Ossama')
    18 
    19employee.convertToString(20)

    Explanation:

    In this case we're adding a private method called convertToString and its role is simply converted the number to string type. We tried to access it outside the class and here is the output:

    1(method) Employee.convertToString(num:number): string
    2property 'convertToString' is private and only accessible within class 'Employee'

    As you can see you can access the private (methods, properties ...) just inside the class and not outside.

    protected Access Modifiers

    Protected members are accessible only internally within the class or any class that extends it, but not externally.

    Meaning, you can access protected members only inside the class or when you extended the class

    Let's take a look at a practical example:

    1class Employee
    2{
    3 public employeeName: string
    4 
    5 constructor(name: string)
    6 {
    7 this.employeeName = name
    8 }
    9 
    10 protected greet() {
    11 console.log(`Good Morning ${this.employeeName}`)
    12 }
    13}

    here if you're trying to access greet method outside the class like this:

    1let employee = new Employee('ossama')
    2employee.greet()

    We can't and the compiler throw an error

    1(method) Employee.greet(): void
    2Property 'greet' is protected and only accessible within class 'Employee' and its subclasses

    So, in this case, we have two options to access the greet method:

    • within the class itself
    • within its subClasses

    Let's see an example at the second option:

    1class Employee
    2{
    3 public employeeName: string
    4 
    5 constructor(name: string)
    6 {
    7 this.employeeName = name
    8 }
    9 
    10 protected greet() {
    11 console.log(`Good Morning ${this.employeeName}`)
    12 }
    13}
    14 
    15class Manager extends Employee
    16{
    17 public managerName: string
    18 
    19 constructor(managerName: string) {
    20 super(managerName) // super refer to the Employee constructor
    21 }
    22 
    23 managerGreet() {
    24 this.greet()
    25 }
    26}
    27 
    28let manager = new Manager('Ossama')
    29 
    30manager.greet()
    31 
    32manager.managerGreet()

    Explanation:

    In this case we create a new class extends the Employee class. When you extend a class it called inheritance, which mean you are borrowing its (properties, methods, ...etc.)

    So, is this situation:

    • You can't access greet directly from Manager class because it's protected method and inherited from Employee class and the method still protected.

    • You can access the greet method from ManagerGreet Because it's a public method and the greet protected method inside it, and this is the point from the example.

    Conclusion

    In this article we take a look at the access modifier public, private and protected.

    We can summarize everything in:

    • public: when you want to access the members everywhere in your application.
    • private: when you want to access the members only inside the class.
    • protected: when you want to access the members inside the class and its subclasses.

    Related Tags

    About the Author

    Oussama's Profile Picture
    Oussama
    Full Stack Web Developer

    I'm a full stack web developer and telecommunications engineer who love to share knowledge and build stuff online!


    Comments

    Join our newsletter

    Subscribe to Our Newsletter and never miss our offers, latest news, Articles, etc.

    We care about the protection of your data. Read our Privacy Policy.