156

In ES6, both of these are legal:

var chopper = {
    owner: 'Zed',
    getOwner: function() { return this.owner; }
};

and, as shorthand:

var chopper = {
    owner: 'Zed',
    getOwner() { return this.owner; }
}

Is it possible to use the new arrow functions as well? In trying something like

var chopper = {
    owner: 'John',
    getOwner: () => { return this.owner; }
};

or

var chopper = {
    owner: 'John',
    getOwner: () => (this.owner)
};

I get an error message suggesting that the method does not have access to this. Is this just a syntax issue, or can you not use fat-arrow methods inside of ES6 objects?

Improve this question
13
  • 1
    While using the fat arrow syntax? Only if you alter the this value by first creating the chopper object, then doing the assignment in a function that has this pointing to that object. This can be accomplished pretty cleanly with a constructor function. Commented Jun 28, 2015 at 3:09
  • 2
    This demo will run in Firefox. Chrome doesn't have it yet. jsfiddle.net/bfyarxfe Commented Jun 28, 2015 at 3:12
  • 2
    @fox, you must use 'use strict' on that jsfiddle. Commented Jun 28, 2015 at 3:32
  • 1
    @fox: It works fine in a supported environment. Firefox doesn't yet have complete support. Try it in Continuum and console.log() the result of the method call. It works. Commented Jun 28, 2015 at 3:39
  • 3
    Mozilla docs says Does not have its own bindings to this or super, and should not be used as methods Mozilla Arrow function documentation Commented Sep 26, 2020 at 15:20

6 Answers 6

Reset to default
240

Arrow functions are not designed to be used in every situation merely as a shorter version of old-fashioned functions. They are not intended to replace function syntax using the function keyword. The most common use case for arrow functions is as short "lambdas" which do not redefine this, often used when passing a function as a callback to some function.

Arrow functions cannot be used to write object methods because, as you have found, since arrow functions close over the this of the lexically enclosing context, the this within the arrow is the one that was current where you defined the object. Which is to say:

// Whatever `this` is here...
var chopper = {
    owner: 'Zed',
    getOwner: () => {
        return this.owner;    // ...is what `this` is here.
    }
};

In your case, wanting to write a method on an object, you should simply use traditional function syntax, or the method syntax introduced in ES6:

var chopper = {
    owner: 'Zed',
    getOwner: function() {
        return this.owner;
    }
};

// or

var chopper = {
    owner: 'Zed',
    getOwner() {
        return this.owner;
    }
};

(There are small differences between them, but they're only important if you use super in getOwner, which you aren't, or if you copy getOwner to another object.)

There was some debate on the es6 mailing list about a twist on arrow functions which have similar syntax but with their own this. However, this proposal was poorly received because that is mere syntax sugar, allowing people to save typing a few characters, and provides no new functionality over existing function syntax. See the topic unbound arrow functions.

Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

If I'm reading this correctly, it seems to suggest that the mailing list deprioritizes syntactic sugar, even if it would lead to greater uniformity/readability of code. As it stands, it's much more challenging to use the fat-arrow functions in an OOP context under ES6 than, say, under coffeescript.
As I understand it, syntactic sugar is considered a valid reason for considering language extensions, but as you say with a lower priority--in other words, the bar is higher for such proposals.
A bit confused. From what I understand for the function keyword notation, this points to the context of execution, where it is called, not where it is defined. developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/… . In the example above, can you really relay on on this.owner the be equal to the value that is defined on the chopper object?
18

In this line getOwner: () => this.owner should be:

var chopper = {
    owner: 'John',
    getOwner: () => this.owner
}; //here `this` refers to `window` object.

console.log(chopper.getOwner());

You would have to declare this into a function:

var chopper = {
    owner: 'John',
    getOwner() { return this.owner }
};

console.log(chopper.getOwner());

Or:

var chopperFn = function(){

    this.setOwner = (name) => this.owner = name;
    Object.assign(this,{
        owner: 'Jhon',
        getOwner: () => this.owner,
    })

}

var chopper = new chopperFn();
console.log(chopper.getOwner());
chopper.setOwner('Spiderman');
console.log(chopper.getOwner());

Improve this answer

6 Comments

I'm getting an error here: "TypeError: Cannot read property 'owner' of undefined\n at Object.chopper.getOwner
I see, it is the correct use, however the method esta always returns window Object. You would have to declare this within a function.
this doesn't necessarily refer to window. It refers to whatever the current value of this is in the enclosing environment, which may or may not be window. Maybe that's what you meant. Just want to make sure he understands it isn't some default value.
@torazaburo That is fine for me, I tried it, this now refers to class
What you have written is equivalent to, but more verbose than, simply writing var chopperFn = function() { this.owner = 'Jhon'; this.getOwner = () => this.owner; }.
|
11

If you have to use arrow function, you can change this to chopper,

var chopper = {
  owner: "John",
  getOwner: () => chopper.owner
};

Although this is not best practice, when you change the object name, you have to change this arrow function.

Improve this answer

Comments

5

A quick tip that I follow to use arrow functions.

  • Use non-arrow functions for methods that will be using object.method() syntax. (Those are functions that will receive meaningful this value from their caller.)
  • Use arrow function for almost everything else.
Improve this answer

Comments

3

Another tip, in strict mode, this still refers to Window instead of undefined.

  (() => {
    "use strict";
    console.log(this); // window
  })();

  (function () {
    "use strict";
    console.log(this); // undefined
  })();
Improve this answer

Comments

0

This inside arrow function doesn't reflect context of the object. Instead it gives the context where the object method is called.

Check this, This gives some insight about when to use arrow and when not. https://dmitripavlutin.com/when-not-to-use-arrow-functions-in-javascript/

Improve this answer

1 Comment

No, this inside an arrow function inside an object literal refers to the scope where the object literal is, not where it is called.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.