- cross-posted to:
- programmerhumor@lemmy.ml
- cross-posted to:
- programmerhumor@lemmy.ml
You must log in or register to comment.
It makes sense though
It does to some degree.
- “11” is string, 1 is an int, because strings can be added (+) convert int to string and combine: “11”+“1” = “111”
- “11” is string, 1 is an int, because strings cant be subtracted (-) convert string to int and combine: 11-1 = 10
I’m not into JS so I don’t know how it takes priority. ints can be added too, so I guess its basing it on the first variable which is compatible with the operator: in the first case string, in the second case int.
If this is how it works, it makes sense. But imo its a case of the designers being preoccupied with whether or not they could, they didn’t stop to think if they should.
This here is my absolute favorits way to diss someone. Send the a wikipeda link and bam!
What no type safety does to an MF…
Imagine doing math with strings and then blaming the language not yourself
The risk is when it happens unintentionally. The language is bad for hiding such errors by being overly ‘helpful’ in assuming intent.
Sure, but at this point it’s your own fault if you don’t use Typescript to keep these issues from happening.
“Use a different language” is a common defense of javascript, but kind of a weird one.
Not really, considering Typescript only adds static types to JS. It’s not a different language, it’s an extension.
Since it needs to be compiled to JavaScript in order to be used, I kind of consider it a different language. Yes, it’s a strict superset of JavaScript, but that makes it different.
So, just don’t use JavaScript?
That’s also my understanding: “Javascript is great because you can use other languages and then transpile them to JS.”
This is too stupid so I had to check.
Fuck me.
pro tip:
"ba" + 0/0 + "a"This has got to be baNaNa
From all the Javascript quiks this is the least stupid and the most obvious.
Unfortunately, it makes sense if you know what + means, which is concatenate. - is strictly a math function though.
Not saying that makes this better. It just makes sense.
Hm, playing devil’s advocate, I think it is because the minus has not been defined as a string operation (e.g. it could pop the last char), so it defaults to the mathematical operation and converts both inputs into ints.
The first is assumed to be a concat because one of the parcels is a string…
It’s just doing a lot of stuff for you that it shouldn’t be in first place 🤭
Yeah, this looks dumb on the surface, but you’ve got bigger problems if you’re trying to do math with strings
Yup. It’s completely inconsistent in its interpretation of the + operator.
Yeah, I actually had to try 1+“11” to check that it didn’t give me 12, but thankfully
it commutesit’s consistent 😇it commutes
Maybe the behaviour with regard to type conversion, but not for the operation itself.
“13”+12 and 12+“13” don’t yield the same result.
Nor would I expect “1312” to equal “1213”… Still that operator with these operands should just throw an exception
People that try to do mathematical operations with strings blaming the programming language that had a stated design goal to do its best and try to keep running scripts that make no sense because they realized it would be used by people that have no idea what they are doing. Clearly they were right.
it would be used by people that have no idea what they are doing. Clearly
And so let’s enable these people?
Let’s add AI to the mix while we’re at it.Now that you mention it, it is a bit funny how Lemmy is hating LLMs as a code generation tool while also hating on the interpreter for their own hand typed code not running.
I seldom use an interpreter.
Then you do not do Javascript, because it is an interpreted language.
Edit: or Python, or a command line shell, or any CORS, or databases, or… Well idk really what you do use honestly.
the programming language that had a stated design goal to do its best and try to keep running scripts that make no sense…
…itself makes no sense. It is wrong and bad that Javascript was ever designed that way in the first place.
It was never intended to run full applications but only the small business scripts and hobbyist homepage stuff that were the thing in the 90s, across inconsistent browsers that were a jungle of hit and miss behaviour where it was preferred that menus keep working even if the mouse effect was not. Anything of scale was expected to be done in Java. Dynamic web pages did not exist and as anything not static was generated server side into a static html file to be rendered on the client.
Anyway, back then it wasn’t considered the job of the programming language to hold the hand of the aspiring developer as it is common today. It’s not a bad thing that IDE and even compilers and preprocessors try to help you write better code today, but then it simply didn’t exist.
JavaScript is from a different time and because it has the hard requirement or backwards compatibility there is no changing it and has not been for thirty years except to add stuff to it.
I think it’s just silly to ask the past to keep up with the present. Bad code is not the fault of the language regardless, even though junior devs and even seasoned ones like to think so to protect their ego. I think it is better to accept it, learn from it and roll with it because every single platform and language has their weird quirks anyway.
Signed, old dude that learned programming in 8 bit BASIC and 6502 machine code without an assembler, where code bad enough would freeze your machine that required a cold boot and starting over from your last save that you didn’t do.
That is just the tip of the iceberg:
so plus coerces into string if not number, was that so hard?
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.
- should also do some string action
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.The interpreter knows that this is not something anyone will ever do on purpose, so it should not silently handle it.
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:
NaN is the number which results from math operations which make no sense
And the above example fits that.
"hello" - 1makes no sense at all.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.
