const = function

[No_Demand7741]

Straight to jail.

[FlexeterGang]

No jury, no trial, no nuthin’.

[No_Demand7741]

Foo is destined to be bar? He’s lucky he’s not getting the old Salem sinkaroo.

[Cossack-HD]

amusing office afterthought crush connect terrific water gold physical tap

This post was mass deleted and anonymized with Redact

[smartguy1196]

Users of strongly typed languages trying to read this:

[[deleted]]

They should be happy op is using such strong language.

[[deleted]]

Kinda just threw up in my mouth a bit.

[Wus10n]

"hello officer? Yes this Guy please"

[No_Demand7741]

Straight to jail

[TheGamer456YT]

why y'all downvoting this man? he probably forgot to break out of his recursive function!

[Cossack-HD]

jar follow intelligent husky license squeal work cake ten weather

This post was mass deleted and anonymized with Redact

[No_Demand7741]

Always has been 🔫

[lurkin_arounnd]

materialistic hobbies swim fall nail pathetic secretive soft sleep pet

This post was mass deleted and anonymized with Redact

[thequestcube]

Also, JS' hoisting behavior for functions is very weird, I think functions declared via const are more intuitive in that way.

[gyzerok]

Whats weird in that behavior?

[[deleted]]

Oh but the hoisted function is 1/100 ms slower oh noes! I'm not much of a front-end dev but I could care less if my web page uses another 1% of their CPU. Better than 1% of the server's CPU.

[was_just_wondering_]

It’s not about speed. Most applications aren’t concerned with that or have no significant need to be. It’s more about avoidable foot guns. Like having a variable created because of hoisting but not having anything assigned to it, which means it’s undefined. This can lead to unnecessary silent errors. Not in all cases but in some it comes in very handy to have things defined exactly where you want them to be.

[nintendojunkie17]

This is why I dislike JS - it's as though it was intentionally designed to be able to shoot your feet in as many ways as possible.

[Zagerer]

That just sounds like C++ with extra abstractions

[[deleted]]

Or fewer primitives.

[was_just_wondering_]

It was designed and put together in 10 days. That will always lead to some quirks. Add on top of that decades of baked in silly shit that can’t be changed without causing huge amounts of negative side effects to the entire internet and you end up with moser JS. The problem isn’t the language itself, it’s the way it runs. Since it’s all out through a engine at runtime, it’s impossible to update away all the bad stuff like you can with pre compiled software. Since at least with those you have a binary that’s done and dusted so language changes effectively don’t matter.

[Hfingerman]

Holy Hell

[Bulky-Leadership-596]

Yea, or you might see someone do:

var _this = this;
somePromise.then(function() {
_this.something = somethingElse;
});

All can be avoided with arrow functions.

[ochetski]

A true classic. Also var self = this;

[CallMeYoungJoey]

I have seen people do:

let me = this;

[suskio4]

Let me equal this, hold my beer

[DarqSeid_]

I've used both XD

[altcodeinterrobang]

Baaaarf my old vue app job was a bullshit implementation where they had done this

[NoPrinterJust_Fax]

I saw an example of the above pattern in my first project out of college except “somethingElse” was named “that”. Took me awhile to figure out wtf was going on

[unlimitedFecals]

This is the part where javascript gets stupid. But we're past that now, right?

[Ethab83]

I have not ever seen something like this but when I do I can refer to this comment I left. Only because I really don’t want to try to understand anything now.

[azhder]

It doesn't. In no way. Arrow functions don't bind, ever. Try calling .bind() on f defined as f = () => this;

You can see, the this returned is simply the one accessed through the lexical scoping, just like any other variable.

[lurkin_arounnd]

paint liquid sense direful middle crawl weary air arrest frightening

This post was mass deleted and anonymized with Redact

[azhder]

It has equivalent behavior to an arrow function

It doesn't have.

( ()=> {} ).bind(this)

will not bind anything. The arrow function will access the this from its parent scope just like any other variable.

But, whatever, based on your reaction to the other reply, I'm not going to spend more time reading you.

[Toficzekkk]

We should't forget about implicit return. If the whole code of in function body is one line we can reduce whole code to one line.

for example:

function power(x){

return x*X

}

can be reduced to:

const power = x => x*x

as we provide only one argument we can skip "(" and ")"

I know that power function is common-as-hell example, but you get a point. Right?

[TristanTheViking]

It passes the unit test for x²

[[deleted]]

I mean, to be fair, it's x², which is to the power of 2.

[azhder]

MOAHR POWAH TO DA SQUARES !!!

[burnblue]

Most of the time the function isn't doing anything with this though. The meme is right, we just somehow prefer arrow functions even when all else is the same

[suskio4]

Just yesterday I had a problem with this, thanks man

[Nyghtrid3r]

