逗号操作符可以用来在一条语句中执行多个操作，如下所示：

在一条语句中同时声明多个变量是逗号操作符最常用的场景。不过，也可以使用逗号操作符来辅助

赋值。在赋值时使用逗号操作符分隔值，最终会返回表达式中最后一个值：

 在这个例子中，num 将被赋值为 2，因为 2 是表达式中最后一项。逗号操作符的这种使用场景并不 多见，但这种行为的确存在。

二、逗号操作符的拓展用法

逗号操作符还有很多意想不到的操作,例如可以使我们的代码最大程度的进行简写,如下所示：

let arr = [{ id: 1, value: '正式' }, { id: 2, value: '非正式' }]

当我们的需要将arr的值处理成为{1: '正式', 2: '非正式'}的时候

按照我们正常的写法来说,用reduce方法是最合适不过的。

      let newArr= arr.reduce((acc,item)=>{
           acc[item.id]=item.value
           return  acc
        },{})
        console.log(newArr);
        
    这时我们打印输出newArr得到的值就是 {1: '正式', 2: '非正式'}

可以看出这样也是可以得到我们想要求的值,但是如何让这些代码一行就能达到效果呢?

这里我们就可以用到逗号操作符了

  let newArr= arr.reduce((acc,item)=> (acc[item.id]=item.value, acc),{})
  console.log(newArr);
  这里我们输出打印的值也一样可以得到我们需求的值 {1: '正式', 2: '非正式'}

由此可见逗号操作符可以使我们的代码尽可能的进行压缩

一、逗号操作符的基础用法

逗号操作符可以用来在一条语句中执行多个操作，如下所示：

在一条语句中同时声明多个变量是逗号操作符最常用的场景。不过，也可以使用逗号操作符来辅助

赋值。在赋值时使用逗号操作符分隔值，最终会返回表达式中最后一个值：

 在这个例子中，num 将被赋值为 2，因为 2 是表达式中最后一项。逗号操作符的这种使用场景并不 多见，但这种行为的确存在。

二、逗号操作符的拓展用法

逗号操作符还有很多意想不到的操作,例如可以使我们的代码最大程度的进行简写,如下所示：

let arr = [{ id: 1, value: '正式' }, { id: 2, value: '非正式' }]

当我们的需要将arr的值处理成为{1: '正式', 2: '非正式'}的时候

按照我们正常的写法来说,用reduce方法是最合适不过的。

      let newArr= arr.reduce((acc,item)=>{
           acc[item.id]=item.value
           return  acc
        },{})
        console.log(newArr);
        
    这时我们打印输出newArr得到的值就是 {1: '正式', 2: '非正式'}

可以看出这样也是可以得到我们想要求的值,但是如何让这些代码一行就能达到效果呢?

这里我们就可以用到逗号操作符了

  let newArr= arr.reduce((acc,item)=> (acc[item.id]=item.value, acc),{})
  console.log(newArr);
  这里我们输出打印的值也一样可以得到我们需求的值 {1: '正式', 2: '非正式'}

由此可见逗号操作符可以使我们的代码尽可能的进行压缩

逗号操作符（,）在c\c++中的原生语义：

1）逗号表达式用于将多个子表达式连接为一个表达式

2）逗号表达式的值为最后一个子表达式的值

3）逗号表达式的前N-1个子表达式可以没有返回值

4）逗号表达式按照从左到右的顺序计算每个子表达式的值

例子：

#include <iostream>
#include <string>

using namespace std;

void func(int i)
{
    cout << "func() : i = " << i << endl;
}

int main()
{   
    int a[3][3] = {
        (0, 1, 2), //此处没有使用 {} 所以变成了逗号表达式 
        (3, 4, 5),
        (6, 7, 8)
    };
	   
    int i = 0;
    int j = 0;
    
    while( i < 5 )    
        func(i),  //实际上等价于这样 func(i),i++;
    
    i++;
        
    for(i=0; i<3; i++)
    {
        for(j=0; j<3; j++)
        {
            cout << a[i][j] << endl;
        }
    }
    
    (i, j) = 6; //等价于 j = 6;
    
    cout << "i = " << i << endl;
    cout << "j = " << j << endl;

    return 0;
}

运行结果

func() : i = 0
func() : i = 1
func() : i = 2
func() : i = 3
func() : i = 4
2
5
8
0
0
0
0
0
0
i = 3
j = 6

逗号运算符的重载试验

#include <iostream>
#include <string>

using namespace std;

class Test
{
	int m_value;
public:
    Test (int i)
	{
		m_value = i;
	}	
	int value()
	{
		return m_value;
	}
	
};

Test& operator , (const Test& a , const Test& b)
{
    //按照逗号运算符的原生语义 返回第二个参数的引用
	return const_cast<Test&>(b);  //使用const_cast去除b参数的只读属性
}


Test func(Test& i)
{
    cout << "func() : i = " << i.value() << endl;
	
	return i;
}

int main()
{   
    Test t0(0);
	Test t1(1);
	
	Test t2 = (t0,t1);//逗号表达式 t2使用t1进行初始化
	
	cout << t2.value() << endl;
	
	Test t4 = (func(t0),func(t1));
	cout << t4.value() << endl;

    return 0;
}

运行结果

1
func() : i = 1
func() : i = 0
1

这里我们可以看到，逗号运算符并没有按照从左到右运行，违背了其原生语义。

那到底是什么原因呢？

其实在上面的代码对t4进行初始化时的代码是

Test t4 = (func(t0),func(t1)); 

等效于

Test t4 = operator , (func(t0),func(t1));

在c/c++中，进入函数体之前，必须完成所有参数的计算，且参数的计算次序也是不确定。所以出现了这样的运行结果。

最后我们做一个小实验，去除之前代码中的逗号操作符重载，编译执行，得到的结果如下：

1
func() : i = 0
func() : i = 1
1

结果正确，且编译器没有报错，说明实际上编译器就能处理包含对象的逗号操作符。重载逗号操作符是没有意义的。