Manuals & specifications

Reliable answers beat lucky guesses

JavaScript is too big to memorize. Professional developers do not keep every method, edge case, and browser version in their heads. They learn where to find trustworthy answers, how to read them quickly, and when to verify a detail with a small experiment.

In A short history of JavaScript, you met ECMAScript: the standard maintained by Ecma TC39, with ES5, ES2015, and yearly releases. In Engines, runtimes & hosts, you met the split between language features and host APIs. This lesson turns that into a practical skill: when you ask “what does this JavaScript do?” you need the language manual; when you ask “does this browser have it?” you need compatibility data; when you ask about the DOM, you may need host specifications such as WHATWG HTML or DOM.

We will use Array.prototype.at() as the running example because it is small, useful, and full of teachable details: negative indexes, out-of-range results, specification steps, and browser support.

MDN Web Docs is usually your first stop. A good reference page answers four beginner questions quickly: “how do I call it?”, “what do the inputs mean?”, “what comes back?”, and “can I see examples?”. It also points deeper: specification links and browser compatibility tables live near the bottom of many reference pages.

Do not read a reference page like a novel from top to bottom every time. Use it like a dictionary. Jump to the section that answers your question, then read surrounding notes if the answer depends on edge cases.

1Array.prototype.at(index)2 3Syntax4  at(index)5 6Parameters7  index: Zero-based position to read. Negative values count back from the end.8 9Return value10  The element at that position, or undefined when the position is outside the array.11 12Description13  Does not change the array. Converts the index to an integer before choosing.14 15Examples16  [10, 20, 30].at(0)   // 1017  [10, 20, 30].at(-1)  // 3018 19Specifications20  ECMAScript language specification: Array.prototype.at21 22Browser compatibility23  Check the compatibility table before depending on it in older browsers.

This simplified entry is modeled on MDN’s common layout, but the wording is ours. Notice the pattern: a concise summary, a syntax line, parameters, a return value, description details, examples, a specification link, and compatibility information. When a method surprises you, the return value and description sections are often the fastest fix.

The ECMAScript specification is the official rulebook for the JavaScript language: values, syntax, objects, functions, arrays, promises, modules, and many built-in methods. Engine teams use it to make V8, SpiderMonkey, JavaScriptCore, and other engines agree. It is not where most beginners should start, but it is the source of truth for exact behavior.

Specifications are written in careful algorithm steps. For Array.prototype.at(index), the important ideas are:

1. Let O be ? ToObject(this value).
2. Let len be ? LengthOfArrayLike(O).
3. Let relativeIndex be ? ToIntegerOrInfinity(index).
4. If relativeIndex ≥ 0, let k be relativeIndex.
5. Else, let k be len + relativeIndex.
6. If k < 0 or k ≥ len, return undefined.
7. Return ? Get(O, ! ToString(𝔽(k))).

Here is a small real function that mirrors those big decisions for array-like values. It is not a full replacement for the spec, but it is close enough for the cases in this lesson, and the test suite compares it with real Array.prototype.at for negative zero, fractional indexes, strings, NaN, and out-of-range positions.

1function simplifiedAt(array, index) {2  const object = Object(array);3  const length = object.length >>> 0;4  const relativeIndex = Math.trunc(Number(index)) || 0;5  const k = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;6  if (k < 0 || k >= length) return undefined;7  return object[String(k)];8}

1const letters = ["a", "b", "c"];Run2const answer = simplifiedAt(letters, -1);3console.log(answer);

Two precise details are worth learning early. First, 1.7 becomes 1; it does not round to 2. Second, NaN behaves like 0 here. You do not have to memorize those rules today, but you should know where to find them when a bug depends on them.

The spec can say what a feature means before every user has a browser that supports it. Compatibility data answers a different question: “where does this work?” MDN tables list browser versions and often include notes for partial support, flags, or old behavior. Caniuse.com is another common way to scan support for web-platform features.

Baseline is a simpler label for the modern web. Newly available means a feature is supported in the current versions of the core browsers: Chrome, Edge, Firefox, and Safari. Widely available arrives about 30 months after that cross-browser point. It is a traffic-light style shortcut, not a promise that every old browser is safe.

1typeof Array.prototype.at2"toSorted" in Array.prototype3typeof Object.groupBy4typeof structuredClone

Feature detection asks the browser you are actually running: “do you have this?” It is a useful runtime guard, but it does not replace planning. You still need compatibility data before choosing a feature for a production app, because your users may not have the same browser you do.

Now practice reading the small signals in a reference entry. A syntax line like at(index) tells you the method name and parameter names. A line like padStart(targetLength) / padStart(targetLength, padString) tells you there is a shorter form and a longer form; the second argument is optional, and the page explains the default.

1at(index)2padStart(targetLength)3padStart(targetLength, padString)

1"7".padStart(3);       // "  7"2"7".padStart(3, "0");  // "007"3[10, 20, 30].at(-1);    // 30

The return value section matters just as much as the parameters. If .at() cannot find an element at the final position, it returns undefined; it does not throw an error. Step through a few real calls and connect each result back to the reference sections above.

1const numbers = [10, 20, 30];Run2const result = numbers.at(-1);3console.log(result);

This is the habit to build: read the syntax to make a valid call, read parameters to understand inputs, read return value before using the result, then read examples to check your model. If an example still surprises you, use the spec link or make a tiny experiment in your console.

Each resource is reliable for a different kind of question. Sort these everyday developer questions by the place you would check first.

Where you’ll use this

References are not only for trivia. You use them while writing everyday code. Suppose you are showing the last message in a list:

const lastMessage = messages.at(-1);
if (lastMessage === undefined) {
  showEmptyState();
} else {
  renderMessage(lastMessage);
}

MDN helps you confirm that .at(-1) means “last item.” The return value section reminds you to handle undefined when the list is empty. Compatibility data tells you whether older target browsers need a fallback like messages[messages.length - 1]. The spec is there if a strange input, such as a fractional index, becomes important.

Common misconceptions

Your score counts first tries. Read every explanation; wrong choices are designed to teach the boundary between MDN, the spec, and compatibility data.

Key takeaways

• MDN Web Docs is the friendly first stop for JavaScript reference pages, examples, and practical notes.
• The ECMAScript specification is the official rulebook for the language; host APIs like the DOM are specified elsewhere.
• Compatibility data answers support questions. Baseline Newly available means current core browsers support a feature; Widely available comes about 30 months later.
• Read reference entries by section: syntax, parameters, return value, description, examples, specifications, and browser compatibility.
• When a result matters, prove it with a tiny real program or test.

Up next: Setting up your tools — VS Code, the DevTools console, and Node.js.