Est Ruby passer par référence ou par valeur?

@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 objet ajoute les erreurs à la lang_errors variable dans le update_lanugages méthode.
lorsque j'effectue une sauvegarde sur le @user objet que je perds les erreurs qui ont été initialement stockées dans le lang_errors variable.

Si ce que je cherche à faire serait de plus d'un hack (ce qui ne semble pas fonctionner). J'aimerais comprendre pourquoi les valeurs de la variable sont délavées. Je comprends passage par référence, donc je voudrais savoir comment la valeur peut être tenu dans cette variable sans être lavé.

Je remarque aussi que je suis en mesure de conserver cette valeur dans un objet cloné
Vous devriez regarder Abe Voelker réponse. Mais après avoir exécuté autour du bloc sur ce, voici comment je dirais ça. lorsque vous transmettez un objet Foo à une procédure, une copie de la référence à l'objet est passé, un bar, un Passage par valeur. vous ne pouvez pas modifier l'objet qui les Foo points, mais vous pouvez modifier le contenu de l'objet vers lequel il pointe. Donc, si vous passez un tableau, le contenu du tableau peut être modifié, mais vous ne pouvez pas modifier ce tableau est d'être référencé. agréable d'être en mesure d'utiliser les méthodes de Foo sans avoir à vous soucier de gâcher autres dépendances sur Foo.

InformationsquelleAutor Sid | 2009-12-09

234

Dans la terminologie traditionnelle, Ruby est strictement passer-par-valeur. Mais ce n'est pas vraiment ce que vous demandez ici.

