Method chaining with function arguments

Question

What's the best way to chain methods in CoffeeScript? For example, if I have this JavaScript how could I write it in CoffeeScript?

var req = $.get('foo.htm')
  .success(function( response ){
    // do something
    // ...
  })
  .error(function(){
    // do something
    // ...
  });

a paid nerd · Accepted Answer · 2014-12-08T22:55:04.303

70

Using the latest CoffeeScript, the following:

req = $.get 'foo.html'
  .success (response) ->
    do_something()
  .error (response) ->
    do_something()

...compiles to:

var req;
req = $.get('foo.html').success(function(response) {
  return do_something();
}).error(function(response) {
  return do_something();
});

edited Dec 08 '14 at 22:55

answered May 10 '11 at 07:30

a paid nerd

30,702
30
134
179

2

This is awesome. Thank you, a language that puts the operator first on the next line rather than awkward trailing syntaxes. Hooray! – Walt W Oct 31 '12 at 23:11
2

worth noting that the parens are no longer necessary around the 'foo.html' in Coffeescript 1.7 (see my answer below) – Ben McCormick Feb 18 '14 at 16:27

score 37 · Answer 2 · answered Feb 28 '11 at 16:18

There are two approaches you can take: The best "literal" translation to CoffeeScript is (in my opinion)

req = $.get('foo.htm')
  .success((response) ->
    # do something
  )
  .error( ->
    # do something
  )

The other approach is to move the inline functions "outline," a style that Jeremy Ashkenas (the creator of CoffeeScript) generally favors for non-trivial function arguments:

onSuccess = (response) ->
  # doSomething

onError = ->
  # doSomething

req = $.get('foo.htm').success(onSuccess).error(onError)

The latter approach tends to be more readable when the success and error callbacks are several lines long; the former is great if they're just 1-2 liners.

+1 for the "outline" tip, definitely keeps the code more readable. — Mark Rendle, Aug 10 '11 at 12:21

score 11 · Answer 3 · edited Aug 14 '15 at 00:04

11

I sometimes prefer having fewer parentheses as opposed to chaining, so I'd modify Trevor's last example:

req = $.get 'foo.htm'
req.success (response) -> # do something
req.error -> # do something

edited Aug 14 '15 at 00:04

Maximillian Laumeister

19,884
8
59
78

answered Mar 02 '11 at 19:40

Amir

4,131
26
36

2

This is not the same as chaining, as req object is being used each time – Jagtesh Chadha Mar 13 '15 at 20:55

score 9 · Answer 4 · answered Feb 18 '14 at 16:25

As of Coffeescript 1.7, chaining has been significantly simplified, and you shouldn't need any of the parens-related workarounds mentioned here. Your above example can now be written as

req = $.get 'foo.htm'
.success ( response ) ->
  alert "success"
.error ->
  alert "error"

Which compiles to

var req;

req = $.get('foo.htm').success(function(response) {
  return alert("success");
}).error(function() {
  return alert("error");
});

You can see an explanation of this and other CS 1.7 features here: https://gist.github.com/aseemk/8637896

Method chaining with function arguments

4 Answers4

Linked