3 reasons that I can think of:

1. You can implicitly return things so it provides nice syntactic sugar

2. Using an arrow function results in `this` being bound in the way you'd expect (coming from something like C++) in all cases without having to call .bind(this) anywhere. I'll never forget seeing promise chains starting with `const that = this;` in order to keep the right reference throughout the promises.

3. You use it for the previous 2 reasons and use it everywhere in order to be consistent

I agree with one and two, and really appreciate arrow functions in those two, and other appropriate use cases.

With three, I disagree. It is kind of like saying let us just use var everywhere to be consistent.

I fall into category 3 which is why I list it. It's not a technical reason so much as a code style reason so it is definitely subject to the opinions of each developer.

> For example, an arrow function accessing variables outside its scope is much slower

That doesn’t sound true. Do you have any evidence? (Under an uncommon JavaScript engine?)

javascript function does too much.

It is both method and closure. Which is not universal - io has method and block, ruby has def and block

And it is constructor. So it can be called both with and without `new` with different results. Other can't:

    arrow = () => {}
    // new arrow()
    // TypeError: arrow is not a constructor

    object = {
      shorthand() {},
      ['computed']() {},
      get getter() {}
    }
    // new object.shorthand()
    // TypeError: object.shorthand is not a constructor
    // new object.computed
    // TypeError: object.computed is not a constructor

    // getter = Object.getOwnPropertyDescriptor(object, 'getter').get
    // new getter
    // TypeError: getter is not a constructor

    class Class {
      static staticMethod () {}
      method () {}
      get getter() {}
    }
    // Class()
    // TypeError: Class constructor Class cannot be invoked without 'new'
    // new Class.staticMethod
    // TypeError: Class.staticMethod is not a constructor
    // klass = new Class
    // new klass.method
    // TypeError: klass.method is not a constructor
    // getter = Object.getOwnPropertyDescriptor(Class.prototype, 'getter').get
    // new getter
    // TypeError: getter is not a constructor

    function* generator() {}
    // TypeError: generator is not a constructor
    // new generator()

I actually was surprised just how many ways TC39 introduced so we do not use function. The change you observe is not a coincidence - it is carefully crafted.

Let me get this straight: Are you saying all the changes in arrow functions, the class syntax and generator functions were all a carefully planned initiative to get rid of the "function" keyword because it does too much?

Yes, replace "function" usage with safe alternatives. And don't forget 'use strict' - it affected "function" too.

"function" is too entrenched. It's usage as a constructor appeared even before .prototype:

    function Cat() {
      this.say = function() { return 'nyan' }
    }

All the confusion about javascript object system is because of classes which have no name, we call them by their constructors. Give them real names:

    Cat = class {}.prototype // or function {}.prototype
    Cat.say = () => 'nyan'
    cat = new Cat.constructor
    cat.say()
    cat.__proto__ === Cat

A little bit inconvenient... oh! it's everywhere:

    cat instanceof Cat.constructor
    Tom = class extends Cat.constructor {}.prototype

And all the base classes are constructors

    Object = Object.prototype

with their helper methods, it should be separate like Reflect and Math:

    Reflect.create = Object.constructor.create
    object = Reflect.create(Object)

There is no simple answer, breaking change is not an option, let the planned obsolescence begin.

And it works! Slow but steady so much done since 2012 http://brendaneich.github.com/Strange-Loop-2012/#/

Ok.

I'm not convinced at all, we'll simply have to agree to disagree on that.

And I'd love to see the codebase of a JS app that completely bans the "function" keyword. Any links or examples?

Sorry, typo

>> Yes, <typo>they</typo> replace<typo>d</typo> "function" usage with safe alternatives. And don't forget 'use strict' - it affected "function" too.

> I'm not convinced at all

It could appear I've tried to convince you not to use "function". That never was the case, should have added at least one. And I do not agree with TC39 direction, just making observations. Please check my comment assuming that and typo.

My fix would be different. Prototype based inheritance is awesome http://iolanguage.com/tutorial.html and javascript could be as simple too:

    Object
    Object.__proto__ === null

    object = new Object
    object.__proto__ === Object
    object.constructor === Object.constructor
    object.toString === Object.toString

    f = new Function
    f.__proto__ === Function
    fun.constructor === Function

    object.private = function () { return 'hello' }
    Object.shared  = function () { return 'world' }
    Object.constructor.static = function () { return '!' } // we need functions

