Just curious, are you using => functions exclusively or still sticking to traditional function syntax? No judgement!

@JavaScript I sometimes like old ones for hoisting or inline util functions

@JavaScript => almost all the time!

@JavaScript .then() .then() And .then()

@JavaScript Arrow functions since it’s neater especially if written on one line. 👨🏼‍💻

@JavaScript Lambdas are faster but less readable. It depends!

@JavaScript I use normal function syntax but for array methods and stuff i use arrow syntax as it looks a lot cleaner

@JavaScript I use both, but prefer =>

@JavaScript I now default to arrow functions instinctively but can’t say I “prefer” one over the other.

@JavaScript Starting to use them for any instance in which I don’t need to worry about what ‘this’ is bound to.

@JavaScript I dnt have a preference yet. I’m still fighting for my life learning the material. 🤣

@JavaScript Using both! 💪

@JavaScript I default to the "function" keyword for most things. Hoisting is helpful for module-level functions. For inline callback functions/closures, I like that the function keyword allows me to give the function a descriptive name.

@JavaScript Both. There is a reason for using each.

@JavaScript Does using one over the other make any difference to the code?

@JavaScript Both, because it's required - they aren't equal. One such example of where arrow functions catch me out, is in event listener callbacks. Arrow functions don't bind 'this', which can lead to debugging hell when I forget 😁

@JavaScript Arrow functions because I like that functions are just values.

@JavaScript Mostly fat arrow (=>) functions. The only time I use traditional functions(function()) is when I need the scope of 'this' to be the function itself, instead of global scope. I guess that's a major difference between the two approaches that really sets apart their use cases.

@JavaScript `function` keyword for everything but one-liners and inline functions (e.g callbacks on array methods, etc). The function keyword is plenty terse and the hoisting behavior is useful. I'm also positive this is the only correct opinion to have 😁.

@JavaScript Probably quite unpopular but I prefer the traditional function syntax: function doSomething (x, y) { ... } I use arrow functions mostly for one liners and some trivial callbacks.

@JavaScript For tiny bits of code where the absence of 𝚝𝚑𝚒𝚜 isn't an inconvenience, sure. As a wholesale replacement for using the 𝚏𝚞𝚗𝚌𝚝𝚒𝚘𝚗 keyword, no I am not interested in trying to look cool by making everything a variable assignment.

@JavaScript Depends on the scope required of that function 😋

@JavaScript Traditional function syntax user here... 🥹

@JavaScript Mostly arrow functions for callbacks definitely...

@JavaScript Traditional functions feels original lol

@JavaScript Arrow functions all the way

@JavaScript I like to take advantage of the hoisting behavior available with traditional functions

@JavaScript utility functions are mostly traditional for me... but member functions are always arrow syntax as I don't want the burden of binding scope.

@JavaScript This is rather funny bc i just decided to make the switch to => yesterday! However it almost feels to clean lol

@JavaScript Both of them! I use more => functions when I'm coding in React.js and inside functions wrote in traditional syntax. I love => functions! 😁

@JavaScript Yes! Use => when you want to pass the "this" context from caller to function. No if that function is ever used outside that context.

@JavaScript =>

@JavaScript arrow because i’m not a baby.

@JavaScript Arrow functions are more than just syntax sugar. That being said they are my go to way to write a function unless an occasion calls for me to use the original syntax.

@JavaScript `function` tells the reader that the line contains a function declaration, var/let/const doesn't until you keep reading. I only use arrows if I need a one-liner or to bind `this` to its lexical context, otherwise, you're adding noise to the code IMO.

@JavaScript I use a mix of both. When its a short one I will use an arrow function to keep it compact and cleaner when I have more going on I opt for a traditionally defining function

@JavaScript I like to mix it up