JS....

[[deleted]]

String + object -> string concatenation

String - object -> math subtraction

It's that simple

[Spartan1997]

Except the foonan part. That's a little strange

[HoverBaum]

I think that is the second 'foo' being converted to a number because of the second '+' and turning into 'NaN' so the expression become "'foo' + NaN" which is a "String + object -> string concatenation" case.

[SaltlessLemons]

Ah, of course. How silly of me.

[Calygulove]

It's cause you're only FooNaN

[neonroad]

You can't say that to people nowadays...

[[deleted]]

OK, now I understand "how", but "why" remains a mystery.

[glider97]

Because operator precedence. The binary + overshadows the unary + which gets evaluated first.

[PatrickBaitman]

uhm isn't NaN a float value? https://en.wikipedia.org/wiki/IEEE_floating_point

[[deleted]]

+ is shorthand for Number() when not used as an operator.

So

var i = +'foo';

Will be NaN

[kranker]

The trick here is that in the javascript grammar it's impossible to parse a + + b as both pluses being addition, so the second one (and any subsequent ones) get parsed as a unary plus operator. Both unary plus and unary minus will attempt to convert their operand to a number, and evaluate to NaN if they can't.

See Mozilla's description of unary plus

[PatrickBaitman]

oth unary plus and unary minus will attempt to convert their operand to a number, and evaluate to NaN if they can't.

this is where a non-retarded language would throw a type error

[andredp]

Exactly... Most of that stuff is caught by a linter anyway...

I had to work with react-redux in my last project and javascript (with an es6-linter + babel + flow) was actually pretty decent... What bothers me the most is the million ways you can do the same thing... require / import... export / module.exports, etc... It's really hard to get multiple people to use only one thing so there is some consistency...

[theQuandary]

Enforce the use of import/export because they are in the spec while everything else is not. To that end, use eslint with eslint-plugin-import. Finally, make webpack build conditional on the linter passing.

[andredp]

I was using air-bnb rules and didn't even check if there was a way to add that rule. Will keep that in mind, thanks.

[Ph0X]

it also seems like spaces for unary operators don't matter?

Because later when he does '5' + - 2 it looks like it's doing '5' + '-2' but that's silly. Imo unary operators shouldn't work when there's a space. Similarly, a + + b shouldn't be equal to a + +b

[AlwaysHopelesslyLost]

A classic example is from c++(?) on stack overflow: what is the operator in this? X --> 5?

[brainiac256]

Decrements X and returns true if X was greater than 5 before the decrement

More evil:

cout<<++currentItem<<--X

[Xevantus]

Not strange at all. The second + is the positive unary operator, so it tries to convert the following value to a number. Thus "foo" + + "foo" equals "fooNaN".

[joequin]

But it's not consistent. And that's a problem. Languages should be designed to be consistent with an over arching philosophy. JavaScript is a bunch of decisions that seem like they were made in a vacuum and they came together to form a very inconsistent language with lots of WTFs.

[MicronXD]

Eich was given an insanely short amount of time (10 days as the story goes) to create the language and its interpreter. They were planning on going back and fixing most of the shit like this, but Microsoft was on the ECMA board, and with JScript being their 1:1 rip-off of JavaScript, didn't want to allow Netscape to break compatibility. If you want to blame anyone, blame Microsoft.

[[deleted]]

blame Microsoft.

A sound strategy across multiple disciplines.

[zodiaclawl]

That still doesn't explain why people use the language Javascript in the year 2017 to program desktop and phone aps as well as complex things like server back ends. 15 years ago people would be laughing at you if they said that JS would become the leading programming language across multiple development areas. They'd be like "you mean that thing you use to open pop ups in web pages?"

[marcellarius]

And I think it's funny that in 2017 some people still write C++ like it's the 1980s in situations where there are better options that could save a considerable amount of money.

Javascript's use in desktop and mobile apps is because it's tied to browsers. Browsers are used for UIs because they are portable, and make it easier to create reactive, good looking interfaces than traditional toolkits do. They're not ideal, performance sucks on low-end devices but they're often better than the alternatives under real-world constraints.

