blocks|key|1015107|text|Ruby将值传递给函数，而这些值是对对象的引用。在您的函数中，您将s重新分配到另一个值，在本例中是对1的引用。它不修改原始对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1015108|您的方法不是更改传入的对象，而是更改s引用的内容。|1015109|entityMap^0|X|1|1E|1|0|I|1|0^^$0|@$1|2|3|4|5|6|7|J|8|@$9|K|A|L|B|C]|$9|M|A|N|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|H|3|-4|5|6|7|R|8|@]|D|@]|E|$]]]|I|$]]

Ruby passes values around to functions, and these values are references to objects. In your function you are reassigning <code>s</code> to another value, in this case a reference to <code>1</code>. It does not modify the original object.

Your method isn't changing the object passed in, you're changing what <code>s</code> refers to.

blocks|key|1015113|text|因为$string和s都是对同一个对象的引用，所以字符串"+string“。但是，当您将s分配给1时，您不会更改对象"String"，而是让它引用一个新对象。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1015114|entityMap^0|2|7|A|1|18|1|1C|1|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]|$9|M|A|N|B|C]|$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|G|$]]

Because both <code>$string</code> and <code>s</code> are references to the same object, the string "String". However, when you assign <code>s</code> to <code>1</code>, you don't change the object "String", you make it reference a new object.

