Rubyは参照渡しですか、値渡しですか？

@user.update_languages(params[:language][:language1], 
                       params[:language][:language2], 
                       params[:language][:language3])
lang_errors = @user.errors
logger.debug "--------------------LANG_ERRORS----------101-------------" 
                + lang_errors.full_messages.inspect

if params[:user]
  @user.state = params[:user][:state]
  success = success & @user.save
end
logger.debug "--------------------LANG_ERRORS-------------102----------" 
                + lang_errors.full_messages.inspect

if lang_errors.full_messages.empty?

@userオブジェクトはメソッドのlang_errors変数にエラーを追加しますupdate_lanugages。@userオブジェクトの保存を実行すると、lang_errors変数に最初に格納されたエラーが失われます。

私がやろうとしていることは、もっとハックすることです（それは機能していないようです）。なぜ変数値が洗い流されるのか理解したいのですが。参照渡しを理解しているので、値が洗い流されることなくその変数に保持される方法を知りたいのですが。

従来の用語では、Rubyは厳密に値渡しです。しかし、それは本当にあなたがここで求めていることではありません。

Rubyには純粋な非参照値の概念がないため、メソッドに値を渡すことはできません。変数は常にオブジェクトへの参照です。下から変更されないオブジェクトを取得するには、渡されたオブジェクトを複製または複製する必要があります。これにより、他の誰も参照していないオブジェクトを取得できます。（ただし、これは完全なものではありません。両方の標準的なクローン作成方法は浅いコピーを行うため、クローンのインスタンス変数は、元のオブジェクトが行ったのと同じオブジェクトをまだ指します。ivarsによって参照されるオブジェクトが変化すると、同じオブジェクトを参照しているため、まだコピーに表示されます。）

他の回答者はすべて正解ですが、友人から説明を求められました。具体的には、Rubyが変数を処理する方法です。そのため、私が書いた簡単な写真や説明を共有したいと思いました（長さの謝罪）そしておそらくいくつかの単純化）：

Q1：新しい変数strを値に割り当てるとどうなります'foo'か？

str = 'foo'
str.object_id # => 2000

A：という名前のラベルstrが作成されます'foo'。このオブジェクトは、このRubyインタープリターの状態では、たまたまメモリロケーションにあり2000ます。

Q2：を使用して既存の変数strを新しいオブジェクトに割り当てるとどうなります=か？

str = 'bar'.tap{|b| puts "bar: #{b.object_id}"} # bar: 2002
str.object_id # => 2002

A：ラベルstrは別のオブジェクトをポイントしています。

Q3：新しい変数=をに割り当てるとどうなりますstrか？

str2 = str
str2.object_id # => 2002

A：と呼ばれる新しいラベルがstr2作成されることで、ポイント同じオブジェクトとしてstr。

Q4：オブジェクトが参照することにより、どうなりますstrとstr2変更されますか？

str2.replace 'baz'
str2 # => 'baz'
str  # => 'baz'
str.object_id # => 2002
str2.object_id # => 2002

A：どちらのラベルも同じオブジェクトを指していますが、そのオブジェクト自体が変更されています（内容が別のものに変更されています）。

これは元の質問とどのように関連していますか？

これは基本的に、Q3 / Q4で発生することと同じです。メソッドは、str2それに渡される変数/ラベル（）の独自のプライベートコピーを取得します（str）。ラベルがstr 指すオブジェクトを変更することはできませんが、両方が参照するオブジェクトのコンテンツを変更することはできます。

str = 'foo'

def mutate(str2)
  puts "str2: #{str2.object_id}"
  str2.replace 'bar'
  str2 = 'baz'
  puts "str2: #{str2.object_id}"
end

str.object_id # => 2004
mutate(str) # str2: 2004, str2: 2006
str # => "bar"
str.object_id # => 2004

Rubyは「オブジェクト参照による受け渡し」を使用します

（Pythonの用語を使用しています。）

Rubyが「値による受け渡し」または「参照による受け渡し」を使用していると言うのは、実際に役立つほど十分に説明的ではありません。最近、ほとんどの人が知っているように、その用語（ "値"と "参照"）はC ++に由来しています。

