No, there is not. With ES6, you might be able to use an arrow function: ()=>{} which is a bit shorter.

If you really need this very often (you shouldn't?!), you can declare one yourself:

function noop(){}

and then refer to that repeatedly. If you don't want to clutter your scope, you can also use the Function.prototype function (sic!) which does nothing but constantly return undefined - yet that's actually longer than your function expression.

It’s an in-line anonymous arrow function

The empty parentheses indicate that the function takes no argument(s), and are required by the syntax. Arrow function expressions are also anonymous, whether they take arguments or not. That just means they don't have a specific name.

Hello Andrew, I too thought arrow functions were shorthand for function() {} when I was first introduced to them. But as it turns out, they do add some special functionality. Specifically when it comes to "this." This is a relatively big topic, so I won't go into crazy depth here. However I'll provide some additional resources that will hopefully get you on the right path. First of all, your code. Try removing the arrow function from: countWords: () => { return this.string.split(" ").length; } so it looks like this: countWords: function() { return this.string.split(" ").length; } So the question is, why does "this" return return an empty object instead of the myString object? The short answer is that since you're using an arrow function, "this" is bound to the countWords function/method instead of the myObject object. This is the first article (https://medium.freecodecamp.org/when-and-why-you-should-use-es6-arrow-functions-and-when-you-shouldnt-3d851d7f0b26) I'd suggestion reading. Specifically the Main benefit: No binding of ‘this’ section towards the bottom of the article. Here's an excerpt: In classic function expressions, the this keyword is bound to different values based on the context in which it is called. With arrow functions however, this is lexically bound. It means that it uses this from the code that contains the arrow > function. "this" is a very confusing and misunderstood aspect of JavaScript. If you want to go deeper into how it works, Kyle Simpson has written a book (available for free on GitHub) (https://github.com/getify/You-Dont-Know-JS/tree/master/this%20%26%20object%20prototypes) that goes deep into how "this" works. There are four rules to determine the context of "this": Is the function called with new (new binding)? If so, this is the newly constructed object. Is the function called with call or apply (explicit binding), even hidden inside a bind hard binding? If so, this is the explicitly specified object. Is the function called with a context (implicit binding), otherwise known as an owning or containing object? If so, this is that context object. Otherwise, default the this (default binding). If in strict mode, pick undefined, otherwise pick the global object. Treehouse also has a workshop on arrow functions (https://teamtreehouse.com/library/arrow-functions) that I'd recommend checking out if you haven't already done so. I hope this helps! If you have any additional questions, please let me/us know! Have a great weekend, Brandon

The only reason I can think of for why that line would exist would be if the function this whole block is being used in is somewhere such that the resolve value of myBroker.dispatch should not be (or is better not) exposed to the consumer of the larger function. For example:

const thisModule = (() => {
  const myBroker = ...;
  function getSomethingAndDispatchBroker() {
    return(
      myModule.getSomething(args.url)
      .then(stream => module.uploadData({
        param1: args.param1,
        param2: args.param2,
        param3: stream,
      }))
      .then(() => myBroker.dispatch({
        queueUrl: myQueueUrl,
        payload: JSON.stringify(args.payload),
      }))
      .then(msgInfo => {})
      .catch(error => {
        myBroker.dispatch({
          queueUrl: anotherQueueUrl,
          payload: JSON.stringify({ type: 'error', payload: `[ERROR] ${error}` }),
        });
        throw error;
      })
    );
  }
  return { getSomethingAndDispatchBroker };
})();

Here, the function getSomethingAndDispatchBroker can be called from outside, but perhaps the resolve value of myBroker.dispatch is better kept internal to the thisModule - either due to privacy, or due to code clarity - perhaps you only want users of the function to know if the Promise resolved (if the process succeeded), without telling them unnecessary details.

Still, if none of that is a concern, then yes, feel free to remove the .then(msgInfo => {}) line.