What does it mean when variable value in round brackets?

Question

What does it mean when variable value in round brackets in js? For example,

let a = (1,2,3);

What does it mean and why console.log(a) output is 3?

What is usage of comma operator in round brackets in variable initialization?

Answer 1

The parentheses are needed for grouping. In a let statement, commas are normally used to separate multiple variables that are being declared, e.g.

let a = 1, b = 2, c;

which is short for

let a = 1;
let b = 2;
let c;

If you write

let a = 1, 2, 3;

you'll get a syntax error, because after the comma it expects another variable declaration; it's equivalent to:

let a = 1;
let 2;
let 3;

The second and third declarations are clearly wrong, as 2 and 3 are not variable names.

The parentheses indicate that the whole expression 1, 2, 3 is being used to initialize one variable.

The expression 1, 2, 3 uses the Comma operator, which executes each of its subexpressions and returns the last one as its value. It's pretty useless when the subexpressions are all constants, so I assume your code was just a simplified example. Because the way it's written, it's really just equivalent to:

let a = 3;

Answer 2

What you have encountered is the comma operator.

Quoting the docs

The comma operator evaluates each of its operands (from left to right) and returns the value of the last operand.

Therefore in your case 1, 2 and 3 is evaluated and 3 is returned and thus assigned to the variable a.

Answer 3

This is not variable declaration-specific thing. You can write (1,2,3) anywhere in your JS code and it will always evaluate to 3. The thing is, JavaScript (like many other programming languages, e.g. C) has comma operator, which simply returns last element. The expression (1,2,3) basically looks just like (1+2+3) to JavaScript, except for comma operator is applied instead of addition.

Answer 4

It's call the comma operator:

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator

It's a very handy thing to use in JavaScript, because it allows you to run multiple statements as a single value for an arrow function.

Here is an example of a 10x10 identity matrix generated with one line of code. The last comma value is returned as the value.

const m = new Array(9).fill('000000000').map((v,i)=> (v=[...v],v[i]='1',v.join()));
console.log(m);

The same above code as a blocked function would take a lot more lines.

const m = new Array(9).fill('000000000').map((v,i)=> {
   v = [...v];
   v[i] = '1';
   return v.join()
});
console.log(m);