Keep a lookup map concise - more in comments

lookup-map-lean.js

const logMessage = (message) => console.log(Date.now(), message)

const responses = [
  {
    input: "test-one",
    answer: "One"
  },
  {
    input: "test-two",
    helper: (input, callback) => callback("Two helper")
  }
]

const matchResponses = (input, callback) => {
  const results = responses.filter((response) => response.input == input)
  results.forEach((result) => {
    if (typeof result.helper == "function") result.helper(input, callback)
    else if (typeof callback == "function") callback(result.answer)
  })
}

// Add a second response for test-one
responses.push({ input: "test-one", answer: "OneTwo" })

/*
  The old logic here used the map like this - and it matched all responses
  ["test", "test-one", "test-two"].forEach((input) =>
    matchResponses(input, logMessage)
  )

  Our quick refactor below will choose a random matching response instead of all of them
*/

const selectArray = (pool) => pool[Math.floor(Math.random() * pool.length)]

const potentialResponses = []

matchResponses("test-one", (response) => potentialResponses.push(response))
logMessage(selectArray(potentialResponses) || "default response")

The function attached to a lookup map should remain lean by either expecting processing logic in an argument, or wholly returning the matched data's object.

We can demonstrate this with a refactor of this gist

In our new case, inputs should only receive one answer. matchResponses will remain just as useful, without change, due to how we pass our logic through an argument.

We could further refactor this with the goal of being lean by passing the property name (input) to match the provided case against.