Introduction

In JavaScript, a variable name can legally start with $, and the language gives that character no special built-in meaning. When you see a name like $button or $http, you are looking at a naming convention chosen by a library, framework, or team rather than a JavaScript keyword or operator.

$ Is Just a Valid Identifier Character

JavaScript allows identifiers to begin with letters, _, and $. So code like this is perfectly normal:

1const $value = 42;
2const $_cache = new Map();
3
4console.log($value);
5console.log($_cache.size);

The engine does not treat $value differently from value or _value. It is just a legal name.

The jQuery Convention

The best-known reason developers use $ at the start of a variable name comes from jQuery. In jQuery-heavy codebases, a $ prefix often means "this variable holds a jQuery object."

const $paragraphs = $("p");
$paragraphs.hide();

That convention helps readers know which methods are available. A variable named $paragraphs suggests jQuery methods such as .hide(), .addClass(), or .on(), not a plain DOM node list.

Framework and Library Conventions

Different ecosystems reused $ for different reasons:

• AngularJS used services such as $scope, $http, and $timeout
• some teams use $el for DOM wrappers or special reactive values
• some libraries expose a top-level function named $

These meanings come from the surrounding codebase, not from the language specification itself.

For example:

function updateTitle($element, text) {
  $element.text(text);
}

In a jQuery-style codebase, $element signals that text(...) is likely a jQuery call rather than a method on a raw DOM element.

Why Teams Still Use It

The main benefit is readability through convention. A prefix can carry a hint about the variable's role:

• '$userInput might mean a wrapped DOM element'
• '$store might mean a reactive store object in a certain codebase'
• '$ by itself might be a library entry point'

This is similar to any naming convention: it adds meaning only if the team uses it consistently.

When It Is Not Helpful

A $ prefix can also be noise if it does not communicate anything real. For example:

const $count = 5;

If $count is just a number, the prefix does not help. It may even confuse readers into thinking the value is special in some way.

That is why modern codebases often reserve $ for specific conventions instead of sprinkling it everywhere.

It Does Not Mean "Private"

Some developers coming from other naming traditions assume $name means private or protected. JavaScript does not work that way. A $`` prefix has no access-control effect at all.

If you need actual privacy in modern JavaScript classes, use language features such as private fields:

1class Counter {
2  #value = 0;
3
4  increment() {
5    this.#value += 1;
6  }
7}

That is real language-level privacy. $value is only a naming style.

Team Conventions Matter More Than the Character

The real question is not "what does $ mean in JavaScript?" but "what does $ mean in this codebase?" In one project it may indicate jQuery objects. In another it may mark framework-managed values. In another it may mean nothing at all.

So the safest reading is contextual:

• check the surrounding style
• check project conventions
• do not assume a universal meaning

Common Pitfalls

The biggest mistake is assuming $ has a built-in JavaScript meaning. It does not; it is just part of an identifier.

Another issue is copying the convention without the reason behind it. If the prefix does not signal anything useful, it becomes visual clutter.

Developers also sometimes mistake $ for privacy, framework magic, or a required syntax rule. None of that is true at the language level.

Finally, conventions can collide across libraries. A $ prefix that means "jQuery object" in one project may mean something completely different in another.

Summary

• '$ is a legal character in JavaScript variable names.'
• It has no special built-in meaning in the language.
• Developers often use it as a convention, especially for jQuery objects or framework-specific values.
• Its meaning is defined by the codebase, not by JavaScript itself.
• Use it only when it communicates something real to readers.