Fandom

RPG Maker Wiki

String

212páginas nessa wiki
Adicione uma página
Comentários0 Compartilhar

Strings em programação são cadeias de caractéres, ou seja, letras, espaços, quebras de linha, tabulação, símbolos, números, dentre outros. Na maioria dos casos, dentro do RPG Maker, são simples frases ou palavras. As strings do RGSS são muito semelhantes à strings de outras linguagens de programação, no entanto, existem alguns diferenciais. Um diferencial notável é que, diferentemente de linguagens de baixo nível, a memória que uma string gasta e a liberação dessa memória é manuseada automaticamente pelo próprio Ruby. As strings, em conjunto com as expressões regulares, podem executar operações de formatação bem poderosas.

Notação

Strings podem ser intepretadas pelo RGSS de duas diferentes formas: literalmente ou não-literalmente. A primeira, cria a string com praticamente tudo o que estiver escrito nela, salvo \\ e \', enquanto a segunda procura formatações e afins para fabricar a string final. Veja as sintáxes:

  • Literal - Para criar strings que são interpretadas literalmente basta delimitar o seu conjunto de caractéres através de apóstrofos. Assim:
s = 'Isto é uma string'                     #=> Isto é uma string
s = 'Teste #{0+1} de\sstring\n\tformatada'  #=> Teste #{0+1} de\sstring\n\tformatada
  • Não-literal - Para criar strings que aceitam formatações, basta delimitar o conjunto de caractéres e formatações dentro de àspas. É importante notar que qualquer tipo de formatação entre as àspas será convertido. Assim:
s = "Isto é uma string"                     #=> Isto é uma string
s = "Teste #{0+1} de\sstring\n\tformatada"  #=> Teste 1 de string
                                            #=> 	formatada

Algo interessante de se notar é que declarar uma string que não possui formatação através do meio não-literal resulta no mesmo que o fazer pelo literal. Assim, pode parecer que a forma literal é inútil, no entanto, processar strings literais é, muitas vezes, mais rápido que processar strings não-literais. Assim deve-se user strings literais sempre que formatações não forem necessárias.[1]

  • Multi-linha - Usado para inserir dados formatados sem se preocupar em usar caracteres de formatação. É comum quando se deseja inserir um código de programação em uma scring. Possui algumas variações:
 # Você pode escolher o delimitador da string:
s = <<END
exemplo de
string com
mais de uma linha!
END
 # Mesmo que: "exemplo de\nstring com\nmais de uma linha!\n"
 
 # Caracteres de formatação são aceitos.
 # Para permitir espaços em branco antes do delimitador, acrescente "-":
s = <<-FIM_DA_STRING
\texemplo de formatação
	mesma coisa aqui
  FIM_DA_STRING
 # Mesmo que: "\texemplo de formatação\tmesma coisa aqui\n"
 
 # Se quiser utilizar caracteres especiais para o delimitador, use aspas:
s = <<"$#**FIM**#$"
string normal aqui
linha 2
$#**FIM**#$
 # Mesmo que: "string normal aqui\nlinha 2\n"
 
 # Se não quiser usar formatação na string, como na string literal, use
 #apóstrofos no delimitador:
s = <<'FIM'
formatação\nnão\nterá\nefeito!
literalmente, continua
FIM
 # Mesmo que: "formatação\\nnão\\nterá\\nefeito!\nliteralmente, continua\n"
 # Repare que todos os \n foram transformados em \\n, para
 # anular o efeito da \
  • Especial - Pouco usado. Geralmente quando a string contem aspas e se deseja evitar o uso da barra invertida (\). Exemplo:
%|Ele falou: "Olá! Como 'você' vai?".|
 #=> "Ele falou: \"Olá! Como 'você' vai?\"."

Pode-se usar qualquer caractere como delimitador, exceto alfanuméricos e quebra de linha. Se utilizar abertura de parênteses, de colchetes ou chaves, deve-se terminar com fechamento de parênteses, colchetes ou chaves. Se um desses estiver contido no corpo da string, deverá vir acompanhado de seu respectivo fechamento, caso contrário deverá vir prefixado por uma barra invertida. Formatação funciona dentro dessa notação.

%.isso é uma string\..
 #=> "isso é uma string."
 
%{teste}
 #=> "teste"
 
%("aaa" (string))
 #=> "\"aaa\" (string)"

Se não desejar formatação, adicione "q" antes do delimitador. Usar "Q" funciona igual aos exemplos anteriores.

%Q|Com\nformatação|
 #=> "Com\nformatação"
 
%q|Sem\nformatação|
 #=> "Sem\\nformatação"

Comandos básicos de formatação

As strings processam dentro de si comandos para formatar o texto de saída. A seguir, uma lista com tais formatações:

  • Formatações para strings literais:
# \' -> Coloca um caractére de apóstrofo na string, exemplo:
 
string = 'Caixa d\'água' # Resultado: Caixa d'água
 
# \\ -> Coloca um caractére de barra na string, exemplo:
 
string = 'Abraços \\o/'  # Resultado: Abraços \o/
  • Formatações para strings não-literais:
# \a -> Coloca um caractére para marcação, exemplo:
 
string = "Separando\aas\apalavras\a" # Resultado: Separando•as•palavras•
 
# \b -> Outro tipo de caractére para marcação, exemplo:
 
