Why do PHP Array Examples Leave a Trailing Comma?

Question

I have seen examples like the following:

$data = array(
   'username' => $user->getUsername(),
   'userpass' => $user->getPassword(),
   'email' => $user->getEmail(),
);

However, in practice I have always not left the trailing comma. Am I doing something wrong, or is this just 'another' way of doing it? If I was using a framework would not having the trailing comma affect code generation negatively? I have seen the use of trailing commas in array declarations in other languages (Java, C++) as well, so I assume the reasons for leaving trailing commas are not specific to PHP, but this has piqued my interest.

Answer 1

Why do PHP Array Examples Leave a Trailing Comma?

Because they can. :) The PHP Manual entry for array states:

Having a trailing comma after the last defined array entry, while unusual, is a valid syntax.

Seriously, this is entirely for convenience so you can easily add another element to the array without having to first add the trailing comma to the last entry.

Speaking of other languages: Be careful with this in JavaScript. Firefox will leniently tolerate trailing commas; Internet Explorer will, rightly, throw an error.

Answer 2

This is a good practice when defining array on multiple lines. It's also encouraged by ZendFramework's coding standards:

When using this latter declaration, we encourage using a trailing comma for the last item in the array; this minimizes the impact of adding new items on successive lines, and helps to ensure no parse errors occur due to a missing comma.

Answer 3

I noticed when working with version control (git) that if we add 1 thing to an array and we don't have the trailing comma, it will look like we modified 2 lines because the comma had to be added to the previous line. I find this looks bad and can be misleading when looking at the file changes, and for this reason I think a trailing comma is a good thing.

Answer 4

Because it keeps entries uniform.

If you've had to swap the order, or add or delete entries, you know being able to leave a trailing comma is very convenient.

If the last element cannot have a comma, then you end up having to maintain the last comma by modifying entries. It's a pointless exercise and a waste of time and finger strokes because the intent of swapping or modifying entries is already accomplished.

By allowing a trailing comma on the last element, it frees the programmer from having to tend to this annoying and fruitless detail.

Answer 5

I can't speak for other people, but I usually leave a trailing comma in my code. I do so because if/when I later add to the array, I do not have to worry about missing out a comma due to forgetting to add a comma to what was previously the last line.

Answer 6

I feel that even though it is allowed it is bad practice, its like leaving out the last semi colon of your functions and loops.

Answer 7

The reason is commit changes.

If you have to add the trailing comma when adding a new element. You're changing 1 line and adding 1 line. (-++)

When adding a new element when a comma is already in the line above. There is only 1 added line, and no changed ones. (+)

Answer 8

I'm always doing trailing comma because it helps to avoid syntax errors while adding new array elements... it's just a good practice.

Answer 9

This surprised me recently, but it makes sense. I have long tried to adhere to an earlier convention that accomplishes the same thing, which is to put the separating comma in front of each entry rather than at the end.

$data = array(
   'username' => $user->getUsername()
 , 'userpass' => $user->getPassword()
 , 'email' => $user->getEmail()
);

The commas also all line up that way, which looks nice, but it can make the indenting a little awkward. Maybe for that reason, it doesn't seem to have caught on much over the years, and I've had others ask me why I do it. I guess PHP's solution is a good compromise, and in any case, it's apparently the accepted solution now.

Answer 10

I've always added commas at the start of the new entry. Compilers see it as the single-character token of look-ahead that says "there is another one coming". I don't know if modern compilers use LR(1) (left-recursive, single token look-ahead) but I think that's where the syntax error originates when an a comma has nothing after it. It is rare that I've ever had another developer agree with me, but it looks like JohnBrooking does!