a

ASCII (igual a nenhum). Este é o padrão.

e

EUC.

n

Nenhum (igual ao ASCII).

u

UTF-8.

str % arg

Formata uma string usando uma especificação de formato. arg deve ser uma matriz se contiver mais de uma substituição. Para obter informações sobre a especificação do formato, consulte sprintf em "Módulo de kernel".

str * integer

Retorna uma nova string contendo número inteiro vezes str. Em outras palavras, str são imes inteiros repetidos.

str + other_str

Concatena other_str para str.

str << obj

Concatena um objeto para str. Se o objeto for um Fixnum no intervalo de 0,255, ele será convertido em um caractere. Compare-o com concat.

str <=> other_str

Compara str com other_str, retornando -1 (menor que), 0 (igual) ou 1 (maior que). A comparação diferencia maiúsculas de minúsculas.

str == obj

Testa str e obj para igualdade. Se obj não for uma String, retorna falso; retorna verdadeiro se str <=> obj retornar 0.

str =~ obj

Corresponde str a um padrão de expressão regular obj. Retorna a posição onde a partida começa; caso contrário, false.

str.capitalize

Capitaliza uma string.

str.capitalize!

O mesmo que capitalizar, mas as alterações são feitas no local.

str.casecmp

Faz uma comparação de strings que não diferencia maiúsculas de minúsculas.

str.center

Centraliza uma corda.

str.chomp

Remove o separador de registro ($ /), geralmente \ n, do final de uma string. Se não houver separador de registro, não faz nada.

str.chomp!

O mesmo que chomp, mas as alterações são feitas no local.

str.chop

Remove o último caractere em str.

str.chop!

O mesmo que cortar, mas as alterações são feitas no local.

str.concat(other_str)

Concatena other_str para str.

str.count(str, ...)

Conta um ou mais conjuntos de caracteres. Se houver mais de um conjunto de caracteres, conta a interseção desses conjuntos

str.crypt(other_str)

Aplica um hash criptográfico unilateral a str. O argumento é a string salt, que deve ter dois caracteres, cada caractere no intervalo az, AZ, 0,9,. ou /.

str.delete(other_str, ...)

Retorna uma cópia de str com todos os caracteres na interseção de seus argumentos excluídos.

str.delete!(other_str, ...)

O mesmo que excluir, mas as alterações são feitas no local.

str.downcase

Retorna uma cópia de str com todas as letras maiúsculas substituídas por minúsculas.

str.downcase!

Igual ao downcase, mas as alterações são feitas no local.

str.dump

Retorna uma versão de str com todos os caracteres não imprimíveis substituídos pela notação \ nnn e todos os caracteres especiais com escape.

str.each(separator = $/) { |substr| block }

Divide str usando o argumento como separador de registro ($ / por padrão), passando cada substring para o bloco fornecido.

str.each_byte { |fixnum| block }

Passa cada byte de str para o bloco, retornando cada byte como uma representação decimal do byte.

str.each_line(separator=$/) { |substr| block }

Divide str usando o argumento como separador de registro ($ / por padrão), passando cada substring para o bloco fornecido.

str.empty?

Retorna verdadeiro se str estiver vazio (tem comprimento zero).

str.eql?(other)

Duas strings são iguais se tiverem o mesmo comprimento e conteúdo.

str.gsub(pattern, replacement) [or]

str.gsub(pattern) { |match| block }

Retorna uma cópia de str com todas as ocorrências de padrão substituídas por substituição ou o valor do bloco. O padrão normalmente será um Regexp; se for uma string, nenhum metacaractere de expressão regular será interpretado (ou seja, / \ d / corresponderá a um dígito, mas '\ d' corresponderá a uma barra invertida seguida por um 'd')

str[fixnum] [or] str[fixnum,fixnum] [or] str[range] [or] str[regexp] [or] str[regexp, fixnum] [or] str[other_str]

Referências str, usando os seguintes argumentos: um Fixnum, retorna um código de caractere em fixnum; dois Fixnums, retorna uma substring começando em um deslocamento (primeiro fixnum) até o comprimento (segundo fixnum); intervalo, retorna uma substring no intervalo; regexp retorna parte da string combinada; regexp com fixnum, retorna os dados correspondentes em fixnum; other_str retorna substring que corresponde a other_str. Um Fixnum negativo começa no final da string com -1.

str[fixnum] = fixnum [or] str[fixnum] = new_str [or] str[fixnum, fixnum] = new_str [or] str[range] = aString [or] str[regexp] = new_str [or] str[regexp, fixnum] = new_str [or] str[other_str] = new_str ]

Substitua (atribua) toda ou parte de uma string. Sinônimo de fatia !.

str.gsub!(pattern, replacement) [or] str.gsub!(pattern) { |match|block }

Executa as substituições de String # gsub no lugar, retornando str ou nil se nenhuma substituição foi realizada.

str.hash

