Question

Input:

 const before_sort = [

            { id: 1, name: 't1' , events:[{id: 1, fromDate:10, toDate:12}
                                           {id: 26, fromDate: 2, toDate: 6}
                                           {id: 47, fromDate: 1, toDate: 2}
                                           {id: 46, fromDate: 3, toDate: 3}]
            },

            { id: 2, name: 't2' , events:[{id: 1, fromDate:11,toDate:15}]},
            { id: 3, name: 't3' , events:[]}
        ];


Output:

const after_sort = [{ id: 2, name: 't2' , events:[{id: 1, fromDate:11, toDate:15}]},
            { id: 1, name: 't1' , events:[{id: 1, fromDate:10, toDate:12}
                                         {id: 46, fromDate: 3, toDate: 3}
                                         {id: 26, fromDate: 2, toDate: 6}
                                         {id: 47, fromDate: 1, toDate: 2}]},
            {id: 3, name: 't3' , events:[]}
        ];

伙计们，我是新来的人，我尝试根据事件[嵌套对象]的fromDate对程序（t1，t2，t3）[主数组]进行排序。但是，过去的事件阻碍了整体排序。我的方法是：

为特定程序排序所有事件。
将所有即将发生的事件推送到临时数组中。
根据第一个事件对程序进行排序。

此逻辑运作良好，但是会导致该程序过去事件的数据丢失。以下是我实现的代码。

如何根据Date的即将发生的事件对程序进行排序，而不会丢失数据。

export const SortProgram = (ProgramSet) => {

    let programWithUpcomingEvents = [];
    let programWithPastEvents = [];
    let programWithNoEvents = [];

    ProgramSet.map((program) => {
        if ((program.events.length) !== 0) {

            let tempEvents = [];
            program.events.map((event) =>
            {
                if (event.toDate >= new Date().getTime()){
                    tempEvents.push(event);
                }
               return 0;
            })

            if (tempEvents.length !== 0) {
                program.events = tempEvents;
                programWithUpcomingEvents.push(program);
            }
            else{
                programWithPastEvents.push(program);
            }
        }
        else {
            programWithNoEvents.push(program);
        }
        return 0;
    })

    programWithUpcomingEvents = programWithUpcomingEvents.sort((A,B) => (A.events[0].fromDate) - (B.events[0].fromDate));
    programWithPastEvents = programWithPastEvents.sort((A,B) => (A.events[0].fromDate) - (B.events[0].fromDate));
    let sortedTrainings = programWithUpcomingEvents.concat(programWithPastEvents, 

trainingWithNoEvents);

        return trainingSet;
    }

根据内部对象（fromDate）对程序（主数组）进行排序

0 个答案: