Javascript 将具有多个索引的项分组到子数组中

尝试创建一个函数，将数组中的重复项分组为子数组，并将字符串（如果有）分组为另一个子数组

我尝试使用findIndex方法定义I，然后使用reduce对其进行迭代，并将其推入[]

let roughArray = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20];

function sortArray() {
    roughArray.map(num => {
        if (num[i] > 1) {
            roughArray.reduce((acc, num) => {
                return acc.concat(num)
            }, [])
        }
    })

sortArray()

我还尝试：

const cleanArray = roughArray.reduce((acc, num) => {
    let i = acc.findIndex(num);
    if (i) {
        return acc.concat(num);
    }
}, [])
cleanArray();

我希望这只是数字的情况

 [[1,1,1,1],[2,2,2], 4,5,10,[20,20], 391, 392,591]

对于某些包含的字符串：

 [[1,2], ["2", "3"]]

---

您可以为各种类型的分组声明一些回调，并通过检查数组获得想要的类型，并为分组值获取一个对象

函数排序（数组）{
常数
混合=（r，v）=>{
var键=v的类型；
r[键]=r[键]| |[]；
r[键]。按（v）；
返回r；
},
数字=（r，v）=>{
如果（r中的v）r[v]＝[]concat（r[v]，v）；
否则r[v]=v；
返回r；
};
返回Object.values（array.reduce（array.some）（v=>typeof v==='string'））
？混合
：数字，
Object.create（空）
));
}
log（sortOf（[1,1,2,3]）；
log（sortOf（[5,2,3,3,4,5,5,1]）
.as console wrapper{max height:100%！important；top:0；}
您可以为各种类型的分组声明一些回调，并通过检查数组获得所需类型，并为分组值获取一个对象


函数排序（数组）{
常数
混合=（r，v）=>{
var键=v的类型；
r[键]=r[键]| |[]；
r[键]。按（v）；
返回r；
},
数字=（r，v）=>{
如果（r中的v）r[v]＝[]concat（r[v]，v）；
否则r[v]=v；
返回r；
};
返回Object.values（array.reduce（array.some）（v=>typeof v==='string'））
？混合
：数字，
Object.create（空）
));
}
log（sortOf（[1,1,2,3]）；
log（sortOf（[5,2,3,3,4,5,5,1]）
.as console wrapper{max height:100%！important；top:0；}
这里我使用一个对象文本
{}
作为
数组的累加器。prototype.reduce
，如果数组中有字符串，我使用
str
作为对象{}累加器的键，并添加字符串作为值。因此，如果遇到字符串，累加器将是
{str:“23”}

对于数字，我检查值是否重复，如果重复，我创建了一个数组，并将新的重复数字添加到其中，其中键是数字本身，例如
{1:[1,1]}

最后，当构建累加器对象时，我只使用
object.values
获取累加器对象的值部分，我返回：


让roughArray=[1,2,4,591,392,391,2,5,10,2,1,1,20,20,23,23,34]；
函数组（数组）{
返回Object.values（roughArray.reduce（（r，e）=>{
如果（r['str']&&typeof e==“string”）{r['str']=Array.isArray（r['str']）？[…r['str']].concat（e）：[r['str']，e]；]
else if（typeof e==“string”）{r['str']=[e]}
如果（r[e]）{r[e]=Array.isArray（r[e]）？[…r[e]].concat（e）：[r[e]，e]；}
else{r[e]=e}
返回r；
}, {}));
}
log（组（数组））
这里我使用对象文本
{}
作为
数组的累加器。prototype.reduce
，如果数组中有字符串，我使用
str
作为对象{}累加器的键，并添加字符串作为值。因此，如果遇到字符串，累加器将是
{str:“23”}

对于数字，我检查值是否重复，如果重复，我创建了一个数组，并将新的重复数字添加到其中，其中键是数字本身，例如
{1:[1,1]}

最后，当构建累加器对象时，我只使用
object.values
获取累加器对象的值部分，我返回：


让roughArray=[1,2,4,591,392,391,2,5,10,2,1,1,20,20,23,23,34]；
函数组（数组）{
返回Object.values（roughArray.reduce（（r，e）=>{
如果（r['str']&&typeof e==“string”）{r['str']=Array.isArray（r['str']）？[…r['str']].concat（e）：[r['str']，e]；]
else if（typeof e==“string”）{r['str']=[e]}
如果（r[e]）{r[e]=Array.isArray（r[e]）？[…r[e]].concat（e）：[r[e]，e]；}
else{r[e]=e}
返回r；
}, {}));
}
log（组（数组））首先将字符串与其余字符串分开。对数字进行排序、分组，然后将字符串添加回末尾

如果愿意，可以将所有单个项数组映射为单个项，但这似乎会使输出混乱


let start=[1,2,4591392391,2,5,10,2,1,1,20,20,2,3']；
让strings=start.filter（v=>typeof（v）='string'）；
让notStrings=start.filter（v=>typeof（v）！==string'）；
让sortedNotStrings=notStrings.sort（（a，b）=>a>b）；
let grouped=SortedNotString.reduce（（acc，值）=>
{
如果（附件长度>0）
{
如果（acc[0][0]==值）
{
acc[0]。推送（值）；
}
其他的
{
根据取消移位（[值]）；
}
}
其他的
{
根据取消移位（[值]）；
}
返回acc；
}, []);
让sortedGrouped=grouped.sort（（g1，g2）=>g1[0]>g2[0]）；
设WithString=[SortedGroup，String]；
控制台日志（带字符串）；
让lonelySingleItems=sortedGroup.map（arr=>arr.length>1？arr:arr[0]）；
log（[lonelysingletems，strings]）首先将字符串与其余字符串分开。对数字进行排序、分组，然后将字符串添加回末尾

如果愿意，可以将所有单个项数组映射为单个项，但这似乎会使输出混乱


let start=[1,2,4591392391,2,5,10,2,1,1,20,20,2,3']；
让strings=start.filter（v=>typeof(
let roughArray = [1, 2, 4, 591, 392, 391, 2, 5, 10, 2, 1, 1, 1, 20, 20];
let results = {}
roughArray.map( num => {
    if(results[num])
        results[num].push(num)
    else 
        results[num] = [num]
    })
let bigArray = []
bigArray = Object.values(results)
let final_result = []
bigArray.map(array => {
    if(array.length == 1)
        final_result.push(array[0])
    else 
        final_result.push(array)
})
console.log(final_result)