Menu
I'm working through a tutorial right now, and I'd like to understand why the following occurs:
original_string = "Hello, "
hi = original_string
there = "World"
hi += there
assert_equal "Hello, ", original_string
original_string = "Hello, "
hi = original_string
there = "World"
hi << there
assert_equal "Hello, World", original_string
Why does += have no effect on original_string, and << does? I was absolutely certain that the second case would also equal "Hello, ", but that's not the case.
hi = original string in the first example appears to copy the value of original_string into hi, but hi = original string in the second example appears to set hi to point to the same string as original string. I would guess there is some kind of implicit decision behind the scenes as to whether to copy the value or copy the reference... or something.
935
In Ruby, we use #concat to append a string to another string or an element to the array. We can also use #prepend to add a string at the beginning of a string.
The chop method is used to remove the last character of a string in Ruby. If the string ends with \r\n , it will remove both the separators. If an empty string calls this method, then an empty string is returned. We can call the chop method on a string twice.
The replace() is an inbuilt method in Ruby which replaces the contents of the set with the contents of the given enumerable object and returns self. Parameters: The function accepts an enumerable object which to be replaced in the set.
<< on string mutates the original object while += creates a copy and returns that.
See the object_id of the respective strings below:
2.1.1 :029 > original_string = "Hello, "
=> "Hello, "
2.1.1 :030 > hi = original_string
=> "Hello, "
2.1.1 :031 > there = "World"
=> "World"
2.1.1 :032 > original_string.object_id
=> 70242326713680
2.1.1 :033 > hi.object_id
=> 70242326713680
2.1.1 :034 > hi += there
=> "Hello, World"
2.1.1 :035 > hi.object_id
=> 70242325614780
Note the different object_id on hi on line 35. Once you reset hi to original_string in your example above, and use <<, it modifies the same object.
157
In both examples, hi = original_string copies the reference.
With +=, however, you reassign hi to point to a new string, even though the variable name is the same.
This is because hi += there expands in the interpreter to the expression hi = hi + there.
Before this operation, hi and original string share a reference to the same string object. Upon the = operation in the expanded expression, hi now references the newly-created string result of hi + there.
In the expression hi << there, nothing happens to change which object hi refers to. It refers to the same string as original_string, and therefore both hi and original_string reflect the change (which is of course due to the fact that they both reference the same string object).
44
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