string = "\b\b\b tcha-dã \b\b\b" # Resultado: ◘◘◘ tcha-dã ◘◘◘
 
# \r -> Vai para o começo da linha seguinte, exemplo:
 
string = "\rQuebra\rde\rlinha"
# Resultado:
# Quebra
# de
# linha
 
# \n -> Quebra de linha, exemplo:
 
string = "\nQuebra\nde\nlinha"
# Resultado:
# Quebra
# de
# linha
 
# \s -> Espaço em branco, exemplo:
 
string = "E\ss\sp\sa\sç\so\ss" # Resultado: E s p a ç o s
 
# \t -> Tabulação, semelhante ao tab em editores de texto, exemplo:
 
string = "Estamos\tlonge" # Resultado: Estamos         longe
 
# Caso qualquer outro caractere venha após a barra invertida,
# a barra será removida, exemplo:
 
string = "Caixa d\'água" # Resultado: Caixa d'água
string = "Abraços \\o/"  # Resultado: Abraços \o/

Um programador Ruby pode perceber que alguns dos métodos de formatações do RGSS tiveram suas funções originais alteradas. São eles o \b e a \r.

Formatação avançada

Além dos comandos básicos de formatação, ainda há alguns outros macetes para se fazer strings formatadas. Um deles é a função sprintf, que permite adicionar integers (indicado por %d), floats (indicado por %f) ou outras strings (indicado por %s) dentro de uma string. Para fazer isso, basta adicionar os códigos do que se deseja inserir na string e depois da string, separado por vírgulas, os objetos em questão. Sintáxe e alguns exemplos de uso:

# Números inteiros são representados por %d
# Formatação:
# %3d -> O número é mostrado, se ele tiver menos que 3 caractéres 
# o que faltar é preenchido, à esquerda, com caractéres em branco.
# %04d -> O número é mostrado, se ele tiver menos que 4 caractéres 
# o que faltar é preenchido, à esquerda, com zeros.
# %d -> Simplesmente mostra o número.
# Exemplo:
 
string = sprintf("Ele nasceu em %02d/%02d/%04d", 19, 5, 1987) 
# Resultado: Ele nasceu em 19/05/1987
 
# Números reais são representados por %f
# Formatação:
# %10.3f -> O número é mostrado, com 3 casas decimais e comporta um
# total de 10 caractéres, ou seja, as três casas decimais mais 
# o ponto e a parte inteira que se tiver menos que 6 caractéres
# o que faltar é preenchido, à esquerda, com caractéres em branco.
# %09.4f -> O número é mostrado, com 4 casas decimais e comporta um
# total de 9 caractéres, ou seja, as quatro casas decimais mais 
# o ponto e a parte inteira que se tiver menos que 4 caractéres
# o que faltar é preenchido, à esquerda, com zeros.
# Exemplo:
 
string = sprintf("A concentração do metal A foi %f, do B foi %010.5", 13.77, 52.085)
# Resultado: A concentração do metal A foi 13.770000, do B foi 0052.08500
 
# Strings são representadas por %s
# Exemplo:
 
string = sprintf("Meu nome não é %s", 'Jonny') # Resultado: Meu nome não é Jonny


Além do sprintf também pode-se contar com o #{objetos}, em que os objetos geralmente são números ou outras strings. No caso, dentro dessas chaves pode-se aplicar qualquer operação entre dois objetos ou mais. Exemplos:

string = "1 + 2 = #{1 + 2}" # Resutaldo: 1 + 2 = 3
 
string = "54 / 5 = #{54 / 5.to_f}" # Resultado: 54 / 5 = 10.8
 
string = "Eu sou #{sprintf("o %s", 'Homem de Ferro')}" 
# Resultado: Eu sou o Homem de Ferro

Principais operações

  • Conversões

Strings podem ser facilmente convertida para números e muitos objetos podem ser convertidos para strings, através dos comandos to_s (to string), to_i (to integer) e to_f (to float). No caso de tentar converter uma string para um número e na string não haver número nenhum, o número retornado é o zero. Exemplos de uso e sintáxe:

num = "197".to_f  # num passa a valer 197.0
 
num = "10 está no ínicio desta string".to_i # num passa a valer 10
 
num = "O número 10 está no meio desta string".to_i # num passa a valer 0
 
string = 10.to_s # É o mesmo que: string = "10"
 
string = [10, 3, 4].to_s # É o mesmo que: string = "1034"
  • Concatenação

Unir duas strings é semelhante à somar números. Sintáxe:

string1 = "Olá"
string2 = " mundo"
 
string = string1 + string2 + "!" # Resultado: Olá mundo!

Além destes, existe toda uma infinidade de métodos e operações para se trabalhar com strings, todos eles podem ser encontrados no Ruby-Doc

Ligações externas

Referências

  1. Dicas para evitar lag no RGSS (em português). rgss.com.br. Página visitada em 16 de dezembro de 2010.

Interferência de bloqueador de anúncios detectada!


A Wikia é um site grátis que ganha dinheiro com publicidade. Nós temos uma experiência modificada para leitores usando bloqueadores de anúncios

A Wikia não é acessível se você fez outras modificações. Remova o bloqueador de anúncios personalizado para que a página carregue como esperado.

Outras wikis da Wikia

Wiki aleatória