Lots of other people have addressed the scoping of this but another benefit that is the primary reason why I use them for React components and handlers is that you can use them to conveniently apply types to a function. This is useful for getting types of function arguments with a more concise syntax. export const MyComponent: React.FC = (props) => { const handleOnChange: InputProps["onChange"] = (event) => {}; // ... }; More on reddit.com

What do you mean when you say "2. No self-referencing If your function needs to have a self-reference at any point (e.g. recursion, an event handler that needs to unbind), it will not work." At least Recursion works fine in arrow functions: ​const​ ​helper​ ​=​ (​input​, ​accumulator​ ​=​ ​0​) ​=>​ {     ​if​ (​calculateFuel​(input) ​<​ ​1​) ​return​ ​parseInt​(accumulator);     ​let​ neededFuel ​=​ ​calculateFuel​(input);     ​return​ ​helper​(neededFuel, (accumulator ​+=​ neededFuel)); }; Or am i missing something? (Uch shitty formatting due to mobile) More on reddit.com

I think you said it yourself, it looks short and nice. That code you linked as an example was easily readable because of their use. There is a small adjustment when you first encounter them as they look at bit alien but once used to them they just become part of your workflow.

More on reddit.com

a few reasons. first, brevity. () => {} is fewer chars than function(){}. if its a one-liner, you don't need the curly braces and return is implied. second, javascript has a .. strange .. take on the this keyword. it differs from traditional OOP, like c++, java, or c# etc. in more traditional OOP, in a member function of a class, this refers to the current instance of the class. its usually a syntax error anywhere else to say this. in javascript, this of a function has different meanings depending on how and where it's used. if you have a func var, you can execute it with different this's. if you're used to traditional OO this, then js this has easy to miss bugs and unexpected insanity. arrow functions help alleviate javascript's this oddity. arrows have a fixed this. whatever this is immediately before the arrow func, this will be the same inside that arrow. whomever executes that arrow func cannot decide for them self to attach a different this; only the original this remains. this is particularly useful in making a func var inside of a member func of a class. there this has the traditional OOP meaning (current instance), and inside arrow funcs it maintains that meaning. according to mdn, you can't even use tricks to force a silly new this onto an existing arrow func. ( https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions ) arrows also do not have their own arguments var. they inherit the arguments from their immediate scope, just like this. (arguments is a special variable in javascript. arrows can have their own arguments, but inside an arrow you're getting the same arguments as the surrounding scope.) More on reddit.com