Newlines in array problem

Ruby
1

Is there a way to get rid of newlines in an array?
Example: array = [“hel\nlo”, “bl\nah”]

I want the output to be new_array = [“hello”, “blah”]

I tried:

array.each do |el|
el.delete("\n")
end

But that didn’t work. Can’t figure this out. Any suggestions?

2

use ‘collect’
_md

3

On Thu, Apr 7, 2011 at 6:38 PM, Cyril J. [email protected] wrote:

But that didn’t work. Can’t figure this out. Any suggestions?

String#delete returns a copy of the string, it doesn’t modify it in
place. Use String#delete!

ruby-1.8.7-p334 :017 > array = [“hel\nlo”, “bl\nah”]
=> [“hel\nlo”, “bl\nah”]
ruby-1.8.7-p334 :018 > array.each {|word| word.delete!(“\n”)}
=> [“hello”, “blah”]
ruby-1.8.7-p334 :019 > array
=> [“hello”, “blah”]

Jesus.

4

Thanks Jesus - exactly what I needed.

5

Thanks Jesus - exactly what I needed.

It’s hard to see how that can be the case because:

  1. each() doesn’t create a new array.

  2. You need to be careful using delete!() because it will change the
    strings in the original array too:

array = [“hel\nlo”, “bl\nah”]
new_array = []

array.each do |str|
new_array << str.delete!("\n")
end

p array
p new_array

–output:–
[“hello”, “blah”]
[“hello”, “blah”]

If you really want to preserve the original array, don’t use delete! on
the strings.

You also might prefer map() instead of each() because it
creates a new array for you:

array = [“hel\nlo”, “bl\nah”]

new_arr = array.map do |str|
str.delete("\n")
end

p new_arr
p array

–output:–
[“hello”, “blah”]
[“hel\nlo”, “bl\nah”]

On the other hand, if you don’t need two versions of the
array hanging around in memory, then go ahead and use each() and
delete!()

6

On Thu, Apr 7, 2011 at 8:34 PM, 7stud – [email protected] wrote:

each() doesn’t create a new array. Why not use map()? And you need to
be careful using delete!() because it will change the strings in the
original array too.

This obviously depends on what he needs. The fact that each doesn’t
create a new array can be a good thing :-).

array = [“hel\nlo”, “bl\nah”]

new_arr = array.map do |str|
str.delete!(“\n”)
end

This I don’t understand. You are modifying the original strings but
creating a new array with them. What could be the use case for this?

the strings. On the other hand, if you don’t need two versions of the
array hanging around in memory, then use all ! methods:

array = [“hel\nlo”, “bl\nah”]

array.map! do |str|
str.delete!(“\n”)
end

You don’t need map! here, cause you don’t want to change which object
each position references. You just want to modify the strings
themselves. What I would say is that, if you need to preserve the
original strings (because they are referenced by other variables) but
use the same array, do:

a = “hel\nlo”
b = “bl\nah”
array = [a,b]

array.map! do |str|
str.delete(“\n”)
end

The bang version of map, because you want to change the array, but the
non-bang version of delete so as to keep the original strings. The two
cases you propose above have less use cases, IMHO.

Jesus.

7

“Jesús Gabriel y Galán” [email protected] wrote in post
#991555:

On Thu, Apr 7, 2011 at 8:34 PM, 7stud – [email protected] wrote:

each() doesn’t create a new array. Why not use map()? And you need to
be careful using delete!() because it will change the strings in the
original array too.

This obviously depends on what he needs. The fact that each doesn’t
create a new array can be a good thing :-).

While I realize it isn’t always definitive, let’s re-read what the op
actually said:

Example: array = [“hel\nlo”, “bl\nah”]

I want the output to be new_array = [“hello”, “blah”]

====

array = [“hel\nlo”, “bl\nah”]

new_arr = array.map do |str|
str.delete!(“\n”)
end

This I don’t understand. You are modifying the original strings but
creating a new array with them. What could be the use case for this?

Well, let’s see what I said about that:

  1. You need to be careful using delete!() because
    it will change the strings in the original array too:

“careful” meaning, “Dear op, you don’t want to do that if, as you said,
you want to preserve the original array.”

===

the strings. On the other hand, if you don’t need two versions of the
array hanging around in memory, then use all ! methods:

array = [“hel\nlo”, “bl\nah”]

array.map! do |str|
str.delete!(“\n”)
end

You don’t need map! here,

Yeah, I edited that out before you posted. My final suggestion uses
map() and delete(), and I reference your example if the op actually
wants to change the array in place.