我总是在数组和哈希文档中看到替换,我总是认为这很奇怪。
我敢肯定我已经做过很多次这样的事情:
a = [:a, :b, :c, :d]
...
if some_condition
a = [:e, :f]
end
但我从未想过要用这个来代替:
a = [:a, :b, :c, :d]
...
if some_condition
a.replace [:e, :f]
end
我认为这是预期用途。这真的可以节省内存,还是有其他好处,或者只是一种风格?
和 a.replace [:e, :f],
这两个语句生成指令如下:
1.
a = [:a, :b, :c, :d]
a = [:e, :f]
指示:
Ruby --dump=insns test.rb
== disasm: <RubyVM::InstructionSequence:<main>@test.rb>================= local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1] s1) [ 2] a 0000 trace 1 ( 1) 0002 duparray [:a, :b, :c, :d] 0004 setdynamic a, 0 0007 trace 1 ( 2) 0009 duparray [:e, :f] 0011 dup 0012 setdynamic a, 0 0015 leave
阿拉伯数字。
a = [:a, :b, :c, :d]
a.replace([:e, :f])
指示:
替换方法Ruby --dump=insns test.rb
== disasm: <RubyVM::InstructionSequence:<main>@test.rb>================= local table (size: 2, argc: 0 [opts: 0, rest: -1, post: 0, block: -1] s1) [ 2] a 0000 trace 1 ( 1) 0002 duparray [:a, :b, :c, :d] 0004 setdynamic a, 0 0007 trace 1 ( 2) 0009 getdynamic a, 0 0012 duparray [:e, :f] 0014 send :replace, 1, nil, 0, <ic:0> 0020 leave
并不比赋值运算符快,但替换可以就地修改接收机阵列,而且,替换方法确实节省了内存,这可以从rb_ary_replace的源头看出。
VALUE rb_ary_replace(VALUE copy, VALUE orig) { rb_ary_modify_check(copy); orig = to_ary(orig); if (copy == orig) return copy; if (RARRAY_LEN(orig) <= RARRAY_EMBED_LEN_MAX) { VALUE *ptr; VALUE shared = 0; if (ARY_OWNS_HEAP_P(copy)) { xfree(RARRAY_PTR(copy)); } else if (ARY_SHARED_P(copy)) { shared = ARY_SHARED(copy); FL_UNSET_SHARED(copy); } FL_SET_EMBED(copy); ptr = RARRAY_PTR(orig); MEMCPY(RARRAY_PTR(copy), ptr, VALUE, RARRAY_LEN(orig)); if (shared) { rb_ary_decrement_share(shared); } ARY_SET_LEN(copy, RARRAY_LEN(orig)); } else { VALUE shared = ary_make_shared(orig); if (ARY_OWNS_HEAP_P(copy)) { xfree(RARRAY_PTR(copy)); } else { rb_ary_unshare_safe(copy); } FL_UNSET_EMBED(copy); ARY_SET_PTR(copy, RARRAY_PTR(orig)); ARY_SET_LEN(copy, RARRAY_LEN(orig)); rb_ary_set_shared(copy, shared); } return copy; }
我认为预期用途是就地修改已传递给方法的数组。例如:
def m(a)
a.replace(%w[a b])
end
a = %w[x y z]
m(a)
# a is now ['a', 'b']
如果没有replace
,你必须做这样的事情:
def m(a)
a.clear
a << 'a' # or use .push of course
a << 'b'
end
使用 replace
可以一次完成所有操作,应该绕过自动收缩和自动增长(这可能涉及复制一些内存)行为,这将是逐个元素替换数组内容(而不是数组本身!)的副作用。性能优势(如果有的话)可能只是一个额外的,主要目的可能是获取指针到指针的行为,而无需引入指针或将数组包装在额外的对象中。
a = [:a, :b, :c, :d]
b = [:x, :y, :z]
a.replace(b)
a.object_id == b.object_id
=> false
a = [:a, :b, :c, :d]
b = [:x, :y, :z]
a = b
a.object_id == b.object_id
=> true
也
a = [:a, :b, :c, :d]
c = a
b = [:x, :y, :z]
a.replace(b)
p c # => [:x, :y, :z]
与
a = [:a, :b, :c, :d]
c = a
b = [:x, :y, :z]
a = b
p c # => [:a, :b, :c, :d]
这并不能完全回答您的问题。