Livraria - Scripting Lua - Strings

[Poccnn 385]

As livrarias de Lua

 

Nesse modulo iremos tratar sobre as livrarias disponibilizadas por Lua.

 

 

Iremos tratar agora sobre a livraria básica de strings:

string.len(s)	Retorna o tamanho da string (mesmo uso do operador #)
string.sub(s,i[,j])	Retorna uma string da string s contendo os valores desde a posição i até j. [caso j não seja declarado usa a posição padrão que é a ultima posição da string #s].
string.rep(s,n)	Retorna uma string com n copias de s.
string.upper(s)	Retorna a string formata em letras maiúsculas.
string.lower(s)	Retorna a string formatada em letras minúsculas.

 

 

Códigos de caracteres:

string.byte(s [,i])	Retorna o numero relacionado ao caractere; i seria a posição do caractere requerido, caso seja omitido, vale 1.
string.char(args)	Retorna uma string formada pelos argumentos que são o numero relacionado aos caracteres.

 

 

Marcação de funções:

string.dump(f)

Retorna uma representação binaria da função f.

 

 

Formatação:

string.format(s [,args])

Retorna uma string formatada com os argumentos declarados.

 

Procura, substituição e iterador.

string.match(s,p[,i])	Retorna a captura da pattern p na string s aparti da posição i [deafult 1].
string.find(s,p[,i[,d]])	Retorna três argumentos: inicio, fim e string (ou nil caso não use pattern); encontrado na string s pela procura da pattern p desde a posição i até d, desde que sejam declarados, senão, valem 1 e #s respectivamente.
string.gmatch(s,p)	É um iterador que retorna os argumentos requisitados pela pattern p na string s.
string.gsub(s,p,r[,n])	Retorna uma copia de s a parti da posição n (default = 1) pega pela pattern p e substituída por r (caso r seja uma função, chama-o passando o valor pego pela pattern).

 

 

 

 

Exemplos

string.len(s): é um função que retorna o tamanho de uma string, sem contar caracteres de escape em strings sem formatação.

str = [[olá mundo\n da LUA!]]

print(str:len()) >> 19

 

string.sub(s,i[,j]): essa função serve para pegar os valores de uma parte de uma string; iniciando da posição i até a posição j ou final, caso não seja declarado j.

 str = [[scripting Lua!!!]]

print(str:sub(11)) >> Lua!!!

print(str:sub(11,13)) >> Lua

 

string.rep(s,n): uma função que repete a string s, n vezes.

str = [[repeat>]]

print(str:rep(2)) >> repeat>repeat>

 

string.upper(s): coloca todas as letras da string s em maiúsculas.

str = “Uma StriNG de CARActere”

print(str:upper()) >> UMA STRING DE CARACTERE

 

string.lower(s): faz o inverso da string.upper, ela põe todas as letras em minúsculo:

str = “Uma StriNG de CARActere”

print(str:lower()) >> uma string de caractere

 

string.byte(s[,p]): Retorna o numero associado ao caractere s. esse pode variar dependendo da plataforma utilizada.

str = ‘abc’

print(str:byte()) >> 97 – primeiro caractere da string; letra a

print(str:byte(2)) >> 98 – segundo caractere da string; letra b

print(str:byte(#str)) >> 99 – ultimo caractere da string; letra c

 

string.char(args): faz a ação inversa da função string.byte; retorna o caractere associado ao numero.

numeros = {76,117,97,33}

print(string.char(unpack(numeros)))>> Lua!

 

string.dump(f): converte uma função lua valida em uma cadeia de caracteres com elementos binários que representa tal função.

function ola() return 'ola' end

func = string.dump(ola)

print(type(func)) >> string

 

Para usar essa função; tu terá que chamá-la com o uso da função loadstring(s [,args]).

print(loadstring(func)()) >> ola

 

string.format(s[,args]): formata a string s com alguns argumentos que sejam passados em args.

Caracteres para formatação:

%d	Inteiro decimal (10)
%o	Inteiro octal (8)
%x	Inteiro hexadecimal
%f	Ponto flutuante (fração), no formato [-]nnnn.nnnn
%e	Ponto flutuante (fração), no formato [-]n.nnnn e [+|-]nnn
%g	Ponto flutuante de %e. [< -4 or >=] precisão, se não, sera usado o ponto flutuante de %f.
%c	Insere o caractere associado ao numero (depende do sistema operacional).
%s	Usa apenas strings, caso seja declarado numero, os zeros a esquerda serão suprimidos.
%q	Transforma todos os caracteres de cadeias  em quotes duplos.
%%	O proprio caractere:' % '.

 

Exemplo de uso:

string.format("results: %d, %d", 13, 27)	results: 13, 27
string.format("<%5d>", 13)	<   13>
string.format("<%-5d>", 13)	<13   >
string.format("<%05d>", 13)	<00013>
string.format("<%06.3d>", 13)	<   013>
string.format("<%f>", math.pi)	<3.141593>
string.format("<%e>", math.pi)	<3.141593e+00>
string.format("<%.4f>", math.pi)	<3.1416>
string.format("<%9.4f>", math.pi)	<   3.1416>
string.format("<%c>", 64)	<@>
string.format("<%.4s>", "goodbye")	<good>
string.format("%q", [[she said "hi"]])	"she said \"hi\""

 

 

Antes de explicar sobre as demais funções, fica-se requisitado que seja explicado sobre patterns.

 

Patterns e seus atributos.

cc *	Pode pegar nenhum ou alguns caracteres da classe cc; para a maior sequencia.
cc -	Pode pegar nenhum ou algum caractere da classe cc; para a menor sequencia.
cc +	Pega um ou mais caracteres da classe cc; para a maior sequencia.
cc ?	Pode pegar nenhum ou um caractere da classe cc.
% n	Captura números
^	Ancóra um caracterer.
$	Determina o fim de uma string.

 

 

string.match(s,p[,i]): uma função que procura dados determinados pela pattern p na string s que pode ser iniciada da posição i e retorna uma string com os caracteres buscados, caso não seja encontrados retorna nil.

print(string.match(“um |dois| três |quatro| cinco”, ‘|.*|’)) >> |dois| três |quatro|

print(string.match(“um |dois| três |quatro| cinco”, ‘|.-|’)) >> |dois|

print(string.match(“um |dois| três |quatro| cinco”, ‘[a-u]’)) >> u – primeira letra encontrada

print(string.match(“um |dois| três |quatro| cinco”, ‘[x-z]’)) >> nil – não existe nenhuma letra nessa string entre x e z do alfabeto.

print(string.match(“um |dois| três |quatro| cinco”, ‘|%d+|’)) >> nil

 

 

string.find(s,p[,i[,d]]): uma função que procura dados determinados pela pattern p na string s que pode ser iniciada a parti da posição i até a posição d, e retorna a posição inicial e final desses dados e pode também retornar uma string contendo os dados encontrados; caso não seja encontrado os dados, retorna nil.

local txt = "You see the justice seeker (Atk:47, Def:24 +3). It can only be wielded properly by players of level 75 or higher."

print(txt:find("[def]%d....)")) >> 32, 34, 24 +3

Veja que eu usei na pattern quatro vezes o caractere de ponto final após a pattern; isso é um recurso que lua disponibiliza para pegar mais elementos além do que já foi pego pela pattern; por isso ele retornou a string “24 +3”.

 

 

string.gmatch(s,p): iterador que retorna uma string da pattern p, até que não tenha mais, na string s.

str = [[

         <nome Marcryzius/>

         <nome Vladimir/>

         <nome Sellina/>

]]

for head,name in string.gmatch(str,'<(%a+) (.-)/>') do

         print(head, name)

end

 

>>     nome          Marcryzius

>>     nome          Vladimir

>>     nome          Sellina

 

string.gsub(s,p,r[,n]): uma função que percorre uma cadeia de caracteres há encontrar elementos da pattern p na string s e substitui por r (que pode ser uma função) n ocorrências; retorna uma string com a formatação.

str = [[

         <nome Marcryzius/>

         <nome Vladimir/>

         <nome Sellina/>

]]

print(string.gsub(str,'<(%a+).-/>', "add: ",2)) >>        

add: --foi substituído

         add: -- pela segunda vez e não mais.

         <nome Sellina/> -- a cota de substituições fora expirado.

 

 

Editado Maio 31, 2017 por Poccnn