Trailing commas

Trailing commas (sometimes called "final commas") can be useful when adding new elements, parameters, or properties to JavaScript code. If you want to add a new property, you can add a new line without modifying the previously last line if that line already uses a trailing comma. This makes version-control diffs cleaner and editing code might be less troublesome.

JavaScript has allowed trailing commas in array literals since the beginning, and later added them to object literals, and more recently, to function parameters and to named imports and named exports.

JSON, however, disallows trailing commas.




Trailing commas in literals


JavaScript ignores trailing commas in arrays:

const arr = [

arr; // [1, 2, 3]
arr.length; // 3

If more than one trailing comma is used, an elision (or hole) is produced. An array with holes is called sparse (a dense array has no holes). When iterating arrays for example with Array.prototype.forEach() or, array holes are skipped.

const arr = [1, 2, 3,,,];
arr.length; // 5


Starting with ECMAScript 5, trailing commas in object literals are legal as well:

const object = {
  foo: "bar",
  baz: "qwerty",
  age: 42,

Trailing commas in functions

ECMAScript 2017 allows trailing commas in function parameter lists.

Parameter definitions

The following function definition pairs are legal and equivalent to each other. Trailing commas don't affect the length property of function declarations or their arguments object.

function f(p) {}
function f(p,) {}

(p) => {};
(p,) => {};

The trailing comma also works with method definitions for classes or objects:

class C {
  one(a,) {}
  two(a, b,) {}

const obj = {
  one(a,) {},
  two(a, b,) {},

Function calls

The following function invocation pairs are legal and equivalent to each other.


Math.max(10, 20);
Math.max(10, 20,);

Illegal trailing commas

Function parameter definitions or function invocations only containing a comma will throw a SyntaxError. Furthermore, when using a rest parameters, trailing commas are not allowed:

function f(,) {} // SyntaxError: missing formal parameter
(,) => {};       // SyntaxError: expected expression, got ','
f(,)             // SyntaxError: expected expression, got ','

function f(...p,) {} // SyntaxError: parameter after rest parameter
(...p,) => {}        // SyntaxError: expected closing parenthesis, got ','

Trailing commas in destructuring

A trailing comma is also allowed on the left-hand side when using destructuring assignment:

// array destructuring with trailing comma
[a, b,] = [1, 2];

// object destructuring with trailing comma
const o = {
  p: 42,
  q: true,
const {p, q,} = o;

Again, when using a rest element, a SyntaxError will be thrown:

const [a, ...b,] = [1, 2, 3];
// SyntaxError: rest element may not have a trailing comma

Trailing commas in JSON

Trailing commas in objects were only introduced in ECMAScript 5. As JSON is based on JavaScript's syntax prior to ES5, trailing commas are not allowed in JSON.

Both lines will throw a SyntaxError:

JSON.parse('[1, 2, 3, 4, ]');
JSON.parse('{"foo" : 1, }');
// SyntaxError JSON.parse: unexpected character
// at line 1 column 14 of the JSON data

Omit the trailing commas to parse the JSON correctly:

JSON.parse('[1, 2, 3, 4 ]');
JSON.parse('{"foo" : 1 }');

Trailing commas in named imports and named exports

Trailing commas are valid in named imports and named exports.

named imports

  import {
  } from 'D'

  import { X, Y, Z, } from 'W'

  import { A as B, C as D, E as F, } from 'Z'; //Renaming imports

named exports

  export {

  export { A, B, C, };

  export { A as B, C as D, E as F, }; // Renaming exports

Quantifier prefix

  //{ DecimalDigits[~Sep], DecimalDigits[~Sep] }


ECMAScript Language Specification
# prod-Elision
ECMAScript Language Specification
# prod-ObjectLiteral
ECMAScript Language Specification
# prod-ArrayLiteral
ECMAScript Language Specification
# prod-Arguments
ECMAScript Language Specification
# prod-FormalParameters
ECMAScript Language Specification
# prod-CoverParenthesizedExpressionAndArrowParameterList
ECMAScript Language Specification
# prod-NamedImports
ECMAScript Language Specification
# prod-NamedExports
ECMAScript Language Specification
# prod-QuantifierPrefix
ECMAScript Language Specification
# prod-annexB-InvalidBracedQuantifier

Browser compatibility

BCD tables only load in the browser

See also