If I use:
1.09 * 1; // returns "1.09"
But if I use:
1,09 * 1; // returns "9"
I know that 1,09 isn't a number.
What does the comma do in the last piece of code?
if (0,9) alert("ok"); // alert
if (9,0) alert("ok"); // don't alert
alert(1); alert(2); alert(3); // 3 alerts
alert(1), alert(2), alert(3); // 3 alerts too
alert("2",
foo = function (param) {
alert(param)
},
foo('1')
)
foo('3'); // alerts 1, 2 and 3
The comma operator evaluates both of its operands (from left to right) and returns the value of the second operand.
Source: https://developer.mozilla.org/en/JavaScript/Reference/Operators/Special_Operators/Comma_Operator
For example, the expression 1,2,3,4,5 evaluates to 5. Obviously the comma operator is useful only for operations with side-effects.
console.log(1,2,3,4,5);
console.log((1,2,3,4,5));
for loop.
continue points without duplication, but then you shouldn't have multiple continue points.
Vue docs use it on their template compilation exampleSome more to consider:
console.log((0, 9));
console.log((9, 0));
console.log(("foo", "bar"));The specific syntax allows a bakery to functionally bake bread, hand it to the customer for consumption and also keep the number of returns to zero. All these by utilizing parenthesized arrow functions.
(new Array(3)).fill()
.map(()=>({state:"dough", bake(){this.state="baked"}, consume(){this.state="consumed"}}))
.map(bread=>(console.log(`Adding ${bread.state} to oven.`), bread.bake(), bread))
.map(bread=>(console.log(`Consuming ${bread.state} bread.`), bread.consume(), bread))
.map(bread=>console.log(`Bread is now ${bread.state}.`))
Adding dough to oven.
Adding dough to oven.
Adding dough to oven.
Consuming baked bread.
Consuming baked bread.
Consuming baked bread.
Bread is now consumed.
Bread is now consumed.
Bread is now consumed.
{}with ; inseed of () with , ?return.Adding/modifying properties to an object and returning it in the same line is a possible use-case:
console.log(
((x) => (o = {biggerCond: r => r >= x},
o.r5 = Array.from(window.crypto.getRandomValues(new Uint16Array(5))),
o.isAnyBigger = o.r5.some(o.biggerCond),
o.bigger = o.isAnyBigger ? o.r5.filter(o.biggerCond) : [x], o )
)(5e4)
);
// Example
// {
// bigger: [58414, 56500, 63397],
// isAnyBigger: true,
// isBiggerCond: r => r >= x,
// r5: [58414, 12015, 56500, 63397, 43861]
// }The above anonymous function returns an object with random values bigger than the input value or, if there's none, with the input value itself in an array in contained in the bigger property.
It is still syntactic sugar (like arrow functions), but it does shorten the number of lines... I wonder if some JS minifiers detect and adjust the code in a similar way automatically. Run it in your console:
((x)=>(o={biggerCond:r=>r>=x},o.r5=Array.from(window.crypto.getRandomValues(new Uint16Array(5))),o.isAnyBigger=o.r5.some(o.biggerCond),o.bigger=o.isAnyBigger?o.r5.filter(o.biggerCond):[x],o))(5e4)
Have a look here - the comma stands for multiple expressions / statements. For example in your code you could use a line like this:
var a=0, b=0, c=0;
This would declare all three variables without writing:
var a=0;
var b=0;
var c=0;
Hope that helps.
var declarations don't use the comma operator, even though it's a comma) and (2) you can't separate statments using the comma operators; only expressions are allowed.
alerttakes only one argument. Anything after that is discarded.argumentsobject instead, which can be of any length). Even with modern compiled JS, there would be no way to tell ahead of time how many arguments a function would take. Consider this:function test() { args=[]; for (var i = 0; i < arguments.length; i++) { args.push(arguments[i] + 1); } ;The interpreter would have to know how the function was being used to know how many args it would take. Instead, it evaluates everything.