Ruby n'ont pas de notion de un pur, non-valeur de référence, alors vous avez certainement ne pouvez pas passer à une méthode. Les Variables sont toujours des références à des objets. Afin d'obtenir un objet qui ne change pas de sous, vous devez vous dup ou clone de l'objet que vous êtes passé, et donc de donner un objet que personne d'autre n'a une référence à l'. (Même ce n'est pas l'épreuve des balles, même si — à la fois de la norme méthodes de clonage faire une copie superficielle, de sorte que les variables d'instance de la clone pointent toujours vers les mêmes objets que les originaux n'avaient. Si les objets référencés par le ivars muter, ce sera toujours apparaître dans la copie, puisque c'est de référencement sur les mêmes objets.)
- Je vous remercie. Je ne sais pas encore si c'est une bonne fonctionnalité. Ne serait pas une méthode explicite pour passer par valeur être utile bien que tout est un objet. Une autre chose est que je trouve que la copie clonée a un autre object_id afin de ne pas rendre complètement indifférent à l'objet original, mais il peut contenir les valeurs de l'objet d'origine ou sont mes fondamentaux totalement erronée ici?
- Oui, le clone est complètement indépendant de l'objet. Comme pour le passage par valeur, ce n'est pas vraiment compatible avec pure OO, où les "valeurs" n'existe pas, sauf comme l'état de l'objet. Le plus proche que vous pourriez obtenir quelque chose comme Objective-C est bycopy modificateur de type qui raconte l'exécution pour faire une copie de derrière les coulisses. Qui ne semblent utiles.
- Ruby est passe-par-valeur. Pas de fi. Pas de mais. Pas d'exceptions. Si vous voulez savoir si Ruby (ou toute autre langue) est par référence ou passe-par-valeur, il suffit de l'essayer: def foo(bar) bar = 'reference' end; baz = 'value'; foo(baz); puts "Ruby is pass-by-#{baz}".
- Ouais, mais l'OP confusion est en fait de ne pas passer par valeur ou par référence dans le strict CS sens des mots. Ce qu'il manquait, c'est que les "valeurs" que vous êtes en passant est références. J'ai senti qu'il suffit de dire "Il est passé par valeur" serait pédant et ne l'OP un mauvais service, car ce n'est pas vraiment ce qu'il voulait dire. Mais merci pour la clarification, car il est important pour les futurs lecteurs, et je l'ai incluse. (Je suis toujours tiraillé entre, y compris plus d'infos et de ne pas créer de confusion.)
- Dans cette réponse, que signifie "ivars" signifie?
- Les variables d'Instance. Je ne pense pas qu'il y en a d'autres sens.
- Pas d'accord avec @Jorg. Le rubis est le passage par référence, il change juste la référence. Essayez plutôt ceci: def foo(bar) bar.remplacer "référence" fin; baz = 'valeur'; foo(baz); puts "le Rubis est le passe-par-#{machin}"
- Votre code n'a absolument rien que ce soit à voir avec le passage par référence ou passage par valeur. Il serait d'imprimer exactement la même chose, peu importe si Ruby est passé par référence ou par valeur. La seule chose que votre code prouve que Ruby n'est pas un point de vue purement fonctionnel de la langue, que je ne pense pas que quiconque ferait des différends de toute façon.
- Je suis en désaccord. Pas la peine de belaboring le point toutefois.
- La chose à propos de "par référence" par rapport à "passage par valeur", c'est que par référence signifie que vous êtes directement référence à l'appelant de l'espace mémoire, tels que réaffectation des de la variable de changement de la variable en l'appelant. Cela n'arrive pas. foo's variable bar est une variable indépendante qui n'a tout simplement la même valeur que l'appelant baz. Il se trouve que dans ce cas, la valeur est une référence d'objet. Mais en termes de la convention d'appel, il est passé par valeur.
- Je suis en désaccord. foo bar est une variable références de l'objet d'origine. Sinon, l'objet d'origine ne pouvait pas être affectées par l'intérieur de la méthode. C'est pourquoi je dis passer par référence. Mais je concède que cela peut dépendre de la façon dont vous le regardez.
- Je pense que c'est vraiment juste une question de définitions. Vous êtes à l'aide de la définition de "par référence" que vous avez personnellement vient, alors que Jörg est l'aide de l'ordinateur traditionnel de la science définition. Bien sûr, il n'est pas mon affaire de vous dire comment utiliser les mots — je pense juste que c'est important d'expliquer ce que le terme de normalement signifie. Dans la terminologie traditionnelle, le Rubis est passé par valeur, mais les valeurs elles-mêmes sont des références. Je comprends tout à fait pourquoi vous et les OP aime à penser de ce que le passage par référence — c'est juste pas le sens traditionnel du terme.
- Je suis d'accord que c'est une question de définitions, mais je n'ai pas le composent. Le passage par valeur signifie une copie est envoyée à la méthode, et il est clair que ce n'est pas ce qui se passe.
- cela ressemble à une copie EST envoyée à la méthode: une copie de la référence.
- En C++, "passage par valeur" signifie que la fonction reçoit une copie de la variable et toutes les modifications apportées à la copie ne pas modifier l'original. C'est vrai pour les objets trop. Si vous transmettez un objet variable par la valeur de l'objet entier (y compris l'ensemble de ses membres) d'avoir copié et toute modification aux membres de ne pas modifier ces membres sur l'objet d'origine. (C'est différent si vous passez un pointeur en valeur mais Ruby n'a pas de pointeurs de toute façon, autant que je sache.)
- En C++, "passage par référence" signifie que la fonction obtient l'accès à la variable d'origine. Il peut affecter un tout nouveau littéral entier et la variable d'origine aura alors qu'une valeur trop.
- Ruby, Python, Java, JavaScript, C#, utiliser le passage par valeur (au sens du C++) si l'argument n'est pas un objet. Si l'argument est un objet, puis "passer par la référence d'objet" (pour utiliser Python terminologie) est utilisé: l'objet l'un des membres peut y avoir de nouvelles valeurs qui leur sont confiées et de l'objet d'origine se souviendront de ces changements, mais en l'assignant à un tout nouvel objet à la variable provoque la variable d'arrêter de référencement de l'original. Il n'est donc pas "passer" au sens du C++.
- Tout en Ruby, c'est un objet, de sorte que Ruby n'est ni le passage par valeur, ni passage par référence, au moins dans le sens de ces termes sont utilisés en C++. "passage par référence d'objet" peut-être une meilleure façon de décrire ce que Ruby n'. Au final, cependant, le meilleur pari serait de ne pas mettre trop de sens sur l'une de ces conditions, et avoir une bonne compréhension du comportement qui se passe vraiment.
- @DavidWiniecki commentaire: si l'argument est un objet, puis "passer par la référence d'objet". . Pas de C# qui fait quoi @Chuck commentaire dit. C# par défaut est de passer par la valeur de la variable de référence est copiée. Cette variable est l'adresse d'un objet, non pas l'objet. Sauf si explicitement à l'aide de la ref mot-clé: RefMeBaby( ref addressOfBob );. À l'aide de ref est extrêmement rare.
InformationsquelleAutor Chuck
414

L'autre answerers sont tout à fait correct, mais un ami m'a demandé de l'expliquer à lui et de ce que cela se résume à la façon dont Ruby traite des variables, alors j'ai pensé que je voudrais partager quelques photos /explications que j'ai écrit pour lui (mes excuses pour la longueur et probablement un peu de simplification):

Q1: Qu'advient-il lorsque vous affectez une nouvelle variable str à une valeur de 'foo'?
```
str = 'foo'
str.object_id # => 2000
```
Un: Un label " str est créé que des points à l'objet 'foo', qui, pour l'état de cet interpréteur Ruby arrive à être à l'emplacement de la mémoire 2000.

