Delete key in object of objects with keys and decrement keys of trailing objects

Question

This is complicated to explain in words so let me just show you what I've got and work from there.

I have the following object:

{
  1: { name: 'Initial Step 1', stepNumber: 1 },
  2: { name: 'Initial Step 2', stepNumber: 2 },
  3: { name: 'Initial Step 3', stepNumber: 3 },
  4: { name: 'Initial Step 4', stepNumber: 4 },
}

I would like to perform a delete function for this step and then decreme the trailing keys so that I get the following outcome:

{
  1: { name: 'Initial Step 1', stepNumber: 1 },
  2: { name: 'Initial Step 3', stepNumber: 2 },
  3: { name: 'Initial Step 4', stepNumber: 3 },
};

I'm just not sure of the best way to implement my deleteStep function.

I've got it implemented as follows:

export const deleteStep = (stepNumber, steps) => {
    // What should I do here?
    return steps;
};

Thanks!

*"What should I do here?"* Get a list of all keys, sort them, keep the ones that are larger than the one to remove and reassign the value for each key to `key - 1`, delete the max key. Or create assign to a new object instead. — Felix Kling, Nov 02 '17 at 08:36
*"It's a pre-existing data structure from an API."* So, you could convert that to an array if you wanted to. — Felix Kling, Nov 02 '17 at 08:36
I've updated my question a bit. There's something there that needs to be considered. — Barry Michael Doyle, Nov 02 '17 at 08:39

Nina Scholz · Accepted Answer · 2017-11-02T09:04:51.477

5

You could delete the actual key and check if more keys exists, then create a new property and delete the old reference.

function deleteAndShift(object, key) {
    delete object[key];
    while (++key in object) {
        object[key].stepNumber--;
        object[key - 1] = object[key];
        delete object[key];
    }
}

var object = { 1: { name: 'Initial Step 1', stepNumber: 1 }, 2: { name: 'Initial Step 2', stepNumber: 2 }, 3: { name: 'Initial Step 3', stepNumber: 3 }, 4: { name: 'Initial Step 4', stepNumber: 4 } };

deleteAndShift(object, 2);

console.log(object);

.as-console-wrapper { max-height: 100% !important; top: 0; }

edited Nov 02 '17 at 09:04

answered Nov 02 '17 at 08:41

Nina Scholz

376,160
25
347
392

`while (key in object)`. Wow. Certainly looks like a syntax mistake on first glance :-) – Bergi Nov 02 '17 at 08:45
I would recommend to add a comment, or use a `for (; key in object; key++)` loop instead. – Bergi Nov 02 '17 at 08:45
I've edited your answer's `object` variable to match my question input and it doesn't reset the stepNumber inside each key object like I need it to. – Barry Michael Doyle Nov 02 '17 at 08:47
@BarryMichaelDoyle Well please don't edit your question to include new requirements. On the other hand, it should be quite trivial to add an assignment that changes the `.stepNumber` when moving the object to a new key. – Bergi Nov 02 '17 at 08:49

Felix Kling · Answer 2 · 2017-11-02T08:48:29.270

If you can/want to return a new object you can do the following:

const deleteStep = (stepNumber, steps) => {
    const result = {};
    Object.keys(steps).forEach(key => {
      key = Number(key);
      if (key < stepNumber) {
        // keep preceding entries
        result[key] = steps[key];
      } else if (key > stepNumber) {
        // shift following entries
        result[key - 1] = steps[key]; // or shallow copy with `Object.assign({}, steps[key])`
        result[key - 1].stepNumber--;
      }
    });
    return result;
};

const steps = {
  1: { name: 'Initial Step 1', stepNumber: 1 },
  2: { name: 'Initial Step 2', stepNumber: 2 },
  3: { name: 'Initial Step 3', stepNumber: 3 },
  4: { name: 'Initial Step 4', stepNumber: 4 },
};

console.log(deleteStep(3, steps));

You might want to cast `key` to a number before comparing it — Bergi, Nov 02 '17 at 08:47

score 1 · Answer 3 · answered Nov 02 '17 at 09:00

You could go the immutable route and create a new object like this:

function omitStep (steps, stepNumber) {
  return Object.keys(steps).reduce(function (acc, key) {
    var keyNum = Number(key);
    if (keyNum < stepNumber) { 
      acc[key] = steps[key]
    } else if (keyNum > stepNumber) {
      acc[keyNum - 1] = steps[key];
    }
    
    return acc;
  }, {});
}

var newSteps = omitStep({
  1: { name: 'Initial Step 1', stepNumber: 1 },
  2: { name: 'Initial Step 2', stepNumber: 2 },
  3: { name: 'Initial Step 3', stepNumber: 3 },
  4: { name: 'Initial Step 4', stepNumber: 4 },
}, 3);

console.log(newSteps);

Roman · Answer 4 · 2017-11-02T09:26:14.557

One possible solution is to use reduce
The advantage of reduce is that you return a new object and your old object didn't gets modified.

const removeStep = (steps, stepNumber) => {
  return Object.keys(steps).reduce((newSteps, current) => {
    const numberOfNewStep = Object.keys(newSteps).length + 1
    return Number(current) === stepNumber
      ? newSteps
      : Object.assign(
        {},
        newSteps, 
        { [numberOfNewStep]: Object.assign(
            {}, 
            steps[current], 
            {stepNumber: numberOfNewStep}
          )
        }
      )
  }, {})
}

console.log(removeStep({
  1: { name: 'Initial Step 1', stepNumber: 1 },
  2: { name: 'Initial Step 2', stepNumber: 2 },
  3: { name: 'Initial Step 3', stepNumber: 3 },
  4: { name: 'Initial Step 4', stepNumber: 4 },
}, 1))

Delete key in object of objects with keys and decrement keys of trailing objects

4 Answers4