相关疑难解决方法(0)

当我运行下面的ruby代码时,为什么我的数组被全局操作？我怎样才能在函数范围内操作数组？

a = [[1,0],[1,1]]

def hasRowsWithOnlyOnes(array)
  array.map { |row|
    return true if row.keep_if{|i| i != 1 } == []
  }
  false;
end

puts a.to_s
puts hasRowsWithOnlyOnes(a)
puts a.to_s

$ ruby test.rb 输出:

[[1, 0], [1, 1]]
true
[[0], []]

我无法让它发挥作用.我甚至试过.select{true}把它分配给一个新名字.范围如何在Ruby for Arrays中运行？仅供参考$ ruby -v:

ruby 2.2.1p85 (2015-02-26 revision 49769) [x86_64-linux]

有没有办法按值传递对象而不是Ruby中的引用？例如,

class Person
  attr_accessor :name
end
def get_name(obj)
  obj.name = "Bob"
  puts obj.name
end
jack = Person.new
jack.name = "Jack"
puts jack.name
get_name(jack)
puts jack.name

输出应该是

Jack
Bob
Jack

代替

Jack
Bob
Bob

任何帮助,将不胜感激.

我可以将哈希集更新为另一个变量,如下所示:

d = a = {b: 'c'}

a[:b] = 'qwerty'
d # => {:b=>'qwerty'} # What is this magic?

d[:b] = 'blah'
a # => {:b=>'blah'} # And this magic?

为什么在使用原始变量时不会发生这种情况？

d = a = 'b'

a = 'c'
d # =>'b' # Why is it still the same?

请帮忙找一些下一个行为的文章.

a = 'qwer'
a = b
b << 'ty'
puts b # => 'qwerty'
puts a # => 'qwerty'

但如果

a = 'qwer'
a = b
b = 'ty'
puts b # => 'ty'
puts a # => 'qwer'

我知道为什么在这种情况下

我知道它运作良好,但我找不到解释 - 为什么如此

PS

如果适用 - 请提供有关此主题的文章的链接(或类似的可能我想念这样的更有趣的功能).

THN.

我正在研究在ruby中学习一些Hash操作.代码是关于将每件商品的价格提高10%.为什么这段代码不起作用？

restaurant_menu = { "Ramen" => 3, "Dal Makhani" => 4, "Coffee" => 2 }
restaurant_menu.each do |item, price|
  price = price + (price * 0.1)
end

虽然这个做了:

restaurant_menu = { "Ramen" => 3, "Dal Makhani" => 4, "Coffee" => 2 }
restaurant_menu.each do |item, price|
  restaurant_menu[item] = price + (price * 0.1)
end

至于为什么后者比@Mike Manfrin所解释的更好的方式呢？

我使用此代码得到了意外的返回值：

str = ''; 'abc'.chars.map {|c| str<<c}

预期输出：

["a", "ab", "abc"]

实际输出：

["abc", "abc", "abc"]

添加puts(str)用于调试：

str = ''; 'abc'.chars.map {|c| puts(str); str<<c}

a
ab
=> ["abc", "abc", "abc"]

为什么上面的代码没有返回预期的输出？谢谢。

当我尝试从数组中弹出一个元素时,它会弹出.当我在弹出之前将该数组分配给另一个变量然后如果我弹出时,弹出操作会影响两个数组.

例如:

 ruby-1.9.2-p290 :339 > a= [1,2,3]
     => [1, 2, 3] 
    ruby-1.9.2-p290 :340 > b = a
     => [1, 2, 3] 
    ruby-1.9.2-p290 :341 > a
     => [1, 2, 3] 
    ruby-1.9.2-p290 :342 > b
     => [1, 2, 3] 
    ruby-1.9.2-p290 :343 > a.pop
     => 3 
    ruby-1.9.2-p290 :344 > a
     => [1, 2] 
    ruby-1.9.2-p290 :345 > b
     => [1, 2] #WHY?
    ruby-1.9.2-p290 :346 > x = [1,2,3]
     => [1, 2, 3] 
    ruby-1.9.2-p290 :347 > y = x
     => [1, 2, 3] 
    ruby-1.9.2-p290 :348 …

