Underscore prefix for property and method names in JavaScript

Underscore prefix for property and method names in JavaScript

Is the underscore prefix in JavaScript only a convention, like for example in Python private class methods are?
From the 2.7 Python documentation:

“Private” instance variables that
cannot be accessed except from inside
an object don’t exist in Python.
However, there is a convention that is
followed by most Python code: a name
prefixed with an underscore (e.g.
_spam) should be treated as a non-public part of the API (whether it
is a function, a method or a data
member).

Does this also apply to JavaScript?
Take for example this JavaScript code:
function AltTabPopup() {
this._init();
}

AltTabPopup.prototype = {
_init : function() {

}
}

Also, underscore prefixed variables are used.

this._currentApp = 0;
this._currentWindow = -1;
this._thumbnailTimeoutId = 0;
this._motionTimeoutId = 0;

Only conventions? Or is there more behind the underscore prefix?

I admit my question is quite similar to this question, but it didn’t make one smarter about the significance of the underscore prefix in JavaScript.

Related:  WebDriver click() vs JavaScript click()

Solutions/Answers:

Solution 1:

Welcome to 2019!

It appears a proposal to extend class syntax to allow for _ prefixed variable names to be public and # prefixed ones, private was accepted. Chrome 74 ships with this support.

Solution 2:

That’s only a convention. The Javascript language does not give any special meaning to identifiers starting with underscore characters.

That said, it’s quite a useful convention for a language that doesn’t support encapsulation out of the box. Although there is no way to prevent someone from abusing your classes’ implementations, at least it does clarify your intent, and documents such behavior as being wrong in the first place.

Solution 3:

JavaScript actually does support encapsulation, through a method that involves hiding members in closures (Crockford). That said, it’s sometimes cumbersome, and the underscore convention is a pretty good convention to use for things that are sort of private, but that you don’t actually need to hide.

Solution 4:

JSDoc 3 allows you to annotate your functions with the @access private (previously the @private tag) which is also useful for broadcasting your intent to other developers – http://usejsdoc.org/tags-access.html

Related:  OnChange event handler for radio button (INPUT type=“radio”) doesn't work as one value

Solution 5:

“Only conventions? Or is there more behind the underscore prefix?”

Apart from privacy conventions, I also wanted to help bring awareness that the underscore prefix is also used for arguments that are dependent on independent arguments, specifically in URI anchor maps. Dependent keys always point to a map.

Example ( from https://github.com/mmikowski/urianchor ) :

$.uriAnchor.setAnchor({
  page   : 'profile',
  _page  : {
    uname   : 'wendy',
    online  : 'today'
  }
});

The URI anchor on the browser search field is changed to:

\#!page=profile:uname,wendy|online,today

This is a convention used to drive an application state based on hash changes.

Solution 6:

import/export is now doing the job with ES6. I still tend to prefix not exported functions with _ if most of my functions are exported.

If you export only a class (like in angular projects), it’s not needed at all.

export class MyOpenClass{

    open(){
         doStuff()
         this._privateStuff()
         return close();
    }

    _privateStuff() { /* _ only as a convention */} 

}

function close(){ /*... this is really private... */ }