¿Cuál es la forma canónica de recortar una cadena en Ruby sin crear una nueva cadena?

Por cierto, ahora ruby ya soporta solo strip sin "!".

Comparar:

p "abc".strip! == " abc ".strip!  # false, because "abc".strip! will return nil
p "abc".strip == " abc ".strip    # true

También es imposible strip sin duplicados. Ver fuentes en cadena.c:

static VALUE
rb_str_strip(VALUE str)
{
    str = rb_str_dup(str);
    rb_str_strip_bang(str);
    return str;
}

ruby 1.9. 3p0 (2011-10-30) [i386-mingw32]

Actualización 1: Como veo ahora was fue creado en 1999 año (ver rev #372 en SVN):

Actualización2: strip! no creará duplicados - ambos en 1.9.x, 2.versiones x y trunk.

No es necesario tanto el strip como el chomp, ya que el strip también eliminará los retornos de carro finales, a menos que haya cambiado el separador de registros predeterminado y eso es lo que está masticando.

La respuesta de Olly ya tiene la forma canónica de hacer esto en Ruby, aunque si te encuentras haciendo esto mucho siempre podrías definir un método para ello:

def strip_or_self!(str)
  str.strip! || str
end

Dando:

@title = strip_or_self!(tokens[Title]) if tokens[Title]

También tenga en cuenta que la instrucción if evitará que @title se asigne si el token es nil, que resultará en que mantenga su valor anterior. Si quiere o no le importa @title que siempre se le asigne, puede mover el cheque al método y reducir aún más la duplicación:

def strip_or_self!(str)
  str.strip! || str if str
end

Como alternativa, si te sientes aventurero puedes definir un método en la propia cadena:

class String
  def strip_or_self!
    strip! || self
  end
end

Dando uno de:

@title = tokens[Title].strip_or_self! if tokens[Title]

@title = tokens[Title] && tokens[Title].strip_or_self!

Si estás usando Ruby on Rails hay un squish

> @title = " abc "
 => " abc " 

> @title.squish
 => "abc"
> @title
 => " abc "

> @title.squish!
 => "abc"
> @title
 => "abc" 

Si estás usando solo Ruby, quieres usar strip

Aquí yace el gotcha.. en su caso que desea utilizar la tira sin la explosión !

Mientras tira! ciertamente devuelve nil si no hubo acción todavía actualiza la variable así que tira! no se puede usar en línea. Si desea utilizar tira en línea se puede utilizar la versión sin la explosión !

Tira! usando varias líneas enfoque

> tokens["Title"] = " abc "
 => " abc "
> tokens["Title"].strip!
 => "abc"
> @title = tokens["Title"]
 => "abc"

Strip single line approach... SU RESPUESTA

> tokens["Title"] = " abc "
 => " abc "
> @title = tokens["Title"].strip if tokens["Title"].present?
 => "abc"

Creo que su ejemplo es un enfoque sensato, aunque podría simplificarlo ligeramente como:

@title = tokens[Title].strip! || tokens[Title] if tokens[Title]

Alternativa podría ponerlo en dos líneas:

@title = tokens[Title] || ''
@title.strip!

Si quieres usar otro método después de necesitar algo como esto:

( str.strip || str ).split(',')

De esta manera puedes desnudarte y seguir haciendo algo después:)

A mi manera:

> (@title = " abc ").strip!
 => "abc" 
> @title
 => "abc" 

Si tiene ruby 1.9 o activesupport, puede hacer simplemente

@title = tokens[Title].try :tap, &:strip!

Esto es realmente genial, ya que aprovecha el método :try y el método :tap, que son las construcciones funcionales más poderosas en ruby, en mi opinión.

Una forma aún más linda, pasando funciones como símbolos en conjunto:

@title = tokens[Title].send :try, :tap, &:strip!

@title = tokens[Title].strip! || tokens[Title]

Es completamente posible que no esté entendiendo el tema, pero ¿no haría esto lo que necesitas?

" success ".strip! || "rescue" #=> "success"
"failure".strip! || "rescue" #=> "rescue"