我显然不太了解传递值.

irb(main):001:0> a="UPPER CASE STRING"
=> "UPPER CASE STRING"
irb(main):002:0> b=a
=> "UPPER CASE STRING"
irb(main):003:0> a
=> "UPPER CASE STRING"
irb(main):004:0> b
=> "UPPER CASE STRING"
irb(main):005:0> b.downcase
=> "upper case string"
irb(main):006:0> a
=> "UPPER CASE STRING"
irb(main):007:0> b.downcase!
=> "upper case string"
irb(main):008:0> b
=> "upper case string"
irb(main):009:0> a
=> "upper case string"
irb(main):010:0>

为什么是小写,如果通过值然后不是一个副本？

这是因为a是String对象的(引用|指针),因此b是指针的副本而不是对象吗？

根据这个问题,红宝石是严格按价值传递的.我遇到了一个案例,其中包括修改哈希,如下所示:

h = {"one" => ["un", "ein"], "two"=> ["deux", "zwei"]}
h.each { |k,v| v << "overriden"}

导致:

{"one"=>["un", "ein", "overriden"], "two"=>["deux", "zwei", "overriden"]}

但是,以下行为有所不同:

h = {"one" => "un", "two"=> "deux"}
h.each { |k,v| v = "overriden"}

导致:

{"one"=>"un", "two"=>"deux"}

我怎么能预测到这个？

我在下面有一个简单的代码

    def testarray
      arr_tree = [1,2,3,4,5]
      (1..3).each do |index|
        abcde(arr_tree)
        puts arr_tree[0]
      end
    end

    def abcde(node_tree)
      node_tree[0] += 100
    end

所以在 testarray 函数中，我有一个arr_tree传递给函数的数组abcde。我在abcde函数内部更改数组的值并在内部打印数组testarray我在这里得到更改的值。所以输出是

101
201
301

但我期待

1
1
1

请解释为什么结果是这样？另外我怎样才能达到我的预期结果？

问题是Ruby通过引用或值传递？吸引了很多有用的答案,也有很多不同意见.到目前为止,我在任何答案中都没有看到的是解释以下内容的任何内容:

ruby -e "def f(x) x=7 end; a=3; f(a); print a" 打印3.

ruby -e "def f(x) x[0]=7 end; a=[3]; f(a); print a[0]" 打印7.

根据经验,这看起来像标量对象和更复杂的对象(如散列和数组)之间存在某种区别,标量通过引用传递给值和复杂对象.这类似于C的语义.

我的理解是ruby中的所有东西都是一个对象,而早期问题的答案都没有提到标量和复杂类型之间的区别.那么我的描述是错误的,如果是,那么更好的描述是什么？

我只是想确保我了解这里发生了什么。我知道 += 是重新分配，所以也许这就是为什么 str 没有被修改但为什么upcase!这里也不修改 str ？

def change_me(str)
  str += "?"
  str.upcase!
end

question = "whats your name"
change_me(question)

puts question

'whats your name'
=> nil

我无法理解这种红宝石行为,代码更好地解释了我的意思:

class DoNotUnderstand
    def initialize
        @tiny_array = [3,4]
        test
    end

    def messing(ary)
        return [ary[0]+=700, ary[1]+=999]
    end

    def test
        puts @tiny_array.join(",")  # before => 3,4
        messing(@tiny_array)
        puts @tiny_array.join(",")  # after  => 703,1003
    end
end

question = DoNotUnderstand.new

@tiny_array是的[3,4],[703,1003]
如果我不使用课程,那就会发生:

@tiny = [1,2]
def messing(ary)
    return [ary[0]+693,ary[1]+999]
end

puts @tiny.join(",")                        # before  => 1,2
messing(@tiny)
puts @tiny.join(",")                        # after   => 1,2

数组只是[1,2]
为什么？