Patterns

[MaXwEllDeN 89]

 

Pattern

Pattern ("Padrão" em pt-br) é uma poderosa funcionalidade para manipulação de strings (caso você não saiba o que é uma "string", busque saber antes de continuar, recomendo
também ter um certo domínio sobre a biblioteca string), e usada para buscar um padrão de texto pré-definido.

Porque aprender ?

Possui recursos indispensáveis quando se precisa trabalhar com strings, alta aplicabilidade em scripts direcionados a otserv (talkactions), não que se vá usar isso a todo o momento, mas é altamente recomendado que se saiba trabalhar com patterns, é extremamente útil as vezes.

Funções

Algumas funções da biblioteca padrão string que aceitam pattern em seus parâmetros:

string.find(string, pattern) – Procura a primeira instância da pattern na string
string.gfind(string, pattern) – Quando for chamada repetidamente, retorna cada instância da pattern na string
string.gsub(string, pattern, replace) – Retorna uma string em que todas as instâncias da pattern foram substituidas por replace
string.match(string, pattern, init) – Retorna uma lista de ocorrências da pattern na string, começando em init (1 significa o primeiro caractere da string, 2 o segundo, assim por diante)

Conjuntos

Quando se constrói uma pattern, se utiliza alguns caracteres, cada um representando um conjunto diferente:

(onde "x" não é um caractere mágico ^$()%.[]*+-?) → Representa o caractere "x" mesmo;
. → Representa todos os caracteres;
%a → Representa todas as letras;
%c → Representa todos os caracteres de controle;
%d → Representa todos os dígitos;
%l → Representa todas as letras minusculas;
%p → Representa todos os caracteres de pontuação;
%s → Representa todos os caracteres de espaço;
%u → Representa todas as letras maiúsculas;
%w → Representa todos os caracteres alfanuméricos;
%x → Representa todos os dígitos hexadecimais;
%z → Representa o caractere com a representação do 0 (zero). Ao usar zeros na pattern ela não irá funciona, use esta nesse caso;
Ao usar letra maiúscula, isso faz representar o contrário (Exemplo: %A → Representa tudo que não for letras; %D → Representa tudo que não for um digito; assim por diante...).
Como dito anteriormente, para se criar uma pattern é necessário utilizar esses conjuntos, uma pattern é feita de uma sequência desses conjuntos. Se você quisesse criar uma pattern para encontrar uma certa string em um texto, por exemplo, para encontrar os números da string "23otserv", você teria que usar esta pattern "%d%dotserv", assim você estaria definindo que quer os numeros que estão ao lado da palavra ‘otserv’.

• Mas e se tivesse que encontrar um numero com 10 "casas" ?
  

Por isso existe os modificadores, para evitar essa repetição desnecessária.

Modificadores

Servem principalmente para poupar serviço e são quatro, entenda 'x' como sendo algum conjunto (%a, %c, %d, ...):

x* → Retorna 0 ou mais repetições do conjunto x. Sempre retornará a maior cadeia possível encontrada;
x+ → Retorna 1 ou mais repetições do conjunto x. Sempre retornará a maior cadeia possível encontrada;
x- → Retorna 0 ou mais repetições do conjunto x. Sempre retornará a menor cadeia possível encontrada;
x? → Retorna 0 ou 1 ocorrência de x;

Elementos especiais

Existe também quatro elementos especiais:

%n → Sendo n um numero entre 1 e 9, busca a enésima captura (apenas vi sendo usada na função string.gsub);
%bxy → Procura uma string que inicia com x e termina com y;
^ → Quando está no começo da pattern, força a pattern a ser encontrada no começo da string;
$ → Quando está no final da pattern, força a pattern a ser encontrada no fim da string;
Nota: Se ^ ou $ estiverem em outros lugares da pattern, não fazem nada, apenas representam eles mesmos.

Construindo uma pattern

Vamos construir algumas patterns com os elementos citados acima.

Primeiro alguns exemplos e depois uma explicação mais detalhada de cada elemento da pattern:

String para as patterns: "Exemplo lua de pattern lua feito em lua"
exemplos toscos, a gente se vê por aqui
Pattern:
(%a+) lua
Capturaria:

Exemplo lua de pattern lua feito em lua
Ele só retornará o primeiro caso que corresponder com a pattern.
Agora, ao invés de usar o "%a" fosse usado o "." (que captura tudo), aconteceria isso:

Pattern:
(.+) lua

Capturaria:
Exemplo lua de pattern lua feito em lua

Como "%a" captura apenas letras e não o "espaço", foi por isso que no primeiro exemplo só capturou a palavra "Exemplo" e no segundo exemplo, como foi usado o "." que captura tudo, capturou uma parte maior (ai que vêm a parte do modificador) por causa do modificador "+" que sempre vai buscar a maior cadeia possivel, agora veja um exemplo usando o "-":

Pattern:
(.-) lua

Capturaria:
Exemplo lua de pattern lua feito em lua

O modificador "-", como dito anteriormente, captura a menor cadeia e por isso capturaria apenas o "Exemplo".
Todos os modificadores são importantes.

Um exemplo maior:
Pattern:
(%a+) lua (.-) lua (.+)

Capturaria:
Exemplo lua de pattern lua feito em lua