blocks|key|3053217|text|Ruby的工作方式是按值传递和通过引用传递的组合。实际上，Ruby在引用中使用pass值。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3053218|您可以在以下线程中阅读更多内容：|3053219|3053220|Pass+by+reference+or+pass+by+value|unordered-list-item|offset|length|3053221|Pass+by+reference?|3053222|3053223|一些值得注意的引语是：|3053224|3053225|绝对正确:+Ruby带有引用。|blockquote|3053226|3053227|：004:0>+def+foo(x)+x=+10+=>+nil+irb(main):005:0>+def+bar；x=+20；foo(x)；x+end+=>+nil+irb(main):006:0>+bar+=>+20+irb(main):007:0>|3053228|在调用作用域中，没有任何标准的方法(例如，除了涉及eval和元编程魔术)使变量指向另一个对象。而且，顺便说一句，这与变量引用的对象无关。Ruby中的直接对象与其他对象无缝集成(例如，与Java中的POD不同)，从Ruby语言的角度来看，您不会看到任何不同(除了性能之外)。这就是为什么Ruby如此优雅的原因之一。|3053229|3053230|和|3053231|3053232|向方法传递参数时，传递指向引用的变量。在某种程度上，它是由值传递和引用传递的组合。我的意思是，将变量的值传递给方法，但是变量的值始终是对对象的引用。|3053233|3053234|以下两者之间的区别：|3053235|my_method(+A)+a.gsub!(+/foo/，'ruby‘)结束str+=+'foo是可怕的’my_method(+str+)+#=>+'ruby是可怕的‘str+#=>+'ruby是可怕的’|3053236|以及：|3053237|def+your_method(+A)a=+a.gsub(+/foo/，'ruby‘)结束str+=+'foo是可怕的’my_method(+str+)+#=>+'ruby‘str+#=>+'foo是可怕的’|3053238|在#my_method中，您正在调用#gsub！它改变了已到位的对象(a)。因为'str‘变量(在方法范围之外)和'a’变量(在方法范围内)都有一个“值”，即对同一个对象的引用，因此在调用方法之后，对该对象的更改将反映在'str‘变量中。在#your_method中，调用#gsub不修改原始对象。相反，它创建一个包含修改的字符串的新实例。当您将该对象赋值给“a”变量时，您将“a”的值更改为对该新字符串实例的引用。但是，'str‘的值仍然包含对原始(未修改的)字符串对象的引用。|3053239|3053240|方法是否更改引用或引用对象取决于类类型和方法实现。|3053241|string+=+"hello"

def+changer(str)
++str+=+"hi"
end

changer(string)
puts+string
#+=>+"hello"|code-block|syntax|javascript|3053242|string不会更改，因为字符串上的赋值替换引用，而不是引用值。如果你想修改字符串的位置，你需要使用String#replace。|style|CODE|3053243|string+=+"hello"

def+changer(str)
++str.replace+"hi"
end

changer(string)
puts+string
#+=>+"hi"|3053244|String是一种常见的情况，大多数操作都在克隆上工作，而不是在self实例上工作。出于这个原因，有几个方法有一个执行相同操作的bang版本。|3053245|str1+=+"hello"
str2+=+"hello"

str1.gsub("h",+"H")
str2.gsub!("h",+"H")

puts+str1
#+=>+"hello"
puts+str2
#+=>+"Hello"|3053246|最后，要回答原来的问题，您不能更改字符串。您只能给它分配一个新值，或者将字符串包装到一个不同的可变对象中，并替换内部引用。|3053247|$wrapper+=+Struct.new(:string).new
$wrapper.string+=+"String"

def+changer(w)
++w.string+=+1
end

changer($wrapper)

puts+$wrapper.string
#+=>+1|3053248|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-forum.com/topic/41160|1|http://blade.nagaokaut.ac.jp/cgi-bin/vframe.rb/ruby/ruby-talk/236333?236301-237226^0|0|0|0|0|Y|0|0|0|I|1|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|6|1E|E|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|2A|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|2B|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|2C|8|@]|9|@]|A|$]]|$1|E|3|F|5|G|7|2D|8|@]|9|@$H|2E|I|2F|1|2G]]|A|$]]|$1|J|3|K|5|G|7|2H|8|@]|9|@$H|2I|I|2J|1|2K]]|A|$]]|$1|L|3|-4|5|6|7|2L|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|2M|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|2N|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|2O|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|2P|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|2Q|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|2R|8|@]|9|@]|A|$]]|$1|X|3|-4|5|6|7|2S|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|2T|8|@]|9|@]|A|$]]|$1|10|3|-4|5|6|7|2U|8|@]|9|@]|A|$]]|$1|11|3|12|5|R|7|2V|8|@]|9|@]|A|$]]|$1|13|3|-4|5|6|7|2W|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|2X|8|@]|9|@]|A|$]]|$1|16|3|17|5|6|7|2Y|8|@]|9|@]|A|$]]|$1|18|3|19|5|6|7|2Z|8|@]|9|@]|A|$]]|$1|1A|3|1B|5|6|7|30|8|@]|9|@]|A|$]]|$1|1C|3|1D|5|6|7|31|8|@]|9|@]|A|$]]|$1|1E|3|-4|5|6|7|32|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|33|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|1J|7|34|8|@]|9|@]|A|$1K|1L]]|$1|1M|3|1N|5|6|7|35|8|@$H|36|I|37|1O|1P]|$H|38|I|39|1O|1P]]|9|@]|A|$]]|$1|1Q|3|1R|5|1J|7|3A|8|@]|9|@]|A|$1K|1L]]|$1|1S|3|1T|5|6|7|3B|8|@]|9|@]|A|$]]|$1|1U|3|1V|5|1J|7|3C|8|@]|9|@]|A|$1K|1L]]|$1|1W|3|1X|5|6|7|3D|8|@]|9|@]|A|$]]|$1|1Y|3|1Z|5|1J|7|3E|8|@]|9|@]|A|$1K|1L]]|$1|20|3|-4|5|6|7|3F|8|@]|9|@]|A|$]]]|21|$22|$5|23|24|25|A|$26|27]]|28|$5|23|24|25|A|$26|29]]]]

The way Ruby works is a combination of pass by value and pass by reference. In fact, Ruby uses pass by value with references.

You can read more in the following threads:

<ul>
<li><a href="http://www.ruby-forum.com/topic/41160">Pass by reference or pass by value</a></li>
<li><a href="http://blade.nagaokaut.ac.jp/cgi-bin/vframe.rb/ruby/ruby-talk/236333?236301-237226">Pass by reference?</a></li>
</ul>

Some notable quotes:

<blockquote>
 Absolutely right: Ruby uses pass by value - with references.

<pre><code>irb(main):004:0&gt; def foo(x) x = 10 end
=&gt; nil
irb(main):005:0&gt; def bar; x = 20; foo(x); x end
=&gt; nil
irb(main):006:0&gt; bar
=&gt; 20
irb(main):007:0&gt;
</code></pre>
 
 There is no standard way (i.e. other than involving eval and 
 metaprogramming magic) to make a variable in a calling scope point to 
 another object. And, btw, this is independent of the object that the 
 variable refers to. Immediate objects in Ruby seamlessly integrate with 
 the rest (different like POD's in Java for example) and from a Ruby 
 language perspective you don't see any difference (other than 
 performance maybe). This is one of the reasons why Ruby is so elegant.
</blockquote>

and 

<blockquote>
 When you pass an argument into a method, you are passing a
 variable that points to a reference. In a way, it's a combination of
 pass by value and pass by reference. What I mean is, you pass the
 value of the variable in to the method, however the value of the
 variable is always a reference to an object.
 
 The difference between:

<pre><code>def my_method( a )
 a.gsub!( /foo/, 'ruby' )
end

str = 'foo is awesome'
my_method( str ) #=&gt; 'ruby is awesome'
str #=&gt; 'ruby is awesome'
</code></pre>
 
 and:

<pre><code>def your_method( a )
 a = a.gsub( /foo/, 'ruby' )
end

str = 'foo is awesome'
my_method( str ) #=&gt; 'ruby is awesome'
str #=&gt; 'foo is awesome'
</code></pre>
 
 is that in #my_method, you are calling #gsub! which changes the object
 (a) in place. Since the 'str' variable (outside the method scope) and
 the 'a' variable (inside the method scope) both have a "value" that is
 a reference to the same object, the change to that object is reflected
 in the 'str' variable after the method is called. In #your_method, you
 call #gsub which does not modify the original object. Instead it
 creates a new instance of String that contains the modifications. When
 you assign that object to the 'a' variable, you are changing the value
 of 'a' to be a reference to that new String instance. However, the
 value of 'str' still contains a reference to the original (unmodified)
 string object.
</blockquote>

Whether a method changes the reference or the referenced object depends on the class type and method implementation.

<pre><code>string = "hello"

def changer(str)
 str = "hi"
end

changer(string)
puts string
# =&gt; "hello"
</code></pre>

<code>string</code> is not changed because the assignment on strings replaces the reference, not the referenced value.
I you want to modify the string in place, you need to use <code>String#replace</code>.

<pre><code>string = "hello"

def changer(str)
 str.replace "hi"
end

changer(string)
puts string
# =&gt; "hi"
</code></pre>

String is a common case where the most part of operations works on clones, not on the self instance.
For this reason, several methods have a bang version that executes the same operation in place.

<pre><code>str1 = "hello"
str2 = "hello"

str1.gsub("h", "H")
str2.gsub!("h", "H")

puts str1
# =&gt; "hello"
puts str2
# =&gt; "Hello"
</code></pre>

Finally, to answer your original question, you cannot change a String. You can only assign a new value to it or wrap the string into a different mutable object and replace the internal reference.

<pre><code>$wrapper = Struct.new(:string).new
$wrapper.string = "String"

def changer(w)
 w.string = 1
end

changer($wrapper)

puts $wrapper.string
# =&gt; 1
</code></pre>

blocks|key|3053298|text|赋值不将值绑定到对象，而是将对象引用绑定到标识符。参数传递的工作方式也是一样的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3053299|当您输入函数的主体时，世界如下所示：|3053300|+%2B---%2B++++++++++++++++++%2B----------%2B
+%7C+s+%7C----------------->%7C+"String"+%7C
+%2B---%2B++++++++++++++++++%2B----------%2B
++++++++++++++++++++++++++++++%5E
+%2B-------%2B++++++++++++++++++++%7C
+%7C$string%7C--------------------%2B
+%2B-------%2B|code-block|syntax|javascript|3053301|密码|3053302|+s+=+1|3053303|让世界看起来像|3053304|+%2B---%2B+++++++%2B---%2B++++++%2B----------%2B
+%7C+s+%7C------>%7C+1+%7C++++++%7C+"String"+%7C
+%2B---%2B+++++++%2B---%2B++++++%2B----------%2B
++++++++++++++++++++++++++++++%5E
+%2B-------%2B++++++++++++++++++++%7C
+%7C$string%7C--------------------%2B
+%2B-------%2B|3053305|赋值语法操纵变量，而不是对象。|3053306|与许多类似的语言(Java、C#、Python)一样，ruby是按值传递的，其中的值通常是引用的。|3053307|若要操作string对象，可以在字符串上使用方法，例如s.upcase!。这类事情将反映在方法之外，因为它操作对象本身。|offset|length|style|CODE|3053308|entityMap^0|0|0|0|0|0|0|0|0|0|R|9|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|13|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|14|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|15|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|16|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|18|8|@]|9|@]|A|$G|H]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|6|7|1A|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1B|8|@$W|1C|X|1D|Y|Z]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1E|8|@]|9|@]|A|$]]]|11|$]]

Assignment does not bind values to objects, it binds object references to identifiers. Argument passing works the same way.

When you enter the body of the function, the world looks like this:

<pre><code> +---+ +----------+
 | s |-----------------&gt;| "String" |
 +---+ +----------+
 ^
 +-------+ |
 |$string|--------------------+
 +-------+
</code></pre>

The code

<pre><code> s = 1
</code></pre>

makes the world look like

<pre><code> +---+ +---+ +----------+
 | s |------&gt;| 1 | | "String" |
 +---+ +---+ +----------+
 ^
 +-------+ |
 |$string|--------------------+
 +-------+
</code></pre>

The assignment syntax manipulates variables, not objects.

Like many similar languages (Java, C#, Python) ruby is pass-by-value, where the values are most often references.

To manipulate the string object, you can use a method on the string, such as <code>s.upcase!</code>. This sort of thing will be reflected outside of the method as it manipulate the object itself.

blocks|key|3038000|text|实际上，大多数托管编程语言如java、c#.所有的都不是通过引用..。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3038001|他们都是通过价值传递引用..。这意味着他们又提出了另一个指向同一对象的引用。用新值分配它不会改变原始引用的值.指的是..。|3038002|此外，字符串在大多数语言中是不可变的，这意味着在创建后不能更改值。他们必须被重新创造为新的..。所以你不会看到真正的字符串有任何变化..。|3038003|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

Actually, most managed programming languages like java , c#... almsot all do not pass by reference...

They all pass the reference by value ... that means they make another reference that point to the same object ... assigning it with a new value won't change the value of the original reference ... just what s points to ... 

Besides, strings are immutable in most langs, meaning that you cannot change the value after being created.. they have to be recreated as new ones... so you will never see any change in the actual string ...

Considering that in the Ruby programming language everything is said to be an Object, I safely assumed that passing arguments to methods are done by reference. However this little example below puzzles me:

<pre><code>$string = "String"

def changer(s)
 s = 1
end

changer($string)

puts $string.class
String
 =&gt; nil
</code></pre>

As you can see the original Object wasn't modified, I wish to know why, and also, how could I accomplish the desired behavior ie. Getting the method to actually change the object referenced by its argument.

Why doesn't this work if in Ruby everything is an Object?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

考虑到在Ruby编程语言中，所有的东西都被认为是一个对象，我认为将参数传递给方法是通过引用来完成的。然而，下面这个小小的例子让我感到困惑：$string = "String"def changer(s)  s = 1endchanger($string)puts $string.classString => nil正如...

问如果在Ruby中，这一切都是一个对象，为什么这不起作用呢？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如果在Ruby中，这一切都是一个对象，为什么这不起作用呢？EN