When I First encountered arrow functions, I was exited about the syntax difference. So I started putting them in everything; that was a huge mistak...
For further actions, you may consider blocking this person and/or reporting abuse
This is not correct. If you put an underscore there, your function is accepting an argument called
_
- and you are just choosing to ignore it. The correct way to do it is:This can also be verified by checking the
length
property of the function that returns the number of non-optional parameters it takes:If you write functions that take no arguments in the way you describe - you could end up with issues when working with libraries that make use of
.length
. It is also not good for readability.Thanks for the feedback i have adjusted that portion to better convey my thoughts
I also adjusted my comment to better convey my thoughts 😀
lol .. just followed you
Problem #5/#6 is a good thing to me. People mess up
this
bindings way too often. I stopped usingthis
~2012, and stopped writing mutative code around the same time, and life has only gotten better, as whole classes of bugs disappeared. But if it helps:using the arrow like this will always get the binding right. Even if you pass the function in as a callback, or save it as a variable, or reference it on a different object, et cetera. Something that the other functions do not get right.
Issue #7 isn't because of the arrow function, it's because of the const keyword. A const can't have a competing name in the same context.
The same thing happens when you use const to shadow the name of an argument.
Issue #8 actually has 2 bugs. The first is to do with const, not the function.
This is the deadzone. You can't use a let or a const above where it is declared. Even if there is something with the same name in an outer scope.
The second problem with #8 is specific to functions, but not unique to arrows.
Function hoisting does not work on any function expression of any kind, including assignment statements. Even if you are using var.
The only functions that are hoisted are function declarations.
For that reason and others, it's better to not run the code in the same file that you define the code.
but arrow function are always written as expression otherwise they are anonymous so...
So are function expressions. Even if you name a function expression it is still not hoisted.
There are many ways of defining functions and there is exactly 1 of those ways that is hoisted.
So your problem is with literally all function expressions, which... fine... prefer declarations if you want to. But for people who prefer expressions, there is no difference between using the arrow and not, for #8, so using arrows is just more concise.
Yes i gave an example of that in the beginning; you can write normal function as an expression but its optional.
also no # 7 is not because of the const keyword (try let keyword with my example to confirm)
I Appreciate #6 comment
Yes, function expressions are optional. Function declarations are optional, too. Only function declarations can be hoisted, so if you choose to use any form of expression, your functions aren't hoisted, regardless of whether they are named, unnamed, arrow, or otherwise.
Re: #7
let
andconst
have the same rules regarding deadzones and variable shadowing. Try it again withvar
.Or just try
There's no arrow function there, so why is the error the same?
#7 was about parameters not declaration or identifiers
Perhaps I remembered incorrectly.
But if your problem with arrow functions is that you can't have
(x, x, x, x) => {}
then it's a problem with the ECMAScript 2015 standard, not with arrows, as anything following the ES5 (ECMAScript 2015) standard (ie: "strict mode") is going to give you the same problems. Everything these days is based on ES5-strict. ES Modules are automatically strict just by using import/export, TS might let you export ES3, but it will make you write ES5-strict source code.Arrow functions also don't provide caller information, which ES3 functions did, and was a large security concern. But no ES5+ functions provide caller information, it's just that arrows didn't exist before ES6, so no functions that looked like them ever had caller information or shadowed parameter names.
I'm not against anything in JS just that I ran back as quickly as went into arrows function at first because of the strange behavior but its history now and I honestly appreciate your engagement
Really got my knowledge of arrow function, declaration and the "this" key refreshed once again. This is resourceful
Regular functions have access to the arguments object.
Arrow functions do not have access to the arguments object.
Regular functions have their own this binding.
Arrow functions don't have their own this binding, arguments object, or prototype.
more: findbestone.com/difference-between...