Naming conventions and constant style

Understanding Naming conventions and constant style

The engine enforces only a few naming rules: an identifier must start with a letter, `_`, or `$`, may not start with a digit, may not contain a hyphen (because `-` is already the subtraction operator), and may not be a reserved word like `class` or `new`. Everything past that is convention. `const maxRetries`, `const MaxRetries`, and `const max_retries` all run identically, so casing is a message to the next person reading the file rather than to the runtime. Plain JavaScript has no type annotations, so the name is often the only clue about what a binding holds and whether it is safe to touch.

The ecosystem has settled on three shapes: camelCase for variables, functions, and methods, matching the built-ins you already call (`parseInt`, `getElementById`); PascalCase for classes and constructor functions, so `new Sensor()` looks deliberate and the instance `sensor` is never confused with its class; and SCREAMING_SNAKE_CASE for a value fixed at the moment you typed it, such as a magic number lifted out of the code and given a name. The split that trips people up is that `const` is a rule about the binding while ALL_CAPS is a claim about the value. `const activeUsers = []` stays camelCase, because the array fills up even though the binding never moves. `MAX_RETRIES = 3` earns the shout because nothing about it depends on how the program runs.

Beyond casing, the shape of a name carries information. Values get nouns, functions get verbs, booleans get an is/has/can/should prefix so `if (isVerified)` reads as a sentence, collections get plurals, and ambiguous numbers get their unit baked in (`timeoutMs`, `sizeKb`) so no caller has to guess seconds versus milliseconds. Prefixes such as `_cache` for "internal" and `$row` for "this holds a DOM element" are pure signalling with nothing enforcing them, unlike `#count` in a class, which the engine genuinely makes private. Consistency inside one codebase matters more than any individually perfect name, which is why teams encode these rules in a linter (`camelcase`, `new-cap`, `id-length`) so they are checked instead of remembered.

const MAX_RETRIES = 3;
const REQUEST_TIMEOUT_MS = 5000;

const startedAt = Date.now();
const activeUsers = ["ada", "linus"];

function canRetry(attemptCount) {
  return attemptCount < MAX_RETRIES;
}

activeUsers.push("grace");

console.log(canRetry(2), canRetry(3));
console.log(activeUsers.length, REQUEST_TIMEOUT_MS);
console.log(typeof startedAt);

Worked examples

let userName = "Ada";
let username = "ada";
const _internalCache = {};
const $form = { id: "signup" };

console.log(userName === username);
console.log(userName, username);
console.log(Object.keys(_internalCache).length, $form.id);

const user = { name: "Grace", posts: [], verifiedAt: null };

const isVerified = user.verifiedAt !== null;
const hasPosts = user.posts.length > 0;

function shouldShowWelcome(isVerified, hasPosts) {
  return isVerified && !hasPosts;
}

console.log(isVerified, hasPosts);
console.log(shouldShowWelcome(isVerified, hasPosts));
console.log(shouldShowWelcome(true, false));

class TemperatureSensor {
  constructor(label) {
    this.label = label;
    this.readings = [];
  }

  record(celsius) {
    this.readings.push(celsius);
    return this;
  }

  get average() {
    const total = this.readings.reduce((sum, n) => sum + n, 0);
    return total / this.readings.length;
  }
}

const CELSIUS_FREEZING_POINT = 0;
const roofSensor = new TemperatureSensor("roof");

roofSensor.record(4).record(-2).record(1);

console.log(roofSensor.label, roofSensor.average);
console.log(roofSensor.average > CELSIUS_FREEZING_POINT);

Important notes

Common mistakes

Try it yourself