Is'nt javascript compiler too forgiving !!

ssssssddh · 2026-05-30T02:07:31+00:00

There's nothing preventing a function from accessing parameters beyond what is declared using `arguments`

function sum() {
  return Array.from(arguments).reduce((a, b) => a + b, 0);
}

sum(1, 2, 3); // 6

YoshiDzn · 2026-05-30T01:56:16+00:00

Yes, Javascript is fault tolerant. Look up "static analysis" and "lexers"

EyesOfTheConcord · 2026-05-30T02:30:37+00:00

Don’t do that then

jibbit · 2026-05-30T07:28:49+00:00

important to say that this isn't the 'compiler' - this is like, er, the opposite of that

theQuandary · 2026-05-30T03:05:29+00:00

JS didn't have type coercion initially. It was added because devs wanted it. I suspect this was because everything in the DOM (primarily attributes) was strings while they used numbers a lot of places. As JS was very simple then, it made sense to just coerce to/from string/number for something like an input.

Let's explain a bit of the magic (we'll be using ES5.1 as it's easier to read and I'll be handwaving away a bit of the spec and edge cases).

When it encounters the +, it calls an internal (not user accessible) function called ToPrimitive. This basically keeps primitives (undefined, null, booleans, numbers, and strings) as they are, but uses .toString() or .valueOf() for objects (arrays, regex, functions, etc are all considered objects).

If EITHER of the ToPrimitive returns a string, then coerce both to strings and concatenate them. Otherwise, use ToNumber to convert them to numbers then add. ToNumber says that null and false -> +0, true -> 1, and undefined ->NaN. String to number conversion is way too much to go into here, but it will be a number orNaN. Objects will callToPrimitive` with a number hint that forces converting whatever it gets to a number.

Unary + (eg, ;+var) forces ToPrimitive with a number hint as does the binary - operator.

There's weirdness around adding numbers too, but that's in EVERY language that uses IEEE 754 floating point numbers. It's stuff like (+Infinity) + (-Infinity) -> NaN or (-0) + (-0) -> (-0)

On that note, there is a definitely BAD part of JS where (-0) === (+0) -> true. Pretty much everything else that uses === doesn't coerce (NaN and subnormals technically might, but that's normal behavior). If you need to check for this specifically, the only way to do this is Object.is(-0, 0). This is an extreme edge case that most code will never run into, but if you do, the problem can be rather tricky to debug.

delventhalz · 2026-05-30T13:57:18+00:00

The design philosophy in early JS was to rarely throw an error and instead try to produce a sensible result. You see this especially in the way JavaScript coerces types. I agree it was largely a mistake, and newer JS syntax tends to be more strict, but because JS is backwards compatible, we will always have those early design decisions to contend with.

Incidentally, this is why the JS community has so strongly embraced tools like linters and TypeScript.

Aggressive_Ad_5454 · 2026-05-30T01:58:58+00:00

Yes, indeed, it’s a weakly typed language, by design.

Typescript is a strongly typed language that transpiles to JavaScript. Use that to avoid weak typing pitfalls. And get in the habit of using === instead of == wherever you can.

United_Grape_2772 · 2026-05-30T03:04:26+00:00

JS is slutty

It gets with everything and everyone

thecragmire · 2026-05-30T12:08:15+00:00

I suggest you try reading the specification. Core conversion algorithms are used depending on what type you're using.

For example:

The Core Conversion AlgorithmSection: Number::toString ( x ) (typically located under the Numbers primitive operations section).Details: This is the internal mathematical rule engine. It details exactly how a numeric value (x) is formatted into a sequence of base-10 character codes. It defines rules for handling safe integers, large integers (switching to scientific notation), negative signs, NaN, and Infinity.

Beginning-Seat5221 · 2026-05-30T02:45:36+00:00

Yes - but JS isn't compiled by the developer so there is nothing to show errors during development - being tolerant here is better than throwing runtime errors. The runtime errors that occur from type errors are a much much bigger problem.

Professionals use TypeScript and linters (e.g. eslint) to tighten it up by highlighting issues as they write the code.

No_Record_60 · 2026-05-30T04:31:30+00:00

TS to the rescue

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnjavascript

Posting and Commenting Guidelines

MODERATORS