regulares - ¿Cómo elimino los retornos de carro con Ruby?

ruby regex validator

Question

Pensé que este código funcionaría, pero la expresión regular nunca coincide con el / r / n. He visto los datos que estoy leyendo en un editor hexadecimal y verifico que realmente hay un patrón hexadecimal D y hexadecimal A en el archivo.

También probé las expresiones regulares / / xD / xA / m y / / x0D / x0A / m pero tampoco coinciden.

Este es mi código ahora mismo:

   lines2 = lines.gsub( //r/n/m, "/n" )
   if ( lines == lines2 )
       print "still the same/n"
   else
       print "made the change/n"
   end

Además de las alternativas, sería bueno saber lo que estoy haciendo mal (para facilitar algo de aprendizaje de mi parte). :)

Answer 1

¿Por qué no leer el archivo en modo texto, en lugar de modo binario?

Answer 2

¿Qué obtienes cuando haces puts lines ? Eso te dará una pista.

De forma predeterminada, File.open abre el archivo en modo texto, por lo que sus caracteres /r/n se convertirán automáticamente a /n . Tal vez ese es el motivo por el que las lines siempre son iguales a lines2 . Para evitar que Ruby analice los extremos de la línea, use el modo rb :

C:/> copy con lala.txt a file with many lines ^Z C:/> irb irb(main):001:0> text = File.open(''lala.txt'').read => "a/nfile/nwith/nmany/nlines/n" irb(main):002:0> bin = File.open(''lala.txt'', ''rb'').read => "a/r/nfile/r/nwith/r/nmany/r/nlines/r/n" irb(main):003:0>

Pero de su pregunta y código veo que simplemente necesita abrir el archivo con el modificador predeterminado. No necesita ninguna conversión y puede usar File.read más File.read .

Answer 3

¿Qué tal lo siguiente?

irb(main):003:0> my_string = "Some text with a carriage return /r"
=> "Some text with a carriage return /r"
irb(main):004:0> my_string.gsub(//r/,"")
=> "Some text with a carriage return "
irb(main):005:0>

O...

irb(main):007:0> my_string = "Some text with a carriage return /r/n"
=> "Some text with a carriage return /r/n"
irb(main):008:0> my_string.gsub(//r/n/,"/n")
=> "Some text with a carriage return /n"
irb(main):009:0>

Answer 4

Creo que su expresión regular está casi completa, esto es lo que haría:

lines2 = lines.gsub(/[/r/n]+/m, "/n")

En lo anterior, puse / r y / n en una clase (de esa manera no importa en qué orden podrían aparecer) y agregué el calificador "+" (de modo que "/ r / n / r / n / r / n "también coincidiría una vez, y todo se reemplazaría por" / n ")

Answer 5

En general, cuando trato con stripping / r o / n, buscaré ambos haciendo algo como

lines.gsub(//r/n?/, "/n");

Descubrí que, dependiendo de cómo se guardaron los datos (el SO utilizado, el editor utilizado, la relación de Júpiter con Io en ese momento) puede haber o no una nueva línea después del retorno del carro. Parece extraño que veas ambos personajes en modo hexadecimal. Espero que esto ayude.

Answer 6

Puedes usar esto:

my_string.strip.gsub(//s+/, '' '')

Answer 7

Si está utilizando Rails, hay un método squish

"/tgoodbye/r/n".squish => "goodbye"

"/tgood /t/r/nbye/r/n".squish => "good bye"

Answer 8

Solo otra variante:

lines.delete(" /n")

Answer 9

Utilice String#strip

Devuelve una copia de str con el espacio en blanco inicial y final eliminado.

p.ej

"    hello    ".strip   #=> "hello"   
"/tgoodbye/r/n".strip   #=> "goodbye"

Usando gsub

string = string.gsub(//r/," ")
string = string.gsub(//n/," ")

Answer 10

"still the same/n".chomp
o
"still the same/n".chomp!

http://www.ruby-doc.org/core-1.9.3/String.html#method-i-chomp

Answer 11

def dos2unix(input)
  input.each_byte.map { |c| c.chr unless c == 13 }.join
end

remove_all_the_carriage_returns = dos2unix(some_blob)

Answer 12

lines.map(&:strip).join(" ")

Answer 13

lines2 = lines.split.join("/n")

Answer 14

modified_string = string.gsub(//s+/, '' '').strip