Q2: Qu'advient-il lorsque vous affectez à la variable existante str à un nouvel objet à l'aide de =?
```
str = 'bar'.tap{|b| puts "bar: #{b.object_id}"} # bar: 2002
str.object_id # => 2002
```
Un: L'étiquette str maintenant pointe vers un objet différent.

Q3: Qu'advient-il lorsque vous affectez une nouvelle variable = à str?
```
str2 = str
str2.object_id # => 2002
```
Une: Un nouveau label appelé str2 est créé points à la même objet comme str.

Q4: Qu'advient-il si l'objet référencé par str et str2 est changé?
```
str2.replace 'baz'
str2 # => 'baz'
str  # => 'baz'
str.object_id # => 2002
str2.object_id # => 2002
```
Une: les Deux étiquettes toujours au même objet, mais l'objet en lui-même a muté (son contenu ont été modifiés pour être autre chose).

Comment est-ce lié à la question de départ?

C'est essentiellement le même que ce qui se passe en Q3/Q4; la méthode obtient sa propre copie privée de la variable /étiquette (str2) qui est transmis à celle-ci (str). Il ne peut pas changer l'objet sur lequel l'étiquette str points de, mais il peut changer le contenu de l'objet qu'ils ont tous deux référence à contenir autre chose:
```
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
```
- Robert Heaton aussi blogué à propos de cette dernièrement: robertheaton.com/2014/07/22/...
InformationsquelleAutor Abe Voelker
45

Est Ruby passer par référence ou par valeur?

Ruby est passé par valeur. Toujours. Pas d'exceptions. Pas de fi. Pas de mais.