C ++では、「値渡し」とは、関数が変数のコピーを取得し、そのコピーを変更しても元の変数は変更されないことを意味します。これはオブジェクトにも当てはまります。オブジェクト変数を値で渡すと、オブジェクト全体（そのメンバーのすべてを含む）がコピーされ、メンバーを変更しても、元のオブジェクトのメンバーは変更されません。（値によってポインターを渡すかどうかは異なりますが、Rubyにはとにかくポインターがありません。

class A {
  public:
    int x;
};

void inc(A arg) {
  arg.x++;
  printf("in inc: %d\n", arg.x); // => 6
}

void inc(A* arg) {
  arg->x++;
  printf("in inc: %d\n", arg->x); // => 1
}

int main() {
  A a;
  a.x = 5;
  inc(a);
  printf("in main: %d\n", a.x); // => 5

  A* b = new A;
  b->x = 0;
  inc(b);
  printf("in main: %d\n", b->x); // => 1

  return 0;
}

出力：

in inc: 6
in main: 5
in inc: 1
in main: 1

C ++では、「参照渡し」は、関数が元の変数にアクセスすることを意味します。まったく新しいリテラル整数を割り当てることができ、元の変数もその値になります。

void replace(A &arg) {
  A newA;
  newA.x = 10;
  arg = newA;
  printf("in replace: %d\n", arg.x);
}

int main() {
  A a;
  a.x = 5;
  replace(a);
  printf("in main: %d\n", a.x);

  return 0;
}

出力：

in replace: 10
in main: 10

Rubyは、引数がオブジェクトでない場合、値渡し（C ++の意味で）を使用します。しかし、Rubyではすべてがオブジェクトであるため、RubyのC ++の意味での値渡しは実際にはありません。

Rubyでは、「オブジェクト参照による受け渡し」（Pythonの用語を使用するため）が使用されます。

• 関数内では、オブジェクトの任意のメンバーに新しい値を割り当てることができ、これらの変更は関数が戻った後も保持されます。*
• 関数内で、まったく新しいオブジェクトを変数に割り当てると、変数は古いオブジェクトの参照を停止します。ただし、関数が戻った後も、元の変数は古いオブジェクトを参照し続けます。

したがって、RubyはC ++の意味で「参照渡し」を使用しません。その場合、関数内の変数に新しいオブジェクトを割り当てると、関数が戻った後に古いオブジェクトが忘れられてしまいます。

class A
  attr_accessor :x
end

def inc(arg)
  arg.x += 1
  puts arg.x
end

def replace(arg)
  arg = A.new
  arg.x = 3
  puts arg.x
end

a = A.new
a.x = 1
puts a.x  # 1

inc a     # 2
puts a.x  # 2

replace a # 3
puts a.x  # 2

puts ''

def inc_var(arg)
  arg += 1
  puts arg
end

b = 1     # Even integers are objects in Ruby
puts b    # 1
inc_var b # 2
puts b    # 1

出力：

1
2
2
3
2

1
2
1

*これが、Rubyで関数内のオブジェクトを変更したいが、関数が戻ったときにそれらの変更を忘れたい場合は、コピーに一時的な変更を加える前に、オブジェクトのコピーを明示的に作成する必要がある理由です。

Rubyは参照渡しですか、値渡しですか？

Rubyは値渡しです。常に。例外なく。いいえ。お尻ない。

その事実を示す簡単なプログラムを次に示します。

def foo(bar)
  bar = 'reference'
end

baz = 'value'

foo(baz)

puts "Ruby is pass-by-#{baz}"
# Ruby is pass-by-value

Rubyは厳密な意味で値渡しですが、値は参照です。

これは、「値による参照渡し」と呼ぶことができます。この記事には、私が読んだ最良の説明があります。http：//robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/

値による参照渡しは、次のように簡単に説明できます。

関数は、呼び出し元が使用するのと同じメモリ内のオブジェクトへの参照を受け取ります（アクセスします）。ただし、呼び出し元がこのオブジェクトを格納しているボックスは受け取りません。値渡しの場合と同様に、関数は独自のボックスを提供し、それ自体に新しい変数を作成します。

結果の動作は、実際には、参照渡しと値渡しの従来の定義の組み合わせです。

すでにいくつかの素晴らしい回答がありますが、私はこの件に関する2つの当局の定義を投稿したいと思いますが、誰かが当局のマッツ（Rubyの作成者）とデビッドフラナガンが優れたO'Reillyの本で何を意味していたかを説明してくれることを願っています。Rubyプログラミング言語。

