我可以在不将其作为参数传递的情况下，使一个全局函数访问另一全局函数的局部变量吗？

Question

Disclaimer: This absurdly long post has more to do with learning how to code more elegantly, as opposed to solving a real problem, in case that's a relevant factor to whether you make it to the end!

My script deals with attributes for a roleplaying game. Each attribute has three elements: an ID used internally ( attrID ), a proper name for display in-game ( attrName ), and the value of the attribute ( attrVal ).

I've declared a global function getAttrName(attrID) , which accepts an attribute ID and returns the appropriate display name via a global lookup table:

const ATTRNAMES = {id1: "Strength", id2: "Dexterity", id3: "Health"}
const getAttrName = id => ATTRNAMES[id]

console.log(getAttrName("id1"))
 // > Strength

Now, attribute values have to be retrieved asynchronously via an internal API method, getAttrs(idArray) , which passes the requested values to a callback function as a list of {attrID: attrVal} pairs:

getAttrs(["id1", "id2", "id3"], attrList => {
    // the attributes' IDs, values and display names are accessible:
    _.each(attrList, (v, k) => {
        [attrID, attrVal, attrName] = [k, v, getAttrName(k)]
        console.log([attrID, attrVal, attrName])
    })
})
 // > ["id1", 3, "Strength"]
 // > ["id2", 4, "Dexterity"]
 // > ["id3", 10, "Health"]

Complications arise with custom attributes , which can be created dynamically by the player as the game runs. The global lookup table can't contain these names, so they're instead stored in "partner" attributes with ids of the form <id>_name . It's easier to just show a typical attrList (passed to the callback function by getAttrs() ) that contains both standard and custom attributes:

{        
// STANDARD attributes, in the form {attrID: attrVal}:
    id1: 3,
    id2: 4,
    id3: 10,                  // ... for Strength 3, Dexterity 2, Health: 10.
// CUSTOM attributes, each with a partner <ID>_name attribute:
    id4: 1,
    id4_name: "Coding",
    id5: 0,
    id5_name: "Brevity"       // ... for Coding: 1, Brevity: 0.
}

(Importantly: I'm working within the confines of a third-party API, and I have no control over how the attribute list is structured, or how custom attributes are stored.)

The Problem

I want getAttrName() to handle custom and standard attributes interchangeably within the callback function. For this, it needs access to attrList , whose scope is the callback function.

Discarded Solution #1: I could declare getAttrName() inside the callback function as well:

getAttrs(["id1", "id2", "id3", "id4", "id5"], attrList => {
    const getAttrName = id => ATTRNAMES[id] || attrList[`${id}_name`]
          /* returns from the global lookup ATTRNAMES if it exists,
                      OR from the <ID>_name attribute in attrList if not. */

    // as before, the attributes' elements are accessible, whether custom or standard
    _.each(attrList, (v, k) => { 
          // ... after filtering out the "<ID>_name" partners, which are also passed
        if (!k.includes("_name")) {
            [attrID, attrVal, attrName] = [k, v, getAttrName(k)]
            console.log([attrID, attrVal, attrName])
        }
    })
})
 // > ["id1", 3, "Strength"]
 // > ["id2", 4, "Dexterity"]
 // > ["id3", 10, "Health"]
 // > ["id4", 1, "Coding"]
 // > ["id5", 0, "Brevity"]

This is pretty much the behavior I want... however, the getAttrs() API method is used numerous times in my code, and even at a single line, it grates on me to declare the same function again and again (indeed, it grates on me enough to spend like an hour writing and formatting this question to y'all ;) )

Discarded Solution #2: I could also add a second parameter to getAttrName , and use that to pass attrList to it when it's called. I really don't want to do this for a number of reasons, but the one that inspired me to write all of this is that doing so grates on me as clunky (especially since getAttrName is called plenty of times where passing attrList won't be necessary), I'm trying to improve my coding skills, and I'm really interested and curious to hear about a third solution I haven't considered!

The Question

Is there any way to retain the global scope of the getAttrName function declaration, AND give it access to a local variable declared before getAttrName is called, WITHOUT having to declare getAttrName multiple times or give it more parameters?

Answer 1

You could make a function-making function:

const makeGetAttrName = list => id => list[id]

const globalGetAttrName = makeGetAttrName(ATTRNAMES);

Then inside the callback, you can make a local version:

    const localGetAttrName = makeGetAttrName(attrList);