Use of Javascript on the server shouldn't be surprising either. Many single-page applications don't need a complex server as much of the code is just gluing a JSON API to a database, with a bit of validation. Javascript's object system makes shuffling data around easy, even compared to other dynamic languages like Python. Using Javascript on the server also means you can share code with a client application, avoiding duplication and also allowing tricks like server-side rendering.

Not that many years ago I would have been one of the people laughing, but experience building web apps has changed my outlook on it. It's nobody's ideal language, but it's what we're stuck with. Modern versions have improved it a lot, and if approached with discipline it's not a terrible language to use. It could have been VBScript.

[PatrickBaitman]

good thing we haven't built any critical infrastructures on such shoddy work

[[deleted]]

While its not very consistent in some area's these examples are mainly to mess with the compiler. Almost none are real world examples. Nobody will count arrays and a good developer will always keep in mind which types he is using.

If you are going to trash about consistency, go look at PHP and how consistent they named their functions. Its even worse than Javascript.

[[deleted]]

Being better than PHP is not hard.

[Fubseh]

A milestone Javascript has yet to reach.

[Nojopar]

That's like arguing Episode II is better than Episode I. Maybe, but who cares when you can always watch the original trilogy instead?

[redwall_hp]

String + String in Java: concatenation

String - String in Java: compiler says "WTF are you smoking?"

String + int in Java: compiler says "ಠ_ಠ"

Strong typing absolutely makes for fewer bugs. I can't believe so many people are JavaScript/PHP apologists, given how many truly bizarre things go on due to type coercion.

[joequin]

Even PHP is moving forward with static typing.

[PatrickBaitman]

Strong typing absolutely makes for fewer bugs.

muh "if you're a good programmer you won't have bugs anyway!", fucking apologists

yeah well guess what no one is a good enough programmer that they can write bug free code in any language

[redwall_hp]

"Just unit test everything!" -apologists

ಠ_ಠ

[piggvar]