[3.8.1から：オブジェクト参照]

Rubyのメソッドにオブジェクトを渡す場合、メソッドに渡されるのはオブジェクト参照です。これはオブジェクト自体ではなく、オブジェクトへの参照への参照でもありません。別の言い方をすると、メソッドの引数はreferenceではなく値で渡されますが、渡される値はオブジェクト参照であるということです。

オブジェクト参照はメソッドに渡されるため、メソッドはそれらの参照を使用して、基になるオブジェクトを変更できます。これらの変更は、メソッドが戻るときに表示されます。

これは、最後の段落、特に最後の文まで、すべて私にとって理にかなっています。これはせいぜい誤解を招きやすく、さらに悪いことに交絡です。何らかの方法で、値渡しの参照を変更すると、基になるオブジェクトをどのように変更できるでしょうか。

Rubyは参照渡しですか、値渡しですか？

Rubyは参照渡しです。常に。例外なく。いいえ。お尻ない。

その事実を示す簡単なプログラムを次に示します。

def foo(bar)
  bar.object_id
end

baz = 'value'

puts "#{baz.object_id} Ruby is pass-by-reference #{foo(baz)} because object_id's (memory addresses) are always the same ;)"

=> 2279146940 object_id（メモリアドレス）は常に同じなので、Rubyは参照渡し2279146940です;）

def bar(babar)
  babar.replace("reference")
end

bar(baz)

puts "some people don't realize it's reference because local assignment can take precedence, but it's clearly pass-by-#{baz}"

=>ローカル割り当てが優先される可能性があるため、参照であることに気付かない人もいますが、それは明らかに参照渡しです

パラメータは、元の参照のコピーです。したがって、値は変更できますが、元の参照は変更できません。

これを試して： -

1.object_id
#=> 3

2.object_id
#=> 5

a = 1
#=> 1
a.object_id
#=> 3

b = 2
#=> 2
b.object_id
#=> 5

識別子aには値オブジェクト1のobject_id 3が含まれ、識別子bには値オブジェクト2のobject_id 5が含まれます。

今これを行います：-

a.object_id = 5
#=> error

a = b
#value(object_id) at b copies itself as value(object_id) at a. value object 2 has object_id 5
#=> 2

a.object_id 
#=> 5

これで、aとbの両方に、値オブジェクト2を参照する同じobject_id 5が含まれます。したがって、Ruby変数には、値オブジェクトを参照するためのobject_idsが含まれます。

以下を実行してもエラーが発生します。--

c
#=> error

しかし、これを実行してもエラーは発生しません：-

5.object_id
#=> 11

c = 5
#=> value object 5 provides return type for variable c and saves 5.object_id i.e. 11 at c
#=> 5
c.object_id
#=> 11 

a = c.object_id
#=> object_id of c as a value object changes value at a
#=> 11
11.object_id
#=> 23
a.object_id == 11.object_id
#=> true

a
#=> Value at a
#=> 11

ここで、識別子aは、オブジェクトIDが23の値オブジェクト11を返します。つまり、object_id 23は識別子aにあります。次に、メソッドを使用して例を示します。

def foo(arg)
  p arg
  p arg.object_id
end
#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23

fooのargには、xの戻り値が割り当てられます。引数が値11によって渡され、値11自体がオブジェクトであることは、一意のオブジェクトID 23を持っていることを明確に示しています。

これも見てください：-

def foo(arg)
  p arg
  p arg.object_id
  arg = 12
  p arg
  p arg.object_id
end

#=> nil
11.object_id
#=> 23
x = 11
#=> 11
x.object_id
#=> 23
foo(x)
#=> 11
#=> 23
#=> 12
#=> 25
x
#=> 11
x.object_id
#=> 23

ここで、識別子argには最初に参照するためのobject_id 23が含まれ、値object 12による内部割り当ての後、object_id 25が含まれます。ただし、メソッドの呼び出しで使用される識別子xによって参照される値は変更されません。

したがって、Rubyは値渡しであり、Ruby変数には値は含まれませんが、値オブジェクトへの参照が含まれます。

Rubyが解釈されます。変数はデータへの参照ですが、データ自体ではありません。これにより、異なるタイプのデータに同じ変数を使用することが容易になります。

lhs = rhsを割り当てると、データではなくrhsの参照がコピーされます。これは、割り当てがrhsからlhsへのデータコピーを行うCなどの他の言語では異なります。