Voici un programme simple qui illustre ce fait:
```
def foo(bar)
  bar = 'reference'
end

baz = 'value'

foo(baz)

puts "Ruby is pass-by-#{baz}"
# Ruby is pass-by-value
```
- l'erreur ici est que le paramètre local est réaffecté (souligné une nouvelle place dans la mémoire)" – ce n'est pas une erreur, c'est le définition de passe-par-valeur. Si Ruby ont été passé par référence, puis la réaffectation de locaux argument d'une méthode de liaison en l'appelant aurait également réaffectés la variable locale de liaison en l'appelant. Ce qui n'était pas le cas. Ergo, le Rubis est passé par valeur. Le fait que si vous modifiez une valeur mutable, les changements de valeur est complètement hors de propos, c'est juste la façon dont mutable état des œuvres. Ruby n'est pas un langage purement fonctionnel.
- Grâce à Jörg à défendre la vraie définition de "passage par valeur". C'est clairement la fonte de notre cerveau lorsque la valeur est en fait une référence, bien que le rubis passe toujours par valeur.
- C'est un sophisme. Pratique, la distinction entre "passage par valeur" et de "passage par référence" est une sémantique, et non pas syntaxique, une. Diriez-vous que C des tableaux sont passé par valeur? Bien sûr que non, même si, quand vous passez le nom d'un tableau à une fonction, vous êtes de passage à immuable du pointeur, et seules les données à laquelle le pointeur se réfère peut être muté. Clairement les types de valeur en Ruby sont passés par valeur et les types référence sont passés par référence.
- Les deux Ruby et C sont passé par valeur. Toujours. Pas d'exceptions, pas de fi n mais. La distinction entre passé par valeur et par référence est de savoir si vous transmettez la valeur des points de référence ou passer la référence. C toujours passe la valeur, jamais la référence. La valeur peut ou peut ne pas être un pointeur, mais ce, la valeur n'est pas pertinent de savoir si il est passé en premier lieu. Ruby aussi toujours passe la valeur, jamais la référence. Cette valeur est toujours un pointeur, mais encore une fois, cela n'est pas pertinent.
- Dans la réalité, certaines Ruby implémentations fait de ne pas toujours passer un pointeur en valeur. Parfois, ils passent directement la valeur par valeur. Cependant, ils ne cela pour des objets ayant une certaine immuabilité des garanties de l'Ruby Langage de Spécification, de sorte que cette optimisation ne permet pas de modifier les comportements observables du programme (comme toutes les optimisations devraient). ...
- Puisque la différence entre la réussite de l'objet directement par valeur ou en passant un pointeur vers l'objet par valeur ne peut être observé lorsque l'objet est muté, et ces objets spécifiques (Fixnums, true, false, nil, Symbols, Floats) vous ne pouvez pas être muté, il est sans danger pour le compilateur/interpréteur de passer de l'objet directement par valeur et non pas le pointeur de la valeur. Mais c'est une optimisation de la performance qui ne modifie pas le comportement observable du programme – toute Ruby programme se comporte exactement identiques si les pointeurs de Symbols et Fixnums ont été passé à la place.
- Il n'y a pas une telle créature comme un "Langage Ruby cahier des charges." Nous ne pouvons que déduire une telle chose de Ruby code source et/ou de son comportement.
- Il y a plusieurs créatures que l'on peut raisonnablement appeler un "Langage Ruby cahier des charges". iso.org/iso/iso_catalogue/catalogue_tc/... est un. RubySpec.Org est un autre. Le consensus des réalisateurs de différents Ruby Implémentations, comme il est de Matz cerveau. Et elles sont toutes d'accord: Ruby est passé par valeur. Période.
- Cette réponse, bien que strictement parlant, true, est un utile. Le fait que la valeur transmise est toujours un pointeur est pas hors de propos. C'est une source de confusion pour les personnes qui sont en train d'apprendre, et votre réponse ne fait absolument rien pour aider à la confusion.
- Si Ruby est passé par valeur, parce que vous passez toujours la valeur d'un pointeur, puis une ligne comme baz = 'reference' n'a pas beaucoup de sens. Un pointeur n'est pas une Chaîne. Si vous avez été la manipulation de la valeur de la référence, vous ne sera en mesure d'affecter à un autre pointeur. Dans ce cas = n'est pas l'affectation d'un pointeur, c'est à dire que instancier une nouvelle Chaîne et de stocker un pointeur vers la Chaîne de bar. Fondamentalement, l'exemple ci-dessus, nous travaillons avec des pointeurs et utilise ensuite une opération de Chaîne pour le prouver. La Chaîne est passé dans foo par référence. Les pointeurs ne sont pas.
- appel bar.gsub!(/value/, 'reference') dans la méthode. Vous verrez que l'objet extérieur est en effet l'objet d'une mutation. effectivement la seule chose passés par valeur est la référence à l'objet.
- Oui, et cela fait de Ruby passé par valeur. Il n'a pas d'importance ce est passé, c'est important comment il est passé, et comme vous le dites vous-même, le pointeur est passé par valeur. Ergo, le Rubis est passé par valeur. C est toujours aussi passé par valeur, indépendamment du fait que vous passez un int ou un int*. Juste parce que vous êtes en passant un pointeur ne change pas les conventions d'appel. Vous pouvez imaginer Rubis était comme en C, sauf que toutes les méthodes d'accepter et retourner opaque object_t* pointeur. C'est encore passé par valeur.
- Suis-je complètement à côté de quelque chose ici, ou dans certaines circonstances, le Rubis est passé par référence, comme each do par exemple ahimmelstoss.github.io/blog/2014/06/11/...
- pas de, qui a exactement rien à voir avec le passage par valeur, contre passé par référence. C'est tout simplement mutation. Ruby n'est pas un point de vue purement fonctionnel de la langue, si vous dites à un objet pour le changement lui-même, il change. Si vous dites à une chaîne de caractères à ajouter une ! à lui-même, il aura une ! ajouté.
- ok cela fait sens. Ce comportement avec each do est juste un peu étrange, pour moi comme je l'ai récemment emménagé à Ruby. Donc, on dirait que j'ai pour cloner un objet si je ne veux pas d'incidence sur l'original (ou dans mon cas, où l'original est en "lecture seule") dans un each do itération?
- Oui, c'est un des problèmes de l'mutable état, et pourquoi tant de nombreux programmeurs sont de nature purement objets immuables avec referentially des méthodes transparentes, même non purement fonctionnelle des langues comme Java ou Ruby. (Si vous lisez, par exemple, des livres comme Efficace Java et Java de la Simultanéité dans la Pratique, le contenu de ces deux livres peuvent être assez bien résumées comme "l'utilisation de la programmation fonctionnelle".) Si vous avez mutable état, vous devez définir serré contrats sur qui est autorisé à muter, ce qui, dans la manière dont de quand ou si vous ne pouvez pas faire confiance à ces contrats, vous avez pour tout copier.
- C'est un peu serviable exemple. Si le contenu de la fonction de cette réponse ont été bar.replace 'reference' le résultat Ruby is pass-by-reference
- Oui, il y a bien sûr de nombreuses façons d'obtenir cette option pour imprimer la mauvaise chose en le modifiant pour imprimer quelque chose de mal. Cependant, ce que votre exemple aurait spectacle est pas par référence, mais plutôt partagé mutable état, ce qui n'est pas la question ici. Personne, et certainement pas moi) soutient que le Ruby est un langage purement fonctionnel. Bien sûr, il a partagé mutable état, et lorsque vous muter à l'état partagé que la mutation est visible partout. Si je coupe mes cheveux, mes cheveux s'en est allé, peu importe si vous faites référence m'a "Jörg" comme mes collègues ou de "fils" comme mon père.
- Je pensais que votre exemple est d'essayer de montrer que la fonction fait une copie du paramètre de chaîne de sorte que lorsque vous changez de chaîne en fonction de la chaîne d'origine n'est pas modifié. C'est pourquoi j'ai fait le commentaire ci-dessus. Maintenant, je comprends plus, je vois que ce que vous montrez, c'est que la fonction fait une copie de la référence à la chaîne de sorte que lorsque vous réaffectez la référence de la référence d'origine n'est pas modifiée. Si vous aviez fait cela très clair dans votre réponse, cela aurait permis d'économiser beaucoup de confusion, probablement pour d'autres personnes aussi.
- Pourriez-vous nous expliquer cette impression de Ruby est passé par référence: def foo(bar) bar[0..-1] = 'reference' end; baz = 'value'; foo(baz); puts "Ruby is pass-by-#{baz}"
- vous êtes à la mutation de l'objet, en ne changeant pas la référence. La mutation des objets est parfaitement autorisé en Ruby, Ruby n'est pas un point de vue purement fonctionnel de la langue comme Haskell. Cela n'a rien à voir avec passe-par-référence vs-passer-par-valeur, c'est simple mutation.
InformationsquelleAutor Jörg W Mittag
43

