Guía del usuario de Ruby
AnteriorSiguiente

Capítulo 4. Cadenas

Ruby maneja tanto cadenas como datos numéricos. Las cadenas pueden estar entre comillas dobles("...") o comillas simples ('...'). 


ruby> "abc"
"abc"
ruby> 'abc'
"abc"

Las comillas simples y dobles a veces tienen efectos diferentes. Una cadena de comillas dobles permite la presencia embebida de caracteres de escape precedidos por un backslash y la expresión de evaluación #{ }. Una cadena de comillas simples no realiza esta evaluación, lo que se ve es lo que se obtiene. Ejemplos: 


ruby> print "a\nb\nc","\n"
a
b
c
nil
ruby> print 'a\nb\nc',"\n"
a\nb\nc
nil
ruby> "\n"
"\n"
ruby> '\n'
"\\n"
ruby> "\001"
"\001"
ruby> '\001'
"\\001"
ruby> "abcd #{5*3} efg"
"abcd 15 efg"
ruby> var = " abc "
" abc "
ruby> "1234#{var}5678"
"1234 abc 5678"

El manejo de las cadenas en Ruby es más inteligente e intuitivo que en C. Por ejemplo, se pueden concatenar cadenas con + y se puede repetir una cadena varias veces con *: 


ruby> "foo" + "bar"
"foobar"
ruby> "foo" * 2
"foofoo"

La concatenación de cadenas en C es más incómoda debido a la necesidad de una gestión explícita de la memoria: 


char *s = malloc(strlen(s1)+strlen(s2) +1);
strcpy(s, s1);
strcat(s, s2);
/* ... */
free(s);

Ya que al usar Ruby no tenemos que considerar el espacio que va a ocupar una cadena, estamos liberados de la gestión de la memoria.

A continuación se muestran algunas cosas que se pueden hacer con las cadenas.

Concatenación: 


ruby> word = "fo" + "o"
"foo"

Repetición: 


ruby> word = word * 2
"foofoo"

Extracción de caracteres (obsérvese que los caracteres en Ruby son enteros): 


ruby> word[0]
102             # 102 es el código ASCII de 'f'
ruby> word[-1]
111             # 111 es el código ASCII de 'o'

(Los índices negativos indican desplazamientos desde el final de la cadena, en vez del comienzo).

Extracción de subcadenas: 


ruby> herb = "parsley"
"parsley"
ruby> herb[0,1]
"p"
ruby> herb[-2,2]
"ey"
ruby> herb[0..3]
"pars"
ruby> herb[-5..-2]
"rsle"

Verificación de la igualdad: 


ruby> "foo" == "foo"
true
ruby> "foo" == "bar"
false

Pongamos ahora alguna de estas características en uso. Este acertijo es "Adivina la palabra", aunque tal vez la palabra "acertijo" es demasiado elevada para lo que viene ;-). 


# Salvar como guess.rb
words = ['foobar', 'baz', 'quux']
secret = words[rand(3)]

print "adivina? "
while guess = STDIN.gets
  guess.chop!
  if guess == secret
    print "¡Ganas!\n"
    break
  else
    print "Lo siento. Pierdes\n"
  end
  print "adivina? "
end
print "La palabra era ", secret, ".\n"

Por el momento no te preocupes de los detalles del código. A continuación se muestra una ejecución del programa del acertijo. 


$ ruby guess.rb
adivina? foobar
Lo siento. Pierdes.
adivina? quux
Lo siento. Pierdes.
adivina? ^D 
La palabra era baz.

(Debería haberlo hecho mejor dada la probabilidad de 1/3 de acertar).

AnteriorInicioSiguiente
El bucle de entrada/evaluación Expresiones regulares