Array.prototype.push and Array.prototype.pop operate on the end of the array, both in O(1) amortized time. Reading the last element via array[array.length - 1] (or array.at(-1)) gives a non-mutating peek. This pattern is what most JavaScript code uses in place of a dedicated stack class. The trade-off versus a real Stack is that the array exposes other methods (shift, splice, indexed access) which a strict consumer might mis-use; if discipline matters, wrap it in a class.

The class wrapper exposes only the four operations that make sense for a stack (push, pop, peek, size), which prevents downstream code from accidentally calling shift or splicing in the middle. The private field (#data) keeps the underlying array hidden so refactoring to a different storage (e.g. a linked list for very large stacks) does not break callers. The push method returns this so calls can be chained. Reach for the class form when you want self-documenting code or when the team mixes seasoned and junior engineers.

Stacks shine on bracket matching because LIFO is exactly what nested structures require: every closer must match the most recent opener. The implementation pushes openers and pops on closers, comparing each pop against the expected matching pair. Returning stack.length === 0 at the end catches unclosed openers (((), and the early return false catches mismatches and excess closers. This algorithm generalises to HTML tag matching, expression parsing, and validating JSON structure.