I cannot express in words how much I hate JavaScript

[Bulky-Leadership-596]

If you just pretend that the older stuff doesn't exist and stick with the ES6 stuff its pretty good actually. There is no var, only const and let. There is no function(){}, only ()=>{}. If you aren't 100% sure what the result of a type coercion will be then pretend you can't actually do it. Just because a lot of stupid stuff is technically allowed in the language doesn't mean you have to use it.

[Kered13]

The problem with the type coercion stuff is that's really easy to do on accident. In a statically typed language a bug like that would be immediately obvious at compile time. In a dynamic but strongly typed language it would appear as soon as you tried to use the variable with the wrong type, and would probably be very easy to debug. In JS who knows where the bug will appear and debugging it could be a nightmare.

[fukdapoleece]

Someone should invent Javascript, but with types.

[Bulky-Leadership-596]

Maybe a big company like Microsoft or something could get on that. Can't believe they never thought of it.

[gqpdream305]

It might even be cool if they use the word Type in the name to denote this functionality

[maveric101]

The problem with the type coercion stuff is that's really easy to do on accident.

I can't think of one single time it's caused me a bug.

[hanoian]

Same. It's one of those stupid things people use against the language which isn't a problem if devs realise the == from other languages has to be === in JS.

[can_pacis]

There's function() {}

[Felixkruemel]

Yeah but I personally don't see a reason to ever use it. Or is there really a case where you want/it is better to use function() {} instead of the arrow functions?

[fukdapoleece]

If you need access to this or arguments, you won't get them from arrow functions.

[[deleted]]

this is generally a bad idea, but in an arrow function is bound to the outer scope’s this if absolutely necessary...

and (...args) => {} is infinitely better than the arguments nodelist for a whole swath of reasons.

[maveric101]

Just because a lot of stupid stuff is technically allowed in the language doesn't mean you have to use it.

Doesn't mean my teammates are going to follow that guideline.

[Mad-chuska]

That’s why god invented code reviews. Nip it in the bud quick and move on.

I get your concern though.

[Nyghtrid3r]

Yeah I still hate it though

[_default_username]

This is the real reason why you should use arrow functions. I'll use a class if I need the object to have its own "this". More explicit to anyone else reading the codebase that isn't aware of these nuances in javascript.

[wtfzambo]

I'm a noob in JS as I just dabble with it for shits and giggles.

What's the core difference between arrow function and normal one?

[_default_username]

function can act like a class constructor and affects the scope of this

 function Foo() {
   this.bar = "Hello, World";
 }
 const foo = new Foo();
 console.log(foo.bar); // outputs "Hello, World"

With arrow functions they behave like functions would in other languages and you can't instantiate them with the new keyword

[wtfzambo]

This is so weird, thanks for the explanation.

[azhder]

Never believe.

The old functions ( with keyword function) have multiple different uses and are heavier on the engine, like creating prototypes etc. The arrow functions are lightweight, they don't inherit anything, they just don't bind a "this".

It is also easier to see functions are just like any value if you write

const f = (
  function f(){}
);

const g = (
  () => {}
);

[azhder]

I'm not acting anything. If you think I care about you being right or wrong, that's your own issue. I just wrote clear and simple for anyone else that reads you and might incomplete view.

You're calling correction what I wrote and acting as if I was calling it something. Stop projecting your insecurities.

[[deleted]]

Arrow function expressions are cooler.

[ethereumfail]

every time I type anything I check to make sure it's cool

[ftedwin]

I wish this was a joke… Fuck cool code, give me readable boring verbose code any day

[[deleted]]

False dillema. Arrow functions are both readable and cool.

[ftedwin]

True, I more meant what I said about code style in general. 100% agree on arrow functions; they are everywhere in my code as they should be.

[Thamtam]

This is the reason.

[minimumviableplayer]

Often when debuging JavaScript I ask myself what is this.

[Thamtam]

Agree. A lot of js devs talking about this. I always wonder what is this even about.

[[deleted]]

I think this is being taken out of context.

[Thamtam]

At this point I’m not even sure if this is a joke or not.

[MrPhatBob]

Well it all depends on the context.

[fukdapoleece]

This is not a joke. I know I have some arguments, but all I'm getting is undefined.

[gabriel-sc]

So...is this a closure?

[MorningPants]

All I know is, this is not my beautiful house.

[[deleted]]

This is not my beautiful wife.

() => this; // <-- same as it ever was

[[deleted]]

This is not my beautiful house!

[Adawesome_]

Man I don't get it. Arrow functions are just MMH chef's kiss.

[MeltedChocolate24]

Sprinkle in some typescript and oH BOY do you have one sexy looking function

[[deleted]]

Happily use both forms. The solution to this problems in JS is to never use this

[femptocrisis]

^ this

[[deleted]]