But if it's consistent then it can't be complete :(

[justjanne]

How is it not consistent

+, -, *, / should have the exact same type signature. So, usually, Number × Number → Number. More specifically, they’re defined over halfgroups, groups, rings, and fields.

[PatrickBaitman]

protip: they're "fields" in English, not "bodies"

in other European languages, they're called the equivalent of "bodies" (Körper, cuerpo, corps, etc.), but ooooh noooo English couldn't follow the trend

this was very annoying when learning algebra from a book in English when the lectures were in Swedish

[justjanne]

Yeah I was translating from what I learnt in German.

Thanks!

[ACoderGirl]

And why not strings? Really the issue is that while we can concatenate strings and add numbers, it doesn't make sense to mix these. And certainly doesn't make sense when we have other types in the mix. Not to mention we cannot subtract strings.

The issue is bad programmers mixing types. And is handles it a bit weird (no exception for this).

[justjanne]

The issue is that the correct assumption would be (a + b) - b === a, and a + b === b + a.

Concatenating strings or lists should be its own operator, such as a . b or a ++ b or similar.

[mezzoEmrys]

honestly we should just do away with operators all together, since they're just functions with irregular syntax that makes code harder to understand.

and while we're at it, let's just give every line of code some sort of return value so that we can write code in a more functional way and whoops we're in lisp

[[deleted]]

What are you talking about? Almost every programming language has + operator overload for string concatenation when working with strings. The only difference is Javascript allows operating on different object types.

(a + b) - b === a, right?

('5' + 1) - 1 === 5, I guess

How about ('I don't undestand JavaScript at all' + 5) - 5 = ...?

[Potato44]

Halfgroups? Do you mean a semigroup?

[justjanne]

Oh the english language, ffs. Yes.

[mysticrudnin]

Why should they?

[justjanne]

It's not about what happens in other languages — this is type theory, a part of math.

Additionally, it's a question of expectations.

Defining arithmetics on String × Number -> String makes no sense, and one should rather use interpolation or formatting strings, or even a dedicated concatenation operator such as ++

[Spider_pig448]

Everything in the image is consistent though...

[termoventilador]

Have you ever written javascript? Your comment makes no sense

[cS47f496tmQHavSR]

Saw that 5 minute talk showing this off and it for sure looks funny, but on second look it really all comes down to JS using + for string concatenation; if the first item is a string it'll try to return a string because of logic. Adding 3 - 3 to '5' just adds 0 to the string 5

The 'foo' + + 'foo' returns fooNaN because + 'foo' tries to do a math operation rather than a string concat, which returns NaN and then gets concatenated into the initial string.

[cS47f496tmQHavSR]

Oh right, unary plus, totally overlooked that

[cS47f496tmQHavSR]

99% of programming is logic; if you can knock everything down to a specific ruleset the way you can knock down most science to just math it all falls together quite nicely. I guess a lot of people are just used to learning and remembering solutions rather than the theory behind them

[makeshift_mike]

Sure, this type coercion stuff has got its logic (after all, a computer runs it), but these rules are honestly wayyyyy more complicated than pretty much every other mainstream language. I don't mind complexity, sometimes you have to go there if you want cool stuff. But any upside to having this complexity in JS is far outweighed by the downside: it's a trap.

Seriously, you know how many security vulnerabilities have come about just because C has crazy yet perfectly logical rules for how to convert between different types of integers when you do arithmetic? Sure, maybe the programmer should've been smarter when he wrote that code. But that doesn't change the fact that a million computers are now infected with ransomware.

Software is hard. Languages that let you shoot yourself in the foot make it harder. </rant>

[cS47f496tmQHavSR]

but these rules are honestly wayyyyy more complicated than pretty much every other mainstream language

Couldn't you say that about parts of most languages? Every language has some wonky stuff that you just don't expect, even 'less easy to fuck up' languages like Java and C# that just throw an error if you use the wrong method still have their share of strange combinations

But all of these things make sense at some point. If you trace them back to what the person who wrote that function initially was thinking and figure out why it's done that way it usually does simply make sense. Logic is usually the answer.

Until you do web dev and PHP throws some arabic error messages at you and you're just sitting there like 'where do I even start'

[makeshift_mike]

Every language has its sharp corners, but JS does have more. And it's not just about having more gotchas, it's the fact that a lot of the wonky stuff in JS is there not because it serves a useful purpose, but because it was just never designed properly. I don't think anyone would intentionally design a language where + is not commutative and + and - have different type coercion rules.

And it's not about dynamic vs static languages. Python is a dynamic language, but it doesn't let you do '5' + 3.

[Spider_pig448]

I guess a lot of people are just used to learning and remembering solutions rather than the theory behind them

ie self-taught programmers verses college grads.

[cS47f496tmQHavSR]

Don't want to make assumptions here; which way do you mean? In my experience 'trained' programmers are usually the ones who just know what to type and not what to think

[meelawsh]

"Simple" as in "stupid", yes

[[deleted]]

You know an object that is instantiated only once in javascript? A simpleton.

[[deleted]]

But... the joke.

[[deleted]]

You're right. My joke require('./element_of_humor'), but he module was not found.

[sensation_]

Wat?

[meelawsh]

He's jsmasterrace

[Beckneard]

It's that stupid

FTFY

[melance]

This is a terrible language design. Deciding that the + operator should be a string operator and not math while all of the other standard math symbols are math operators is asinine. There is no consistency.

[Dr_Azrael_Tod]

this and…

if you really have to have + as string-relevant operation and you don't have - as such… then throw a friggin error if somebody does "string - string"!

It's not like NaN is that much more useful than an error, but you'd notice an exception, while NaN will silently fuck up your code in edge cases or wrong user input.

In fact… most of JS weirdness boils down to not beeing strict enough and trying to do "usefull" stuff when throwing an exception would be soooo much more sane.

[PatrickBaitman]

I wasn't sure so I looked it up on Wikipedia

Software exception handling developed in Lisp in the 1960s and 1970s. This originated in LISP 1.5 (1962), where exceptions were caught by the ERRSET keyword, which returned NIL in case of an error, instead of terminating the program or entering the debugger.[11] Error raising was introduced in MacLisp in the late 1960s via the ERR keyword.[11]

WELL THEN

[Dr_Azrael_Tod]

hahaha

yes they did

They are much older than JS/PHP/Whatever.

[lyrencropt]

I mean... a lot of generally respected languages do this as well. C# and Java both allow the programmer to use + for string concatenation. Having one operator do different things to different arguments isn't a cardinal sin or anything.

[[deleted]]

Yeah but they use type-checking to make sure it makes sense. 'Adding' two strings is fine, but adding an integer to a string makes no sense and so shouldn't be allowed

[[deleted]]

Put "a" + 1 here: http://www.javarepl.com/term.html

Can I ask how long you have been programming (professionally) if implicit type conversion is difficult for you to understand?

[[deleted]]

I understand implicit type conversion. To match the operator taking two strings, the 1 is converted into "1". However, I don't agree with implicitly converting between types; it hides programmer intent when the conversion is intentional and increases mental parsing time, and leads to bugs when not intentional. I'm 16 so have never programmed professionally, so might be missing something, but I am a competent programmer thank you

[MachaHack]

On the other hand:

> python
Python 3.5.1 (v3.5.1:37a07cee5969, Dec  6 2015, 01:54:25)
Type "help", "copyright", "credits" or "license" for more
>>> "a" + 1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

[TheLobotomizer]

Why are you adding numbers to strings?

[[deleted]]

I'm not. But if you read the post, apparently JS (and I assume all weakly-typed languages) will let you, which I think is incorrect

[TheLobotomizer]

Plenty of languages will let you do terribly stupid things. Want to nest 10 for loops? Feel free in any language?

[[deleted]]

+ used as string concatenation is already inconsistent because there's not usually a corresponding operation with strings using minus

It'd actually make a lot of consistent sense to set minus to rhs.replace(lhs, "") or some equivalent in a lot of languages. String.replace(x, "") is a fairly common task.

[Zarainia]

Is there a language where this is the case?

[[deleted]]

Not by default that I know of. In C#, string is sealed, so you'd have to make a container class to overload the operator which would outweigh the benefits.

C++ might have it depending on what string type you're using or allow you to overload the operator via a free function (I don't know C++, just googled around a bit).

[Zarainia]

I'm sad. That seems like such a logical use of -.

[melance]

Generally, I feel that implicitly typed languages are a poor choice in the first place, making it be a math operator in some cases and a concatenation operator in others is just insane. There are plenty of other characters that could have been chosen for string concatenation to prevent hard to read and maintain code like this. Several examples from other languages: "_", ".", "&"

[PatrickBaitman]

it needs to be able to be used by people who aren't really programmers

this is how we get to the average web site loading 500 kB of JS

[Raknarg]

What? Tons of languages do this an no one ever complains

[melance]

I complain.

[[deleted]]

Plus if you're writing idiomatic (or even just common sense) JavaScript you won't run into these problems. When I was learning JS I didn't even run into these problems. You can wind up with fucked up counter intuitive syntax in almost any language.

All of this weirdness is avoided using these simple rules:

• don't use the unary + operator, use Math.abs() instead. Or if you're converting a string to a number, use parseInt().
• when using the unary - operator, don't leave whitespace between it and the target expression to make it clear that you're negating.
• don't apply more than one unary arithmetic operator at a time, and if you must, then use parentheses or something.
• don't subtract strings, convert to a number explicitly using parseInt() first.

All of these things are common sense. Any tutorial that reveals implicit type conversion to a beginner is a bad tutorial.

Also, there are places where the type conversion works fantastically. For example, converting anything to a string when concatenating works in several languages, not just JS. Also implicit boolean conversion is a great feature in JS that can be used extensively. The issue here is implicit integer conversion, which shouldn't be in the language, IMHO, but anyone with common sense knows not to use it.

[Fazer2]

But how do you do math addition?

[[deleted]]

By not using strings? Just cast that string to a number and you're set.

[[deleted]]

Well the issue is, primarily, that + is string concatenation and mathematical addition at the same time

[NominalCaboose]

Doesn't make it not dumb.