075:0> a = “hello”
“hello”
076:0> a += " there."
“hello there.”
077:0>
neat!
075:0> a = “hello”
“hello”
076:0> a += " there."
“hello there.”
077:0>
neat!
Simon S. wrote:
075:0> a = “hello”
“hello”
076:0> a += " there."
“hello there.”
077:0>neat!
“+=” will actually work on any class that has “+” defined, including
custom classes. I assume it is the same with “-=”, “*=”, “/=”, “&&=”,
“||=”, and any others that I may have missed…
Hello,
“*=”, “/=”, “&&=”, “||=”, and any others that I may have missed…
Can anybody tell me, where to find, what this means?
Thank you!
Axel
Axel wrote:
Hello,
“*=”, “/=”, “&&=”, “||=”, and any others that I may have missed…
Can anybody tell me, where to find, what this means?
Thank you!
Axel
var1 = var2
is always equivalent to
var1 = var2 2
For example,
num ||= 0
is frequently used to mean “if num is nil, num = 0”. The longhand is
“num = num || 0”, as “num || 0” evaluates to num if num is non-nil, and
“0” otherwise. Good for making sure strings or numbers are initialized:
my_str ||= “”
&&= is good for making sure a group of things are all true:
result = true
expressions.each {|expr| result &&= expr}
The simpler operators are these:
a /= b
means:
a = a/b
Same goes for the others:
my_str = "hello "
my_str *= 3
is the same as:
my_str = my_str * 3
I no longer have my list of web sites I learned Ruby from, but it’s
pretty simple. Hope this helps.
Dan
From: Dan Z. [mailto:[email protected]]
just in case you’ve forgotten, Dan,
expressions.all?
kind regards -botp
Dan Z. wrote:
“+=” will actually work on any class that has “+” defined, including
custom classes. I assume it is the same with “-=”, “*=”, “/=”, “&&=”,
“||=”, and any others that I may have missed…
That is correct (you missed %=, |=, &=, ^=, <<=, >>=, **= and whatever
/I/
may have missed), except that in case of && and || it is not necessary
for
the class to have anthing defined, because those aren’t methods and they
work independently of the object’s class.
On 8/24/07, Simon S. [email protected] wrote:
075:0> a = “hello”
“hello”
076:0> a += " there."
“hello there.”
077:0>neat!
not really
a += " there" is
a = a + " there"
a << " there"
I might be accused of premature optimizationism (A word I just made
up, I have to make an ECR ;).
But seriously there is just no need to pay the cost of the
construction of another String / Array.
Performance difference is already enormous for moderately long strings :
511/11 > cat costs.rb
require ‘benchmark’
N = ARGV.first.to_i
a = “Hello Nice Little "
Benchmark.bmbm do
|mybench|
mybench.report(” += “){ N.times{ a += “.” } }
mybench.report(” << "){ N.times{ a << “.” } }
end # Benchmark.bmbm do
robert@PC:~/log/ruby/ML 10:17:57
512/12 > ruby costs.rb 1000
Rehearsal ----------------------------------------
+= 0.000000 0.000000 0.000000 ( 0.002936)
<< 0.000000 0.000000 0.000000 ( 0.001008)
------------------------------- total: 0.000000sec
user system total real
+= 0.000000 0.010000 0.010000 ( 0.080035)
<< 0.000000 0.000000 0.000000 ( 0.000927)
robert@PC:~/log/ruby/ML 10:18:04
513/13 > ruby costs.rb 10000
Rehearsal ----------------------------------------
+= 0.160000 0.020000 0.180000 ( 0.565431)
<< 0.010000 0.000000 0.010000 ( 0.012393)
------------------------------- total: 0.190000sec
user system total real
+= 0.730000 0.050000 0.780000 ( 0.826307)
<< 0.010000 0.000000 0.010000 ( 0.013734)
robert@PC:~/log/ruby/ML 10:18:08
514/14 > ruby costs.rb 20000
Rehearsal ----------------------------------------
+= 0.620000 0.010000 0.630000 ( 0.741340)
<< 0.030000 0.000000 0.030000 ( 0.077221)
------------------------------- total: 0.660000sec
user system total real
+= 3.060000 0.000000 3.060000 ( 3.131026)
<< 0.030000 0.000000 0.030000 ( 0.076420)
robert@PC:~/log/ruby/ML 10:18:20
515/15 > ruby costs.rb 30000
Rehearsal ----------------------------------------
+= 1.380000 0.020000 1.400000 ( 1.452444)
<< 0.040000 0.000000 0.040000 ( 0.087939)
------------------------------- total: 1.440000sec
user system total real
+= 6.760000 0.040000 6.800000 ( 6.848208)
<< 0.040000 0.000000 0.040000 ( 0.036871)
Cheers
Robert
I no longer have my list of web sites I learned Ruby from, but it’s
pretty simple. Hope this helps.Dan
Very nice! Thank you!
Hi –
On Fri, 24 Aug 2007, Robert D. wrote:
a += " there" is
a = a + " there"a << " there"
I might be accused of premature optimizationism (A word I just made
up, I have to make an ECR ;).
Don’t worry – there’s no Academie Anglaise
But seriously there is just no need to pay the cost of the
construction of another String / Array.
Performance difference is already enormous for moderately long strings :
It depends, though; sometimes you might want a copy, sometimes you
might definitely not. So the + vs. << decision may not be premature,
and the right decision may not even be the optimizing one
David
Hi –
On Fri, 24 Aug 2007, Robert D. wrote:
It depends, though; sometimes you might want a copy, sometimes you
might definitely not. So the + vs. << decision may not be premature,
and the right decision may not even be the optimizing one
Hmm David when one does
a += b
the copy is thrown away and you have the same semantics (save some
implicit calls to to_s) as for
a << b
They’re not interchangeable, though:
a = “Hello”
b = " there"
c = a
a += b
puts a # Hello there
puts c # Hello
a = “Hello”
c = a
a << b
puts a # Hello there
puts c # Hello there
David
On 8/24/07, David A. Black [email protected] wrote:
implicit calls to to_s) as for
puts c # Helloa = “Hello”
c = a
a << b
puts a # Hello there
puts c # Hello there
That is indeed an important - probably the most important - point to
make, I believe that people are not always aware that a+=b is a = a +
b.
I have to admit that I assumed that OP wanted the a << b behavior, but
maybe he did not, that was quite a bad performance of mine…
Robert
On 8/24/07, David A. Black [email protected] wrote:
Hi –
Don’t worry – there’s no Academie Anglaise
I am not French, only my wife is;), but it is a funny remark.But seriously there is just no need to pay the cost of the
construction of another String / Array.
Performance difference is already enormous for moderately long strings :It depends, though; sometimes you might want a copy, sometimes you
might definitely not. So the + vs. << decision may not be premature,
and the right decision may not even be the optimizing one
Hmm David when one does
a += b
the copy is thrown away and you have the same semantics (save some
implicit calls to to_s) as for
a << b
My benchmarks show some dramatic performance degradation already but
imagine the GC kicking in because of the temporary copies, no,
honestly I feel that beginners
should be warned about that idiom.
For sure sometimes you want
a = b + c
but that is a different story.
Robert
Peña wrote:
kind regards -botp
Peña,
Good point–my example wasn’t very good idiomatic Ruby. However, there
are still good occasions to use &&= when your expressions are not in a
convenient list. Example: I have a backup script written in Ruby that
runs several system commands. I just don’t want to put all the commands
in a list. So I use &&= to keep track of the state of success of the
whole script.
Dan
This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.
Sponsor our Newsletter | Privacy Policy | Terms of Service | Remote Ruby Jobs