Ruby utilise le "passage par référence d'objet"

(À l'aide de Python de la terminologie.)

- À-dire Ruby utilise le "passage par valeur" ou de "passage par référence" n'est pas vraiment suffisamment descriptif pour être utile. Je pense que la plupart des gens connaissent ces jours-ci, que la terminologie ("valeur" vs "de référence") vient de C++.

En C++, "passage par valeur" signifie que la fonction reçoit une copie de la variable et toutes les modifications apportées à la copie ne pas modifier l'original. C'est vrai pour les objets trop. Si vous transmettez un objet variable par la valeur de l'objet entier (y compris l'ensemble de ses membres) d'avoir copié et toute modification aux membres de ne pas modifier ces membres sur l'objet d'origine. (C'est différent si vous passez un pointeur en valeur mais Ruby n'a pas de pointeurs de toute façon, autant que je sache.)
```
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;
}
```
De sortie:
```
in inc: 6
in main: 5
in inc: 1
in main: 1
```
En C++, "passage par référence" signifie que la fonction obtient l'accès à la variable d'origine. Il peut affecter un tout nouveau littéral entier et la variable d'origine aura alors qu'une valeur trop.
```
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;
}
```
De sortie:
```
in replace: 10
in main: 10
```
Ruby utilise le passage par valeur (au sens du C++) si l'argument n'est pas un objet. Mais en Ruby, tout est un objet, alors il n'y a vraiment pas de passage par valeur au sens du C++ en Ruby.

En Ruby, "passer par la référence d'objet" (pour utiliser Python terminologie) est utilisé:
- L'intérieur de la fonction, l'objet l'un des membres peut y avoir de nouvelles valeurs qui leur sont confiées et de ces changements persistent après le retour de fonction.*
- L'intérieur de la fonction, l'attribution d'un tout nouvel objet à la variable provoque la variable d'arrêter faisant référence à l'ancien objet. Mais d'après les retours de fonction, la variable d'origine sera toujours référence à l'ancien objet.
Donc Ruby n'utilise pas de "passage par référence" au sens du C++. Si c'était le cas, l'affectation d'un nouvel objet à une variable à l'intérieur d'une fonction serait la cause de l'ancien objet à l'oubli après la fonction renvoyée.
```
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
```
De sortie:
```
1
2
2
3
2

1
2
1
```
* C'est pourquoi, en Ruby, si vous voulez modifier un objet à l'intérieur d'une fonction, mais oublier ces changements lorsque la fonction retourne une valeur, vous devez explicitement de faire une copie de l'objet avant de faire des modifications temporaires à la copie.
- Votre réponse est la meilleure. J'ai aussi envie de poster un exemple simple def ch(str) str.reverse! end; str="abc"; ch(str); puts str #=> "cba"
- C'est la bonne réponse! C'est aussi très bien expliqué ici: robertheaton.com/2014/07/22/.... Mais ce que je ne comprends toujours pas est-ce: def foo(bar) bar = 'reference' end; baz = 'value'; foo(baz); puts "Ruby is pass-by-#{baz}". Ce imprime "Ruby est passé par valeur". Mais la variable à l'intérieur de foo est réaffecté. Si bar serait un tableau de la réaffectation n'aurait pas d'effet baz. Pourquoi?
- Je ne comprends pas votre question. Je pense que vous devriez demander à une toute nouvelle question au lieu de le demander dans les commentaires ici.
InformationsquelleAutor David Winiecki
19

Ruby est passé par valeur dans un sens strict, MAIS les valeurs sont des références.

Ce qui pourrait être appelé "passer de la référence par la valeur". Cet article est la meilleure explication que j'ai lu: http://robertheaton.com/2014/07/22/is-ruby-pass-by-reference-or-pass-by-value/