したがって、関数呼び出しの場合、渡された変数（xなど）は実際に関数のローカル変数にコピーされますが、xは参照です。次に、参照のコピーが2つあり、どちらも同じデータを参照しています。1つは呼び出し元に、もう1つは関数に含まれます。

次に、関数内の代入は、新しい参照を関数のバージョンのxにコピーします。この後、呼び出し元のバージョンのxは変更されません。それはまだ元のデータへの参照です。

対照的に、xで.replaceメソッドを使用すると、rubyがデータをコピーします。新しい割り当ての前にreplaceが使用されている場合、実際に呼び出し元はそのバージョンのデータ変更も確認できます。

同様に、渡された変数に対して元の参照が完全である限り、インスタンス変数は呼び出し元に表示されるものと同じになります。オブジェクトのフレームワーク内では、インスタンス変数は常に最新の参照値を持ちます。これらは、呼び出し元から提供されたものでも、クラスが渡された関数に設定されたものでもあります。

「値による呼び出し」または「参照による呼び出し」は、「=」を混同しているため、ここでは混乱しています。コンパイルされた言語では、「=」はデータのコピーです。この解釈された言語では、 '='は参照コピーです。この例では、渡された参照に続いて '='を介した参照コピーがあり、渡された元の参照を上書きし、人々は '='がデータコピーであるかのようにそれについて話します。

定義との一貫性を保つには、データコピーであるため、「。replace」を使用する必要があります。「.replace」の観点から、これは確かに参照渡しであることがわかります。さらに、デバッガーをウォークスルーすると、変数が参照であるため、参照が渡されていることがわかります。

ただし、参照のフレームとして「=」を保持する必要がある場合は、実際に渡されるデータは割り当てまで表示され、割り当て後は呼び出し元のデータが変更されないまま表示されません。動作レベルでは、渡された値を複合であると見なさない限り、これは値渡しです。単一の割り当てで他の部分を変更しながらその一部を保持できないため（その割り当てとして）参照を変更すると、元のものが範囲外になります）。オブジェクト内のインスタンス変数はすべての変数と同様に参照になるので、いぼも存在します。したがって、「値による参照」の受け渡しについて話し合う必要があり、関連する場所を使用する必要があります。

元の値を変更するために「replace」メソッドを使用する必要がないことにも注意してください。ハッシュにいずれかのハッシュ値を割り当てると、元の値が変更されます。

def my_foo(a_hash)
  a_hash["test"]="reference"
end;

hash = {"test"=>"value"}
my_foo(hash)
puts "Ruby is pass-by-#{hash["test"]}"

Two references refer to same object as long as there is no reassignment. 

同じオブジェクト内の更新は、同じメモリ内にあるため、新しいメモリへの参照を作成しません。ここにいくつかの例があります：

    a = "first string"
    b = a



    b.upcase! 
    => FIRST STRING
    a
    => FIRST STRING

    b = "second string"


a
    => FIRST STRING
    hash = {first_sub_hash: {first_key: "first_value"}}
first_sub_hash = hash[:first_sub_hash]
first_sub_hash[:second_key] = "second_value"

    hash
    => {first_sub_hash: {first_key: "first_value", second_key: "second_value"}}

    def change(first_sub_hash)
    first_sub_hash[:third_key] = "third_value"
    end

    change(first_sub_hash)

    hash
    =>  {first_sub_hash: {first_key: "first_value", second_key: "second_value", third_key: "third_value"}}

はい、でも ....

Rubyはオブジェクトへの参照を渡します。rubyのすべてがオブジェクトであるため、参照渡しであると言えます。

価値のあるものだと主張するここの投稿には同意しません。

ただし、実際には、Rubyのほとんどの操作が「すぐに使える」ため、動作が「非表示」になります。たとえば、文字列操作では、オブジェクトのコピーが作成されます。

> astringobject = "lowercase"

> bstringobject = astringobject.upcase
> # bstringobject is a new object created by String.upcase

> puts astringobject
lowercase

> puts bstringobject
LOWERCASE

つまり、ほとんどの場合、元のオブジェクトは変更されずに残され、ルビーは「値渡し」のように見えます。

もちろん、独自のクラスを設計する場合、この動作の詳細を理解することは、機能的な動作、メモリ効率、パフォーマンスの両方にとって重要です。