arraystypescriptgroupinghigher-order-functions

array.groupBy in TypeScript


The basic array class has .map, .forEach, .filter, and .reduce, but .groupBy i noticably absent, preventing me from doing something like

const MyComponent = (props:any) => {
    return (
        <div>
            {
                props.tags
                .groupBy((t)=>t.category_name)
                .map((group)=>{
                    [...]
                })
            }

        </div>
    )
}

I ended up implementing something myself:

class Group<T> {
    key:string;
    members:T[] = [];
    constructor(key:string) {
        this.key = key;
    }
}


function groupBy<T>(list:T[], func:(x:T)=>string): Group<T>[] {
    let res:Group<T>[] = [];
    let group:Group<T> = null;
    list.forEach((o)=>{
        let groupName = func(o);
        if (group === null) {
            group = new Group<T>(groupName);
        }
        if (groupName != group.key) {
            res.push(group);
            group = new Group<T>(groupName);
        }
        group.members.push(o)
    });
    if (group != null) {
        res.push(group);
    }
    return res
}

So now I can do

const MyComponent = (props:any) => {
    return (
        <div>
            {
                groupBy(props.tags, (t)=>t.category_name)
                .map((group)=>{
                    return (
                        <ul key={group.key}>
                            <li>{group.key}</li>
                            <ul>
                                {
                                    group.members.map((tag)=>{
                                        return <li key={tag.id}>{tag.name}</li>
                                    })
                                }
                            </ul>
                        </ul>
                    )
                })
            }

        </div>
    )
}

Works pretty well, but it is too bad that I need to wrap the list rather than just being able to chain method calls.

Is there a better solution?


Solution

  • you could add the function to the array prototype in your app (note some don't recomend this: Why is extending native objects a bad practice?):

    Array.prototype.groupBy = function(/* params here */) { 
       let array = this; 
       let result;
       /* do more stuff here*/
       return result;
    }; 
    

    Then create an interface in typescript like this:

    .d.ts version:

        interface Array<T>
        {
            groupBy<T>(func:(x:T) => string): Group<T>[]
        }
    

    OR in a normal ts file:

    declare global {
       interface Array<T>
       {
          groupBy<T>(func:(x:T) => string): Group<T>[]
       }
    }
    

    Then you can use:

     props.tags.groupBy((t)=>t.category_name)
         .map((group)=>{
                        [...]
                    })