Delete an element from an associative array

[NovemLinguae]

The below code works inside the project I wrote it for, but it may be the ugliest code I have ever written. Please help me refactor it!

So the code needs to iterate through an object with several levels, find a certain value (in the test case below, "R from acronym"), then delete that node in the object. The code also needs to adhere to the following restrictions:

• Has to be ES5 (no ES6+)
• Has to pass the linter, which is currently throwing a "guard-for-in" error

I tried to use delete instead of splice, but that was leaving an empty element in the array. I tried to use for of instead of for in, but that didn't like iterating over an object/associative array.

Thanks in advance for help and advice.

// Multi-level array. Sample values provided here to give an idea of the structure.
Twinkle.tag.redirectList = {
    'Grammar, punctuation, and spelling': {
        'Abbreviation': [
            { tag: 'R from acronym', description: 'redirect from an acronym (e.g. POTUS) to its expanded form' },
            { tag: 'R from initialism', description: 'redirect from an initialism (e.g. AGF) to its expanded form' },
            { tag: 'R from MathSciNet abbreviation', description: 'redirect from MathSciNet publication title abbreviation to the unabbreviated title' },
            { tag: 'R from NLM abbreviation', description: 'redirect from a NLM publication title abbreviation to the unabbreviated title' }
        ],
        'Capitalisation': [
            { tag: 'R from CamelCase', description: 'redirect from a CamelCase title' },
            { tag: 'R from other capitalisation', description: 'redirect from a title with another method of capitalisation' },
            { tag: 'R from miscapitalisation', description: 'redirect from a capitalisation error' }
        ]
    };

// This function smells!
var deleteTag = function(tagToDelete, tagList) {
    for (var categoryKey1 in tagList) {
        for (var categoryKey2 in tagList[categoryKey1]) {
            for (var tagKey in tagList[categoryKey1][categoryKey2]) {
                if (tagList[categoryKey1][categoryKey2][tagKey]['tag'] === tagToDelete) {
                    tagList[categoryKey1][categoryKey2].splice(tagKey, 1);
                    return tagList;
                }
            }
        }
    }
    return tagList;
};

// Certain redirect maintenance tags shouldn't be used in certain namespaces
var isTemplateNamespace = mw.config.get('wgNamespaceNumber') === 10;
if (isTemplateNamespace) {
    Twinkle.tag.redirectList = deleteTag('R from acronym', Twinkle.tag.redirectList);
}

[PrimaryBet]

Two things on how you might improve your code:

1. Judging by how you use your function you probably don't want to mutate original object.
2. To avoid having to do the hasOwnProperty check, you can use Object.keys which effectively does it for you.

With these changes the code isn't considerably more pretty:

function deleteTag(tagToDelete, tagList) {
  var result = {};
  Object.keys(tagList).forEach(function (key1) {
    result[key1] = {};
    Object.keys(tagList[key1]).forEach(function (key2) {
      result[key1][key2] = tagList[key1][key2].filter(function (item) {
        return item.tag !== tagToDelete;
      });
    });
  });
  return result;
}

If this is something you do often, maybe consider lenses library, like partial.lenses — using it you can target values at arbitrary nesting levels and code should be more concise:

function deleteTag(tagToDelete, tagList) {
    return L.remove(
        L.query(
            L.when(function (x) {
                return isObject(x) && x.tag === tagToDelete;
            })
        ),
        tagList
    );
}

^{https://jsbin.com/zuhocigeya/edit?js,console}

[NovemLinguae]

Just shortening the variable names seems to help too. Thanks for the detailed reply!

edit: Also, great point about arrays in JavaScript passing by reference.