Ruby Language
Instrumentos de cuerda

Sintaxis

• 'Una cadena' // crea una cadena a través de un literal entre comillas simples
• "Una cadena" // crea una cadena a través de un literal entre comillas dobles
• String.new ("Una cadena")
• % q (una cadena) // sintaxis alternativa para crear cadenas entre comillas simples
• % Q (una cadena) // sintaxis alternativa para crear cadenas entre comillas dobles

Diferencia entre literales de cadena entre comillas simples y comillas dobles

La principal diferencia es que los literales de String comillas dobles admiten interpolaciones de cadenas y el conjunto completo de secuencias de escape.

Por ejemplo, pueden incluir expresiones de Ruby arbitrarias a través de la interpolación:

# Single-quoted strings don't support interpolation
puts 'Now is #{Time.now}'
# Now is #{Time.now}

# Double-quoted strings support interpolation
puts "Now is #{Time.now}"
# Now is 2016-07-21 12:43:04 +0200

Las cadenas entre comillas dobles también admiten el conjunto completo de secuencias de escape, incluidos "\n" , "\t" ...

puts 'Hello\nWorld'
# Hello\nWorld

puts "Hello\nWorld"
# Hello
# World

... mientras que las cadenas de comillas simples no admiten secuencias de escape, muestra el conjunto mínimo necesario para que las cadenas de comillas simples sean útiles: comillas simples literales y barras invertidas, '\'' y '\\' respectivamente.

Creando una cadena

Ruby proporciona varias formas de crear un objeto String . La forma más común es usar comillas simples o dobles para crear una " cadena literal ":

s1 = 'Hello'
s2 = "Hello"

La principal diferencia es que los literales de cadena entre comillas dobles son un poco más flexibles ya que admiten la interpolación y algunas secuencias de escape de barra invertida.

También hay varias otras formas posibles de crear un literal de cadena utilizando delimitadores de cadena arbitrarios. Un delimitador de cadena arbitrario es un % seguido por un par de delimitadores coincidentes:

%(A string)
%{A string}
%<A string>
%|A string|
%!A string!

Finalmente, puede usar las secuencias %q y %Q , que son equivalentes a ' y " ":

