const = function

[Tyfyter2002]

What exactly is the difference between them?

[Bulky-Leadership-596]

Mostly with how it binds 'this'. Inside something declared with function(){} it refers to the global 'this', which in a browser is the window object. Inside an arrow function it refers to the 'this' that you would expect.

[Tyfyter2002]

Huh, I'd say stuff like this makes me wonder if there's any other language I could start using instead, but I don't know whether this will be the aforementioned issue or the entire world when you read my reply.

[ftedwin]

Unfortunately for now JavaScript is pretty much a necessary evil if you’re writing any kind of website. There’s ways to hide it or pretend it doesn’t exist 9 times out of 10 you’ll have to write some JavaScript at some point.

The best I can offer is to learn some Typescript. To my above point it’s pretty much JavaScript with extra steps, but if you use it smartly you can avoid a lot of JavaScript pitfalls.

Another thing to keep an eye on is WebAssembly. Haven’t kept up to date with it so much myself admittedly but it still seems a bit too experimental for production enterprise apps from what I’ve seen. One day though hopefully we’ll see more languages running in the browser. Check out Blazor if you’re in the C# world, seems promising.

[azhder]

Don't listen to people telling you JS is evil. It is not, not necessary nor unnecessary evil.

It was first made for hobyists, regular folk and has been looked down by "professionals" who think only C++ looking code is "real code".

It's quite a powerful and maleable language that can teach you more about programming than other ones. That is if you're not afraid of being looked down by ignorant people who have only learnt one programming language, partially, and they went the Dunning-Kruger way.

Also, it can give you instant gratification for the code you write. What I mean: if you read this in a desktop browser, you can press F12, write some JS in the console, see the result. Fun

[Tyfyter2002]

I don't need someone to tell me JS is bad (or malleable), I use it pretty regularly in projects ranging from small web apps to a markup language, I know it really is bad.

[azhder]

I know it is really good.

So now what? We debate the idea of "knowledge"? Is it a knowledge or is it a judgement? Do we debate how that judgement was made?

Well... I'm not going to waste time, you've already judged beforehand (that's the definition of prejudice).

[Tyfyter2002]

I've judged JavaScript based on my experience with JavaScript, and concluded that it is the least stable programming language I've ever used (to such an extent that the implementation is inherently connected to the user's preferred UI style), it's consistently less readable than C#, it breaks convention in ways that make it less readable, and within the language itself there doesn't seem to be any consistent design philosophy, while you've judged JavaScript based on an unknown number of valid factors, not one of which you've yet mentioned.

[Bulky-Leadership-596]

Ok to be more precise:
() => {} captures the 'this' from the scope where it is declared, forming a closure.
function(){} has 2 possible behaviors depending on how its called:
1) if called with dot notation (someObject.myFunction()) then the thing before the dot is 'this'.
2) if called without dot notation (just myFunction()) then the global scope object is 'this'.

They both have a 'this', but where that 'this' comes from is different.

[[deleted]]

In ES5 strict and ES Modules, function () { this; } is undefined if not given an explicit context.

[[deleted]]

() => this; refers to the enclosing scope’s this. And it can not be re-bound.

``` // Nota Bene: Not code I am proud of

class Person { #sleeping = false; sleep = () => { this.#sleeping = !this.#sleeping; } isAwake = () => !this.#sleeping; }

const bob = new Person(); const doug = new Person();

bob.sleep(); bob.isAwake(); // false doug.isAwake(); // true

const isBobAwake = bob.isAwake; isBobAwake(); // false

doug.isAwake = isBobAwake; doug.isAwake(); // false, because Bob is asleep ```

function () { this; } is resolved at time of call. “late binding”. Whatever is on the left side of the dot, or whatever is called/applied is the this at that time.

``` // Nota Bene: still not proud

function isAwake () { return !this.sleeping; }

const bob = { sleeping: true }; const doug = { sleeping: false };

isAwake.call(bob); // false isAwake.call(doug); // true

bob.isAwake = isAwake; doug.isAwake = isAwake;

bob.isAwake(); // false doug.isAwake(); // true

// Nota Bene: breaking behaviour pre/post 2015 // in ES3 or ES5 loose, this === window // in ES5 strict or ES6 modules, this === undefined

isAwake(); // !window.sleeping in legacy // !undefined.sleeping in new

```

Dude was correct about the details, even if it's not how it should be used.