上QQ阅读APP看书，第一时间看更新

Trailing commas in function arguments

Trailing commas are the commas that are used after the last argument of a function. Using a comma after the last parameter of a function can be useful because it is very common for programmers to forget to add a comma when they modify an existing function by adding additional parameters.

For example, the following function only takes one parameter and doesn't use trailing commas:

function greetWithoutTralingCommas( 
    name: string 
): string { 
    return `Hi! ${name}`; 
}

After some time, we might be required to add a parameter to the preceding function. A common mistake is to declare the new parameter and forget to add a comma after the first parameter:

function updatedGreetWithoutTralingCommas( 
    name: string 
    surname: string, // Error 
): string { 
    return `Hi! ${name} ${surname}`; 
}

Using a trailing comma in the first version of the function could have helped us to prevent this common mistake:

function greetWithTralingCommas( 
    name: string, 
): string { 
    return `Hi! ${name}`; 
}

Using a trailing comma eliminates the possibility of forgetting the comma when adding a new argument:

function updatedGreetWithTralingCommas( 
    name: string, 
    surname: string, 
): string { 
    return `Hi! ${name} ${surname}`; 
}

TypeScript will throw an error if we forget a comma, so trailing commas are not needed as much as they are when working with JavaScript. Trailing commas are optional, but using them is considered a good practice by many JavaScript and TypeScript engineers.