array - scan ruby example

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

Question

Esto es lo que tengo ahora, que parece demasiado prolijo para el trabajo que está haciendo.

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

Asumir tokens es una matriz obtenida al dividir una línea CSV. ahora las funciones como strip! ¡chomp! et. todos devuelven nulo si la cadena no fue modificada

"abc".strip! # => nil
" abc ".strip! # => "abc"

¿Cuál es la forma Ruby de decir recortar si contiene espacios iniciales o finales adicionales sin crear copias?

Se vuelve más feo si quiero hacer tokens[Title].chomp!.strip!

Answer 1

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ías ponerlo en dos líneas:

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

Answer 2

Mi manera:

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

Answer 3

No es necesario que se deslicen y muerdan, ya que strip también eliminará los retornos de carro posteriores, 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 puedes 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 impedirá que se @title si el token es nulo, lo que dará como resultado que conserve su valor anterior. Si desea o no le importa que @title le @title siempre, 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 String en sí mismo:

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!

Answer 4

Por cierto, ahora ruby ​​ya admite solo tira 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 string.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 lo veo ahora, fue creado en 1999 años (ver rev # 372 en SVN):

Actualización2: strip! no creará duplicados, tanto en versiones 1.9.x, 2.x y troncales.

Answer 5

Si desea utilizar otro método después de necesitar algo como esto:

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

De esta forma, puedes desnudarte y seguir haciendo algo después de :)

Answer 6

Si está 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í está el problema ... ¡en tu caso quieres usar strip sin la explosión!

mientras que tira! ciertamente devuelve nulo si no hubo acción, todavía actualiza la variable, ¡así que quítate! no se puede usar en línea ¡Si quiere usar strip inline puede usar la versión sin el bang!

¡tira! utilizando un enfoque multilínea

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

enfoque de sola línea de tira ... SU RESPUESTA

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

Answer 7

Si tiene ruby ​​1.9 o active support, puede hacer simplemente

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

Esto es realmente genial, ya que aprovecha los métodos :try y the :tap , que son los constructos funcionales más poderosos 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!

Answer 8

Supongo que lo que quieres es:

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

La #strip! El método devolverá nil si no quitó nada, y la variable en sí misma si se eliminó.

Según los estándares de Ruby, un método con un sufijo con un signo de exclamación cambia la variable en su lugar.

Espero que esto ayude.

Actualización: Esto se irb desde irb para demostrar:

>> @title = "abc"
=> "abc"
>> @title.strip!
=> nil
>> @title
=> "abc"
>> @title = " abc "
=> " abc "
>> @title.strip!
=> "abc"
>> @title
=> "abc"

Answer 9

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

Es muy posible que no entienda el tema, pero ¿no haría esto lo que necesita?

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