this post was submitted on 04 Jun 2025
982 points (98.5% liked)
Programmer Humor
23795 readers
2603 users here now
Welcome to Programmer Humor!
This is a place where you can post jokes, memes, humor, etc. related to programming!
For sharing awful code theres also Programming Horror.
Rules
- Keep content in english
- No advertisements
- Posts must be related to programming or programmer topics
founded 2 years ago
MODERATORS
you are viewing a single comment's thread
view the rest of the comments
view the rest of the comments
If you mix types like that, it's your own fault
BS. A language shouldn't have operators that allow non sensical operations like string concatenation when one operand is not a string.
Especially that + and - act differently. If + does string concattenation, - should also do some string action or throw an error in this situation.
Like what kind of string action?
"Hello" + " world" is what everyone can understand. Switch with "-" and it becomes pointless.
this the “or throw an error”
If you try what I wrote it will throw a NaN. I was asking about the first part of the proposal.
The NaN isn't an thrown. It's just silently put into the result. And in this case it's completely unintelligible. Why would an operation between two strings result in a number?
"Hello" - "world"is an obvious programmer mistake. The interpreter knows that this is not something anyone will ever do on purpose, so it should not silently handle it.The main problem here is downward coercion. Coercion should only go towards the more permissive type, never towards the more restrictive type.
Coercing a number to a string makes sense, because each number has a representation as a string, so
"hello" + 1makes intuitive sense.Coercing a string to a number makes no sense, because not every string has a representation as a number (in fact, most strings don't).
"hello" - 1makes no sense at all. So converting a string to a number should be done by an explicit cast or a conversion function. Using-with a string should always result in a thrown error/exception.You basically defied the whole NaN thing. I may even agree that it should always throw an error instead, but... Found a good explanation by someone:
And the above example fits that.
Yeah but actually there can be many interpretations of what someone would mean by that. Increase the bytecode of the last symbol, or search for "1" and wipe it from string. The important thing is that it's not obvious what a person who wrote that wants really, without additional input.
Anyway, your original suggestion was about discrepancy between + and - functionality. I only pointed out that it's natural when dealing with various data types.
Maybe it is one of the reasons why some languages use . instead of + for strings.
Well, technically this is the explanation, it really isn't a good one.
x + 1with x not being defined also doesn't result in aNaNbut instead it throws a reference error, even though that undefined variable isn't a number either. Andx = 1;x.toUpperCase();also doesn't silently do anything, even though in this case it could totally return"1"by coercing x to a string first. Instead it throws a TypeError.It's really only around number handling where JS gets so weird.
That's exactly the thing. It's not obvious what the person wants and a
NaNis most likely not what the person wants at either. So what's the point in defaulting to something they certainly didn't want instead of making it obvious that the input made no sense?A similarly ambiguous situation would be something like
x = 2 y. For someone with a mathematical background this clearly looks likex = 2 * ywith an implicit multiplication sign. But it's not in the JS standard to interpret implicit multiplication signs. If you want multiplication, it needs to explicitly use the sign. And thus JS dutifully throws a Syntax Error instead of just guessing what the programmer maybe wanted.My main point here was that if you have mathematical symbols for string operations, all of the acceptable operations using mathematical symbols need to be string operations. Like e.g.
"ab" * 2 => "abab", which many languages provide. That's consistent. I didn't mean that all of these operators need to be implemented, but if they aren't they should throw an error (I stated that in my original comment).What's an issue here is that "1" + 1 does a string concatenation, while "1" - 1 converts to int and does a math operation. That's inconsistent. Because even you want to use that feature, you will stumble over
+not performing a math operation like-.So it should either be that +/- always to math operations and you have a separate operator (e.g.
.or..) for concatenation, or if you overload+with string operations, all of the operators that don't throw an exception need to be strictly string-operations-only.That's the case in many languages, pretty much in all that don't have a separate string concatenation operator.
Yeah, and almost all languages I know then would throw an exception when you try to use
-with a string, and if they offer multiple operators that take a string and a number, they always only perform string operations with that and never cast to a number type to do math operations with it.(e.g. some languages have
+for string concatenation and*to add the same string X time together, so e.g."ab" * 2 => "abab". It's a terrible idea to have+perform a string operation and-performs a math operation.)Sure, but then your issue is with type coercion, not operator overloading.
Because there's in fact no operator overloading happening, true, but that's mostly an under-the-hood topic.
It should not happen no matter why it does happen under the hood.
Operator overloading for
string - stringis wrong and type coercion to implicitly cast this toint(string) - int(string)is just as wrong.There is operator overloading happening - the
+operator has a different meaning depending on the types involved. Your issue however seems to be with the type coercion, not the operator overloading.If you don't want it to happen either use a different language, or ensure you don't run into this case (e.g. by using Typescript). It's an unfortunate fact that this does happen, and it will never be removed due to backwards compatibility.
For
string + stringandnumber + numberthere is operator overloading, that's correct. Forstring + numberthere is not, there's only type coercion. It becomesstring + string(number). All of that is fine. Other languages do that as well.What's not fine is that JS also looks the other way on the type coercion tree: There's no
string - stringoverloading, so it goes down the type coercion tree, looking for any-operation that it can cast to and it ends up withnumber(string) - number(string), which makes no sense at all.It's not the point of the discussion that there are other languages that are better. This here is about complaining about bad language design, and no matter how you turn this, this is not a matter of taste or anything, this is just bad language design.
You are obviously right that this crap will stay in JS forever. That doesn't make it good design.