Passer de la référence par la valeur peut brièvement être expliqué comme suit:

Une fonction reçoit une référence à (et access) le même objet en mémoire utilisé par l'appelant. Toutefois, il ne reçoit pas de la case que l'appelant est le stockage de cet objet, comme dans le passage de la valeur par valeur, la fonction fournit sa propre boîte et crée une nouvelle variable pour elle-même.

Le comportement qui en résulte est en fait une combinaison des définitions classiques de passer par référence et par valeur.
- "passer de référence par la valeur" est la même phrase que j'utilise pour décrire le Rubis, l'argument du passage. Je pense que c'est la plus précise et succincte de la phrase.
InformationsquelleAutor Ari
16

Il y a déjà quelques grandes réponses, mais je veux mettre la définition d'une paire des autorités sur le sujet, mais aussi en espérant que quelqu'un peut expliquer ce qu'a indiqué que les autorités Matz (le créateur de Ruby) et David Flanagan signifiait dans leur excellent O'Reilly livre, Le Langage de Programmation Ruby.

[de 3.8.1: Références de l'Objet]

Lorsque vous transmettez un objet à une méthode de Ruby, c'est un objet de référence qui est passé à la méthode. Il n'est pas l'objet lui-même, et il n'est pas une référence à la référence à l'objet. Une autre façon de dire que c'est la méthode, les arguments sont passés en valeur plutôt que par référence, mais que les valeurs transmises sont des références d'objet.

Parce que les références de l'objet sont passés à des méthodes, des méthodes d'utilisation de ces références à modifier l'objet sous-jacent. Ces modifications sont ensuite visibles quand le retour de la méthode.

Tout cela fait sens pour moi jusqu'à ce que le dernier paragraphe, et surtout cette dernière phrase. C'est, au mieux, trompeuses, et au pire de la confusion. Comment, en quelque sorte, pourrait modifications qui sont passés par valeur de référence de changement de l'objet sous-jacent?
- Parce que la référence n'est pas modifiée; l'objet sous-jacent est.
- Parce que l'objet est mutable. Ruby n'est pas un point de vue purement fonctionnel de la langue. C'est complètement orthogonal à passer par-référence vs-passer-par-valeur (à l'exception du fait que, dans un rôle purement fonctionnel de la langue, de passer par valeur et par référence donnent toujours les mêmes résultats, de sorte que la langue peuvent utiliser l'une ou les deux à votre insu).
- Un bon exemple serait si, au lieu d'une affectation de variable dans une fonction, vous regardez le cas de passage d'un hachage de la fonction et de faire une fusion! sur le passé de hachage. L'original de hachage finit modifié.
InformationsquelleAutor Dominick
15

Est Ruby passer par référence ou par valeur?

Ruby est passé par référence. Toujours. Pas d'exceptions. Pas de fi. Pas de mais.

Voici un programme simple qui illustre ce fait:
```
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 Ruby est passé par référence 2279146940 parce que object_id (les adresses de mémoire) sont toujours les mêmes 😉
```
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}"
```
=> certaines personnes ne comprennent pas c'est de la référence parce que la programmation locale peut prendre la priorité, mais c'est clairement passé par référence
- C'est la seule réponse correcte et présente quelques belles astuces: Essayez a = "foobar"; b = a ; b[5] = 'z', a et b sont modifiés.
- votre argument n'est pas entièrement valide. Nous allons passer par votre code d'instruction par instruction. a = "foobar" crée une nouvelle référence vers "foobar". b = a crée une deuxième référence aux mêmes données. b[5] = 'z' modifie la sixième caractère de la valeur référencée par b d'un " z " (la valeur qui est une coïncidence aussi référencé par un est changé). C'est pourquoi "les deux la modification" dans les termes, ou plus précisément, pourquoi "la valeur référencée par les deux variables se modifie".
- Vous n'êtes pas de faire quelque chose avec la référence de votre bar méthode. Vous êtes tout simplement la modification de l'objet de la référence points, mais pas la référence elle-même. La seule manière de modifier les références en Ruby, c'est par cession. Vous ne pouvez pas modifier les références en appelant les méthodes de Ruby parce que les méthodes ne peut être appelé que sur les objets et les références ne sont pas des objets en Ruby. Votre exemple de code montre que Ruby a partagé mutable état (ce qui n'est pas en discussion ici), il n'a cependant rien à éclairer la distinction entre passé par valeur et par référence.
- Quand quelqu'un demande si une langue est "par référence" ils veulent généralement savoir quand vous transmettre quelque chose à une fonction, et la fonction modifie, qu'il sera modifié en dehors de la fonction. Pour Ruby, la réponse est "oui". Cette réponse est utile en démontrant que, @JörgWMittag la réponse est très peu utile.
- Vous êtes bien sûr libre d'utiliser votre propre définition du terme "passage par valeur", qui est différente de la commune, largement utilisée dans la définition. Toutefois, si vous le faites, vous devriez être prêt pour les gens à se confondre, surtout si vous omettez de divulguer le fait qu'on parle très différents, dans certains aspects, même en face de la notion que tout le monde le fait. En particulier, "par référence" est pas de savoir si ou non le "quelque chose" qui est passé peut être modifié, mais plutôt avec ce que "quelque chose" est, en particulier, si c'est la référence ...
- ... lui-même qui est passé (par référence) ou si le valeur, la référence points est en cours de transmission. En Ruby, c'est le dernier. Ergo, le Rubis est passé par valeur. Maintenant, il arrive que la valeur est un pointeur vers un partage mutable objet, et que lorsque vous muter cet objet, d'autres morceaux de code qui ont aussi un pointeur vers cet objet peut observer ces modifications, mais qui n'a rien à voir avec passe-par-référence vs-passer-par-valeur. C'est juste la manière dont les mutable état des œuvres. Ruby n'est pas un langage purement fonctionnel, et personne n'a jamais prétendu que c'était.
- désolé, j'ai parlé de l'ignorance. David Winiecki réponse m'a donné plus de compréhension. Je ne savais pas qu'en C++ par référence lorsque vous avez choisi une nouvelle valeur de référence en fonction de la référence d'origine serait également être réaffectés. Je suppose que c'est la principale différence entre les références et les pointeurs en C++ que je n'ai jamais entendu avant. Je pensais que Ruby comportement était le même que le passage par référence en C++, mais il ne l'est pas.
- J'aime cette réponse parce que, en combinaison avec JörgWMittag réponse, il montre comment l'idiot, il est d'usage de passer par valeur et par référence en C++ les sens du termes quand on parle de Ruby. Les deux cet exemple et de Jörg sont parfaitement valides des exemples qui démontrent Ruby présentant des traits des deux passant de styles, de sorte que, pratiquement parlant, ni définition convient vraiment.
InformationsquelleAutor Brett Allred
8

Paramètres sont une copie de la référence d'origine. Donc, vous pouvez modifier les valeurs, mais ne peut pas modifier la référence d'origine.

InformationsquelleAutor Rael Gugelmin Cunha
1

Ruby est interprété. Les Variables sont des références à des données, mais pas les données. Cela facilite l'utilisation de la même variable pour les données de différents types.

Cession de lhs = rhs puis copie la référence sur les rhs, pas les données. Ce qui diffère dans d'autres langages, comme le C, où l'affectation n'est qu'une copie des données à gauche de rhs.

Donc pour l'appel de la fonction, la variable passée, disons x, est en effet copiée dans une variable locale à la fonction, mais x est une référence. Il y aura ensuite deux copies de la référence, à la fois de référencement sur les mêmes données. On va être dans l'appelant, l'une dans la fonction.

Affectation dans la fonction copie puis une nouvelle référence à la fonction de la version de x. Après cela, l'appelant version de x reste inchangé. Il est encore une référence pour les données d'origine.

En revanche, en utilisant le .remplacement de la méthode sur x sera la cause de ruby pour faire une copie de données. Si le remplacement est utilisé avant tout de nouvelles missions, en effet, l'appelant va voir la modification de données dans sa version aussi.

De la même façon, aussi longtemps que la référence d'origine est intact pour le passé dans de variables, les variables d'instance sera le même que le visiteur voit. Dans le cadre d'un objet, les variables d'instance de toujours avoir le plus à jour des valeurs de référence, que ceux-ci sont fournies par l'appelant ou d'un ensemble dans la fonction de la classe a été transmise à.

L'appel par valeur " ou "appel par la référence" est confuse ici en raison de la confusion sur '=' Dans les langages compilés '=' est une copie des données. Ici, dans ce langage interprété '=' est un exemplaire de référence. Dans l'exemple que vous avez la référence transmise dans suivie par un exemplaire de référence si '=' que clobbers l'original passé en référence, et puis les gens en parler comme si '=' étaient une copie des données.

Pour être cohérent avec les définitions que l'on doit garder avec".remplacer", comme c'est une copie des données. Du point de vue de".remplacer", nous voyons que c'est, en effet, passer par référence. En outre, si nous marchons à travers dans le débogueur, nous voyons des références soit passé, que les variables sont des références.

Toutefois, si l'on doit garder '=' comme un cadre de référence, puis nous avons en effet la chance de voir le passé dans les données que jusqu'à une cession, et puis nous n'avons pas plus le voir après la cession, tout en l'appelant de données reste inchangé. Au niveau comportemental c'est le passage par valeur, tant que nous ne la considérons pas comme le passé dans la valeur composite - qu'on ne sera pas en mesure de garder une partie de lui, tandis que l'évolution de l'autre partie, en une seule commande (ainsi que les modifications d'attributions de la référence et de l'original est hors de portée). Il y aura également une verrue, en l'occurrence des variables dans les objets seront des références, comme le sont toutes les variables. Donc, nous allons être obligés de parler en passant références en valeur " et à l'utilisation des locutions.

InformationsquelleAutor
1

Essayez ceci:--
```
1.object_id
#=> 3

