Map array to implement an specific object type

Question

I have a class Rule as it follows:

export class Rule {

    public text: string
    public severity: number

    constructor(
        text: string,
        severity: number,
    ) {
        this.text = text
        this.severity = severity
    }
}

How can I generate the following object incidenceRules from an array of Rule?

export interface IncidenceRuleObj {
    ruleObj: Rule // The whole object
    text: string // Rule.text should go here
}

export interface IncidenceRules {
    [severity: number]: IncidenceRuleObj
}

export const incidenceRules = (rules: Rule[]): IncidenceRules => {
    return rules.map(rule => {
        // What should go here in order to return an IncidenceRules type object?
    })
}

As an example, this should return the same object structure as in this question.

This returned object from incidenceRules() should not be "hardcoded", therefore the iteration over rules objects is needed.

jcalz · Accepted Answer · 2020-03-24 19:57:00Z

You don't want to use .map(), since that will just create another array with the mapped items in the same position as in the original array. Instead, if you still want to use functional programming methods, you should use .reduce(), which iterates over the array and accumulates a result from it. Here's one way to do it which mutates the result object:

const incidenceRules = (rules: Rule[]): IncidenceRules =>
    rules.reduce<IncidenceRules>(
        (a, rule) => (a[rule.severity] = { ruleObj: rule, text: rule.text }, a),
        {}
    );

You can see that it does what I think you want:

console.log(JSON.stringify(
  incidenceRules([new Rule("a", 1), new Rule("b", 2)]), undefined, 2));
/* {
  "1": {
    "ruleObj": {
      "text": "a",
      "severity": 1
    },
    "text": "a"
  },
  "2": {
    "ruleObj": {
      "text": "b",
      "severity": 2
    },
    "text": "b"
  }
}*/

If you don't consider mutation acceptable, you can instead use object spread to create new result objects at each step:

const incidenceRulesImmutable = (rules: Rule[]): IncidenceRules =>
    rules.reduce<IncidenceRules>(
        (a, rule) => ({ ...a, [rule.severity]: { ruleObj: rule, text: rule.text } }),
        {}
    );

It amounts to the same thing; personally I don't see anything wrong with using an imperative loop:

const incidenceRulesImperative = (rules: Rule[]): IncidenceRules => {
    const ret: IncidenceRules = {};
    for (const rule of rules) {
        ret[rule.severity] = { ruleObj: rule, text: rule.text }
    };
    return ret;
}

Anyway, hope that helps; good luck!

Playground link to code

Collectives™ on Stack Overflow

Map array to implement an specific object type

1 Answer 1

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related