Maybe not the best idea to guess

First: If the programmer made a mistake, you probably should not give them what you think they want. It could easily lead to very confusing / very dangerous code.

Imagine someone makes a typo in code going into a DataStore, and this thing makes the wrong guess. Sure, it may have printed a warning, but it also destroyed information that you won't be able to recover.

-- e.g.,
save( weoifjasodifjasodij )
-- ^ If it's not right, the script does NOT know what the user meant, period
-- It would be wrong to ever try to guess what was meant by the above
-- It's not less wrong if they're off by anymore more than a capitalization error.

You should probably error when there is a problem.

The solution: Edit distance

A simple solution is to measure the edit distance between the requested key and all the methods. Edit distance is basically the 'number of mistakes' you would need to make to get between two strings.

A common algorithm to compute this uses Levenshtein distance. This makes one "edit" be a substitution (cat --> bat), insertion (bat --> brat) or deletion (brat --> bat).

From Rosetta Code, here is an implementation:

function leven(s,t)
    if s == '' then return t:len() end
    if t == '' then return s:len() end
 
    local s1 = s:sub(2, -1)
    local t1 = t:sub(2, -1)
 
    if s:sub(0, 1) == t:sub(0, 1) then
        return leven(s1, t1)
    end
 
    return 1 + math.min(
        leven(s1, t1),
        leven(s,  t1),
        leven(s1, t )
      )
end
 

I believe it can be made faster, though.

Another option for edit distance could use the longest common subsequence algorithm. You might also want to adjust these algorithms to account for mistakes in capitalization, etc.

Then just compare the edit distances to all members.

function guessMember(object, name)
	local keys = {}
	for key in pairs(object) do
		table.insert(keys, key)
	end
	table.sort(keys, function(a, b)
		return leven(name, a) < leven(name, b)
	end)
	if leven(keys[1], name) <= 3 then
		-- up to 3 typos...
		if leven(keys[2], name) > leven(keys[1], name) then
			-- no ties in closest words
			return keys[1]
		end
	end
end

There are faster ways to build these sort of "spell check" systems, but they get more complicated. Since most objects that you need this for shouldn't have many fields on it (and in a correct run of the program this code never runs anyway) they're not needed here.