Para quem não entendeu

Explicação passo a passo:

(%d+)
Captura → O parenteses define que você quer que retorne essa captura.
Conjunto → No caso é o de digitos.
Modificador → No caso mostra que é para obter a maior cadeia possivel com 1 ou mais repetições do conjunto.

Um exemplo mais avançado

Agora usando de exemplo a pattern da função string.trim, que remove os espaços em branco do lado esquerdo e direito da string.

function string.trim(str)-- Function by Colandusreturn (string.gsub(str, "^%s*(.-)%s*$", "%1"))end

string.gsub(str, "^%s*(.-)%s*$", "%1")
str → Uma string qualquer;
^ → Força o começo da pattern ser encontrada no começo de str;
%s* → Conjunto de espaços, podendo ter 0 ou mais repetições;
(.-) → A captura principal, a que vai ser retornada, podendo ser digitos, letras, espaço, etc;
$ → Força o final da pattern ser encontrada no fim de str;
%1 → Retorna a 1ª captura da pattern e usa como parametro da função (Esse é um dos elementos especiais, %n);
Dessa forma será removido os espaços apenas no começo e no fim da string !

Complemento

Depois de dominar e entender como funciona as patterns, vamos aplica-las em funções, vou mostrar um exemplo de cada função (as que foram citadas no começo).


string.find:

init, end, case1, case2 = string.find("minha string123", "(%a+) (.+)")

init → Onde inicia a captura encontrada (nesse caso, init = 1);
end → Onde termina a captura encontrada (end = 15);
case1 → Primeira captura que equivale a pattern (%a+) (case1 = minha);
case2 → Segunda captura que equivale a pattern (.+) (case2 = string123);

string.gfind:

for occ in string.gfind("a1a2a3a4a5", "(%a%d)") doprint(occ)end

occ → Terá um valor para cada instância da pattern (%a%d) encontrada, então irá printar a1, a2, a3, a4 e a5.

string.match:

case1, case2 = string.match("Eu tenho 50 reais", "(%d+) (%a+)")

case1 → Primeira captura que equivale a pattern (%d+) (case1 = 50);
case2 → Segunda captura que equivale a pattern (%a+) (case2 = reais);

Referência

http://www.lua.org/manual/5.1/pt/manual.html#5.4.1
http://lua-users.org/wiki/PatternsTutorial



Então é isso, espero ter sido o mais claro possivel,
Qualquer dúvida, erro ou sugestão, poste !

Lembrando que esse tutorial foi feito pelo Lwkass, de outro fórum. TODOS OS CRÉDITOS SÃO DELE.

 

Editado Agosto 20, 2016 por Drazyn

[Alexclusive 687]

Opa, ótimo tutorial e ótima organização cara.

Tenho certeza que sera de muita utilidade pra alguns por ai.

 

Temos que trazer esse Lwkass ​p/ nosso fórum! rsrs

 

Obrigado por contribuir, abraço!

Editado Maio 8, 2013 por Alexclusive
will always be the same. Sorry!

[BananaFight 196]

Realmente muito bom Max, Bem formatado e simples de se entender.

 

Obrigado por trazer este tutorial para o xtibia.

 

Tópico aprovado e movido.

[MaXwEllDeN 89]

Opa, ótimo tutorial e ótima organização cara.

Tenho certeza que sera de muita utilidade pra alguns por ai.

 

Temos que trazer esse Lwkass ​p/ nosso fórum! rsrs

 

Obrigado por contribuir, abraço!

 

Haha, Lwkass é um ótimo programador, Fera. Só que a muito tempo ele não meche com Open Tibia.

[PsyMcKenzie 150]

Agora sim, ouvi do Mkallo uma vez sobre Patterns, mas nem fazia ideia do que era.

Obrigado pelo conteúdo Max!

[Skymagnum 234]

Realmente patterns são muito legais, mas uma coisa que desinteressa e confunde bastante as pessoas/iniciantes é isso

"^%s*(.-)%s*$", "%1"

 

essa junção de letras e etc... confunde msm heuheuhehu.

[dalvorsn 268]

Tutorial excepcional, está bem detalhado e explicado. A unica coisa que faltou ao meu ver, foi explicar como se usar os colchetes, e a função do ^ quando usado dentro deles.

 

Alguns exemplos:

local str = "albalbalbal121332"

for i in string.gmatch(str, "([%a%d])") do
io.write(i, "\t")
end

io.write("\n")
for i in string.gmatch(str, "([^%a%d])") do
io.write(i, "\t")
end
io.write("\n")

for i in string.gmatch(str, "([^%a])") do
io.write(i, "\t")
end
io.write("\n")

for i in string.gmatch(str, "([^a])") do
io.write(i, "\t")
end
io.write("\n")

for i in string.gmatch(str, "([^%dal])") do
io.write(i, "\t")
end
io.write("\n")

[Vinc 101]

como o dalvorsn falo fato a união de conjuntos.

e tbm casos do tipo [1-9 ](numeros de 1 a 9), [a-d] (letras de "a" á "d"), [1-7a-cf-k] (numeros de 1 a 7 ou letras de "a" a "c" ou letras de "f" a"k"), ect

 

e gfind n existe mais, é gmatch, troca que se n os cara usa e da erro.