Retorna um hash com base no comprimento e no conteúdo da string.

str.hex

Trata os caracteres iniciais de str como uma sequência de dígitos hexadecimais (com um sinal opcional e um 0x opcional) e retorna o número correspondente. Zero é retornado em caso de erro.

str.include? other_str [or] str.include? fixnum

Retorna verdadeiro se str contiver a string ou caractere fornecido.

str.index(substring [, offset]) [or]

str.index(fixnum [, offset]) [or]

str.index(regexp [, offset])

Retorna o índice da primeira ocorrência da substring, caractere (fixnum) ou padrão (regexp) fornecida em str. Retorna nulo se não for encontrado. Se o segundo parâmetro estiver presente, ele especifica a posição na string para iniciar a pesquisa.

str.insert(index, other_str)

Insere other_str antes do caractere no índice fornecido, modificando str. Índices negativos contam a partir do final da string e são inseridos após o caractere fornecido. A intenção é inserir uma string de forma que comece no índice fornecido.

str.inspect

Retorna uma versão imprimível de str, com caracteres especiais escapados.

str.intern [or] str.to_sym

Retorna o símbolo correspondente a str, criando o símbolo se ele não existisse anteriormente.

str.length

Retorna o comprimento de str. Compare o tamanho.

str.ljust(integer, padstr = ' ')

Se inteiro for maior que o comprimento de str, retorna uma nova String de comprimento inteiro com str justificado à esquerda e preenchido com padstr; caso contrário, retorna str.

str.lstrip

Retorna uma cópia de str com os espaços em branco à esquerda removidos.

str.lstrip!

Remove o espaço em branco inicial de str, retornando nulo se nenhuma alteração foi feita.

str.match(pattern)

Converte o padrão em um Regexp (se ainda não for um) e invoca seu método de correspondência em str.

str.oct

Trata os caracteres iniciais de str como uma sequência de dígitos octais (com um sinal opcional) e retorna o número correspondente. Retorna 0 se a conversão falhar.

str.replace(other_str)

Substitui o conteúdo e contaminação de str pelos valores correspondentes em other_str.

str.reverse

Retorna uma nova string com os caracteres de str na ordem inversa.

str.reverse!

Inverte str no lugar.

str.rindex(substring [, fixnum]) [or]

str.rindex(fixnum [, fixnum]) [or]

str.rindex(regexp [, fixnum])

Retorna o índice da última ocorrência da substring, caractere (fixnum) ou padrão (regexp) fornecida em str. Retorna nulo se não for encontrado. Se o segundo parâmetro estiver presente, ele especifica a posição na string para encerrar a pesquisa. Os caracteres além deste ponto não serão considerados.

str.rjust(integer, padstr = ' ')

Se inteiro for maior que o comprimento de str, retorna uma nova String de comprimento inteiro com str justificado à direita e preenchido com padstr; caso contrário, retorna str.

str.rstrip

Retorna uma cópia de str com o espaço em branco final removido.

str.rstrip!

Remove o espaço em branco à direita de str, retornando nulo se nenhuma alteração foi feita.

str.scan(pattern) [or]

str.scan(pattern) { |match, ...| block }

Ambas as formas iteram por meio de str, correspondendo ao padrão (que pode ser um Regexp ou uma String). Para cada correspondência, um resultado é gerado e adicionado ao array de resultados ou passado para o bloco. Se o padrão não contém grupos, cada resultado individual consiste na string correspondente, $ &. Se o padrão contém grupos, cada resultado individual é em si uma matriz contendo uma entrada por grupo.

str.slice(fixnum) [or] str.slice(fixnum, fixnum) [or]

str.slice(range) [or] str.slice(regexp) [or]

str.slice(regexp, fixnum) [or] str.slice(other_str)

See str[fixnum], etc.

str.slice!(fixnum) [or] str.slice!(fixnum, fixnum) [or]

str.slice!(range) [or] str.slice!(regexp) [or]

str.slice!(other_str)

Exclui a parte especificada de str e retorna a parte excluída. As formas que assumem Fixnum geram um IndexError se o valor estiver fora do intervalo; o formulário Range levantará um RangeError, e os formulários Regexp e String irão ignorar silenciosamente a atribuição.

str.split(pattern = $, [limit])

Divide str em substrings com base em um delimitador, retornando uma matriz dessas substrings.

Se pattern for uma String, então seu conteúdo será usado como delimitador ao dividir str. Se o padrão for um único espaço, str é dividido em espaços em branco, com espaços em branco iniciais e execuções de caracteres de espaço em branco contíguos ignorados.

Se o padrão for um Regexp, str será dividido onde o padrão corresponder. Sempre que o padrão corresponde a uma string de comprimento zero, str é dividido em caracteres individuais.

Se o padrão for omitido, o valor de $; é usado. Se $; é nil (que é o padrão), str é dividido em espaços em branco como se `` fosse especificado.

