JavaScript Class Privates

By  on  

One of my aspects of JavaScript that drew me to it as a young developers was that its syntax was loose and I could code quickly. As you gain experience as an engineer, you start to realize that some traditional coding structure is a good thing, even if it slows you down. Using Jest or TypeScript to add typing to your JavaScript can save you from maintenance headaches and unexpected errors, for example. While those are pre-compile tools to accomplish structure, we've traditionally employed vanilla JavaScript patterns to mock private variables and methods in JavaScript.

Did you know, however, that browsers and the JavaScript language support a specific syntax for creating private variables and functions in classes? Let's have a look!

Properties and methods on a class have always been considered public; to make a property or method private, add a # at the beginning of their name:

class Developer {
  name;
  #age; // Don't tell anyone my age!

  constructor(name, age) {
    this.name = name;
    this.#age = age;
  }
};

const David = new Developer('David', 38);

console.log(David.name); // David
console.log(David.age);  // undefined
console.log(David.#age); // Error!  Uncaught SyntaxError: Private field '#age' must be declared in an enclosing class

David.name is available because name is public, while age is private because it's declared with a #. Similarly we can declare a private method with #:

class Developer {
  name;
  #age; // Don't tell anyone my age!

  constructor(name, age) {
    this.name = name;
    this.#age = age;
  }

  #getAgeInDogYears() {
    return this.#age * 7;
  }
};

getAgeInDogYears is only allowed to be called from within the class itself due to being declared with #. We can expose any information from within the class, public or private, if we make it available by public method:

class Developer {
  name = '';
  #age = 0;
  #ageInDogYears = 0;

  constructor(name, age) {
    this.name = name;
    this.#age = age;

    this.#ageInDogYears = this.#getAgeInDogYears();
  }

  #getAgeInDogYears() {
    return this.#age * 7;
  }

  log() {
    console.log(this.name);
    console.log(this.#age);
    console.log(this.#ageInDogYears);
  }
};

const David = new Developer('David', 38);
David.log();

// David
// 38
// 266

Adding a native syntax for declaring private class properties and methods is a welcomed addition to JavaScript; even better is that you can do so by simply adding a # to the beginning of its name.

Have you written code using private syntax in JavaScript? How was the experience?!

Recent Features

  • By
    Send Text Messages with PHP

    Kids these days, I tell ya.  All they care about is the technology.  The video games.  The bottled water.  Oh, and the texting, always the texting.  Back in my day, all we had was...OK, I had all of these things too.  But I still don't get...

  • By
    6 Things You Didn’t Know About Firefox OS

    Firefox OS is all over the tech news and for good reason:  Mozilla's finally given web developers the platform that they need to create apps the way they've been creating them for years -- with CSS, HTML, and JavaScript.  Firefox OS has been rapidly improving...

Incredible Demos

  • By
    CSS Columns

    One major gripe that we've always had about CSS is that creating layouts seems to be more difficult than it should be. We have, of course, adapted and mastered the techniques for creating layouts, but there's no shaking the feeling that there should be a...

  • By
    Fx.Rotate:  Animated Element Rotation with MooTools

    I was recently perusing the MooTools Forge and I saw a neat little plugin that allows for static element rotation: Fx.Rotate. Fx.Rotate is an extension of MooTools' native Fx class and rotates the element via CSS within each A-grade browser it...

Discussion

  1. Lynn Eriksen

    the way they have done private variables is garbage
    symptomatic of the slow pace and lack of creativity in the language these days

  2. It does feel hacky to me, to have added private properties to objects. We already *have* this, in the sense that closures contain private variables and functions but expose the privileged accessors.

    **Is** there a valid use-case for private properties on classes that isn’t cleaner and easier with Factories/Modules/closures?

  3. Hacky is fine as far as I’m concerned. I just want stuff to work as advertised. Was doing fine until Closure Compiler choked and I have to take a step backward to keep it going.

Wrap your code in <pre class="{language}"></pre> tags, link to a GitHub gist, JSFiddle fiddle, or CodePen pen to embed!