如何根据分组在一起的相似值在JavaScript中组织单个数组？

我试图用JavaScript编写一个函数，该函数将数组作为输入，并返回一个数组，其中相似的元素分组在一个子数组中。该函数将数组作为输入，并将数组作为输出返回。 例如，当我输入

groupfunction（[1,2,4591392391,2,5,10,2,1,1,1,20,20]）

时，它应该返回

[1,1,1,1]，[2,2,2]，4,5,10，[20,20]，391392591]

。然而，由于某种原因，函数输出了

[[1,1,1,1]，2[4,4,4]，[591591]，392391,5,10,20]

。我可以使用什么将数组中的相似元素分组到子数组中

我发现以下问题很有帮助，我的代码基于以下内容中的答案：

设numberoftimes=0；
常量函数相等=（input1）=>{if（input1==元素）{return true}
else{return false}；
const indexofelement=array.findIndex（functionisequal）；
while（array.includes（element）==true）{
查找（functionisequal）；
次数+=1；
阵列。拼接（索引键，1）；
}
返回次数；
}
const finduniquevalues=（arr）=>{//此函数将数组减少为仅具有唯一值。
常量映射=[]；
for（arr的let值）{
if（映射索引of（值）=-1）{
map.push（值）；
}
}
返回图；
};
常量removeElementsWithValue=（数组，val）=>{//此函数用于从数组中删除特定值
var i=数组长度；
而(我--){
if（数组[i]==val）{
阵列拼接（i，1）；
}
}
返回数组；
}
const removezeroes=（数组）=>{return removeElementsWithValue（数组，0）}//此函数从数组中删除零}
const repeatelement=（elem，n）=>{//此函数重复一个元素，有效地将一个值[value]的数组乘以n，从而使该值出现n次。
var-arr=[]；
对于（变量i=0；i{let blank=[]；//此函数用于查找数组中每个元素的数量。
让arraycopy=array.concat（[]）；
让sortedArray=array.slice（）.sort（）；
让arraycopysorted=arraycopy.slice（）.sort（）；
对于（arraycopysorted的元素）{let num=findnumberofinstances（SortedDarray，元素）；
blank.push（num）；
}
返回removezeroes（空白）；}
const groupfunction=（array）=>{let sum=[]；//此函数仅当存在多个元素时，才将相同的元素分组到子数组中。
let unique=finduniquevalues（数组）；
设空白=[]；
设number=findnumberofeachement（数组）；
for（设i=0；i1）{sum=repeatelement（唯一[i]，数[i]）
blank.push（和）；}
else{sum=unique[i]
blank.push（和）}
总和=[]
}
返回空白}
log（groupfunction（[1,2,4591392391,2,5,10,2,1,1,1,20,20]）//这应该返回[[1,1,1,1,1]，[2,2,2]，4,5,10[20,20]，391,392591]。

您可以使用

数组#reduce

对对象累加器中的每个值对数组进行分组

constgroupfunction=arr=>Object.values(
arr.reduce（（r，v）=>{
r[v]=r[v]| |[]；
r[v].推（v）；
返回r；
}, {}))
.map（a=>a.length==1？a[0]：a）；
log（groupfunction（[1,2,4,591,392,391,2,5,10,2,1,1,1,20]）
.as控制台包装{max height:100%！important；top:0；}
好了，不简单，但我应该是正确的

function groupUp(array) {
    array.sort(function(a, b){return a - b})
    const map = new Map()
    const order = []
    array.forEach(e => {
        if (map.has(e)) {
            map.get(e).push(e)
        } else {
            map.set(e, [e])
            order.push(e)
        }
    })

    const final = []

    order.forEach(e => {
        const group = map.get(e)
        if (group.length == 1) {
            final.push(group[0])
        } else {
            final.push(group)
        }
    })

    return final
}

console.log(groupUp([1,2,4,591,392,391,2,5,10,2,1,1,1,20,20]))


const a=[1,2,3,3,5,1,10,9,10]；
常数b=a.reduce（（acc，e）=>{
const item=acc.find（i=>i==e）；//在数组中查找项；
if（item）{//如果我们找到了item；
常数索引=附件索引（项目）；
acc.splice（索引，1，[项，项]）//将项转换为数组
}否则{
let inserted=false；//我们将项目推入数组或子数组
acc.forEach（项目=>{
if（数组的项目实例&&item==e）{
item.push（e）；//将项附加到子数组
插入=真；
}
}) 
如果（！inserted）acc.push（e）；//追加为项目；
}
返回acc；
}，[]/*初始数组*/）
console.log（JSON.stringify（b））
这个ewen是如何工作的，它几乎像是专门为这个目的制作的ReduceWOS
function groupUp(array) {
    array.sort(function(a, b){return a - b})
    const map = new Map()
    const order = []
    array.forEach(e => {
        if (map.has(e)) {
            map.get(e).push(e)
        } else {
            map.set(e, [e])
            order.push(e)
        }
    })

    const final = []

    order.forEach(e => {
        const group = map.get(e)
        if (group.length == 1) {
            final.push(group[0])
        } else {
            final.push(group)
        }
    })

    return final
}

console.log(groupUp([1,2,4,591,392,391,2,5,10,2,1,1,1,20,20]))