Se o parâmetro limit for omitido, os campos nulos à direita serão suprimidos. Se limite for um número positivo, no máximo esse número de campos será retornado (se limite for 1, toda a string é retornada como a única entrada em uma matriz). Se negativo, não há limite para o número de campos retornados e os campos nulos à direita não são suprimidos.

str.squeeze([other_str]*)

Cria um conjunto de caracteres a partir do (s) parâmetro (s) other_str usando o procedimento descrito para String # count. Retorna uma nova string em que as execuções do mesmo caractere que ocorrem neste conjunto são substituídas por um único caractere. Se nenhum argumento for fornecido, todas as execuções de caracteres idênticos serão substituídas por um único caractere.

str.squeeze!([other_str]*)

Aperta str no lugar, retornando str ou nil se nenhuma alteração foi feita.

str.strip

Retorna uma cópia de str com os espaços em branco à esquerda e à direita removidos.

str.strip!

Remove os espaços em branco à esquerda e à direita de str. Retorna nulo se str não foi alterado.

str.sub(pattern, replacement) [or]

str.sub(pattern) { |match| block }

Retorna uma cópia de str com a primeira ocorrência do padrão substituída por substituição ou pelo valor do bloco. O padrão normalmente será um Regexp; se for uma string, nenhum metacaractere de expressão regular será interpretado.

str.sub!(pattern, replacement) [or]

str.sub!(pattern) { |match| block }

Executa as substituições de String # sub no lugar, retornando str ou nil se nenhuma substituição foi realizada.

str.succ [or] str.next

Retorna o sucessor de str.

str.succ! [or] str.next!

Equivalente a String # succ, mas modifica o receptor no lugar.

str.sum(n = 16)

Retorna uma soma de verificação básica de n bits dos caracteres em str, onde n é o parâmetro Fixnum opcional, padronizado em 16. O resultado é simplesmente a soma do valor binário de cada caractere em str módulo 2n - 1. Este não é um particular boa soma de verificação.

str.swapcase

Retorna uma cópia de str com caracteres alfabéticos maiúsculos convertidos em minúsculas e caracteres minúsculos convertidos em maiúsculas.

str.swapcase!

Equivalente a String # swapcase, mas modifica o receptor no lugar, retornando str ou nil se nenhuma alteração foi feita.

str.to_f

> Retorna o resultado da interpretação dos caracteres iniciais em str como um número de ponto flutuante. Caracteres estranhos após o final de um número válido são ignorados. Se não houver um número válido no início de str, 0.0 é retornado. Este método nunca levanta uma exceção.

str.to_i(base = 10)

Retorna o resultado da interpretação dos caracteres iniciais em str como uma base inteira (base 2, 8, 10 ou 16). Caracteres estranhos após o final de um número válido são ignorados. Se não houver um número válido no início de str, 0 é retornado. Este método nunca levanta uma exceção.

str.to_s [or] str.to_str

Retorna o receptor.

str.tr(from_str, to_str)

Retorna uma cópia de str com os caracteres em from_str substituídos pelos caracteres correspondentes em to_str. Se to_str for menor do que from_str, ele será preenchido com seu último caractere. Ambas as strings podem usar a notação c1.c2 para denotar intervalos de caracteres, e from_str pode começar com ^, que denota todos os caracteres, exceto aqueles listados.

str.tr!(from_str, to_str)

Traduz str no lugar, usando as mesmas regras da String # tr. Retorna str ou nil se nenhuma alteração foi feita.

str.tr_s(from_str, to_str)

Processa uma cópia de str conforme descrito em String # tr e, em seguida, remove caracteres duplicados em regiões que foram afetadas pela tradução.

str.tr_s!(from_str, to_str)

Executa o processamento da String # tr_s em str no lugar, retornando str ou nil se nenhuma alteração foi feita.

str.unpack(format)

> Decodifica str (que pode conter dados binários) de acordo com a string de formato, retornando um array de cada valor extraído. A string de formato consiste em uma seqüência de diretivas de caractere único, resumidas na Tabela 18. Cada diretiva pode ser seguida por um número, indicando o número de vezes para repetir com esta diretiva. Um asterisco (*) usará todos os elementos restantes. Cada uma das diretivas sSiIlL pode ser seguida por um sublinhado (_) para usar o tamanho nativo da plataforma subjacente para o tipo especificado; caso contrário, ele usa um tamanho consistente independente da plataforma. Os espaços são ignorados na string de formato.

str.upcase

Retorna uma cópia de str com todas as letras minúsculas substituídas por suas contrapartes maiúsculas. A operação é insensível ao local. Apenas os caracteres de a a z são afetados.

str.upcase!

Altera o conteúdo de str para maiúsculas, retornando nil se nenhuma alteração for feita.

str.upto(other_str) { |s| block }

Faz a iteração por valores sucessivos, começando em str e terminando em other_str inclusive, passando cada valor por vez para o bloco. O método String # succ é usado para gerar cada valor.