puts %q(A string)
# A string
puts %q(Now is #{Time.now})
# Now is #{Time.now}

puts %Q(A string)
# A string
puts %Q(Now is #{Time.now})
# Now is 2016-07-21 12:47:45 +0200

%Q secuencias %q y %Q son útiles cuando la cadena contiene comillas simples, comillas dobles o una combinación de ambas. De esta manera, no necesitas escapar del contenido:

%Q(<a href="/profile">User's profile<a>)

Puede usar varios delimitadores diferentes, siempre que haya un par coincidente:

%q(A string)
%q{A string}
%q<A string>
%q|A string|
%q!A string!

Concatenación de cuerdas

Concatenar cadenas con el operador + :

s1 = "Hello"
s2 = " "
s3 = "World"

puts s1 + s2 + s3
# => Hello World

s = s1 + s2 + s3
puts s
# => Hello World

O con el operador << :

s = 'Hello'
s << ' '
s << 'World'
puts s
# => Hello World

Tenga en cuenta que el operador << modifica el objeto en el lado izquierdo.

También puedes multiplicar cadenas, por ejemplo

"wow" * 3
# => "wowwowwow"

Interpolación de cuerdas

El delimitador de doble comillas " y %Q secuencia %Q admiten la interpolación de cadenas usando #{ruby_expression} :

puts "Now is #{Time.now}"
# Now is Now is 2016-07-21 12:47:45 +0200

puts %Q(Now is #{Time.now})
# Now is Now is 2016-07-21 12:47:45 +0200

Manipulación de casos

"string".upcase     # => "STRING"
"STRING".downcase   # => "string"
"String".swapcase   # => "sTRING"
"string".capitalize # => "String"

Estos cuatro métodos no modifican el receptor original. Por ejemplo,

str = "Hello"
str.upcase # => "HELLO"
puts str   # => "Hello"

Hay cuatro métodos similares que realizan las mismas acciones pero modifican el receptor original.

"string".upcase!     # => "STRING"
"STRING".downcase!   # => "string"
"String".swapcase!   # => "sTRING"
"string".capitalize! # => "String"

Por ejemplo,

str = "Hello"
str.upcase!  # => "HELLO"
puts str     # => "HELLO"

Notas:

• Antes de Ruby 2.4, estos métodos no manejan Unicode.

Dividiendo una cadena

String#split divide una String en una Array , basada en un delimitador.

"alpha,beta".split(",")
# => ["alpha", "beta"]

Una String vacía da como resultado una Array vacía:

"".split(",")
# => []

Un delimitador no coincidente da como resultado una Array contiene un solo elemento:

"alpha,beta".split(".")
# => ["alpha,beta"]

También puedes dividir una cadena usando expresiones regulares:

"alpha, beta,gamma".split(/, ?/)
# => ["alpha", "beta", "gamma"]

El delimitador es opcional; por defecto, una cadena se divide en espacios en blanco:

"alpha beta".split
# => ["alpha", "beta"] 

Unirse a cuerdas

Array#join une un Array en una String , basado en un delimitador:

["alpha", "beta"].join(",")
# => "alpha,beta"

El delimitador es opcional, y por defecto es una String vacía.

["alpha", "beta"].join
# => "alphabeta"

Una Array vacía da como resultado una String vacía, sin importar qué delimitador se use.

[].join(",")
# => ""

Cuerdas multilínea

La forma más fácil de crear una cadena multilínea es simplemente usar varias líneas entre comillas:

address = "Four score and seven years ago our fathers brought forth on this
continent, a new nation, conceived in Liberty, and dedicated to the
proposition that all men are created equal."

El principal problema con esa técnica es que si la cadena incluye una cita, romperá la sintaxis de la cadena. Para solucionar el problema, puede utilizar un heredoc en su lugar:

puts <<-RAVEN
  Once upon a midnight dreary, while I pondered, weak and weary, 
  Over many a quaint and curious volume of forgotten lore— 
      While I nodded, nearly napping, suddenly there came a tapping, 
  As of some one gently rapping, rapping at my chamber door. 
  "'Tis some visitor," I muttered, "tapping at my chamber door— 
              Only this and nothing more." 
  RAVEN

Ruby admite documentos de estilo shell aquí con <<EOT , pero el texto de terminación debe comenzar la línea. Eso complica la sangría del código, por lo que no hay muchas razones para usar ese estilo. Desafortunadamente, la cadena tendrá sangrías según la forma en que se sangra el código.

Ruby 2.3 resuelve el problema introduciendo <<~ que elimina los espacios iniciales en exceso:

def build_email(address)
  return (<<~EMAIL)
    TO: #{address}

    To Whom It May Concern:

    Please stop playing the bagpipes at sunrise!
                     
    Regards,
    Your neighbor               
  EMAIL
end

Porcentaje de cadenas también trabajan para crear cadenas multilínea:

%q(
HAMLET        Do you see yonder cloud that's almost in shape of a camel?
POLONIUS        By the mass, and 'tis like a camel, indeed.
HAMLET        Methinks it is like a weasel.
POLONIUS        It is backed like a weasel.
HAMLET        Or like a whale?
POLONIUS        Very like a whale
)

Hay algunas formas de evitar la interpolación y las secuencias de escape:

• Comillas simples en lugar de comillas dobles: '\n is a carriage return.'

• Minúscula q en una cadena de porcentaje: %q[#{not-a-variable}]

• Cita simple la cadena terminal en un heredoc:

  <<-'CODE'
     puts 'Hello world!'
  CODE
  

Cuerdas formateadas

Ruby puede inyectar una matriz de valores en una cadena reemplazando cualquier marcador de posición con los valores de la matriz suministrada.

"Hello %s, my name is %s!" % ['World', 'br3nt']
# => Hello World, my name is br3nt!

Los marcadores de posición están representados por dos %s y los valores son proporcionados por la matriz ['Hello', 'br3nt'] . El operador % indica a la cadena que inyecte los valores de la matriz.

Reemplazos de caracteres de cadena

El método tr devuelve una copia de una cadena donde los caracteres del primer argumento son reemplazados por los caracteres del segundo argumento.

"string".tr('r', 'l') # => "stling"

Para reemplazar solo la primera aparición de un patrón con otra expresión, use el método sub

"string ring".sub('r', 'l') # => "stling ring"

Si desea reemplazar todas las apariciones de un patrón con esa expresión, use gsub

"string ring".gsub('r','l') # => "stling ling" 

Para eliminar caracteres, pase una cadena vacía para el segundo parámetro

También puedes usar expresiones regulares en todos estos métodos.

Es importante tener en cuenta que estos métodos solo devolverán una nueva copia de una cadena y no la modificarán en su lugar. Para hacer eso, necesitas usar el tr! , sub! y gsub! métodos respectivamente.

Entendiendo los datos en una cadena

En Ruby, una cadena es solo una secuencia de bytes junto con el nombre de una codificación (como UTF-8 , US-ASCII , ASCII-8BIT ) que especifica cómo puede interpretar esos bytes como caracteres.

Las cadenas de Ruby se pueden usar para contener texto (básicamente una secuencia de caracteres), en cuyo caso se suele usar la codificación UTF-8.

"abc".bytes  # => [97, 98, 99]
"abc".encoding.name  # => "UTF-8"

Las cadenas de Ruby también se pueden usar para almacenar datos binarios (una secuencia de bytes), en cuyo caso se suele utilizar la codificación ASCII-8BIT.

[42].pack("i").encoding  # => "ASCII-8BIT"

Es posible que la secuencia de bytes en una cadena no coincida con la codificación, lo que resulta en errores si intenta usar la cadena.

"\xFF \xFF".valid_encoding? # => false
"\xFF \xFF".split(' ')      # ArgumentError: invalid byte sequence in UTF-8

Sustitución de cuerdas

p "This is %s" % "foo"
# => "This is foo"

p "%s %s %s" % ["foo", "bar", "baz"]
# => "foo bar baz"

p "%{foo} == %{foo}" % {:foo => "foo" }
# => "foo == foo"

Vea String % docs y Kernel :: sprintf para más detalles.

Cadena comienza con

Para encontrar si una cadena comienza con un patrón, el start_with? el método es útil

str = "zebras are cool"
str.start_with?("zebras")      => true

También puede comprobar la posición del patrón con el index

str = "zebras are cool"
str.index("zebras").zero?      => true

Cadena termina con

Para encontrar si una cadena termina con un patrón, el end_with? el método es útil

str = "I like pineapples"
str.end_with?("pineaaples")      => false

Cuerdas de posicionamiento

En Ruby, las cadenas pueden ser justificadas a la izquierda, justificadas a la derecha o centradas

Para justificar a la izquierda la cadena, use el método ljust . Esto incluye dos parámetros, un entero que representa el número de caracteres de la nueva cadena y una cadena, que representa el patrón a rellenar.

Si el número entero es mayor que la longitud de la cadena original, la nueva cadena se justificará a la izquierda con el parámetro de cadena opcional tomando el espacio restante. Si no se proporciona el parámetro de cadena, la cadena se rellenará con espacios.

str ="abcd"
str.ljust(4)          => "abcd"
str.ljust(10)         => "abcd      "

Para justificar a la derecha una cadena, use el método rjust . Esto incluye dos parámetros, un entero que representa el número de caracteres de la nueva cadena y una cadena, que representa el patrón a rellenar.

Si el número entero es mayor que la longitud de la cadena original, la nueva cadena se justificará a la derecha con el parámetro de cadena opcional que ocupará el espacio restante. Si no se proporciona el parámetro de cadena, la cadena se rellenará con espacios.

str = "abcd"
str.rjust(4)          => "abcd"
str.rjust(10)         => "      abcd"

Para centrar una cadena, usa el método center . Esto incluye dos parámetros, un entero que representa el ancho de la nueva cadena y una cadena con la que se rellenará la cadena original. La cuerda se alineará al centro.

str = "abcd"
str.center(4)          => "abcd"
str.center(10)         => "   abcd   "