with just a simple change

    Object = Object.prototype
    Function = Function.prototype

    syntax new = function (ctx) {
      let ident = ctx.next().value
      return #`new ${ident}.constructor`
    }

It looks almost boring (just don't redefine .constructor). Now this one is much harder:

    Object.prototype
    Object.prototype.__proto__ === null

    object = new Object
    object.__proto__ === Object.prototype
    object.constructor === Object
    object.toString === Object.prototype.toString

    fun = new Function
    fun.__proto__ === Function.prototype
    fun.constructor === Function

    object.private = function () { return 'hello' }
    Object.prototype.shared  = function () { return 'world' }
    Object.static = function () { return '!' } // we need functions

Anecdotal if you're interested: I can't show it since it belongs to the company, but I just ran a grep in the app I architected and it has exactly 21 instances of the word "function"... some are comments, but most of the ones that aren't are inside a lodash debounce function. Total of 140000 non-blank/non-commented lines of code.

Btw, it's not banned, and I never really enforced it... but since I never use it myself, I guess the others devs picked it up?

It's in Vue.js, and in Vue you rarely see old-style functions anywhere, so there's that.

That's interesting. However, the Vue.js library itself uses the "function" keyword a lot, and the library is part of your applications code. Infact, it uses normal functions almost exclusively.

source: https://raw.githubusercontent.com/vuejs/vue/dev/dist/vue.com...

Furthermore, the official Vue documentation explicitly discourage the use of arrow functions in some places, so whoever set that rule just did not know what they were doing, sorry if that sounds harsh.

source:

- https://vuejs.org/v2/guide/instance.html#Instance-Lifecycle-...

- https://stackoverflow.com/questions/43929650/vuejs-why-is-th...

Saying all arrows functions are bad and evil or that all normal functions are bad and evil is nothing but dogma. Each has its own place and uses, it seems many JS devs would rather not think of this at all and just use one form everywhere.

We're not using arrow functions for everything. Why are you assuming this?

We're using shorthand syntax in methods inside Vue.js objects [1], they also don't need the "function" keyword. In fact, they are suggested in the second link you posted, please read again. Arrow functions wouldn't even work in this situation.

We're mainly using two forms: shorthand and arrow. That's how we only have 21 instances of the "function" word in our entire JS codebase, and we could remove all of them if we wanted. That's what you asked for: a "JS app that completely bans the 'function' keyword". Well, we don't ban but it's possible.

And please read my comment again: I explicitly mentioned that this is not a rule, and I never enforced it. The team (39 committers ATM) reached that result organically, mostly influenced by my own personal style.

And sorry if this sounds harsh, but it seems that you have extremely limited knowledge of Javascript and ES6, so I'd suggest learning before you make such claims before you make a fool of yourself.

Btw, you're seem to be the one holding on to dogma here, since you seem unable to accept that the keyword is not strictly necessary in a large app.

[1] https://developer.mozilla.org/en-US/docs/Web/JavaScript/Refe...

Many reasons.

1) Hoisting + mutability

  a = 'lol';
  function a() {}
  a() // error

2) one-liners

  const findByName = (list, name) => list.find(item => item.name === name);
  //vs
  function findByName(list, name) {
    return list.find(item => item.name === name);
  }

3) signaling that `this` keyword usage should not happen

And when you don't need any of that, how do you signal that you do not need it?

Arrow functions help save you from `this` insanity.

I agree, but do all functions use 'this'?

No, and part of the reasoning is to explicitly avoid the chance you might accidentally refer to the wrong `this`. There's an ESLint rule to enforce this: it will complain if you use a `function` without referring to the prototype this. Makes it handy because if I do use `function` I know it's because there's a reason -- e.g. some libraries still make heavy use of the local this.

https://eslint.org/docs/rules/prefer-arrow-callback

The rule you link to is specific to "function expressions", which may or may not use 'this'.

To ask the same question differently, what about functions that do not need 'this'?

I'm not sure what your proposal is -- use functions that use prototype this or no this, and arrow functions for ones that use contextual this?

It's easier to use arrow functions for everything except for the tiny minority of cases where you want prototype this.