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]]
&&= is good for making sure a group of things are all true:
result = true
expressions.each {|expr| result &&= expr}
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
vim: sw=2 sts=2 ft=ruby expandtab tw=0:
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!
- Axel
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