trailing commas

sckott profile image Scott Chamberlain Originally published at recology.info on ・3 min read

Let’s talk about trailing commas (aka: “final commas”, “dangling commas”). Trailing commas refers to a comma at the end of a series of values in an array or array like object, leaving an essentially empty slot. e.g., [1, 2, 3,]

I kind of like them when I work on Ruby and Python projects. A number of advantages of trailing commas have been pointed out, the most common of which is diffs:

diff --git a/hello.json b/hello.json
index e36ffac..d387a2f 100644
--- a/hello.json
+++ b/hello.json
@@ -1,4 +1,5 @@
   "foo": 5,
   "bar": 6,
+ "apple": 7,
diff --git a/world.json b/world.json
index 14a2818..41f8a01 100644
--- a/world.json
+++ b/world.json
@@ -1,4 +1,5 @@
   "foo": 5,
- "bar": 6
+ "bar": 6,
+ "apple": 7

Example blog posts on the topic: https://dontkry.com/posts/code/trailing-commas.html, https://medium.com/@nikgraf/why-you-should-enforce-dangling-commas-for-multiline-statements-d034c98e36f8

Many languages support trailing commas, and some even consider it best practice to use trailing commas.


["hello", "world"]
# => ["hello", "world"]
["hello", "world",]
# => ["hello", "world"]

Works the same for hashes.


["hello", "world"]
# Out[1]: ['hello', 'world']
["hello", "world",]
# Out[2]: ['hello', 'world']

Works the same for sets and dictionaries.


Mozilla gives a thorough overview of trailing commas in Javascript.

["hello", "world"]
// ['hello', 'world']
["hello", "world",]
// ['hello', 'world']

Probably works for other data types…?



["hello", "world"]
// vs
["hello", "world",]

Probably works for other data types…?



( 1, 2 )
# (1, 2)
( 1, 2, )
# (1, 2)

works the same with arrays in Julia.


Apparently others do as well: Perl, C#, Swift, etc …


Some do not like trailing commas:


However, the main dev work I do is in R, which does not support trailing commas.

c("hello", "world")
#> [1] "hello" "world
c("hello", "world", )
#> Error in c("hello", "world", ) : argument 3 is empty

The one caveat is that you will see trailing commas in subsetting procedures of lists, vectors, data.frames, matrices, e.g.,


One blogger provides an override to allow trailing commas though I’d imagine it’s not a good idea to use as you probably don’t want such fundamentally different behavior in your own R console compared to others.

I’ve not seen any discussion of trailing commas in R as a language feature, whether good, bad or otherwise. Doesn’t mean it doesn’t exist though :)


Like R, doesn’t allow trailing commas!

And in fact, allegedly (I don’t use Haskell):

Because it is much more common to append to lists rather than to prepend, Haskellers have developed the idiom of leading comma:

  ( foo
  , bar
  , baz
  , quux


Unfortunately for many people JSON does not allow trailing commas

see also: leading with commas

Posted on by:


Editor guide

Someone else recently also told me trailing commas help with diffs which is great but I’ve also found that it helped me when I edit an array or object as the comma is already present on the previous entry, it is less prone to errors for me. 😄


Right, good point about being easier to make changes. I also appreciate that.


I've seen some people hit the leading comma in R as well. In fact I saw a speaker at Chicago SatRdays live stream using them: twitter.com/just_add_data/status/1...


interesting, is there a link to a talk?


Sure, the whole thing is here, and this is the point the leading commas are at