2.object_id
#=> 5

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

b = 2
#=> 2
b.object_id
#=> 5
```
identificateur contient object_id 3 pour objet de valeur 1 et l'identifiant de b contient object_id 5 pour la valeur de l'objet 2.

Maintenant le faire:--
```
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
```
Maintenant, a et b contiennent les même object_id 5 qui se réfère à la valeur de l'objet 2.
Donc, Ruby variable contient object_ids à se référer à des objets de valeur.

Suivant donne également d'erreur:--
```
c
#=> error
```
mais cela ne donnera pas d'erreur:--
```
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
```
Ici identificateur retourne un objet de valeur 11 objet dont l'id est de 23 c'est à dire object_id 23 est à un identificateur, nous voyons Maintenant un exemple en utilisant la méthode.
```
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
```
arg foo est affecté avec la valeur de retour de x.
Il montre clairement que l'argument est passé par valeur 11, et la valeur 11 étant lui-même un objet a objet unique id 23.

Maintenant voir aussi ceci:--
```
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
```
Ici, identifiant arg première contient object_id 23 référer 11 et après affectation interne avec l'objet de valeur 12, il contient object_id 25. Mais il ne change pas la valeur référencée par l'identificateur x utilisés dans la méthode appelante.

Par conséquent, le Rubis est le passage par valeur et Ruby variables ne contiennent pas de valeurs, mais ne contiennent référence à la valeur de l'objet.

InformationsquelleAutor Alok Anand
1

Il convient de noter que vous n'avez pas à même d'utiliser la fonction "remplacer" la méthode pour modifier la valeur d'origine de la valeur. Si vous affectez une des valeurs de hachage pour une table de hachage, vous modifiez la valeur d'origine.
```
def my_foo(a_hash)
  a_hash["test"]="reference"