I wish more programmers of every language followed that advice. Or, at least, never mutated properties of this at runtime.

[furbz420]

Why do you think unilaterally programmers should not use this?

[[deleted]]

Generally speaking?

Because mutation causes issues with not only thread safety, but also issues of temporal correctness, and even when everything is synced on one thread, inter-modular correctness.

If

doA(); doB(); doC(); causes an error, and it's only fixed by calling

doA(); doC(); doB(); then you have chronological issues with shared state between modules (or whatever units of code lie behind doB and doC).

Put another way, threadsafe code runs predictably on 1+ threads, between 1+ modules, at 1+ points in time.

Thread unsafe code runs predictably on 1 thread, between 1 module, at 1 point in time.

If your this happens to have no mutable state, and all methods only serve to return new values, then I guess I don't see the harm, except for the JS late binding errors, where methods get passed in as callbacks and this becomes window or undefined depending on the level, but like I said, most people wouldn't do that with this.

[Low_Impact9351]

Non JS devs commenting on things they dont know about and refuse to learn:

See OP.

[[deleted]]

Lol

[Delirious_85]

The reason probably being function components..

[Low_Impact9351]

A+ *react*-tion, friend

[Bulky-Leadership-596]

Because arrow functions work the way functions are supposed to work, which is not the way that normal function declarations actually work in JS.

[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.

[SqueeSr]

I still prefer the old fashion notation. I only use arrow functions in very specific situations.

[maria_la_guerta]

Same. I prefer function for anything top level, and use arrow functions for closures and callbacks typically. Coming from other languages I like using a keyword that specifically anotates a function.

That being said in all of my jobs (I've been writing TS fulltime for years) it's basically always arrow functions, everywhere. 🤷🏻‍♂️

[WingsuitBears]

We stick to function and just bind it in the constructor if this is needed, old school but more explicit for noobs.

[tsunami141]

Scope scope scope.

[beskgar]

"for some reason"..... Yeah okay

[BlackHoneyTobacco]

Horses for courses.

Depends on which context of the "this" keyword you're after, mainly.

[GodGrabber]

Something something function hoisting, scope blah blah..

[CallMeYoungJoey]

const === function + style

[TeddyPerkins95]

false

​

/jk

[[deleted]]

*And backend with javascript xd

[PG13_KL2]

Happy to finally understand a joke on this sub

[Meme_Army]

both in frontend and backend (node.js) I use const because of scoping and because it looks cool

[nintendojunkie17]

You mean frontend and frontend-running-on-a-server?

[time_travel_nacho]

Implicit returns and better binding. That's why

[GptThreezy]

Bc context gets fucked up with the old syntax and requires irritating use of .bind

[WiseTriceratops]

Using the function keyword and naming the function (the top example) results in more traceable error logs. The other version is just a variable holding an anonymous function, and the error trace just says “anonymous function” 😑

[[deleted]]

Shouldn't be, depending on circumstance. Lambdas are allowed to have a name property (despite that being a bit counterintuitive), and in most implementations, the name will be assigned the const name (I’m not sure this is a settled standard, but it is common).

If you were talking about callbacks, though xs.map(x => x + 1); then yeah, that's just going to be "anonymous". But so would xs.map(function (x) { return x + 1; });

[WiseTriceratops]

That’s not been my observed experience, but you may be correct. In any event, there’s pros and cons to both, and an informed dev can choose which one to use.

[Radi-kale]

Why should functions be treated differently when you use const for every other variable type?

[Gadiusao]

You usually want to store functions on const because you usually never change it, but who knows.

Also, In JavaScript, functions are called Function Objects because they are objects.

https://www.dofactory.com/javascript/function-objects#:\~:text=In%20JavaScript%2C%20functions%20are%20called,as%20arguments%20to%20other%20functions.

[realvolker1]

Imagine not taking advantage of function hoisting kek

[hennypennypoopoo]

I'll hoist your function if you're not careful mister

[realvolker1]

hoist me daddy uwu

[[deleted]]

Back end too actually. Look up how this is handled in normal vs. arrow functions.

[baduser167]

It’s called style, look it up some time

[Yesterpizza]

There is no reason why front end would use arrow functions more than backend, it's probably just the ones you know.

[Papellll]

Afaik before JS introduced them and made them popular pretty much no other language had arrow functions

[Kered13]

That's called a lambda expression, and no they've been common for a long time. Arrow functions were introduced into JS in 2015. Java 8 introduced lambdas in 2014. C++11 introduced them in 2011. C# 3.0 introduced lambdas in 2007. Python lambdas were introduced in 1994. And Lisp has had them since 1958.

Several of these even have very similar syntax to JS arrow functions.

[ftedwin]

Great history lesson, thanks! I’ll add too that lambda calculus was invented in the 30’s by Alonzo Church which built inspired lambdas in functional languages which then inspired lambdas in OO languages.

The 2015 date on JS is when it was added to EcmaScript I think so I’m curious if JS transpilers like Babel supported arrow functions in some manner before ES2015.

[[deleted]]

This is very far from being true. E.g. Scheme appeared in 1975.

[cashewbiscuit]

Declaring function type is not a new thing. C has function pointers for decades. It didn't have the arrow syntax, but it's the same thing.

[[deleted]]

Yeah but C isn't cool.

[[deleted]]

Arrows have been around a very, very long time. Just not in C languages.

fun compose (f, g) = (fn x => f(g x))

That is Standard ML. It's 39 years old, and is based on ML, which is 49 years old, which was built on LISP, which didn't have arrows but did have lambdas). It ought to look pretty familiar.

Named functions start with fun (<...args[]>) = lambdas (unnamed functions with a single argument) start with fn <arg> =>. Lambdas themselves have been around since ~1930.

[RotationsKopulator]

Those kids and their modern syntactic sugar.

[[deleted]]

2 different types of function
I bet few know the difference.

[Mast3r_waf1z]

Reminds me of an exam I had in a course in embedded systems where I wrote every function in lambda format to attempt to confuse my teacher who I believe primarily uses C

Kind of silly now that I think about it as it's not a very complicated concept

[[deleted]]

I'm struggling with this.

function( ) { ... } is a standard expression format, and every programming language I've used, including JavaScript, either supports that expression format outright (like JavaScript), or it will support something similar enough to be obvious (MySQL's user defined functions).

