Arreglo insensible a mayúsculas y minúsculas en Lua

Question

Estoy intentando programar un complemento para WoW (en lua). Es un filtro de chat basado en palabras específicas. No puedo entender cómo hacer para que la matriz de estas palabras no distinga entre mayúsculas y minúsculas, por lo que cualquier combinación de mayúsculas y minúsculas de la palabra coincide con la matriz. Cualquier idea sería muy apreciada. ¡Gracias!

local function wordFilter(self,event,msg) 
local keyWords = {"word","test","blah","here","code","woot"} 
local matchCount = 0; 
    for _, word in ipairs(keyWords) do 
      if (string.match(msg, word,)) then 
      matchCount = matchCount + 1; 
     end 
    end 
    if (matchCount > 1) then 
      return false; 
    else 
     return true; 
    end 
end 

Answer 1

1. Definir palabras clave fuera de la función. De lo contrario, está recreando la tabla cada vez solo para espirar momentos más tarde, perdiendo el tiempo tanto en la creación como en el GC.
2. Convertir palabras clave para el patrón que coincida con letras mayúsculas y minúsculas.
3. No necesita los datos capturados de la cadena, por lo que utilice string.find para ver la velocidad.
4. Según su lógica , si tiene más de una coincidencia, señaliza 'falso'. Desde solo necesita 1 coincidencia, no necesita contarlos. Simplemente devuelva falso tan pronto como lo golpee. Le ahorra tiempo para verificar todas las palabras restantes también. Si más adelante decide que desea más de una coincidencia , es mejor que lo revise dentro del ciclo y regrese tan pronto como haya alcanzado el conteo deseado.

5. No utilice ipairs. Es más lento que simple para el bucle de 1 a la longitud de la matriz y ipairs está en desuso en Lua 5.2 de todos modos.

   local keyWords = {"word","test","blah","here","code","woot"} 
   local caselessKeyWordsPatterns = {} 
   
   local function letter_to_pattern(c) 
       return string.format("[%s%s]", string.lower(c), string.upper(c)) 
   end 
   
   for idx = 1, #keyWords do 
       caselessKeyWordsPatterns[idx] = string.gsub(keyWords[idx], "%a", letter_to_pattern) 
   end 
   
   local function wordFilter(self, event, msg) 
       for idx = 1, #caselessKeyWordsPatterns do 
        if (string.find(msg, caselessKeyWordsPatterns[idx])) then 
         return false 
        end 
       end 
       return true 
   end 
   
   local _ 
   print(wordFilter(_, _, 'omg wtf lol')) 
   print(wordFilter(_, _, 'word man')) 
   print(wordFilter(_, _, 'this is a tEsT')) 
   print(wordFilter(_, _, 'BlAh bLAH Blah')) 
   print(wordFilter(_, _, 'let me go')) 
   

El resultado es:

true 
false 
false 
false 
true 

Answer 2

Uso if msg:lower():find (word:lower() , 1 , true) then

==> TI casos más bajos tanto de los argumentos a string.find: de ahí que no se distingan. También utilicé string.find porque probablemente quiera la opción 'plain', que no existe para string.match.

También puede volver fácilmente en la primera palabra que se encuentra:

for _ , keyword in ipairs(keywords) do 
    if msg:lower():find(keyword:lower(), 1, true) then return true end 
end 
return false 

Answer 3

También se puede organizar esto con metatablas, de una manera totalmente transparente:

mt={__newindex=function(t,k,v) 
    if type(k)~='string' then 
     error'this table only takes string keys' 
    else 
     rawset(t,k:lower(),v) 
    end 
end, 
__index=function(t,k) 
    if type(k)~='string' then 
     error'this table only takes string keys' 
    else 
     return rawget(t,k:lower()) 
    end 
end} 

keywords=setmetatable({},mt) 
for idx,word in pairs{"word","test","blah","here","code","woot"} do 
    keywords[word]=idx; 
end 
for idx,word in ipairs{"Foo","HERE",'WooT'} do 
    local res=keywords[word] 
    if res then 
     print(("%s at index %d in given array matches index %d in keywords"):format(word,idx,keywords[word] or 0)) 
    else 
     print(word.." not found in keywords") 
    end 
end 

De esta manera la tabla puede ser indexado en cualquier caso. Si agrega palabras nuevas, también las minúsculas automáticamente. Incluso puede ajustarlo para permitir la coincidencia con patrones o lo que quiera.