end;

hash = {"test"=>"value"}
my_foo(hash)
puts "Ruby is pass-by-#{hash["test"]}"
```
- Une autre chose que j'ai trouvé. Si vous êtes de passage à un type numérique, tous de type numérique sont immuables, et SONT donc le passage par valeur. La fonction de remplacement qui a travaillé avec la chaîne ci-dessus, ne fonctionne PAS pour tout les types numériques.
InformationsquelleAutor Don Carr

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

Des mises à jour de l'objet même de ne pas rendre les références à nouveau de la mémoire, car il est toujours dans la même mémoire.
Voici quelques exemples :

    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"}}

InformationsquelleAutor Ayman Hussain

Vous devez vous connecter pour publier un commentaire.

Est Ruby passer par référence ou par valeur?

Q1: Qu'advient-il lorsque vous affectez une nouvelle variable `str` à une valeur de `'foo'`?

Un: Un label " `str` est créé que des points à l'objet `'foo'`, qui, pour l'état de cet interpréteur Ruby arrive à être à l'emplacement de la mémoire `2000`.

Q2: Qu'advient-il lorsque vous affectez à la variable existante `str` à un nouvel objet à l'aide de `=`?

Un: L'étiquette `str` maintenant pointe vers un objet différent.

Q3: Qu'advient-il lorsque vous affectez une nouvelle variable `=` à `str`?

Une: Un nouveau label appelé `str2` est créé points à la même objet comme `str`.

Q4: Qu'advient-il si l'objet référencé par `str` et `str2` est changé?

Une: les Deux étiquettes toujours au même objet, mais l'objet en lui-même a muté (son contenu ont été modifiés pour être autre chose).

Comment est-ce lié à la question de départ?

Ruby utilise le "passage par référence d'objet"

Q1: Qu'advient-il lorsque vous affectez une nouvelle variable str à une valeur de 'foo'?

Un: Un label " str est créé que des points à l'objet 'foo', qui, pour l'état de cet interpréteur Ruby arrive à être à l'emplacement de la mémoire 2000.

Q2: Qu'advient-il lorsque vous affectez à la variable existante str à un nouvel objet à l'aide de =?

Un: L'étiquette str maintenant pointe vers un objet différent.

Q3: Qu'advient-il lorsque vous affectez une nouvelle variable = à str?

Une: Un nouveau label appelé str2 est créé points à la même objet comme str.

Q4: Qu'advient-il si l'objet référencé par str et str2 est changé?