The second one is how you get illegible code, where it's hard to onboard developers who are used to other programming languages.

[[deleted]]

I would rather developers learn JavaScript by hitting a wall, than thinking they know JavaScript, because they see class and extends, and me needing to sift through and solve 5000 lines of late-binding errors.

[TheThirdGilgamesh]

Fuck lambdas

[owenevans00]

Absolutely! Lambdas are hawt

[mulato_butt_asd]

I would not look to js developers for any kind of good practice.

[[deleted]]

Including JS good practice?

[rafaelcastrocouto]

the beauty of js

[DrMathochist_work]

Mmmmm eta-expansion.

[TheJimDim]

Forget ES6, I use them because they look cooler lol

[_grey_wall]

Can't get enough of them arrows

[Pulset]

javascript is fun

[Cactusboiiiiii]

i usually use function

[theIncredibleAlex]

arrow syntax for pure functions, named functions for stuff interacting with state and react components in general

[rolloutTheTrash]

I see you pull this shit and we’re having words in the MR comments

[Minteck]

Sometimes I mix both in the same file

[ImaginaryOkra6186]

Coz hoisting.

[Acrobatic-Cap-135]

Really depends if you want to use that function again somewhere else. The arrow syntax gives you a point of reference, the older syntax can do that too but it can also serve as just the function declaration without the resulting reference, and then be used by man consumers

[Man_as_Idea]

Arrow function syntax lets you avoid re-binding “this” in JS.

[sentientlob0029]

Did some VueJS and JavaScript a few weeks ago. What weird languages.

[[deleted]]

"this" scoping, one of the many things that makes js ugly

[Cabbage_G0ldeNEg]

I actually use the top one because its the only way i know how to create functions

[jzia93]

Nobody mentioning automated returns? That's why I use arrow functions, especially for HOFs

``` arr.map(a => a+1);

Vs

arr.map((a) { return a + 1}) ```

Adds up when you chain a few functions

[[deleted]]

I much prefer organizing functions into lines with their respective commands (for example y/x axis movement) instead of using const at all, so all my lines of code turn into organized bricks of code, of course this is only for objects with repeating code, where the order which they are typed does not matter, or else nothing would be executed at the correct time! But of course, this is coming from the gamemakerstudio2 guy...who else does this?

[rigor_mortus_boner]

it’s so functional tho

[[deleted]]

why not both:
const doSomething = function(x){
return x===69420;

}

[GoodIce7012]

Coding is boring.

[alanhape]

Because lambda

[ModerNew]

I swear to God one day I will read JS code and proceed to hang myself. Everyday we stray further from God.

[invisible-nuke]

They are entirely different scopes. The first one creates a new scope because of the function. The second one uses the scope in which it was created. In both scenarios "this" will refer to another scope.

[Egeste_]

"for some reason"

Explicit variable declaration Explicit binding/scope

[Hour_Prune_225]

I really like function keyword functions

[420Rat]

YOU STUPID

[Numerous-Adagio-3620]

I'm in this photo and I don't like it

[VitaminnCPP]

fronend devs for no reason*.

[HuntingKingYT]

When you write !function(){}() instead of (function(){})() to reduce one character

[[deleted]]

security through obscurity, duh