const data = [{ a: '123' }, { a: '123' },{ a: '000' }]
const pushData = [{ b: '321', c: '322' }]

通过for循环把data里a的值作为新数组的key，接着把pushData中的数据作为值，但是当data里a的值都为相同时，新数组只能有一个“123”的key，输出如下↓

 const newData = [{ '123': [{ b: '321', c: '322' }] },
                  { '000': [{ b: '321', c: '322' }] }]

现在我需要的效果是，判断data里a的值是否相同，相同的话在后面哪一个加上"-1"，然后再把pushData里的数据放进去。

理想效果↓

 const newData = [{ '123': [{ b: '321', c: '322' }] },
                  { '123-1': [{ b: '321', c: '322' }] },
                  { '000': [{ b: '321', c: '322' }] }]

我该怎么操作才能达到效果呢~..

感谢各位大神大哥的指导，先感谢你们的回答，小弟感激不尽，还请轻喷！

先说一下你问题的前半段，因为你没贴代码，并不清楚你是怎么做的，出现了当data里a的值都为相同时，新数组只能有一个“123”的key这样的情况。

通过for循环把data里a的值作为新数组的key，接着把pushData中的数据作为值 以下两种均可实现：

const data = [{ a: '123' }, { a: '123' },{ a: '000' }]
const pushData = [{ b: '321', c: '322' }]
const newData = data.map(p => {
        const label = p.a
        return {
          [label]: pushData
        }
      })

const data = [{ a: '123' }, { a: '123' },{ a: '000' }]
const pushData = [{ b: '321', c: '322' }]
const newData = []
      data.forEach(p => {
        const label = p.a
        newData.push({
          [label]: pushData
        })
      })

以上不知道满不满足你的需求。

然后你说的后半段：
判断data里a的值是否相同，相同的话在后面哪一个加上"-1"，然后再把pushData里的数据放进去，楼上已经给出了很好的答案。

let data = [{ a: "123" }, { a: "123" }, { a: "123" }, { a: "000" }];
let pushData = [{ b: "321", c: "322" }];
let obj = {}
let res = data.map(item => {
    let key = item.a
    if(obj[item.a] !== undefined){
        obj[item.a] += 1
        key += '-' + obj[item.a]
    }else{
        obj[item.a] = 0
    }
   return {[key]: [...pushData]};
}, []);
console.log(res);

    const data = [{ a: "123" }, { a: "123" }, { a: "000" }];
    const pushData = [{ b: "321", c: "322" }];
    const res = data.reduce((a, b) => {
      return [...a, { [a.some(r => r[b.a]) ? `${b.a}-1` : b.a]: pushData }];
    }, []);
    console.log(res);

  const data = [{ a: "123" }, { a: "123" }, { a: "123" }, { a: "000" }];
  const pushData = [{ b: "321", c: "322" }];

  let obj = {};
  data.forEach((item, idx) => {
    if (obj[item.a] !== undefined) {
      obj[item.a] += 1;
    } else {
      obj[item.a] = 1;
    }
  });
  let result = [];
  for (let key in obj) {
    let count = obj[key];
    for (let i = 0; i < count; i++) {
      let name = i == 0 ? key : `${key}-${i}`;
      let item = {};
      item[name] = pushData;
      result.push(item);
    }
  }
  console.log(JSON.stringify(result));

const data = [{ a: "123" }, { a: "123" }, { a: "000" }];
const pushData = [{ b: "321", c: "322" }];
const res = data.reduce((acc, dataItem) => {
   const hasKey = acc.some(item => item[dataItem.a] !== undefined);
   const newKey = hasKey? `${dataItem.a}-1` : dataItem.a;
   return [...acc, {[newKey]: {...pushData}}];
}, []);
console.log(res);

如果有3个相同的a怎么处理？

要处理多于1个的重复可能，其实有一个取巧的方法，会占用一些空间。

const data = [{ a: "123" }, { a: "123" }, { a: "123" }, { a: "000" }];
const pushData = [{ b: "321", c: "322" }];
var outData=[];
let keys={};
let Ntmp={};
let mkey='';
for(let i=0;i<data.length;i++){
  Ntmp={};
  mkey='';
  if(keys[ data[i]['a'] ]!=undefined ){
    mkey=  data[i]['a']  + '-'+ keys[ data[i]['a'] ];
    keys[data[i]['a']]=keys[data[i]['a']]+1;
  }else{
    mkey =data[i]['a']; 
    keys[data[i]['a']]=1;
  }
  Ntmp[mkey]= pushData;
  outData.push(Ntmp);
}
console.log(keys);
console.log(outData);

这个对多于1个重复的a值会自动递增

var obj={},newArr=[];
data.map(res=>{
    for(let key in res){
        if(obj[res[key]] !=undefined){
            var newObj = { };
            newObj[[res[key]]+'-'+obj[res[key]]] = pushData
            newArr.push(newObj)
            obj[res[key]] = obj[res[key]]+1;
        }else{
            obj[res[key]] = 1;
            var newObj = {};
            newObj[[res[key]]] = pushData
                newArr.push(newObj)
            }
        }
},[]);
console.info(newArr);